anchor.diff:          Acc andalso All
       end, true, Store),
   
  -    FoldResult;
  +    %% Everything there is something we wrote.
  +    NodeToStoreResult = dict:fold(fun(Node, Results, Acc) ->
  +        case Results of 
  +            badrpc ->
  +                node_debug("=> node crashed, considering valid.", []),
  +                Acc andalso true;
  +            _ ->
  +                All = dict:fold(fun(Key, Value, Acc1) ->
  +                    case dict:find(Key, Store) of 
  +                        {ok, Value} ->
  +                            Acc1 andalso true;
  +                        Other ->
  +                            node_debug("Node ~p had result key: ~p value: ~p but in the store we had ~p", [Node, Key, Value, Other]),
  +                            Acc1 andalso false
  +                    end
  +                end, true, Results),
  +
  +                Acc andalso All
  +        end
  +    end, true, AllResults),
  +
  +    node_debug("=> written values: ~p", [dict:to_list(Store)]),
  +    node_debug("=> StoreToNodeResult: ~p", [StoreToNodeResult]),
  +    node_debug("=> NodeToStoreResult: ~p", [NodeToStoreResult]),
  +
  +    StoreToNodeResult andalso NodeToStoreResult;
   node_postcondition(_NodeState, Command, Response) ->
       node_debug("generic postcondition fired (this probably shouldn't be hit) for command: ~p with response: ~p", 
                  [Command, Response]),
  
positive.code:     NodeState;
  node_next_state(_State, NodeState, _Response, {call, ?MODULE, read, [_Node, _Key]}) ->
      NodeState;
  node_next_state(_State, #node_state{store=Store0}=NodeState, _Response, {call, ?MODULE, write, [_Node, Key, Value]}) ->
      Store = dict:store(Key, Value, Store0),
      NodeState#node_state{store=Store};
  node_next_state(_State, NodeState, Response, Command) ->
      node_debug("generic state transition made for response: ~p command: ~p", [Response, Command]),
  
negative.code: 
      ?PROPERTY_MODULE:command_preamble(RunnerNode, [verify]),
  
      node_debug("waiting 1s for quiesence...", []),
      timer:sleep(1000),
  
      Results = lists:foldl(fun(Node, Acc) ->
          case rpc:call(?NAME(Node), implementation_module(), state, [], infinity) of
              {ok, State} ->
                  dict:store(Node, State, Acc);
              {badrpc, _} ->
                  dict:store(Node, badrpc, Acc)
          end
      end, dict:new(), names()),
  
      ?PROPERTY_MODULE:command_conclusion(RunnerNode, [verify]),
  