textus 0.10.4 → 0.12.1

data/lib/textus/manifest/entry.rb

@@ -4,10 +4,12 @@ module Textus
       PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
       PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
 
+      COMPUTE_KINDS = %w[projection external].freeze
+
       attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
                   :projection, :template, :publish_to, :publish_each,
                   :intake_handler, :intake_config,
-                  :events, :inject_intro
+                  :events, :inject_intro, :index_filename, :compute
 
       def initialize(manifest, raw)
         @manifest = manifest
@@ -18,13 +20,13 @@ module Textus
         @schema = raw["schema"]
         @owner = raw["owner"]
         @nested = raw["nested"] == true
-        @generator = raw["generator"]
-        @projection = raw["projection"]
+        parse_compute!(raw)
         @template = raw["template"]
         @publish_to = Array(raw["publish_to"])
         @publish_each = raw["publish_each"]
         @events = raw["events"] || {}
         @inject_intro = raw["inject_intro"] == true
+        @index_filename = raw["index_filename"]
         @format = resolve_format!(raw["format"])
 
         validate_events!
@@ -32,6 +34,7 @@ module Textus
         validate_format_matrix!
         validate_publish_each!
         validate_inject_intro!
+        validate_index_filename!
       end
 
       # Resolves the per-leaf target path (relative to repo root) for a full
@@ -54,18 +57,49 @@ module Textus
       end
 
       # Signal-based zone-kind predicates: derive the "kind" of a zone from its
-      # writable_by signals rather than its literal name, so detection keeps
+      # write_policy signals rather than its literal name, so detection keeps
       # working when users rename the default zones.
       def in_generator_zone?
-        zone_writers.include?("build")
+        zone_writers.include?("builder")
       end
 
       def in_proposal_zone?
-        zone_writers.include?("ai")
+        zone_writers.include?("agent")
       end
 
       private
 
+      # `index_filename:` makes a nested entry treat a fixed basename (e.g.
+      # `SKILL.md`) as the per-directory row. The directory path becomes the
+      # key suffix; sibling files are not enumerated. Allows projecting
+      # spec-mandated filenames that would otherwise be rejected by the
+      # lowercase-only key segment grammar.
+      def validate_index_filename!
+        return if @index_filename.nil?
+
+        raise UsageError.new("entry '#{@key}': index_filename requires nested: true") unless @nested
+        unless @index_filename.is_a?(String) && !@index_filename.empty?
+          raise UsageError.new("entry '#{@key}': index_filename must be a non-empty string")
+        end
+        if @index_filename.include?("/") || File.basename(@index_filename) != @index_filename
+          raise UsageError.new("entry '#{@key}': index_filename must be a bare basename (no slashes)")
+        end
+
+        ext = File.extname(@index_filename)
+        inferred = Manifest::EXT_TO_FORMAT[ext]
+        if inferred.nil?
+          raise UsageError.new(
+            "entry '#{@key}': index_filename #{@index_filename.inspect} has unknown extension #{ext.inspect}",
+          )
+        end
+        return if inferred == @format
+
+        raise UsageError.new(
+          "entry '#{@key}': index_filename extension #{ext.inspect} implies format #{inferred.inspect}, " \
+          "but entry format is #{@format.inspect}",
+        )
+      end
+
       def zone_writers
         @manifest.zone_writers(@zone)
       rescue UsageError => e
@@ -178,6 +212,32 @@ module Textus
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+      def parse_compute!(raw)
+        src = raw["compute"]
+        unless src
+          @compute = nil
+          @projection = nil
+          @generator = nil
+          return
+        end
+
+        kind = src["kind"]
+        unless COMPUTE_KINDS.include?(kind)
+          raise BadManifest.new(
+            "entry '#{@key}': compute.kind must be one of #{COMPUTE_KINDS.join(", ")} (got #{kind.inspect})",
+          )
+        end
+
+        @compute = src.freeze
+        if kind == "projection"
+          @projection = @compute
+          @generator  = nil
+        else
+          @generator  = @compute
+          @projection = nil
+        end
+      end
+
       def parse_intake!(src)
         src ||= {}
         @intake_handler = src["handler"]

data/lib/textus/manifest/{policies.rb → rules.rb}

@@ -1,8 +1,8 @@
 module Textus
   class Manifest
-    class Policies
-      PolicySet = Data.define(:refresh, :handler_allowlist, :promote, :retention)
-      EMPTY_SET = PolicySet.new(refresh: nil, handler_allowlist: nil, promote: nil, retention: nil)
+    class Rules
+      RuleSet = Data.define(:refresh, :handler_allowlist, :promote, :retention)
+      EMPTY_SET = RuleSet.new(refresh: nil, handler_allowlist: nil, promote: nil, retention: nil)
 
       def self.parse(raw)
         new(Array(raw).map { |b| Block.new(b) })
@@ -21,7 +21,7 @@ module Textus
 
           slots.each_key { |slot| slots[slot] << b if b.public_send(slot) }
         end
-        PolicySet.new(
+        RuleSet.new(
           refresh: pick(slots[:refresh], :refresh, key),
           handler_allowlist: pick(slots[:handler_allowlist], :handler_allowlist, key),
           promote: pick(slots[:promote], :promote, key),
@@ -47,10 +47,10 @@ module Textus
         attr_reader :match, :refresh, :handler_allowlist, :promote, :retention
 
         def initialize(raw)
-          @match = raw["match"] or raise Textus::UsageError.new("policy block missing match:")
+          @match = raw["match"] or raise Textus::UsageError.new("rule block missing match:")
           @refresh = parse_refresh(raw["refresh"])
-          @handler_allowlist = parse_handler_allowlist(raw["handler_allowlist"])
-          @promote = parse_promote(raw["promote_requires"])
+          @handler_allowlist = parse_handler_allowlist(raw["intake_handler_allowlist"])
+          @promote = parse_promotion(raw["promotion"])
           @retention = raw["retention"] # reserved — passthrough only
         end
 
@@ -72,10 +72,12 @@ module Textus
           Textus::Domain::Policy::HandlerAllowlist.new(handlers: arr)
         end
 
-        def parse_promote(arr)
-          return nil if arr.nil?
+        def parse_promotion(h)
+          return nil if h.nil?
+
+          raise Textus::BadManifest.new("promotion: must be a hash with a 'requires:' array") unless h.is_a?(Hash) && h.key?("requires")
 
-          Textus::Domain::Policy::Promote.new(requires: arr)
+          Textus::Domain::Policy::Promote.new(requires: Array(h["requires"]))
         end
       end
     end

data/lib/textus/manifest/schema.rb

@@ -0,0 +1,49 @@
+module Textus
+  class Manifest
+    module Schema
+      ROOT_KEYS    = %w[version zones entries rules].freeze
+      ZONE_KEYS    = %w[name write_policy read_policy].freeze
+      ENTRY_KEYS   = %w[
+        key path zone schema owner nested format
+        compute template publish_to publish_each
+        intake events inject_intro index_filename
+      ].freeze
+      COMPUTE_KEYS = %w[kind select pluck sort_by limit transform command sources].freeze
+      INTAKE_KEYS  = %w[handler config].freeze
+      RULE_KEYS    = %w[match refresh intake_handler_allowlist promotion retention].freeze
+      REFRESH_KEYS = %w[ttl on_stale sync_budget_ms].freeze
+      PROMOTION_KEYS = %w[requires].freeze
+
+      def self.validate!(raw)
+        raise BadManifest.new("manifest must be a hash") unless raw.is_a?(Hash)
+
+        walk(raw, ROOT_KEYS, "$")
+        Array(raw["zones"]).each_with_index do |z, i|
+          walk(z, ZONE_KEYS, "$.zones[#{i}]")
+        end
+        Array(raw["entries"]).each_with_index do |e, i|
+          path = "$.entries[#{i}]"
+          walk(e, ENTRY_KEYS, path)
+          walk(e["compute"], COMPUTE_KEYS, "#{path}.compute") if e["compute"].is_a?(Hash)
+          walk(e["intake"], INTAKE_KEYS, "#{path}.intake") if e["intake"].is_a?(Hash)
+        end
+        Array(raw["rules"]).each_with_index do |r, i|
+          path = "$.rules[#{i}]"
+          walk(r, RULE_KEYS, path)
+          walk(r["refresh"], REFRESH_KEYS, "#{path}.refresh") if r["refresh"].is_a?(Hash)
+          walk(r["promotion"], PROMOTION_KEYS, "#{path}.promotion") if r["promotion"].is_a?(Hash)
+        end
+      end
+
+      def self.walk(hash, allowed, path)
+        return unless hash.is_a?(Hash)
+
+        hash.each_key do |k|
+          next if allowed.include?(k)
+
+          raise BadManifest.new("unknown key '#{k}' at '#{path}'")
+        end
+      end
+    end
+  end
+end

data/lib/textus/manifest.rb

@@ -1,4 +1,5 @@
 require "yaml"
+require_relative "manifest/schema"
 
 module Textus
   class Manifest
@@ -10,10 +11,26 @@ module Textus
       ".txt" => "text",
     }.freeze
 
+    TEXTUS_2_HINT = "Install textus 0.11.x to run the migrator, then upgrade to this version. " \
+                    "See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110".freeze
+
+    def self.version_hint_for(version)
+      version == "textus/2" ? TEXTUS_2_HINT : nil
+    end
+
+    private_class_method :version_hint_for
+
     attr_reader :root, :entries, :raw
 
     def zones
-      @zones ||= Array(@raw["zones"]).to_h { |z| [z["name"], Array(z["writable_by"])] }
+      @zones ||= Array(@raw["zones"]).to_h { |z| [z["name"], Array(z["write_policy"])] }
+    end
+
+    def zone_readers
+      @zone_readers ||= Array(@raw["zones"]).to_h do |z|
+        rp = z["read_policy"]
+        [z["name"], rp.nil? ? :all : Array(rp)]
+      end
     end
 
     def zone_writers(zone_name)
@@ -23,18 +40,35 @@ module Textus
     def permission_for(zone_name)
       Textus::Domain::Permission.new(
         zone: zone_name,
-        writable_by: zone_writers(zone_name),
-        readable_by: :all,
+        write_policy: zone_writers(zone_name),
+        read_policy: zone_readers[zone_name] || :all,
       )
     end
 
+    def self.parse(yaml_text, root: ".")
+      raw = YAML.safe_load(yaml_text, aliases: false)
+      unless raw["version"] == PROTOCOL
+        raise BadFrontmatter.new(
+          "<string>",
+          "unsupported manifest version #{raw["version"].inspect}; expected #{PROTOCOL.inspect}",
+          hint: version_hint_for(raw["version"]),
+        )
+      end
+
+      new(root, raw)
+    end
+
     def self.load(root)
       manifest_path = File.join(root, "manifest.yaml")
       raise IoError.new("manifest not found: #{manifest_path}") unless File.exist?(manifest_path)
 
       raw = YAML.safe_load_file(manifest_path, aliases: false)
       unless raw["version"] == PROTOCOL
-        raise BadFrontmatter.new(manifest_path, "unsupported manifest version #{raw["version"].inspect}; expected #{PROTOCOL.inspect}")
+        raise BadFrontmatter.new(
+          manifest_path,
+          "unsupported manifest version #{raw["version"].inspect}; expected #{PROTOCOL.inspect}",
+          hint: version_hint_for(raw["version"]),
+        )
       end
 
       new(root, raw)
@@ -45,16 +79,18 @@ module Textus
       @raw = raw
       raise BadFrontmatter.new(File.join(root, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
 
+      Schema.validate!(raw)
+
       @entries = Array(raw["entries"]).map { |e| Manifest::Entry.new(self, e) }
       validate_declared_keys!
     end
 
-    def policies
-      @policies ||= Textus::Manifest::Policies.parse(@raw["policies"] || [])
+    def rules
+      @rules ||= Textus::Manifest::Rules.parse(@raw["rules"] || [])
     end
 
-    def policies_for(key)
-      policies.for(key)
+    def rules_for(key)
+      rules.for(key)
     end
 
     # Returns [Manifest::Entry, resolved_path, remaining_segments]
@@ -76,8 +112,12 @@ module Textus
       else
         raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless entry.nested
 
-        primary_ext = Textus::Entry.for_format(entry.format).extensions.first
-        path = File.join(@root, "zones", entry.path, *remaining) + primary_ext
+        path = if entry.index_filename
+                 File.join(@root, "zones", entry.path, *remaining, entry.index_filename)
+               else
+                 primary_ext = Textus::Entry.for_format(entry.format).extensions.first
+                 File.join(@root, "zones", entry.path, *remaining) + primary_ext
+               end
         [entry, path, remaining]
       end
     end
@@ -96,39 +136,11 @@ module Textus
 
     # Enumerate all entry files reachable through the manifest. Returns
     # [{ key:, path:, manifest_entry: }, ...]
-    # rubocop:disable Metrics/AbcSize
     def enumerate(prefix: nil)
-      out = []
-      @entries.each do |entry|
-        if entry.nested
-          base = File.join(@root, "zones", entry.path)
-          next unless File.directory?(base)
-
-          glob_pattern = nested_glob(entry.format)
-          Dir.glob(File.join(base, glob_pattern)).each do |fp|
-            rel = fp.sub(%r{\A#{Regexp.escape(base)}/?}, "")
-            stripped = rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "")
-            segs = stripped.split("/").reject(&:empty?)
-            next if segs.empty?
-
-            illegal = segs.find { |s| !valid_segment?(s) }
-            if illegal
-              warn("textus: skipping illegal key segment '#{illegal}' at #{fp} — run 'textus key migrate --dry-run'")
-              next
-            end
-
-            full_key = (entry.key.split(".") + segs).join(".")
-            out << { key: full_key, path: fp, manifest_entry: entry }
-          end
-        else
-          fp = resolve_leaf_path(entry)
-          out << { key: entry.key, path: fp, manifest_entry: entry } if File.exist?(fp)
-        end
-      end
+      out = @entries.flat_map { |entry| entry.nested ? enumerate_nested(entry) : enumerate_leaf(entry) }
       out.select! { |row| row[:key] == prefix || row[:key].start_with?("#{prefix}.") } if prefix
       out.sort_by { |row| row[:key] }
     end
-    # rubocop:enable Metrics/AbcSize
 
     def validate_key!(key)
       raise UsageError.new("empty key") if key.nil? || key.empty?
@@ -138,6 +150,34 @@ module Textus
 
     private
 
+    def enumerate_leaf(entry)
+      fp = resolve_leaf_path(entry)
+      File.exist?(fp) ? [{ key: entry.key, path: fp, manifest_entry: entry }] : []
+    end
+
+    def enumerate_nested(entry)
+      base = File.join(@root, "zones", entry.path)
+      return [] unless File.directory?(base)
+
+      glob_pattern = entry.index_filename ? "**/#{entry.index_filename}" : nested_glob(entry.format)
+      Dir.glob(File.join(base, glob_pattern)).filter_map { |path| nested_row_for(entry, base, path) }
+    end
+
+    def nested_row_for(entry, base, path)
+      rel = path.sub(%r{\A#{Regexp.escape(base)}/?}, "")
+      stripped = entry.index_filename ? File.dirname(rel) : rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "")
+      segs = stripped.split("/").reject { |s| s.empty? || s == "." }
+      return nil if segs.empty?
+
+      illegal = segs.find { |s| !valid_segment?(s) }
+      if illegal
+        warn("textus: skipping illegal key segment '#{illegal}' at #{path} — run 'textus key normalize --dry-run'")
+        return nil
+      end
+
+      { key: (entry.key.split(".") + segs).join("."), path: path, manifest_entry: entry }
+    end
+
     def valid_segment?(seg)
       return false if seg.nil? || seg.empty?
       return false if seg.length > Key::Grammar::MAX_SEGMENT_LEN

data/lib/textus/migrate_keys.rb

@@ -122,7 +122,7 @@ module Textus
         File.rename(from, to)
         new_key = compute_new_key(r, renames)
         audit.append(
-          role: "script",
+          role: "runner",
           verb: "migrate-keys",
           key: new_key,
           etag_before: nil,

data/lib/textus/projection.rb

@@ -38,14 +38,14 @@ module Textus
     private
 
     def apply_reducer(rows)
-      name = @spec["reduce"] or return rows
-      callable = @store.registry.rpc_callable(:reduce, name)
+      name = @spec["transform"] or return rows
+      callable = @store.registry.rpc_callable(:transform_rows, name)
       view = Application::Context.new(store: @store, role: "human")
       Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
-        callable.call(store: view, rows: rows, config: @spec["reduce_config"] || {})
+        callable.call(store: view, rows: rows, config: @spec["transform_config"] || {})
       end
     rescue Timeout::Error
-      raise UsageError.new("reduce '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
+      raise UsageError.new("transform_rows '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
     end
 
     def collect_keys

data/lib/textus/refresh.rb

@@ -5,7 +5,7 @@ module Textus
       Textus::Composition.refresh_worker(ctx).run(key)
     end
 
-    def self.refresh_stale(store, prefix: nil, zone: nil, as: "script")
+    def self.refresh_stale(store, prefix: nil, zone: nil, as: "runner")
       ctx = Textus::Composition.context(store, role: as)
       Textus::Application::Refresh::All.call(ctx, prefix: prefix, zone: zone)
     end

data/lib/textus/store/mover.rb

@@ -2,8 +2,12 @@ require "fileutils"
 
 module Textus
   class Store
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     class Mover
+      MovePlan = Data.define(
+        :old_key, :new_key, :old_path, :new_path,
+        :new_mentry, :uid, :etag_before, :as
+      )
+
       def initialize(store:, reader:, writer:, manifest:, audit_log:)
         @store = store
         @reader = reader
@@ -13,6 +17,22 @@ module Textus
       end
 
       def call(old_key, new_key, as: Role::DEFAULT, dry_run: false, correlation_id: nil)
+        plan, pre_env = prepare_plan(old_key, new_key, as: as)
+        return dry_run_result(plan) 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, correlation_id: correlation_id)
+        success_result(plan, new_envelope: new_envelope)
+      end
+
+      private
+
+      # Validates inputs, resolves manifest entries, and reads the source
+      # envelope. Returns [MovePlan, pre_envelope]; the pre_envelope is only
+      # needed by ensure_uid! and is threaded separately to keep MovePlan
+      # focused on the planned operation.
+      def prepare_plan(old_key, new_key, as:)
         @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
@@ -21,81 +41,103 @@ module Textus
         raise UnknownKey.new(old_key) unless File.exist?(old_path)
 
         new_mentry, new_path, = @manifest.resolve(new_key)
+        validate_zone_and_format!(old_mentry, new_mentry)
+        validate_writer!(old_mentry, old_key, as)
+        raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_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"], as: as
+        )
+        [plan, pre_env]
+      end
+
+      def validate_zone_and_format!(old_mentry, new_mentry)
         if old_mentry.zone != new_mentry.zone
           raise UsageError.new(
             "mv: cross-zone move refused (#{old_mentry.zone} → #{new_mentry.zone}). " \
             "Use put+delete for cross-zone moves.",
           )
         end
-        if old_mentry.format != new_mentry.format
-          raise UsageError.new(
-            "mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.",
-          )
-        end
+        return if old_mentry.format == new_mentry.format
 
-        writers = @manifest.zone_writers(old_mentry.zone)
-        raise WriteForbidden.new(old_key, old_mentry.zone, writers: writers) unless writers.include?(as)
+        raise UsageError.new(
+          "mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.",
+        )
+      end
 
-        raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_path)
+      def validate_writer!(mentry, key, as)
+        writers = @manifest.zone_writers(mentry.zone)
+        return if writers.include?(as)
 
-        # Mint uid before the move so the audit row carries it.
-        pre_env = @reader.get(old_key)
-        current_uid = pre_env["uid"]
-        etag_before = pre_env["etag"]
-
-        if dry_run
-          return {
-            "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-            "from_key" => old_key, "to_key" => new_key,
-            "from_path" => old_path, "to_path" => new_path,
-            "uid" => current_uid
-          }
-        end
+        raise WriteForbidden.new(key, mentry.zone, writers: writers)
+      end
 
-        if current_uid.nil?
-          # Write the uid in place first so the source file carries it before mv.
-          pre_env = @writer.put(old_key,
-                                meta: pre_env["_meta"],
-                                body: pre_env["body"],
-                                content: pre_env["content"],
-                                as: as,
-                                suppress_events: true)
-          current_uid = pre_env["uid"]
-          etag_before = pre_env["etag"]
-        end
+      def ensure_uid!(plan, pre_env:)
+        return plan if plan.uid
 
-        FileUtils.mkdir_p(File.dirname(new_path))
-        FileUtils.mv(old_path, new_path)
-        rewrite_name_for_mv!(new_mentry, new_path, new_key)
-        etag_after = Etag.for_file(new_path)
+        env = @writer.put(
+          plan.old_key,
+          meta: pre_env["_meta"],
+          body: pre_env["body"],
+          content: pre_env["content"],
+          as: plan.as,
+          suppress_events: true,
+        )
+        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)
+      end
 
+      def record_move(plan, etag_after:, correlation_id:)
         extras = {
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_path, "to_path" => new_path,
-          "uid" => current_uid
+          "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"] = correlation_id if correlation_id
 
         @audit_log.append(
-          role: as, verb: "mv", key: new_key,
-          etag_before: etag_before, etag_after: etag_after,
+          role: plan.as, verb: "mv", key: plan.new_key,
+          etag_before: plan.etag_before, etag_after: etag_after,
           extras: extras
         )
+        new_envelope = @reader.get(plan.new_key)
+        @store.fire_event(
+          :entry_renamed,
+          key: plan.new_key, from_key: plan.old_key, to_key: plan.new_key,
+          envelope: new_envelope
+        )
+        new_envelope
+      end
+
+      def dry_run_result(plan)
+        {
+          "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
+        }
+      end
 
-        new_envelope = @reader.get(new_key)
-        @store.fire_event(:mv, key: new_key, from_key: old_key, to_key: new_key, envelope: new_envelope)
+      def success_result(plan, new_envelope:)
         {
           "protocol" => PROTOCOL, "ok" => true,
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_path, "to_path" => new_path,
-          "uid" => current_uid,
+          "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
         }
       end
 
-      private
-
       # If the moved file carries a `name:` field (markdown) or `_meta.name`
       # (json/yaml), rewrite it to the new basename so enforce_name_match! stays
       # happy on the next read. Only touches the bytes when name actually changes.
@@ -121,6 +163,5 @@ module Textus
         end
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
   end
 end