textus 0.55.1 → 0.55.2

data/lib/textus/action/enqueue.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Enqueue < Base
-      verb :enqueue
-      summary "Push a registered job type onto the convergence queue, to be run by drain/serve."
-      surfaces :cli, :mcp
-      cli "enqueue"
-      arg :type, String, required: true, positional: true,
-                         description: "registered job type (e.g. materialize, re-pull, sweep)"
-      arg :args, Hash, default: {},
-                       description: "type-specific arguments (e.g. { key: ... } or { scope: ... })"
-
-      def self.call(container:, call:, type:, args: {})
-        action_class = Textus::Jobs.fetch(type.to_s)
-
-        if action_class.const_defined?(:REQUIRED_ROLE) && call.role != action_class::REQUIRED_ROLE
-          return Failure(code: :forbidden,
-                         message: "role '#{call.role}' is not authorized to enqueue this job type",
-                         details: { "role" => call.role, "required_role" => action_class::REQUIRED_ROLE })
-        end
-
-        job = Textus::Store::Jobs::Queue::Job.new(
-          type: type,
-          args: args,
-          role: call.role,
-          max_attempts: 3,
-        )
-        Textus::Store::Jobs::Queue.new(store: container.job_store).enqueue(job)
-        Success({ "protocol" => Textus::PROTOCOL, "ok" => true, "id" => job.id })
-      rescue Textus::UsageError
-        Failure(code: :usage_error, message: "unregistered job type '#{type}'")
-      end
-    end
-  end
-end

data/lib/textus/action/get.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Get < Base
-      verb :get
-      summary "Read one entry - a pure on-disk read annotated with a freshness " \
-              "verdict; never ingests (quarantine freshness is drain + hook " \
-              "only, ADR 0089). Returns the envelope (uid, etag, _meta, body, " \
-              "freshness)."
-      surfaces :cli, :mcp
-      arg :key, String, required: true, positional: true,
-                        description: "dotted entry key to read, e.g. 'knowledge.project'"
-      view(:default) { |v, _i| v&.to_h_for_wire }
-
-      def self.call(container:, call:, key:)
-        envelope = container.compositor.read(key)
-        return Failure(code: :not_found, message: "no entry at #{key}") unless envelope
-
-        entry = container.manifest.resolver.resolve(key).entry
-        file_stat = Textus::Port::Storage::FileStat.new
-        Success(envelope.with(freshness: freshness_evaluator(container, call, file_stat).verdict(entry)))
-      end
-
-      def self.freshness_evaluator(container, call, file_stat)
-        Textus::Core::Freshness::Evaluator.new(
-          manifest: container.manifest,
-          file_stat: file_stat,
-          clock: call,
-        )
-      end
-    end
-  end
-end

data/lib/textus/action/ingest.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "date"
-require "digest"
-
-module Textus
-  module Action
-    class Ingest < Base
-      verb :ingest
-      summary "Capture external source material into the raw lane. Write-once, agent-owned."
-      surfaces :cli, :mcp
-      arg :kind,  String, required: true, positional: true,
-                          description: "source kind: url | file | asset"
-      arg :slug,  String, required: true,
-                          description: "human slug for the key suffix (kebab-case)"
-      arg :url,   String, description: "remote URL (required when kind=url)"
-      arg :path,  String, description: "local file path (required when kind=file or kind=asset)"
-      arg :zone,  String, description: "asset group subdirectory (required when kind=asset)"
-      arg :label, String, description: "human label stored in source.label"
-      view { |env| { "key" => env.key, "uid" => env.uid, "etag" => env.etag } }
-
-      SOURCE_KINDS = %w[url file asset].freeze
-      CONTENT_HASH_ALGO = "sha256"
-      TOMBSTONE_RETAIN = %w[ingested_at].freeze
-
-      def self.call(container:, call:, kind:, slug:, url: nil, path: nil, zone: nil, label: nil, **) # rubocop:disable Metrics/ParameterLists
-        validation = validate_inputs(kind:, url:, path:, zone:)
-        return validation if validation.is_a?(Dry::Monads::Result::Failure)
-
-        now = Time.now.utc
-        key = derive_key(now, kind:, slug:)
-
-        content_hash = compute_content_hash(kind:, url:, path:)
-        writer = Textus::Store::Envelope::Writer.from(container: container, call: call)
-        mentry = container.manifest.resolver.resolve(key).entry
-        ts = now.iso8601
-        structured = build_structured(ts, container, now, content_hash, kind:, url:, path:, label:, zone:)
-
-        store = container.job_store
-        index = Textus::Store::Index::Lookup.new(store: store)
-        duplicate_key = find_duplicate(index, content_hash, kind:, url:)
-
-        result = if duplicate_key && duplicate_key != key
-                   supersede_entry(duplicate_key, key, structured, container, call, store: store, kind:, zone:)
-                 else
-                   env = write_raw_entry(key, structured, mentry, writer)
-                   rebuild_index(container, store)
-                   env
-                 end
-        Success(result)
-      end
-
-      def self.validate_inputs(kind:, url:, path:, zone:)
-        unless SOURCE_KINDS.include?(kind)
-          return Failure(code: :usage_error,
-                         message: "ingest kind must be one of #{SOURCE_KINDS.join("|")}, got #{kind.inspect}")
-        end
-        case kind
-        when "url"
-          return Failure(code: :usage_error, message: "ingest url requires --url") unless url
-        when "file"
-          return Failure(code: :usage_error, message: "ingest file requires --path") unless path
-        when "asset"
-          return Failure(code: :usage_error, message: "ingest asset requires --path") unless path
-          return Failure(code: :usage_error, message: "ingest asset requires --zone") unless zone
-        end
-        nil
-      end
-
-      # Key derivation for Gate pre-dispatch auth. Must match the runtime
-      # derivation in #call so the same key is checked by auth and used by
-      # the action body.
-      def self.dispatch_key(kind:, slug:, **)
-        derive_key(Time.now.utc, kind:, slug:)
-      end
-
-      def self.derive_key(now, kind:, slug:)
-        date = now.strftime("%Y.%m.%d")
-        "raw.#{date}.#{kind}-#{slug}"
-      end
-
-      def self.compute_content_hash(kind:, url:, path:)
-        digest = Digest::SHA256.new
-        case kind
-        when "url"
-          digest.update(url)
-        when "file", "asset"
-          digest.file(path)
-        end
-        "#{CONTENT_HASH_ALGO}:#{digest.hexdigest}"
-      end
-
-      def self.build_structured(timestamp, container, now, content_hash, kind:, url:, path:, label:, zone:) # rubocop:disable Metrics/ParameterLists
-        base = { "ingested_at" => timestamp, "content_hash" => content_hash }
-        case kind
-        when "url"
-          base.merge("source" => { "kind" => "url", "url" => url, "label" => label || url },
-                     "body" => nil)
-        when "file"
-          body_content = File.read(path)
-          base.merge("source" => { "kind" => "file", "path" => path,
-                                   "label" => label || File.basename(path) },
-                     "body" => body_content)
-        when "asset"
-          asset_rel = copy_asset_file(container, now, path:, zone:)
-          base.merge("source" => { "kind" => "asset",
-                                   "label" => label || File.basename(path) },
-                     "asset" => asset_rel,
-                     "body" => nil)
-        end
-      end
-
-      def self.write_raw_entry(key, structured, mentry, writer)
-        writer.put(key, mentry: mentry,
-                        payload: Textus::Store::Envelope::Writer::Payload.new(
-                          meta: nil, body: nil, content: structured,
-                        ))
-      end
-
-      def self.find_duplicate(index, content_hash, kind:, url:)
-        dup = index.find_by_hash(content_hash)
-        return dup if dup
-
-        return unless kind == "url"
-
-        index.find_by_url(url)
-      end
-
-      def self.rebuild_index(container, store)
-        Textus::Store::Index::Builder.new(store: store).rebuild!(resolver: container.manifest.resolver)
-      end
-
-      def self.supersede_entry(old_key, new_key, structured, container, call, store:, kind:, zone:) # rubocop:disable Metrics/ParameterLists
-        old_mentry = container.manifest.resolver.resolve(old_key).entry
-        writer = Textus::Store::Envelope::Writer.from(container: container, call: call)
-
-        reader = Textus::Store::Envelope::Reader.from(container: container)
-        old_env = reader.read(old_key)
-        old_content = old_env&.content || {}
-        tombstone = {}
-        TOMBSTONE_RETAIN.each do |k|
-          tombstone[k] = old_content[k] if old_content.key?(k)
-        end
-        source_kind = old_content.dig("source", "kind")
-        tombstone["source"] = { "kind" => source_kind } if source_kind
-        tombstone["superseded_by"] = new_key
-
-        writer.put(old_key, mentry: old_mentry,
-                            payload: Textus::Store::Envelope::Writer::Payload.new(
-                              meta: nil, body: nil, content: tombstone,
-                            ))
-
-        structured["supersedes"] = old_key
-        env = write_raw_entry(new_key, structured, container.manifest.resolver.resolve(new_key).entry, writer)
-
-        move_asset_file(container, old_content["asset"], zone:) if kind == "asset" && old_content["asset"]
-
-        rebuild_index(container, store)
-        env
-      end
-
-      def self.move_asset_file(container, old_asset_rel, zone:)
-        old_path = File.join(container.root, "assets", old_asset_rel)
-        return unless File.exist?(old_path)
-
-        now = Time.now.utc
-        date_path = now.strftime("%Y/%m/%d")
-        filename = File.basename(old_path)
-        new_dir = File.join(container.root, "assets", "raw", date_path, zone)
-        new_path = File.join(new_dir, filename)
-
-        return if old_path == new_path
-
-        FileUtils.mkdir_p(new_dir)
-        FileUtils.mv(old_path, new_path)
-      rescue Errno::ENOENT, Errno::EACCES => e
-        warn "[textus ingest] could not move asset #{old_asset_rel}: #{e.message}"
-      end
-
-      def self.copy_asset_file(container, now, path:, zone:)
-        date_path = now.strftime("%Y/%m/%d")
-        filename  = File.basename(path)
-        assets_dir = File.join(container.root, "assets", "raw", date_path, zone)
-        FileUtils.mkdir_p(assets_dir)
-        FileUtils.cp(path, File.join(assets_dir, filename))
-        create_gitignore_sentinel(container)
-        "raw/#{date_path}/#{zone}/#{filename}"
-      end
-
-      def self.create_gitignore_sentinel(container)
-        assets_root = File.join(container.root, "assets")
-        FileUtils.mkdir_p(assets_root)
-        sentinel = File.join(assets_root, ".gitignore")
-        File.write(sentinel, "*\n") unless File.exist?(sentinel)
-      end
-    end
-  end
-end

data/lib/textus/action/jobs.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Jobs < Base
-      verb :jobs
-      summary "List queued jobs by state; retry a dead-lettered job or purge a state."
-      surfaces :cli, :mcp
-      cli "jobs"
-      arg :state, String, default: "ready", description: "ready|leased|done|failed"
-      arg :action, String, default: nil, description: "retry|purge (optional)"
-      arg :job_id, String, default: nil, description: "job id (required for action=retry)"
-
-      def self.call(container:, call:, state: "ready", action: nil, job_id: nil) # rubocop:disable Lint/UnusedMethodArgument
-        queue = Textus::Store::Jobs::Queue.new(store: container.job_store)
-        case action
-        when "retry"
-          queue.retry_failed(job_id)
-        when "purge"
-          queue.purge(state)
-        end
-
-        Success({ "protocol" => Textus::PROTOCOL, "ok" => true, "state" => state, "jobs" => queue.list(state) })
-      end
-    end
-  end
-end

data/lib/textus/action/key_delete.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class KeyDelete < Base
-      verb :key_delete
-      summary "Delete one entry by key. Single-key, lower blast radius than key_delete_prefix; " \
-              "guarded by an optional optimistic-concurrency etag. Returns {ok, key, deleted}."
-      surfaces :cli, :mcp
-      cli "key delete"
-      arg :key, String, required: true, positional: true,
-                        description: "dotted entry key to delete"
-      arg :if_etag, String,
-          description: "optimistic-concurrency guard: the etag you last read; the delete is rejected if the entry changed since"
-
-      def self.call(container:, call:, key:, if_etag: nil)
-        Textus::Manifest::Data.validate_key!(key)
-        mentry = container.manifest.resolver.resolve(key).entry
-
-        container.compositor.delete(key, mentry: mentry, if_etag: if_etag, call: call)
-
-        Success({ "protocol" => Textus::PROTOCOL, "ok" => true, "key" => key, "deleted" => true })
-      end
-    end
-  end
-end

data/lib/textus/action/key_delete_prefix.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class KeyDeletePrefix < Base
-      verb :key_delete_prefix
-      summary "Bulk-delete every leaf key under prefix."
-      surfaces :cli, :mcp
-      cli "key delete-prefix"
-      arg :prefix, String, required: true, positional: true,
-                           description: "every leaf key under this dotted prefix is deleted"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the keys that would be deleted without deleting them; " \
-                                           "defaults to false, so omitting it deletes immediately"
-      view { |v, _i| v.to_h }
-
-      def self.call(container:, call:, prefix:, dry_run: false)
-        return Failure(code: :usage_error, message: "prefix required") if prefix.nil? || prefix.empty?
-
-        leaves = Textus::Action::List.leaf_keys(container: container, prefix: prefix)
-
-        warnings = leaves.empty? ? ["no keys under #{prefix}"] : []
-        steps = leaves.map { |key| { "op" => "delete", "key" => key } }
-
-        plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: warnings)
-        return Success(plan) if dry_run
-
-        steps.each do |step|
-          Value::Result.unwrap(Textus::Action::KeyDelete.call(container: container, call: call, key: step["key"]))
-        end
-        Success(plan)
-      end
-    end
-  end
-end

data/lib/textus/action/key_mv.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class KeyMv < Base
-      verb :key_mv
-      summary "Rename one entry (same zone + format). Refuses if the target exists. Single-key, lower blast radius than key_mv_prefix."
-      surfaces :cli, :mcp
-      cli "key mv"
-      arg :old_key, String, required: true, positional: true,
-                            description: "current dotted key"
-      arg :new_key, String, required: true, positional: true,
-                            description: "new dotted key (must be the same zone and format as old_key)"
-      arg :dry_run, :boolean,
-          description: "when true, returns the planned move (from/to paths, uid) without applying it; " \
-                       "defaults to false, so omitting it applies the move immediately " \
-                       "(unlike the bulk key_mv_prefix, which defaults to a dry-run plan)"
-
-      def self.call(container:, call:, old_key:, new_key:, dry_run: false)
-        execute_move(container: container, call: call, old_key: old_key, new_key: new_key, dry_run: dry_run)
-      end
-
-      def self.execute_move(container:, call:, old_key:, new_key:, dry_run:)
-        prepared = prepare(container: container, old_key: old_key, new_key: new_key)
-        return prepared if prepared.is_a?(Dry::Monads::Result::Failure)
-
-        old_res, new_res = prepared
-        if dry_run
-          return Success(dry_run_result(container: container, old_key: old_key, new_key: new_key, old_res: old_res,
-                                        new_res: new_res))
-        end
-
-        envelope = apply_move(container: container, call: call, old_key: old_key, new_key: new_key, old_res: old_res, new_res: new_res)
-        Success(success_result(old_key: old_key, new_key: new_key, old_res: old_res, new_res: new_res, envelope: envelope))
-      end
-
-      def self.apply_move(container:, call:, old_key:, new_key:, old_res:, new_res:)
-        ensure_uid!(container: container, call: call, old_key: old_key, old_mentry: old_res.entry)
-        container.compositor.move(
-          from_key: old_key,
-          to_key: new_key,
-          new_mentry: new_res.entry,
-          call: call,
-        )
-      end
-
-      def self.success_result(old_key:, new_key:, old_res:, new_res:, envelope:)
-        {
-          "protocol" => Textus::PROTOCOL,
-          "ok" => true,
-          "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 self.prepare(container:, old_key:, new_key:)
-        Textus::Manifest::Data.validate_key!(old_key)
-        Textus::Manifest::Data.validate_key!(new_key)
-        return Failure(code: :usage_error, message: "mv: old and new keys are identical") if old_key == new_key
-
-        old_res = container.manifest.resolver.resolve(old_key)
-        new_res = container.manifest.resolver.resolve(new_key)
-        return Failure(code: :not_found, message: "source key '#{old_key}' not found") unless container.compositor.exists?(old_key)
-
-        zone_check = validate_zone_and_format(old_mentry: old_res.entry, new_mentry: new_res.entry)
-        return zone_check if zone_check.is_a?(Dry::Monads::Result::Failure)
-
-        if container.compositor.exists?(new_key)
-          return Failure(code: :usage_error, message: "mv: target '#{new_key}' already exists at #{new_res.path}")
-        end
-
-        [old_res, new_res]
-      end
-
-      def self.validate_zone_and_format(old_mentry:, new_mentry:)
-        if old_mentry.lane != new_mentry.lane
-          return Failure(code: :usage_error,
-                         message: "mv: cross-zone move refused (#{old_mentry.lane} -> #{new_mentry.lane}). " \
-                                  "Use put+delete for cross-zone moves.")
-        end
-        return unless old_mentry.format != new_mentry.format
-
-        Failure(code: :usage_error,
-                message: "mv: format mismatch (#{old_mentry.format} -> #{new_mentry.format}); refusing.")
-      end
-
-      def self.ensure_uid!(container:, call:, old_key:, old_mentry:)
-        pre_env = container.compositor.read(old_key)
-        return if pre_env.uid
-
-        container.compositor.write(
-          old_key,
-          mentry: old_mentry,
-          payload: Textus::Store::Envelope::Writer::Payload.new(
-            meta: pre_env.meta,
-            body: pre_env.body,
-            content: pre_env.content,
-          ),
-          call: call,
-        )
-      end
-
-      def self.dry_run_result(container:, old_key:, new_key:, old_res:, new_res:)
-        pre_env = container.compositor.read(old_key)
-        {
-          "protocol" => Textus::PROTOCOL,
-          "ok" => true,
-          "dry_run" => true,
-          "from_key" => old_key,
-          "to_key" => new_key,
-          "from_path" => old_res.path,
-          "to_path" => new_res.path,
-          "uid" => pre_env.uid,
-        }
-      end
-    end
-  end
-end

data/lib/textus/action/key_mv_prefix.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class KeyMvPrefix < Base
-      verb :key_mv_prefix
-      summary "Bulk-rename every leaf key under from_prefix to to_prefix. Dry-run returns a Plan; apply with dry_run: false."
-      surfaces :cli, :mcp
-      cli "key mv-prefix"
-      arg :from_prefix, String, required: true, positional: true,
-                                description: "dotted prefix whose leaf keys are renamed"
-      arg :to_prefix, String, required: true, positional: true,
-                              description: "dotted prefix the keys are renamed to"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the planned moves without applying them; defaults " \
-                                           "to false, so omitting it applies the rename immediately"
-      view { |v, _i| v.to_h }
-
-      def self.call(container:, call:, from_prefix:, to_prefix:, dry_run: false)
-        return Failure(code: :usage_error, message: "from_prefix and to_prefix required") if from_prefix.nil? || to_prefix.nil?
-
-        leaves = Textus::Action::List.leaf_keys(container: container, prefix: from_prefix)
-
-        if leaves.include?(from_prefix)
-          return Failure(code: :usage_error,
-                         message: "from_prefix '#{from_prefix}' is itself a leaf — use `mv` to rename a single key")
-        end
-
-        warnings = []
-        warnings << "no keys under #{from_prefix}" if leaves.empty?
-
-        steps = leaves.map do |old_key|
-          tail = old_key.delete_prefix("#{from_prefix}.")
-          new_key = "#{to_prefix}.#{tail}"
-          { "op" => "mv", "from" => old_key, "to" => new_key }
-        end
-
-        plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: warnings)
-        return Success(plan) if dry_run
-
-        steps.each do |step|
-          Value::Result.unwrap(Textus::Action::KeyMv.call(container: container, call: call, old_key: step["from"], new_key: step["to"]))
-        end
-        Success(plan)
-      end
-    end
-  end
-end

data/lib/textus/action/list.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class List < Base
-      verb :list
-      summary "List keys filtered by lane and/or prefix."
-      surfaces :cli, :mcp
-      arg :prefix, String,
-          description: "restrict to keys starting with this dotted prefix, e.g. 'knowledge.runbooks'"
-      arg :lane, String,
-          description: "restrict to one lane by name (see `boot` lanes); combine with prefix to narrow further"
-      view(:cli) { |rows| { "entries" => rows } }
-
-      def self.call(container:, call: nil, prefix: nil, lane: nil) # rubocop:disable Lint/UnusedMethodArgument
-        manifest = container.manifest
-        rows = manifest.resolver.enumerate(prefix: prefix)
-        rows = rows.select { |row| row[:manifest_entry].lane == lane } if lane
-        Success(rows.map { |row| { "key" => row[:key], "lane" => row[:manifest_entry].lane, "path" => row[:path] } })
-      end
-
-      def self.leaf_keys(container:, prefix: nil, lane: nil)
-        rows = Value::Result.unwrap(call(container: container, prefix: prefix, lane: lane))
-        rows.map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
-      end
-    end
-  end
-end

data/lib/textus/action/propose.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Propose < Base
-      verb :propose
-      summary "Write a proposal to the role's propose_lane. Auto-prefixes the key."
-      surfaces :cli, :mcp
-      cli_stdin :json
-      arg :key, String, required: true, positional: true,
-                        description: "key relative to propose_lane, e.g. 'decisions.feature-x'"
-      arg :meta, Hash, required: false, wire_name: :_meta,
-                       description: "frontmatter; reads back as `_meta` from `get`. Include a 'proposal:' block naming the target_key"
-      arg :body, String,
-          description: "markdown/text payload for markdown-format entries; omit (use `content`) for json/yaml entries. Do not send both"
-      arg :content, Hash,
-          description: "structured payload for json/yaml-format entries; omit (use `body`) for markdown entries. Do not send both"
-      view { |env, _i| env.to_h_for_wire }
-
-      def self.call(container:, call:, key:, meta: nil, body: nil, content: nil)
-        zone = container.manifest.policy.propose_lane_for(call.role)
-        unless zone
-          return Failure(code: :propose_forbidden,
-                         message: "role '#{call.role}' has no writable propose_lane",
-                         details: { "role" => call.role })
-        end
-
-        mentry = container.manifest.resolver.resolve("#{zone}.#{key}").entry
-        Success(container.compositor.write(
-                  "#{zone}.#{key}",
-                  mentry: mentry,
-                  payload: Textus::Store::Envelope::Writer::Payload.new(
-                    meta: meta || {},
-                    body: body,
-                    content: content,
-                  ),
-                  call: call,
-                ))
-      end
-    end
-  end
-end

data/lib/textus/action/published.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Published < Base
-      verb :published
-      summary "List all entries that declare a publish_to target."
-      surfaces :cli
-      cli "published"
-
-      def args
-        {}
-      end
-
-      def self.call(container:, **)
-        Success(container.manifest.data.entries.reject { |entry| entry.publish_to.empty? }.map do |entry|
-          { "key" => entry.key, "publish_to" => entry.publish_to }
-        end)
-      end
-    end
-  end
-end

data/lib/textus/action/pulse.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module Textus
-  module Action
-    class Pulse < Base
-      verb :pulse
-      summary "Delta since cursor — changed entries, pending proposals, index freshness."
-      surfaces :cli, :mcp
-      arg :since, Integer, session_default: :cursor,
-                           description: "audit seq to diff from; defaults to the session cursor"
-
-      def self.call(container:, call:, since: nil, **)
-        manifest = container.manifest
-        audit_log = container.audit_log
-        root = container.root
-        since ||= Textus::Store::Cursor.new(root: root, role: call.role).read
-
-        changed = Value::Result.unwrap(Textus::Action::Audit.call(container: container, seq_since: since))
-
-        result = {
-          "cursor" => audit_log.latest_seq,
-          "changed" => changed,
-          "pending_review" => review_keys(manifest, container),
-          "contract_etag" => Textus::Value::Etag.for_contract(root),
-          "index_etag" => index_etag(container),
-        }
-
-        Textus::Store::Cursor.new(root: root, role: call.role).write(result["cursor"])
-        Success(result)
-      end
-
-      def self.review_keys(manifest, container)
-        queue = manifest.policy.queue_lane
-        return [] unless queue
-
-        Textus::Action::List.leaf_keys(container: container, lane: queue)
-      end
-
-      def self.index_etag(container)
-        path = container.manifest.resolver.resolve("artifacts.system.index").path
-        File.exist?(path) ? container.file_store.etag(path) : nil
-      rescue Textus::Error
-        nil
-      end
-    end
-  end
-end