textus 0.18.0 → 0.20.2

data/lib/textus/application/refresh/worker.rb

@@ -6,17 +6,22 @@ module Textus
       class Worker
         FETCH_TIMEOUT_SECONDS = 30
 
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, store:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @store        = store
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def run(key)
-          res = @ctx.store.manifest.resolve(key)
+          res = @manifest.resolver.resolve(key)
           mentry = res.entry
           path = res.path
           remaining = res.remaining
-          raise UsageError.new("no intake declared for '#{key}'") unless mentry.intake_handler
+          raise UsageError.new("no intake declared for '#{key}'") unless mentry.is_a?(Textus::Manifest::Entry::Intake)
 
           before_etag = File.exist?(path) ? Etag.for_file(path) : nil
           result = fetch_with_bus(key, mentry, remaining)
@@ -25,19 +30,14 @@ module Textus
 
         private
 
-        def read_view
-          Application::Context.new(store: @ctx.store, role: @ctx.role)
-        end
-
         def fetch_timeout_for(key)
-          rule = @ctx.store.manifest.rules_for(key)
+          rule = @manifest.rules_for(key)
           rule&.refresh&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
         end
 
         def fetch_with_bus(key, mentry, remaining)
-          callable = @ctx.store.registry.rpc_callable(:resolve_intake, mentry.intake_handler)
-          @ctx.bus.publish(:refresh_started, store: read_view, key: key, mode: :sync,
-                                             correlation_id: @ctx.correlation_id)
+          callable = @bus.rpc_callable(:resolve_intake, mentry.handler)
+          @bus.publish(:refresh_started, ctx: @hook_context, key: key, mode: :sync)
           call_intake(key, mentry, callable, remaining)
         end
 
@@ -45,38 +45,38 @@ module Textus
           timeout = fetch_timeout_for(key)
           Timeout.timeout(timeout) do
             callable.call(
-              store: @ctx,
-              config: mentry.intake_config,
+              store: @store,
+              config: mentry.config,
               args: { trigger_key: key, leaf_segments: remaining || [] },
             )
           end
         rescue Timeout::Error
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: "Timeout::Error",
-                                            error_message: "intake '#{mentry.intake_handler}' exceeded #{timeout}s",
-                                            correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' exceeded #{timeout}s timeout")
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key,
+                                        error_class: "Timeout::Error",
+                                        error_message: "intake '#{mentry.handler}' exceeded #{timeout}s")
+          raise UsageError.new("intake '#{mentry.handler}' exceeded #{timeout}s timeout")
         rescue Textus::Error => e
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                            error_message: e.message, correlation_id: @ctx.correlation_id)
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
+                                        error_message: e.message)
           raise
         rescue StandardError => e
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                            error_message: e.message, correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' raised: #{e.class}: #{e.message}")
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
+                                        error_message: e.message)
+          raise UsageError.new("intake '#{mentry.handler}' raised: #{e.class}: #{e.message}")
         end
 
         def persist_and_notify(key, mentry, result, before_etag)
-          normalized = Textus::Refresh.normalize_action_result(result, format: mentry.format)
-          envelope = Textus::Application::Writes::Put.new(ctx: @ctx, envelope_io: @envelope_io).call(
+          normalized = self.class.send(:normalize_action_result, result, format: mentry.format)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
+          envelope = @envelope_io.write(
             key,
-            meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
-            suppress_events: true
+            mentry: mentry,
+            payload: Textus::Application::Writes::EnvelopeIO::Payload.new(
+              meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
+            ),
           )
           change = detect_change(before_etag, envelope)
-          unless change == :unchanged
-            @ctx.bus.publish(:entry_refreshed, store: read_view, key: key, envelope: envelope, change: change,
-                                               correlation_id: @ctx.correlation_id)
-          end
+          @bus.publish(:entry_refreshed, ctx: @hook_context, key: key, envelope: envelope, change: change) unless change == :unchanged
           envelope
         end
 
@@ -86,6 +86,30 @@ module Textus
           else :updated
           end
         end
+
+        def self.normalize_action_result(res, format:)
+          res = res.transform_keys(&:to_s) if res.is_a?(Hash)
+          res ||= {}
+          meta_val = res["_meta"]
+          body     = res["body"]
+          content  = res["content"]
+
+          case format
+          when "markdown" then { meta: meta_val || {}, body: body.to_s, content: nil }
+          when "text"     then { meta: {}, body: body.to_s, content: nil }
+          when "json", "yaml"
+            if !content.nil?
+              { meta: meta_val || {}, body: nil, content: content }
+            elsif !body.nil?
+              { meta: {}, body: body.to_s, content: nil }
+            else
+              raise Textus::UsageError.new("intake for #{format} returned neither content nor body")
+            end
+          else
+            raise Textus::UsageError.new("unknown format #{format.inspect}")
+          end
+        end
+        private_class_method :normalize_action_result
       end
     end
   end

data/lib/textus/application/writes/accept.rb

@@ -1,16 +1,28 @@
+require_relative "authority_gate"
+
 module Textus
   module Application
     module Writes
       class Accept
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        include AuthorityGate
+
+        def initialize(ctx:, manifest:, file_store:, schemas:, envelope_io:, bus:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @schemas      = schemas
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(pending_key)
-          raise ProposalError.new("only human role can accept proposals; got '#{@ctx.role}'") unless @ctx.role == "human"
+          assert_accept_authority!("accept")
 
-          env = Textus::Application::Reads::Get.new(ctx: @ctx).call(pending_key)
+          env = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          ).call(pending_key)
           proposal = env.meta["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
           target = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
           action = proposal["action"] || "put"
@@ -23,33 +35,48 @@ module Textus
             # target. Not related to the removed intake-handler legacy bridge.
             target_meta = env.meta["frontmatter"] || {}
             target_body = env.body
-            Textus::Application::Writes::Put.new(ctx: @ctx, envelope_io: @envelope_io).call(target, meta: target_meta, body: target_body)
+            put_op.call(target, meta: target_meta, body: target_body)
           when "delete"
-            Textus::Application::Writes::Delete.new(ctx: @ctx, envelope_io: @envelope_io).call(target)
+            delete_op.call(target)
           else
             raise ProposalError.new("unknown action: #{action}")
           end
 
-          Textus::Application::Writes::Delete.new(ctx: @ctx, envelope_io: @envelope_io).call(pending_key)
+          delete_op.call(pending_key)
 
-          @ctx.bus.publish(:proposal_accepted,
-                           store: @ctx.with_role(@ctx.role),
-                           key: pending_key,
-                           target_key: target,
-                           correlation_id: @ctx.correlation_id)
+          @bus.publish(:proposal_accepted,
+                       ctx: @hook_context,
+                       key: pending_key,
+                       target_key: target)
 
           { "protocol" => PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action }
         end
 
         private
 
+        def put_op
+          @put_op ||= Textus::Application::Writes::Put.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          )
+        end
+
+        def delete_op
+          @delete_op ||= Textus::Application::Writes::Delete.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          )
+        end
+
         def evaluate_promotion!(env, target_key)
-          rules = @ctx.manifest.rules_for(target_key)
+          rules = @manifest.rules_for(target_key)
           promote = rules.promote
           return if promote.nil? || promote.requires.empty?
 
-          policy = Textus::Domain::Policy::Promotion.from_names(promote.requires)
-          result = policy.evaluate(entry: env, store: @ctx.store)
+          policy = Textus::Application::Policy::Promotion.from_names(promote.requires)
+          result = policy.evaluate(
+            entry: env, schemas: @schemas, manifest: @manifest, role: @ctx.role,
+          )
           return if result.ok?
 
           raise ProposalError.new(

data/lib/textus/application/writes/authority_gate.rb

@@ -0,0 +1,26 @@
+module Textus
+  module Application
+    module Writes
+      # Shared gate for write verbs that require the caller to hold the
+      # manifest's accept_authority role. Provides one method, expressed
+      # as two early-returns rather than a ternary, so each failure mode
+      # reads on its own line.
+      module AuthorityGate
+        def assert_accept_authority!(verb)
+          return if @manifest.role_kind(@ctx.role) == :accept_authority
+
+          authority = @manifest.roles_with_kind(:accept_authority).first
+          if authority.nil?
+            raise ProposalError.new(
+              "no role with accept_authority kind is declared in this manifest; #{verb} is disabled",
+            )
+          end
+
+          raise ProposalError.new(
+            "only #{authority} role can #{verb} proposals; got '#{@ctx.role}'",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/textus/application/writes/delete.rb

@@ -2,24 +2,27 @@ module Textus
   module Application
     module Writes
       class Delete
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(key, if_etag: nil, suppress_events: false)
-          @ctx.manifest.validate_key!(key)
-          mentry = @ctx.manifest.resolve(key).entry
+          @manifest.validate_key!(key)
+          mentry = @manifest.resolver.resolve(key).entry
 
-          @ctx.authorize_write!(mentry)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
 
           @envelope_io.delete(key, mentry: mentry, if_etag: if_etag)
 
           unless suppress_events
-            @ctx.bus.publish(:entry_deleted,
-                             store: @ctx.with_role(@ctx.role),
-                             key: key,
-                             correlation_id: @ctx.correlation_id)
+            @bus.publish(:entry_deleted,
+                         ctx: @hook_context,
+                         key: key)
           end
 
           { "protocol" => Textus::PROTOCOL, "ok" => true, "key" => key, "deleted" => true }

data/lib/textus/application/writes/envelope_io.rb

@@ -1,3 +1,5 @@
+require "fileutils"
+
 module Textus
   module Application
     module Writes
@@ -6,7 +8,7 @@ module Textus
       # AuditLog, Manifest) instead of File/FileUtils and Store directly.
       #
       # No permission check, no event firing — those belong to the caller
-      # (Application::Writes::Put / ::Delete).
+      # (Application::Writes::Put / ::Delete / ::Mv).
       class EnvelopeIO
         Payload = Data.define(:meta, :body, :content)
 
@@ -18,8 +20,28 @@ module Textus
           @ctx        = ctx
         end
 
+        def exists?(path) = @file_store.exists?(path)
+
+        # Reads an envelope by key, returning nil when absent. Used by Mv
+        # to inspect pre-move state (UID presence, content surfacing) so
+        # the move pipeline can consolidate I/O in one place.
+        def read_envelope(key)
+          res = @manifest.resolver.resolve(key)
+          path = res.path
+          return nil unless @file_store.exists?(path)
+
+          mentry = res.entry
+          raw = @file_store.read(path)
+          parsed = Entry.for_format(mentry.format).parse(raw, path: path)
+          Envelope.build(
+            key: key, mentry: mentry, path: path,
+            meta: parsed["_meta"], body: parsed["body"],
+            etag: Etag.for_bytes(raw), content: parsed["content"]
+          )
+        end
+
         def write(key, mentry:, payload:, if_etag: nil)
-          path = @manifest.resolve(key).path
+          path = @manifest.resolver.resolve(key).path
 
           meta = payload.meta || {}
           strategy = Entry.for_format(mentry.format)
@@ -60,8 +82,8 @@ module Textus
 
         def delete(key, mentry:, if_etag: nil)
           _ = mentry
-          path = @manifest.resolve(key).path
-          raise UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)) unless @file_store.exists?(path)
+          path = @manifest.resolver.resolve(key).path
+          raise UnknownKey.new(key, suggestions: @manifest.resolver.suggestions_for(key)) unless @file_store.exists?(path)
 
           etag_before = @file_store.etag(path)
           raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && if_etag != etag_before
@@ -74,6 +96,44 @@ module Textus
           )
         end
 
+        def move(from_key:, to_key:, new_mentry:, if_etag: nil)
+          from_path = @manifest.resolver.resolve(from_key).path
+          to_path   = @manifest.resolver.resolve(to_key).path
+          raise UnknownKey.new(from_key, suggestions: @manifest.resolver.suggestions_for(from_key)) unless @file_store.exists?(from_path)
+
+          etag_before = @file_store.etag(from_path)
+          raise EtagMismatch.new(from_key, if_etag, etag_before) if if_etag && if_etag != etag_before
+
+          FileUtils.mkdir_p(File.dirname(to_path))
+          FileUtils.mv(from_path, to_path)
+          basename = to_key.split(".").last
+          Entry.for_format(new_mentry.format).rewrite_name(to_path, basename)
+          etag_after = Etag.for_file(to_path)
+
+          raw = @file_store.read(to_path)
+          parsed = Entry.for_format(new_mentry.format).parse(raw, path: to_path)
+          envelope = Envelope.build(
+            key: to_key, mentry: new_mentry, path: to_path,
+            meta: parsed["_meta"], body: parsed["body"],
+            etag: etag_after, content: parsed["content"]
+          )
+
+          extras = {
+            "from_key" => from_key, "to_key" => to_key,
+            "from_path" => from_path, "to_path" => to_path,
+            "uid" => envelope.uid
+          }
+          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
+
+          @audit_log.append(
+            role: @ctx.role, verb: "mv", key: to_key,
+            etag_before: etag_before, etag_after: etag_after,
+            extras: extras
+          )
+
+          envelope
+        end
+
         private
 
         def existing_uid_for(mentry, path)

data/lib/textus/application/writes/materializer.rb

@@ -0,0 +1,50 @@
+require "fileutils"
+
+module Textus
+  module Application
+    module Writes
+      # Materializes a single Derived manifest entry onto disk by running
+      # the builder pipeline (template + projection + external runner).
+      # Extracted from Application::Writes::Build so that Publish can reuse
+      # it without creating a Build dependency.
+      class Materializer
+        def initialize(ctx:, manifest:, file_store:, bus:, root:, store:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @bus        = bus
+          @root       = root
+          @store      = store
+        end
+
+        # Runs the builder pipeline for `mentry` and returns the on-disk
+        # target_path string.
+        def run(mentry)
+          reader = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          )
+          lister = Textus::Application::Reads::List.new(manifest: @manifest)
+          Builder::Pipeline.run(
+            mentry: mentry,
+            manifest: @manifest,
+            reader: reader.method(:call),
+            lister: lister.method(:call),
+            transform_resolver: ->(name) { @bus.rpc_callable(:transform_rows, name) },
+            template_loader: ->(name) { read_template(name) },
+            transform_context: @store,
+            inject_intro: -> { Textus::Intro.run(@store) },
+          )
+        end
+
+        private
+
+        def read_template(name)
+          tpl_path = File.join(@root, "templates", name)
+          raise TemplateError.new("template not found: #{tpl_path}", template_name: name) unless File.exist?(tpl_path)
+
+          File.read(tpl_path)
+        end
+      end
+    end
+  end
+end

data/lib/textus/application/writes/mv.rb

@@ -1,60 +1,46 @@
-require "fileutils"
-
 module Textus
   module Application
     module Writes
       class Mv
-        MovePlan = Data.define(
-          :old_key, :new_key, :old_path, :new_path,
-          :new_mentry, :uid, :etag_before
-        )
-
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(old_key, new_key, dry_run: false)
-          plan, pre_env = prepare_plan(old_key, new_key)
-          return dry_run_result(plan) if dry_run
+          old_res, new_res = prepare(old_key, new_key)
+          return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
 
-          plan = ensure_uid!(plan, pre_env: pre_env)
-          etag_after = perform_move!(plan)
-          new_envelope = record_move(plan, etag_after: etag_after)
-          success_result(plan, new_envelope: new_envelope)
+          ensure_uid!(old_key, old_res.entry)
+          envelope = @envelope_io.move(
+            from_key: old_key, to_key: new_key,
+            new_mentry: new_res.entry
+          )
+          publish_renamed(old_key, new_key, envelope)
+          success_result(old_key, new_key, old_res, new_res, envelope)
         end
 
         private
 
-        def manifest = @ctx.manifest
-        def reader_get(key) = (@reader_get ||= Textus::Application::Reads::Get.new(ctx: @ctx)).call(key)
-
-        def prepare_plan(old_key, new_key)
-          manifest.validate_key!(old_key)
-          manifest.validate_key!(new_key)
+        def prepare(old_key, new_key)
+          @manifest.validate_key!(old_key)
+          @manifest.validate_key!(new_key)
           raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
 
-          old_res = manifest.resolve(old_key)
-          old_mentry = old_res.entry
-          old_path = old_res.path
-          raise UnknownKey.new(old_key) unless @ctx.file_store.exists?(old_path)
+          old_res = @manifest.resolver.resolve(old_key)
+          new_res = @manifest.resolver.resolve(new_key)
+          raise UnknownKey.new(old_key) unless @envelope_io.exists?(old_res.path)
 
-          new_res = manifest.resolve(new_key)
-          new_mentry = new_res.entry
-          new_path = new_res.path
-          validate_zone_and_format!(old_mentry, new_mentry)
-          @ctx.authorize_write!(old_mentry)
-          @ctx.authorize_write!(new_mentry)
-          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if @ctx.file_store.exists?(new_path)
+          validate_zone_and_format!(old_res.entry, new_res.entry)
+          @authorizer.authorize_write!(old_res.entry, role: @ctx.role)
+          @authorizer.authorize_write!(new_res.entry, role: @ctx.role)
+          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if @envelope_io.exists?(new_res.path)
 
-          pre_env = reader_get(old_key)
-          plan = MovePlan.new(
-            old_key: old_key, new_key: new_key,
-            old_path: old_path, new_path: new_path,
-            new_mentry: new_mentry,
-            uid: pre_env.uid, etag_before: pre_env.etag
-          )
-          [plan, pre_env]
+          [old_res, new_res]
         end
 
         def validate_zone_and_format!(old_mentry, new_mentry)
@@ -69,73 +55,50 @@ module Textus
           raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
         end
 
-        def ensure_uid!(plan, pre_env:)
-          return plan if plan.uid
-
-          env = Textus::Application::Writes::Put.new(ctx: @ctx, envelope_io: @envelope_io).call(
-            plan.old_key,
-            meta: pre_env.meta,
-            body: pre_env.body,
-            content: pre_env.content,
-            suppress_events: true,
+        # If the source file lacks a UID, rewrite it in-place via EnvelopeIO#write
+        # so a UID gets injected before the move. This replaces the previous
+        # Put(suppress_events: true) bypass with a direct EnvelopeIO call —
+        # producing one "put" audit row, then the "mv" row from EnvelopeIO#move.
+        def ensure_uid!(old_key, old_mentry)
+          pre_env = @envelope_io.read_envelope(old_key)
+          return if pre_env.uid
+
+          @envelope_io.write(
+            old_key, mentry: old_mentry,
+                     payload: EnvelopeIO::Payload.new(
+                       meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
+                     )
           )
-          plan.with(uid: env.uid, etag_before: env.etag)
         end
 
-        def perform_move!(plan)
-          FileUtils.mkdir_p(File.dirname(plan.new_path))
-          FileUtils.mv(plan.old_path, plan.new_path)
-          rewrite_name_for_mv!(plan.new_mentry, plan.new_path, plan.new_key)
-          Etag.for_file(plan.new_path)
+        def publish_renamed(old_key, new_key, envelope)
+          @bus.publish(:entry_renamed,
+                       ctx: @hook_context,
+                       key: new_key,
+                       from_key: old_key,
+                       to_key: new_key,
+                       envelope: envelope)
         end
 
-        def record_move(plan, etag_after:)
-          extras = {
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
-          }
-          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
-
-          @ctx.audit_log.append(
-            role: @ctx.role, verb: "mv", key: plan.new_key,
-            etag_before: plan.etag_before, etag_after: etag_after,
-            extras: extras
-          )
-          new_envelope = reader_get(plan.new_key)
-          @ctx.bus.publish(:entry_renamed,
-                           store: @ctx.with_role(@ctx.role),
-                           key: plan.new_key,
-                           from_key: plan.old_key,
-                           to_key: plan.new_key,
-                           envelope: new_envelope,
-                           correlation_id: @ctx.correlation_id)
-          new_envelope
-        end
-
-        def dry_run_result(plan)
+        def dry_run_result(old_key, new_key, old_res, new_res)
+          pre_env = @envelope_io.read_envelope(old_key)
           {
             "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_res.path, "to_path" => new_res.path,
+            "uid" => pre_env.uid
           }
         end
 
-        def success_result(plan, new_envelope:)
+        def success_result(old_key, new_key, old_res, new_res, envelope)
           {
             "protocol" => PROTOCOL, "ok" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid,
-            "envelope" => new_envelope.to_h_for_wire
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_res.path, "to_path" => new_res.path,
+            "uid" => envelope.uid,
+            "envelope" => envelope.to_h_for_wire
           }
         end
-
-        def rewrite_name_for_mv!(mentry, new_path, new_key)
-          basename = new_key.split(".").last
-          Entry.for_format(mentry.format).rewrite_name(new_path, basename)
-        end
       end
     end
   end