textus 0.55.1 → 0.56.0

data/lib/textus/protocol/store_engine/put.rb

@@ -0,0 +1,104 @@
+module Textus
+  module Protocol
+    class StoreEngine
+      module Put
+        module_function
+
+        def call(key, mentry:, path:, payload:, deps:, if_etag: nil, fmt: nil)
+          format = fmt || mentry.format
+
+          validate_input(key, payload, format, mentry, path)
+          validate_schema(payload, mentry, deps)
+
+          existing_env = read_existing(key, mentry, path, format, deps)
+          meta, content = inject_meta(payload, existing_env, format, deps)
+          bytes, eff_meta, eff_body, eff_content = serialize(payload, meta, content, path, format)
+
+          etag_before = Pipeline.check_etag(key, path, if_etag, deps.file_system)
+          deps.file_system.write(path, bytes)
+          envelope = Envelope.build(
+            key:, mentry:, path:,
+            meta: eff_meta, body: eff_body,
+            etag: Value::Etag.for_bytes(bytes),
+            content: eff_content
+          )
+
+          append_audit(key, etag_before, envelope, deps)
+          index_entry(key, mentry, format, eff_body, eff_content, deps)
+          Pipeline.emit_event(deps, event_type: "entry.written",
+                                    pending_key: key, emit_key: key,
+                                    emit_lane: mentry.lane)
+          envelope
+        end
+
+        def validate_input(key, payload, format, mentry, path)
+          EntryConstraint.validate_naming!(key, mentry)
+          fmt = Format.for(format)
+          fmt.enforce_name_match!(path, payload.meta)
+          fmt.validate_raw_entry!(
+            { "_meta" => payload.meta, "content" => payload.content },
+            mentry.lane,
+          )
+        end
+
+        def validate_schema(payload, mentry, deps)
+          EntryConstraint.validate_schema!(payload, mentry, schemas: deps.schemas)
+        end
+
+        def read_existing(key, mentry, path, format, deps)
+          return nil unless path && deps.file_system.exists?(path)
+
+          raw = deps.file_system.read(path)
+          parsed = Format.for(format).parse(raw, path:)
+          Envelope.build(
+            key:, mentry:, path:,
+            meta: parsed["_meta"] || {},
+            body: parsed["body"] || "",
+            content: parsed["content"],
+            etag: Value::Etag.for_file(path)
+          )
+        end
+
+        def inject_meta(payload, existing_env, format, deps)
+          existing_meta = existing_env ? existing_env.meta : {}
+          Infra::Store::Envelope::Meta.inject_all(
+            payload.meta || {}, payload.content, existing_meta,
+            format:,
+            etag_for: method(:etag_for_key).curry.call(deps)
+          )
+        end
+
+        def etag_for_key(deps, key)
+          path = deps.manifest.resolver.resolve(key).path
+          return nil unless deps.file_system.exists?(path)
+
+          Value::Etag.for_file(path)
+        rescue Textus::Error
+          nil
+        end
+
+        def serialize(payload, meta, content, path, format)
+          Format.for(format).serialize_for_put(
+            meta:, body: payload.body, content:, path:,
+          )
+        end
+
+        def append_audit(key, etag_before, envelope, deps)
+          deps.audit_log.append(
+            role: deps.call.role, verb: "put", key:,
+            etag_before:, etag_after: envelope.etag,
+            correlation_id: deps.call.correlation_id
+          )
+        end
+
+        def index_entry(key, mentry, format, eff_body, eff_content, deps)
+          content = eff_content ? eff_content.to_json : eff_body
+          deps.entry_index.record(
+            key:, lane: mentry.lane, format:,
+            schema: mentry.schema, content:
+          )
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/store_engine.rb

@@ -0,0 +1,86 @@
+module Textus
+  module Protocol
+    class StoreEngine
+      def initialize(file_system:, manifest:, layout:, store:, event_emitter: nil, schemas: nil)
+        @file_system = file_system
+        @manifest = manifest
+        @layout = layout
+        @store = store
+        @event_emitter = event_emitter
+        @schemas = schemas
+      end
+
+      def read(key:)
+        result = resolve(key:)
+        path = result.path
+        return nil unless path && @file_system.exists?(path)
+
+        raw = @file_system.read(path)
+        parsed = Format.for(result.entry.format).parse(raw, path:)
+        Envelope.build(key:, mentry: result.entry, path:,
+                       meta: parsed["_meta"] || {},
+                       body: parsed["body"] || "",
+                       content: parsed["content"],
+                       etag: Value::Etag.for_file(path))
+      end
+
+      def exists?(key:)
+        path = resolve(key:).path
+        path && @file_system.exists?(path)
+      end
+
+      def list(prefix: nil, lane: nil, q: nil, schema: nil)
+        if @store.entry_index && (q || schema)
+          rows = @store.entry_index.search(query: q, schema:, lane:, prefix:)
+          (rows || []).map { |r| { "key" => r["key"], "lane" => r["lane"] } }
+        else
+          rows = @manifest.resolver.enumerate(prefix:)
+          rows = rows.select { |r| r[:manifest_entry].lane == lane } if lane
+          rows.map { |r| { "key" => r[:key], "lane" => r[:manifest_entry].lane } }
+        end
+      end
+
+      def resolve(key:)   = @manifest.resolver.resolve(key)
+      def mentry_for(key:)= resolve(key:).entry
+
+      def put(key:, meta:, body:, content:, call:, if_etag: nil, format: nil)
+        result = resolve(key:)
+        payload = Value::Payload.new(meta: meta || {}, body:, content:)
+        deps = build_deps(reader: nil, call:)
+
+        if format
+          fmt_mod = Textus::Protocol::Format.for(format)
+          path = result.path.sub(/\.[^.]+$/, "") + fmt_mod.nested_ext(result.remaining.last)
+          Put.call(key, mentry: result.entry, path:, payload:, if_etag:, deps:, fmt: format)
+        else
+          Put.call(key, mentry: result.entry, path: result.path, payload:, if_etag:, deps:)
+        end
+      end
+
+      def delete(key:, call:, if_etag: nil)
+        deps = Pipeline::DeleteDeps.new(
+          file_system: @file_system, manifest: @manifest, store: @store,
+          layout: @layout, event_emitter: @event_emitter, call:
+        )
+        Delete.call(key, if_etag:, deps:)
+      end
+
+      def move(from_key:, to_key:, call:, if_etag: nil, dry_run: false)
+        deps = Pipeline::MoveDeps.new(
+          file_system: @file_system, manifest: @manifest, store: @store,
+          layout: @layout, event_emitter: @event_emitter, reader: self, call:
+        )
+        Move.call(from_key:, to_key:, if_etag:, dry_run:, deps:)
+      end
+
+      private
+
+      def build_deps(reader:, call:)
+        Pipeline::WriteDeps.new(
+          file_system: @file_system, manifest: @manifest, store: @store,
+          layout: @layout, event_emitter: @event_emitter, schemas: @schemas, reader:, call:
+        )
+      end
+    end
+  end
+end

data/lib/textus/protocol/v4.rb

@@ -0,0 +1,25 @@
+module Textus
+  module Protocol
+    module V4
+      LANES = {
+        "knowledge" => { writers: %w[human],
+                         desc: "the maintained source of truth about the repo",
+                         retention_ttl: nil },
+        "scratchpad" => { writers: %w[human agent],
+                          desc: "the agent's own durable scratchpad (working memory)",
+                          retention_ttl: nil },
+        "artifacts" => { writers: %w[automation],
+                         desc: "machine-maintained computed outputs",
+                         retention_ttl: 3600 * 24 * 30 },
+        "raw" => { writers: %w[human agent automation],
+                   desc: "ingested external source material (write-once)",
+                   retention_ttl: nil },
+      }.freeze
+
+      NAMING_PATTERNS = {
+        "sequential" => /\A\d{4}-[a-z0-9-]+\.\w+\z/,
+        "dated" => /\A\d{4}-\d{2}-\d{2}-[a-z0-9-]+\.\w+\z/,
+      }.freeze
+    end
+  end
+end

data/lib/textus/protocol/verb_registry/arg_spec.rb

@@ -0,0 +1,19 @@
+module Textus
+  module Protocol
+    module VerbRegistry
+      ArgSpec = Data.define(
+        :name, :type, :required, :positional,
+        :description, :wire_name, :default, :source, :coerce, :cli_default
+      ) do
+        def wire = wire_name || name
+
+        def self.arg(name:, type: String, required: false, positional: false,
+                     description: nil, wire_name: nil,
+                     default: nil, source: nil, coerce: nil, cli_default: nil)
+          new(name:, type:, required:, positional:,
+              description:, wire_name:, default:, source:, coerce:, cli_default:)
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/verb_registry/core_verbs.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Textus
+  module Protocol
+    module VerbRegistry
+      CoreVerbs = {
+        audit: VerbSpec.new(
+          :audit, "Query the audit log with optional filters.",
+          [ArgSpec.arg(name: :key, description: "filter to rows for this key"),
+           ArgSpec.arg(name: :lane, description: "filter to keys in this lane"),
+           ArgSpec.arg(name: :role, description: "filter to rows written under this role"),
+           ArgSpec.arg(name: :verb, description: "filter to rows for this verb"),
+           ArgSpec.arg(name: :since, description: "ISO-8601 timestamp or relative offset (e.g. 1h, 30m)"),
+           ArgSpec.arg(name: :seq_since, type: Integer, description: "return rows with seq > this cursor value"),
+           ArgSpec.arg(name: :correlation_id, description: "filter to rows with this correlation_id"),
+           ArgSpec.arg(name: :limit, type: Integer, description: "maximum number of rows to return")],
+          %i[cli mcp], :read
+        ),
+
+        blame: VerbSpec.new(
+          :blame, "Annotate audit rows with the git commit that introduced each file state.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "entry key to blame"),
+           ArgSpec.arg(name: :limit, type: Integer, description: "maximum number of audit rows to return")],
+          %i[cli mcp], :read
+        ),
+
+        boot: VerbSpec.new(
+          :boot, "Return the orientation contract: lanes, agent_quickstart, agent_protocol.",
+          [], %i[cli mcp], :read
+        ),
+
+        data_mv: VerbSpec.new(
+          :data_mv, "Rename a data lane — manifest + files. Refuses if destination exists.",
+          [ArgSpec.arg(name: :from, required: true, positional: true, description: "current data lane name"),
+           ArgSpec.arg(name: :to, required: true, positional: true, description: "new data lane name"),
+           ArgSpec.arg(name: :dry_run, type: :boolean, default: false,
+                       description: "when true, returns planned zone move without applying")],
+          %i[cli mcp], :write
+        ),
+
+        deps: VerbSpec.new(
+          :deps, "List the keys a derived entry depends on.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted key of the derived entry whose source keys you want")],
+          %i[cli mcp], :read
+        ),
+
+        drain: VerbSpec.new(
+          :drain, "Seed materialize + sweep jobs then drain the queue to empty.",
+          [], %i[cli mcp], :maintenance
+        ),
+
+        get: VerbSpec.new(
+          :get, "Read one entry — on-disk read with freshness verdict.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted entry key to read, e.g. 'knowledge.project'")],
+          %i[cli mcp], :read
+        ),
+
+        graph: VerbSpec.new(
+          :graph, "Query the link graph — neighbors (direct links) or reachable (transitive, with optional depth limit).",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "entry key to query"),
+           ArgSpec.arg(name: :depth, type: Integer, description: "max traversal depth for reachable query (unlimited when omitted)")],
+          %i[cli mcp], :read
+        ),
+
+        ingest: VerbSpec.new(
+          verb: :ingest, summary: "Capture external source material into the raw lane. Write-once.",
+          args: [ArgSpec.arg(name: :kind, required: true, positional: true, description: "source kind: url | file | asset"),
+                 ArgSpec.arg(name: :slug, required: true, description: "human slug for the key suffix (kebab-case)"),
+                 ArgSpec.arg(name: :url, description: "remote URL (required when kind=url)"),
+                 ArgSpec.arg(name: :path, description: "local file path (required when kind=file or kind=asset)"),
+                 ArgSpec.arg(name: :lane, description: "asset group subdirectory (required when kind=asset)"),
+                 ArgSpec.arg(name: :label, description: "human label stored in source.label")],
+          surfaces: %i[cli mcp], category: :write, lane: :ingest
+        ),
+
+        key_delete: VerbSpec.new(
+          :key_delete, "Delete one entry by key. Returns {ok, key, deleted}.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted entry key to delete"),
+           ArgSpec.arg(name: :if_etag, description: "optimistic-concurrency guard: etag you last read")],
+          %i[cli mcp], :write
+        ),
+
+        key_delete_prefix: VerbSpec.new(
+          :key_delete_prefix, "Bulk-delete every leaf key under prefix.",
+          [ArgSpec.arg(name: :prefix, required: true, positional: true, description: "every leaf key under this dotted prefix is deleted"),
+           ArgSpec.arg(name: :dry_run, type: :boolean, default: false,
+                       description: "when true, returns keys that would be deleted without deleting")],
+          %i[cli mcp], :write
+        ),
+
+        key_mv: VerbSpec.new(
+          :key_mv, "Rename one entry (same zone + format). Refuses if target exists.",
+          [ArgSpec.arg(name: :old_key, required: true, positional: true, description: "current dotted key"),
+           ArgSpec.arg(name: :new_key, required: true, positional: true, description: "new dotted key (same zone and format)"),
+           ArgSpec.arg(name: :dry_run, type: :boolean, description: "when true, returns planned move without applying")],
+          %i[cli mcp], :write
+        ),
+
+        key_mv_prefix: VerbSpec.new(
+          :key_mv_prefix, "Bulk-rename every leaf key under from_prefix to to_prefix.",
+          [ArgSpec.arg(name: :from_prefix, required: true, positional: true, description: "dotted prefix whose leaf keys are renamed"),
+           ArgSpec.arg(name: :to_prefix, required: true, positional: true, description: "dotted prefix the keys are renamed to"),
+           ArgSpec.arg(name: :dry_run, type: :boolean, default: false, description: "when true, returns planned moves without applying")],
+          %i[cli mcp], :write
+        ),
+
+        list: VerbSpec.new(
+          :list, "List keys filtered by lane and/or prefix.",
+          [ArgSpec.arg(name: :prefix, description: "restrict to keys starting with this dotted prefix, e.g. 'knowledge.execution'"),
+           ArgSpec.arg(name: :lane, description: "restrict to one lane by name (see `boot` lanes)"),
+           ArgSpec.arg(name: :q, description: "full-text search query over entry content (FTS5)"),
+           ArgSpec.arg(name: :schema, description: "filter to entries whose schema matches this name")],
+          %i[cli mcp], :read
+        ),
+
+        pulse: VerbSpec.new(
+          :pulse, "Delta since cursor — changed entries, pending proposals, index freshness.",
+          [ArgSpec.arg(name: :since, type: Integer, description: "audit seq to diff from; defaults to the session cursor")],
+          %i[cli mcp], :read
+        ),
+
+        put: VerbSpec.new(
+          :put, "Create or update an entry. Schema-validated. Returns {uid, etag}.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted entry key, e.g. 'knowledge.project'; must resolve to a zone the role may write"),
+           ArgSpec.arg(name: :meta, type: Hash, wire_name: :_meta,
+                       description: "frontmatter; reads back as `_meta`. Schema-validated — call `schema KEY` first"),
+           ArgSpec.arg(name: :data, description: "unified payload — String for body (markdown/text), Hash for content (json/yaml)"),
+           ArgSpec.arg(name: :if_etag, description: "optimistic-concurrency guard; write rejected if entry changed since"),
+           ArgSpec.arg(name: :format, description: "override entry format for this write (e.g. script)")],
+          %i[cli mcp], :write
+        ),
+
+        rdeps: VerbSpec.new(
+          :rdeps, "List the derived entries that depend on a key (reverse deps).",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted key whose dependents you want")],
+          %i[cli mcp], :read
+        ),
+
+        schema_list: VerbSpec.new(
+          :schema_list, "List all registered schemas with their fields.",
+          [], %i[cli mcp], :read
+        ),
+
+        schema_show: VerbSpec.new(
+          :schema_show, "Return the schema (field shape) for an entry's family.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "any key in the family whose schema you want")],
+          %i[cli mcp], :read
+        ),
+
+        uid: VerbSpec.new(
+          :uid, "Return the stable UID of an entry without reading its body.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "entry key")],
+          %i[cli mcp], :read
+        ),
+
+        where: VerbSpec.new(
+          :where, "Resolve a key to its zone, owner, and path without reading the body.",
+          [ArgSpec.arg(name: :key, required: true, positional: true, description: "dotted key to locate")],
+          %i[cli mcp], :read
+        ),
+      }.freeze
+    end
+  end
+end

data/lib/textus/protocol/verb_registry/verb_spec.rb

@@ -0,0 +1,42 @@
+module Textus
+  module Protocol
+    module VerbRegistry
+      TYPE_MAP = {
+        String => "string", Integer => "integer", Hash => "object",
+        Array => "array", :boolean => "boolean"
+      }.freeze
+
+      SYSTEM_VERBS = %i[boot audit blame pulse drain workflow_spec].to_set.freeze
+
+      VerbSpec = Data.define(:verb, :summary, :args, :surfaces, :category) do
+        def initialize(verb:, summary:, args:, surfaces:, category:, lane: nil)
+          @lane = lane
+          super(verb:, summary:, args:, surfaces:, category:)
+        end
+
+        def lane = @lane
+        def system? = SYSTEM_VERBS.include?(verb)
+        def mcp? = surfaces.include?(:mcp)
+        def cli? = surfaces.include?(:cli)
+        def cli_path = verb.to_s.tr("_", " ")
+        def cli_words = cli_path.split
+        def cli_group = cli_words.size > 1 ? cli_words.first : nil
+        def cli_leaf  = cli_words.last
+        def required_args = args.select(&:required)
+        def read? = category == :read
+        def write? = category == :write
+        def maintenance? = category == :maintenance
+
+        def input_schema
+          props = args.to_h do |a|
+            json_type = VerbRegistry::TYPE_MAP[a.type] || "string"
+            h = { "type" => json_type }
+            h["description"] = a.description if a.description
+            [a.wire.to_s, h]
+          end
+          { type: "object", properties: props, required: required_args.map { |a| a.wire.to_s } }
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/verb_registry.rb

@@ -0,0 +1,42 @@
+module Textus
+  module Protocol
+    module VerbRegistry
+      require_relative "verb_registry/arg_spec"
+      require_relative "verb_registry/verb_spec"
+
+      VERBS = {}
+      POSITIONAL = {}
+
+      def self.register(spec)
+        VERBS[spec.verb] = spec
+        POSITIONAL[spec.verb] = spec.args.select(&:positional).map(&:name)
+      end
+
+      def self.for(verb) = VERBS[verb]
+      def self.positional_for(verb) = POSITIONAL[verb] || []
+      def self.summary_for(verb) = VERBS[verb]&.summary
+      def self.registered = VERBS.values
+
+      ENTRY_VERBS = %i[
+        get put list key_delete key_mv propose accept reject
+        audit blame where uid deps rdeps graph diff ingest loop
+        session_open session_close
+      ].freeze
+
+      OPS_VERBS = %i[
+        boot drain pulse data_mv
+        key_mv_prefix key_delete_prefix
+      ].freeze
+
+      VERB_DOMAIN = ENTRY_VERBS.to_h { |v| [v, :entry] }
+                               .merge(OPS_VERBS.to_h { |v| [v, :ops] }).freeze
+
+      require_relative "verb_registry/core_verbs"
+      CoreVerbs.each_value { |spec| register(spec) }
+
+      require_relative "../lanes/knowledge/verbs"
+      require_relative "../lanes/scratchpad/verbs"
+      require_relative "../lanes/artifact/verbs"
+    end
+  end
+end

data/lib/textus/surface/cli/group/{rule.rb → web.rb}

@@ -2,8 +2,8 @@ module Textus
   module Surface
     class CLI
       class Group
-        class Rule < Group
-          command_name "rule"
+        class Web < Group
+          command_name "web"
         end
       end
     end

data/lib/textus/surface/cli/runner.rb

@@ -13,7 +13,7 @@ module Textus
         # verb name — `spec.verb` remains the single source of dispatch.
         class Base < Verb
           class << self
-            attr_accessor :spec
+            attr_accessor :spec, :stdin_json
 
             # ADR 0064: derive the CLI command name from the contract's cli_leaf
             # when not set explicitly, so an escape-hatch class never restates its
@@ -50,17 +50,18 @@ module Textus
         module_function
 
         def dispatch(verb_instance, store, spec)
-          inputs = Textus::Gate::Binder.inputs_from_ordered(
+          inputs = Textus::Protocol::Binder.inputs_from_ordered(
             spec, verb_instance.positional, verb_instance.flag_values(spec)
           )
-          inputs = inputs.merge(Surface::CLI::Sources.from_stdin(spec, verb_instance.stdin)) if spec.cli_stdin
+          inputs = inputs.merge(Surface::CLI::Sources.from_stdin(spec, verb_instance.stdin)) if verb_instance.class.stdin_json
           inputs = Surface::CLI::Sources.acquire(spec, inputs)
           inputs = apply_cli_defaults(spec, inputs)
           role = verb_instance.resolved_role(store)
 
-          result = store.gate.dispatch(spec:, inputs:, role:, surface: :cli)
+          s = store.with_role(role)
+          result = Textus::Surface::Dispatch.call(s, spec.verb, **inputs)
           verb_instance.emit(result)
-        rescue Textus::Gate::MissingArgs => e
+        rescue Textus::Protocol::MissingArgs => e
           raise UsageError.new("#{spec.cli_path} requires #{e.missing.first.wire}")
         end
 
@@ -71,7 +72,7 @@ module Textus
         # contract, not hidden in a hand class.
         def apply_cli_defaults(spec, inputs)
           spec.args.each_with_object(inputs.dup) do |a, h|
-            next if a.cli_default == :__unset || h.key?(a.name)
+            next if a.cli_default.nil? || h.key?(a.name)
 
             h[a.name] = a.cli_default
           end
@@ -83,7 +84,7 @@ module Textus
         # polarity so a verb that applies-by-default on the CLI but plans-by-default
         # for agents (migrate, data_mv) gets a `--dry-run` flag, not `--no-dry-run`.
         def effective_default(arg)
-          arg.cli_default == :__unset ? arg.default : arg.cli_default
+          arg.cli_default.nil? ? arg.default : arg.cli_default
         end
 
         def flagspec_for(arg)
@@ -91,7 +92,7 @@ module Textus
           if arg.type == :boolean
             effective_default(arg) == true ? "--no-#{wire}" : "--#{wire}"
           else
-            "--#{wire}=VALUE"
+            "--#{wire} VALUE"
           end
         end
 
@@ -126,16 +127,7 @@ module Textus
 
         # Contract verbs whose CLI is a plain `< Verb` command, not a projection at
         # all — composite reports assembled outside the contract.
-        # (boot removed: its contract carries surfaces :cli + the :lean arg, so the
-        # generic projection now generates it; the hand-authored CLI::Verb::Boot is
-        # deleted in ADR 0101.)
-        # (doctor retained: hand-authored to preserve --check=NAME flag spelling and
-        # the exit_code: res["ok"] ? 0 : 1 behavior — two things the generic
-        # projection cannot yet express; kept in ADR 0101 pending a future pass.)
-        # (fetch/fetch_all were removed in ADR 0079: Produce::Acquire::Intake is now internal,
-        # driven by the converge sweep (drain/serve) and hook run — ADR 0089 removed the
-        # read-through that once also drove it.)
-        NON_PROJECTED_CLI = %i[doctor].freeze
+        NON_PROJECTED_CLI = %i[].freeze
 
         # The installer skips generation for either category.
         HAND_AUTHORED_VERBS = (BEHAVIORAL_HATCHES + NON_PROJECTED_CLI).freeze
@@ -144,10 +136,7 @@ module Textus
 
         def install!
           @installed ||= {}
-          Textus::Action::VERBS.each_value do |action_class|
-            next unless action_class.respond_to?(:contract?) && action_class.contract?
-
-            spec = action_class.contract
+          Textus::Protocol::VerbRegistry.registered.each do |spec|
             next unless spec.cli?
             next if hand_authored?(spec.verb)
             next if @installed[spec.verb]
@@ -157,17 +146,28 @@ module Textus
           end
         end
 
+        STDIN_VERBS = %i[propose].freeze
+        CLI_PATHS = {
+          uid: "key uid",
+          key_mv_prefix: "key mv-prefix",
+          key_delete_prefix: "key delete-prefix",
+        }.freeze
+
         def install_for(spec)
-          group = spec.cli_group ? ensure_group(spec.cli_group) : nil
-          leaf  = spec.cli_leaf
+          cli_path = CLI_PATHS[spec.verb] || spec.cli_path
+          cli_words = cli_path.split
+          group_name = cli_words.size > 1 ? cli_words.first : nil
+          group = group_name ? ensure_group(group_name) : nil
+          leaf = cli_words.last
           non_positional = spec.args.reject(&:positional)
 
           klass = Class.new(Base)
           klass.spec = spec
+          klass.stdin_json = STDIN_VERBS.include?(spec.verb)
           klass.command_name leaf
           klass.parent_group group if group
           klass.option :as_flag, "--as=ROLE"
-          klass.option :use_stdin, "--stdin" if spec.cli_stdin
+          klass.option :use_stdin, "--stdin" if klass.stdin_json
           non_positional.each { |a| klass.option a.name, Runner.flagspec_for(a) }
 
           # Anchor the anonymous class to a constant so descendants discovery is

data/lib/textus/surface/cli/sources.rb

@@ -25,10 +25,8 @@ module Textus
         # Parse a cli_stdin :json envelope into a by-name inputs hash, mapping
         # envelope keys (wire-names) to arg names.
         def from_stdin(spec, stream)
-          return {} unless spec.cli_stdin == :json
-
           raw = stream.read.to_s
-          return {} if raw.strip.empty? # no envelope piped -> required args surface as missing
+          return {} if raw.strip.empty?
 
           envelope = JSON.parse(raw)
           spec.args.each_with_object({}) do |a, h|

data/lib/textus/surface/cli/verb/get.rb

@@ -3,16 +3,13 @@ module Textus
     class CLI
       class Verb
         class Get < Runner::Base
-          self.spec = Textus::Action::Get.contract
+          self.spec = Textus::Protocol::VerbRegistry.for(:get)
           option :as_flag, "--as=ROLE"
 
           def invoke(store)
             key = positional.shift or raise UsageError.new("get requires a key")
-            spec = Textus::Action::Get.contract
-            result = store.gate.dispatch(spec: spec, inputs: { key: key }, role: resolved_role(store), surface: :cli)
-            raise Textus::UnknownKey.new(key, suggestions: store.manifest.resolver.suggestions_for(key)) if result.nil?
-
-            emit(result)
+            s = store.with_role(resolved_role(store))
+            emit(s.get(key: key))
           end
         end
       end

data/lib/textus/surface/cli/verb/init.rb

@@ -11,7 +11,7 @@ module Textus
 
           def call(_store)
             target = File.join(@cwd, ".textus")
-            emit(Textus::Init.run(target, with_agent: !!with_agent))
+            emit(Textus::Protocol::Init.run(target, with_agent: !!with_agent))
           end
         end
       end