anchor.diff:                                      free_deleters=NewFreeDeleters,
                                       delete_blocks_remaining=NewDeleteBlocksRemaining}).
   
  -
  --spec finish(state()) -> state().
  -finish(State=#state{manifest=?MANIFEST{state=deleted},
  -                    bucket=Bucket,
  -                    key=Key,
  -                    uuid=UUID,
  -                    riakc_pid=RiakcPid}) ->
  +-spec notify_gc_daemon(term()) -> term().
  +notify_gc_daemon(Reason) ->
  +    gen_fsm:sync_send_event(riak_cs_gc_d, notification_msg(Reason), infinity).
  +
  +-spec notification_msg(term()) -> {pid(), ok | {error, term()}}.
  +notification_msg(normal) ->
  +    {self(), ok};
  +notification_msg(Reason) ->
  +    {self(), {error, Reason}}.
  +
  +-spec manifest_cleanup(atom(), binary(), binary(), binary(), pid()) -> ok.
  +manifest_cleanup(deleted, Bucket, Key, UUID, RiakcPid) ->
       {ok, ManiFsmPid} = riak_moss_manifest_fsm:start_link(Bucket, Key, RiakcPid),
       _ = riak_moss_manifest_fsm:delete_specific_manifest(ManiFsmPid, UUID),
  -    State;
  -finish(_State) ->
  -    _State.
  +    _ = riak_moss_manifest_fsm:stop(ManiFsmPid),
  +    ok;
  +manifest_cleanup(_, _, _, _, _) ->
  +    ok.
   
   -spec blocks_to_delete_from_manifest(lfs_manifest()) ->
       {lfs_manifest(), ordsets:ordset(integer())}.
  
positive.code: 
      if
          NewManifest?MANIFEST.state == deleted ->
              State3 = finish(State2),
              {stop, normal, State3};
          true ->
              %% maybe start more deletes
              State3 = maybe_delete_blocks(State2),
              {next_state, deleting, State3}
      end;
  deleting({block_deleted, {error, Error}, _DeleterPid}, State) ->
      _ = finish(State),
      {stop, Error, State}.
  
  handle_event(_Event, StateName, State) ->
  
negative.code: handle_info(_Info, StateName, State) ->
      {next_state, StateName, State}.
  
  terminate(Reason, _StateName, #state{all_delete_workers=AllDeleteWorkers,
                                       manifest=?MANIFEST{state=ManifestState},
                                       bucket=Bucket,
                                       key=Key,
                                       uuid=UUID,
                                       riakc_pid=RiakcPid}) ->
      manifest_cleanup(ManifestState, Bucket, Key, UUID, RiakcPid),
      _ = [riak_moss_block_server:stop(P) || P <- AllDeleteWorkers],
      notify_gc_daemon(Reason),
      ok.
  
  code_change(_OldVsn, StateName, State, _Extra) ->
  