textus 0.54.1 → 0.55.1

data/docs/architecture/README.md

@@ -6,7 +6,8 @@
 ```mermaid
 flowchart TD
     surfaces["Surfaces — CLI · MCP · RoleScope"]
-    contract["Contract — per-verb DSL (source of truth for public interfaces)"]
+    contract["Contract — per-verb DSL (Arg, Spec, DSL)"]
+    dispatch["Dispatch — Binder · Around · CommandBuilder · Dispatcher"]
     gate["Gate — routing (VERB_COMMAND) · Auth"]
     action["Actions — per-verb use cases (action/)"]
     jobs["Jobs — Worker · Planner · Materialize · Retention · Sweep"]
@@ -15,8 +16,10 @@ flowchart TD
     manifest["Manifest — declarative config, no IO (policy/, schema/, entry/)"]
     core["Core — pure value types (Freshness, Retention, Duration, Sentinel)"]
     ports["Ports — IO adapters (FileStore, AuditLog, JobStore, Publisher…)"]
-    surfaces --> contract
-    contract --> gate
+    surfaces --> dispatch
+    surfaces -.->|declare| contract
+    contract --> dispatch
+    dispatch --> gate
     gate --> action
     action --> jobs
     action --> produce
@@ -27,7 +30,7 @@ flowchart TD
     jobs --> produce
 ```
 
-*Dependency rule: inward only.* Surfaces → Contract → Gate → Actions → inner layers. Actions never reference surfaces.
+*Dependency rule: inward only.* Surfaces → Dispatch → Gate → Actions → inner layers. Actions never reference surfaces.
 
 ### What lives in each layer
 
@@ -35,18 +38,27 @@ flowchart TD
 
 ```
 surfaces/cli/     CLI command generation from contracts
+  sources.rb      CLI-only input acquisition (stdin parsing, file sourcing, coercion)
 surfaces/mcp/     MCP server — stdio JSON-RPC 2.0, tools derived from contracts
 surfaces/role_scope.rb
                   (Store#as(role)) — holds (container, role, dry_run, correlation_id);
                   all verb methods injected via define_method in textus.rb
 ```
 
-**Contract**
+**Contract + Dispatch**
 
 ```
-contract/         Per-verb DSL — verb, summary, surfaces, arg, view.
-                  Contract::Binder.inputs_from_ordered splits the uniform inputs hash
-                  into positional/keyword args for every surface.
+contract/         Per-verb DSL — verb, summary, surfaces, arg, view, around.
+                  Pure declaration: Spec and DSL only.
+
+dispatch/         Runtime machinery consumed by every surface.
+  binder.rb       Binder — validates required args, resolves session/literal defaults.
+  around.rb       Around — registry of stateful wrappers (cursor, build_lock).
+  view.rb         View.render(spec, surface, result, inputs) — output shaping.
+  command_builder.rb
+                  CommandBuilder — command construction + role injection.
+  dispatcher.rb   Dispatcher — unified pipeline: Around → Binder → Command → Gate.
+  resources/      Around resource implementations (Cursor, BuildLock).
 ```
 
 **Gate + Auth**

data/docs/reference/conventions.md

@@ -8,11 +8,11 @@ Guidelines for shaping a `.textus/` tree, naming keys, organising schemas, and i
 ## Key naming
 
 - **Segments are lowercase, kebab- or snake-case.** The grammar `^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$` is the hard limit. Prefer `acme-dashboard` over `acmedashboard` when there's a natural word break.
-- **Lead with the zone in the key path.** `working.projects.acme.dashboard`, not `projects.acme.dashboard`. The zone prefix makes it obvious from the key alone whether a write will be accepted.
+- **Lead with the lane in the key path.** `working.projects.acme.dashboard`, not `projects.acme.dashboard`. The lane prefix makes it obvious from the key alone whether a write will be accepted.
 - **Mirror the directory structure.** If `working.projects.acme.dashboard` resolves to `working/projects/acme/dashboard.md`, do not invent shortcuts that diverge.
 - **Don't pluralise the leaf.** `working.network.org.jane`, not `working.network.org.janes`. Pluralise the container, not the entry.
 
-## Zone layout
+## Lane layout
 
 Recommended top-level layout — the spec allows alternatives, but this is what tooling will default to:
 
@@ -20,12 +20,14 @@ Recommended top-level layout — the spec allows alternatives, but this is what
 .textus/
   manifest.yaml
   schemas/        # YAML schema definitions
-  zones/
+  workflows/      # Textus.workflow DSL files for produced entry acquisition
+  templates/      # ERB templates for publish rendering
+  data/
     knowledge/    # authored truth: identity, voice, decisions — author-holders write
     notebook/     # agent's own durable lane (workspace) — keep-holders write
-    feeds/        # automation-fed external inputs (fetch)
     proposals/    # AI proposals awaiting accept (propose)
-    artifacts/    # generated by build automation — never edit by hand
+    artifacts/    # computed outputs produced by drain — never edit by hand
+    raw/          # write-once external source material (ingest)
 ```
 
 Inside `knowledge/`, group by **domain** (identity, people, projects, decisions, runbooks), not by file type or date. `knowledge.identity.*` is the convention for slow-changing identity facts. Inside `artifacts/`, group by **producer** (`artifacts/catalogs/`, `artifacts/indexes/`) so it's clear which build job owns what.
@@ -47,75 +49,57 @@ The `owner:` field in the manifest is **advisory metadata**, not an ACL. Use it
 
 Tooling around `git blame` or audit logs may filter on owner; the gem itself only echoes it back in envelopes.
 
-## Derived entries
+## Produced entries
 
-A derived entry declares a `source:` block with a `from:` discriminator (ADR 0093/0094). A `source:` acquires **data** — it never renders; rendering is a publish concern (below). Two `from:` values for derived entries:
-
-**`source: { from: project }`** — textus computes the entry's data on `textus drain` from other store entries. Declarative; nothing shells out. Projection fields are flat under `source:`.
+A produced entry declares `source: { from: external, command: "true", sources: [] }` and a matching `Textus.workflow` block in `.textus/workflows/**/*.rb`. The `source:` acquires **data** — it never renders; rendering is a publish concern (below).
 
 ```yaml
-- key: artifacts.derived.people
-  path: artifacts/derived/people.md
-  zone: artifacts
-  schema: null
-  owner: automation:catalog-people
-  source:
-    from: project
-    select: knowledge.network.org   # prefix or list of prefixes
-    pluck:  [name, relationship, org]
-    sort_by: name
-    format: json                    # the stored form is data
+- key: artifacts.feeds.skills
+  lane: artifacts
+  kind: produced
+  format: json
+  source: { from: external, command: "true", sources: [] }
   publish:
-    - { to: docs/people.md, template: people.mustache }   # render the data through a template
-```
-
-**`source: { from: command }`** — an external build tool (rake, just, a shell script) produces the file. textus never executes the `command:`; it only tracks `sources:` so `doctor`'s `generator_drift` check can compare source mtimes against the file's `_meta.generated.at`. The role running the build must hold `converge` (default: `automation`).
-
-```yaml
-- key: artifacts.derived.skills
-  path: artifacts/derived/skills.md
-  zone: artifacts
-  owner: automation:catalog-skills
-  source:
-    from: command
-    command: "rake catalog:skills"   # informational; the automation invokes it
-    sources: [knowledge.projects, knowledge.network]
+    - { to: docs/reference/skills.md, template: feeds/skills.erb }
 ```
 
-The build automation is responsible for writing the `generated:` frontmatter block (`by`, `at`, `from`) when it produces the file. `generated.from` SHOULD match `source.sources` — same list, recorded twice so a diff proves what was consumed.
-
-Full contract for both shapes is in [`../../SPEC.md` §5.2.1 and §5.2.2](../../SPEC.md). Data transforms (`source.transform:`) and publishing (a `publish:` list of `{ to, template? }` / `{ tree }` targets — render or copy the data) are covered in §5.2–§5.3.
+The matching workflow block:
 
-## Intake and freshness
+```ruby
+# .textus/workflows/feeds/agentskills.rb
+Textus.workflow "agentskills" do
+  match "artifacts.feeds.skills"
 
-External inputs land via `:resolve_handler` hooks, not shell commands. Each intake entry declares `source: { from: handler, handler: <name>, ttl: <dur> }`; re-pull is system-pushed via `drain` (scheduled sweep) and `hook run` (event push) — a `get` never refreshes (ADR 0089):
+  step :fetch do |_, _ctx|
+    { "content" => { "skills" => [...], "count" => 1 } }
+  end
 
-```sh
-textus pulse --output=json                             # `stale` lists expired entries; `next_due_at` is the soonest deadline
-textus drain --as=automation                       # re-pulls every intake entry past its source.ttl
+  publish
+end
 ```
 
-The re-pull cadence is the entry's own `source.ttl`. Age-based garbage collection is the orthogonal `retention:` rule slot in the top-level `rules:` block, matched by glob (`{ ttl, action: drop | archive }`); the two compose — re-pull hourly *and* archive at 90 days:
+`drain` discovers workflows, matches entries, runs the steps, and writes the result back to the entry's data path. Publishing then copies or renders each `publish:` target.
 
-```yaml
-- key: artifacts.feeds.notion.events
-  kind: produced                # produce-method (intake) read from source.from: handler
-  zone: artifacts
-  source: { from: handler, handler: notion, config: { ... }, ttl: 6h }
+Age-based GC uses a `retention:` rule in the top-level `rules:` block:
 
+```yaml
 rules:
-  - match: artifacts.feeds.notion.**
+  - match: artifacts.feeds.**
     retention: { ttl: 90d, action: archive }
 ```
 
-A typical scheduled integration runs `drain` on a cron to re-pull every
-expired feed:
+Full contract in [`../../SPEC.md` §5.2](../../SPEC.md).
+
+## Freshness
+
+A `get` is always a pure read (ADR 0089) — it never triggers a re-produce:
 
 ```sh
-textus drain --as=automation   # in cron / CI — re-pulls all stale feeds
+textus pulse --output=json       # `stale` lists entries past their ttl
+textus drain --as=automation     # re-produces stale entries
 ```
 
-See [`./zones.md` §6](zones.md) for the full intake contract and [`../how-to/writing-hooks.md`](../how-to/writing-hooks.md) for writing custom handlers.
+See [`./lanes.md`](lanes.md) for lane semantics and [`../how-to/configuring-lanes.md`](../how-to/configuring-lanes.md) for setting up produced entries and workflows.
 
 ### Read vs. refresh
 
@@ -141,11 +125,11 @@ For multi-writer environments, **always pass `if_etag`** on `put`. The gem treat
 
 The application layer is organised around three shapes — `Manifest` as a composition record, a single `Container` capability record handed to every use case, and a split envelope reader/writer. See [ADR 0018](../architecture/decisions/0018-manifest-carving.md), [ADR 0017](../architecture/decisions/0017-envelope-io-split.md), [ADR 0022](../architecture/decisions/0022-container-call-dispatcher.md), and [ADR 0023](../architecture/decisions/0023-uniform-use-case-shape.md).
 
-- **`Manifest` is a composition record** (`Data.define(:data, :resolver, :policy, :rules)`). Reach individual concerns through the field accessors: `manifest.data.entries`, `manifest.policy.permission_for(zone)`, `manifest.resolver.resolve(key)`, `manifest.rules.for(key)`.
-- **Use cases are plain `(container:, call:)` classes.** Each is a single class under `lib/textus/{read,write,maintenance}/` with `def initialize(container:, call:)` and a `#call(...)` method; verbs are looked up in the static `Textus::Dispatcher::VERBS` table. `Container` is a `Data.define` record bundling the wired ports + manifest (`manifest`, `file_store`, `schemas`, `root`, `audit_log`, `events`, `rpc`); `Call` is the immutable per-invocation value (`role`, `correlation_id`, `now`, `dry_run`). A use case that emits events derives its `Hooks::Context` from `(container, call)` — nothing is injected. Use cases pull only what they need into ivars; nobody passes the raw `Store` around the application layer. `store.as(role)` returns a `RoleScope` that forwards verbs to the dispatcher.
+- **`Manifest` is a composition record** (`Data.define(:data, :resolver, :policy, :rules)`). Reach individual concerns through the field accessors: `manifest.data.entries`, `manifest.policy.permission_for(lane)`, `manifest.resolver.resolve(key)`, `manifest.rules.for(key)`.
+- **Use cases are plain `(container:, call:)` classes.** Each is a single class under `lib/textus/action/` with `def initialize(...)` (args from contract) and a `#call(container:, call:)` method; verbs are looked up in the static `Textus::Action::VERBS` table. `Container` is a `Dry::Struct` record bundling the wired ports + manifest (`manifest`, `file_store`, `schemas`, `root`, `audit_log`, `workflows`, `gate`); `Call` is the immutable per-invocation value (`role`, `correlation_id`, `now`, `dry_run`). All dispatch routes through `Gate#dispatch(spec:, inputs:, role:, correlation_id:, session:)` — the single seam that binds inputs via `Gate::Binder`, checks auth, and invokes the action. `store.as(role)` returns a `RoleScope` that forwards verbs to `Gate::dispatch`.
 - **Write path is split**: `Envelope::IO::Reader` owns read/parse (existing-uid lookup, raw read, parse), and `Envelope::IO::Writer` owns put/delete/move + the audit-append invariant (every public method's final action is `@audit_log.append(...)`).
 
-The user-facing CLI surface, the wire envelope shape, and the protocol version (`textus/3`) are unchanged.
+The user-facing CLI surface, the wire envelope shape, and the protocol version (`textus/4`) are unchanged.
 
 ## Pairing with other tools
 

data/exe/textus

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "textus"
-exit Textus::Surfaces::CLI.run(ARGV)
+exit Textus::Surface::CLI.run(ARGV)

data/lib/textus/action/accept.rb

@@ -2,42 +2,44 @@
 
 module Textus
   module Action
-    class Accept < WriteVerb
-      extend Textus::Contract::DSL
-
+    class Accept < Base
       verb :accept
       summary "apply a queued proposal to its target zone; requires the author capability"
       surfaces :cli, :mcp
       cli "accept"
       arg :pending_key, String, required: true, positional: true, description: "the queued proposal's key"
 
-      def initialize(pending_key:)
-        super()
-        @pending_key = pending_key
-      end
+      def self.call(container:, call:, pending_key:)
+        env = container.compositor.read(pending_key)
+        parsed = proposal_from(env, key: pending_key)
+        return parsed if parsed.is_a?(Dry::Monads::Result::Failure)
 
-      def call(container:, call:)
-        env = Textus::Action::Get.new(key: @pending_key).call(container: container, call: call)
-        proposal = env.meta["proposal"] or raise Textus::ProposalError.new("entry has no proposal block: #{@pending_key}")
-        target = proposal["target_key"] or raise Textus::ProposalError.new("proposal missing target_key")
-        action = proposal["action"] || "put"
+        target = parsed[:target_key]
+        action = parsed[:proposal]["action"] || "put"
 
         case action
         when "put"
-          Textus::Action::Put.new(
-            key: target,
-            meta: env.meta["_meta"] || {},
-            body: env.body,
-          ).call(container: container, call: call)
+          mentry = container.manifest.resolver.resolve(target).entry
+          container.compositor.write(
+            target,
+            mentry: mentry,
+            payload: Textus::Store::Envelope::Writer::Payload.new(
+              meta: env.meta["_meta"] || {},
+              body: env.body,
+              content: nil,
+            ),
+            call: call,
+          )
         when "delete"
-          Textus::Action::KeyDelete.new(key: target).call(container: container, call: call)
+          container.compositor.delete(target, call: call)
         else
-          raise Textus::ProposalError.new("unknown action: #{action}")
+          return Failure(code: :proposal_error, message: "unknown action: #{action}")
         end
 
-        Textus::Action::KeyDelete.new(key: @pending_key).call(container: container, call: call)
+        container.compositor.delete(pending_key, call: call)
 
-        { "protocol" => Textus::PROTOCOL, "accepted" => @pending_key, "target_key" => target, "action" => action }
+        Success("protocol" => Textus::PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action,
+                "cascade_key" => target)
       end
     end
   end

data/lib/textus/action/audit.rb

@@ -6,8 +6,6 @@ require "time"
 module Textus
   module Action
     class Audit < Base
-      extend Textus::Contract::DSL
-
       verb :audit
       summary "Query the audit log with optional filters."
       surfaces :cli
@@ -24,42 +22,26 @@ module Textus
       arg :limit, Integer, required: false, description: "maximum number of rows to return"
       view(:cli) { |rows, _i| { "verb" => "audit", "rows" => rows } }
 
-      def initialize(**kwargs)
-        super()
-        @query = Query.build(**kwargs.slice(:key, :lane, :role, :verb, :since, :seq_since, :correlation_id, :limit))
-      end
-
-      def args
-        @query.to_h.compact
-      end
-
-      def call(container:, **)
-        @manifest = container.manifest
-        @root = container.root
-        @log_path = Textus::Layout.audit_log(container.root)
-        @audit_log = container.audit_log
-
-        query = @query
-        check_cursor_expiry!(query.seq_since)
+      def self.call(container:, key: nil, lane: nil, role: nil, verb: nil, since: nil, seq_since: nil, correlation_id: nil, limit: nil, **) # rubocop:disable Metrics/ParameterLists
+        audit_log = container.audit_log
+        manifest = container.manifest
 
-        files = all_log_files
-        return [] if files.empty?
+        cursor_check = check_cursor_expiry(seq_since, audit_log)
+        return cursor_check if cursor_check.is_a?(Dry::Monads::Result::Failure)
 
-        rows = []
-        files.each do |file|
-          File.foreach(file) do |line|
-            parsed = parse_row(line.chomp)
-            next unless parsed
-            next unless query.matches?(parsed)
-            next if query.lane && !key_in_lane?(parsed["key"], query.lane)
-
-            rows << parsed
-            break if limit_reached?(rows, query)
-          end
-          break if limit_reached?(rows, query)
-        end
+        Success(audit_log.scan(
+          seq_since: seq_since,
+          key: key,
+          role: role,
+          verb: verb,
+          correlation_id: correlation_id,
+          limit: limit,
+        ).select do |row|
+          next false if lane && !key_in_lane?(row["key"], lane, manifest)
+          next false if since && (row["ts"].nil? || Time.parse(row["ts"]) < since)
 
-        rows
+          true
+        end)
       end
 
       def self.parse_since(str, now: Time.now.utc)
@@ -91,37 +73,18 @@ module Textus
         end
       end
 
-      private
-
-      def limit_reached?(rows, query) = query.limit && rows.length >= query.limit
-
-      def check_cursor_expiry!(seq_since)
+      def self.check_cursor_expiry(seq_since, audit_log)
         return unless seq_since
 
-        log = @audit_log || Textus::Ports::AuditLog.new(@root)
-        min = log.min_available_seq
-        raise Textus::CursorExpired.new(requested: seq_since, min_available: min) if min && seq_since < min - 1
-      end
-
-      def all_log_files
-        rotated = Dir.glob(File.join(Textus::Layout.audit_dir(@root), "audit.log.*"))
-                     .reject { |path| path.end_with?(".meta.json") }
-                     .sort_by { |path| -path.scan(/\d+$/).first.to_i }
-        active = File.exist?(@log_path) ? [@log_path] : []
-        rotated + active
-      end
-
-      def parse_row(line)
-        return nil if line.empty?
-        return nil unless line.start_with?("{")
+        min = audit_log.min_available_seq
+        return unless min && seq_since < min - 1
 
-        JSON.parse(line)
-      rescue JSON::ParserError
-        nil
+        Failure(code: :cursor_expired, message: "requested seq #{seq_since} is below minimum available #{min}",
+                details: { requested: seq_since, min_available: min })
       end
 
-      def key_in_lane?(key, lane)
-        mentry = @manifest.resolver.resolve(key).entry
+      def self.key_in_lane?(key, lane, manifest)
+        mentry = manifest.resolver.resolve(key).entry
         mentry && mentry.lane == lane
       rescue Textus::Error
         false

data/lib/textus/action/base.rb

@@ -20,22 +20,22 @@ module Textus
     end
 
     class Base
+      extend Contract::DSL
+      extend Dry::Monads[:result]
+
       def self.inherited(subclass)
         super
         Textus::Action.register(subclass) if subclass.name
       end
 
-      def call(**)
-        raise NotImplementedError.new("#{self.class}#call")
+      def self.call(**)
+        raise NotImplementedError.new("#{name}.call")
       end
 
-      def args
-        params = self.class.instance_method(:initialize).parameters
-        names = params.select { |t,| %i[key keyreq].include?(t) }.map(&:last)
-        names.each_with_object({}) do |name, h|
-          val = instance_variable_get(:"@#{name}")
-          h[name] = val unless val.nil?
-        end
+      def self.proposal_from(env, key:)
+        proposal = env.meta&.dig("proposal") or return Failure(code: :proposal_error, message: "entry has no proposal block: #{key}")
+        target = proposal["target_key"] or return Failure(code: :proposal_error, message: "proposal missing target_key")
+        { proposal:, target_key: target }
       end
     end
   end

data/lib/textus/action/blame.rb

@@ -5,8 +5,6 @@ require "open3"
 module Textus
   module Action
     class Blame < Base
-      extend Textus::Contract::DSL
-
       verb :blame
       summary "Annotate audit rows for a key with the git commit that introduced each file state."
       surfaces :cli
@@ -15,59 +13,43 @@ module Textus
       arg :limit, Integer, required: false, description: "maximum number of audit rows to return"
       view(:cli) { |rows, inputs| { "verb" => "blame", "key" => inputs[:key], "rows" => rows } }
 
-      def initialize(key:, limit: nil)
-        super()
-        @key = key
-        @limit = limit
-      end
-
-      def call(container:, **)
-        @container = container
-        @manifest = container.manifest
-        @root = container.root
+      def self.call(container:, key:, limit: nil, **)
+        manifest = container.manifest
+        root = container.root
 
-        audit_rows = Textus::Action::Audit.new(key: @key, limit: @limit).call(container: container)
-        path = resolve_path(@key)
-        return audit_rows.map { |row| row.merge("git" => nil) } unless git_tracked?(path)
+        audit_result = Textus::Action::Audit.call(container: container, key: key, limit: limit)
+        audit_rows = Value::Result.unwrap(audit_result)
+        path = resolve_path(key, manifest: manifest)
+        return Success(audit_rows.map { |row| row.merge("git" => nil) }) unless git_tracked?(path, root: root)
 
-        audit_rows.map { |row| row.merge("git" => git_commit_at(path, timestamp: row["ts"])) }
+        Success(audit_rows.map { |row| row.merge("git" => git_commit_at(path, timestamp: row["ts"], root: root)) })
       end
 
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
-      end
-
-      private
-
-      def resolve_path(key)
-        res = @manifest.resolver.resolve(key)
+      def self.resolve_path(key, manifest:)
+        res = manifest.resolver.resolve(key)
         mentry = res.entry
         path = res.path
-        path || Textus::Key::Path.resolve(@manifest.data, mentry)
+        path || Textus::Key::Path.resolve(manifest.data, mentry)
       rescue Textus::Error
         nil
       end
 
-      def git_tracked?(path)
+      def self.git_tracked?(path, root:)
         return false if path.nil?
         return false unless File.exist?(path)
-        return false unless git_repo?
+        return false unless git_repo?(root)
 
         _out, _err, status = Open3.capture3(
           "git", "ls-files", "--error-unmatch", path,
-          chdir: @root
+          chdir: root
         )
         status.success?
       rescue Errno::ENOENT
         false
       end
 
-      def git_repo?
-        dir = @root
+      def self.git_repo?(root)
+        dir = root
         loop do
           return true if File.directory?(File.join(dir, ".git"))
 
@@ -78,11 +60,11 @@ module Textus
         end
       end
 
-      def git_commit_at(path, timestamp:)
+      def self.git_commit_at(path, timestamp:, root:)
         args = ["git", "log", "-1"]
         args << "--before=#{timestamp}" if timestamp
         args += ["--format=%H%x09%an%x09%aI%x09%s", "--", path]
-        out, _err, status = Open3.capture3(*args, chdir: @root)
+        out, _err, status = Open3.capture3(*args, chdir: root)
         return nil unless status.success?
 
         sha, author, date, subject = out.strip.split("\t", 4)

data/lib/textus/action/boot.rb

@@ -3,14 +3,12 @@
 module Textus
   module Action
     class Boot < Base
-      extend Textus::Contract::DSL
-
       verb :boot
       summary "Return the orientation contract: lanes, agent_quickstart, agent_protocol, and pre-computed artifacts."
       surfaces :cli, :mcp
 
-      def call(container:, **)
-        Textus::Boot.build(container: container)
+      def self.call(container:, **)
+        Success(Textus::Boot.build(container: container))
       end
     end
   end

data/lib/textus/action/data_mv.rb

@@ -5,8 +5,6 @@ require "yaml"
 module Textus
   module Action
     class DataMv < Base
-      extend Textus::Contract::DSL
-
       verb :data_mv
       summary "Rename a data lane — manifest + files. Refuses if destination exists."
       surfaces :cli, :mcp
@@ -19,48 +17,39 @@ module Textus
                                            "defaults to false, so omitting it applies the move immediately"
       view { |v, _i| v.to_h }
 
-      def initialize(from:, to:, dry_run: false)
-        super()
-        @from = from
-        @to = to
-        @dry_run = dry_run
-      end
-
-      def call(container:, **)
+      def self.call(container:, call:, from:, to:, dry_run: false, **) # rubocop:disable Lint/UnusedMethodArgument
         manifest = container.manifest
-        root = container.root
+        geom = container.geometry
 
-        raise UsageError.new("from and to required") if @from.nil? || @to.nil? || @from.empty? || @to.empty?
-        raise UsageError.new("data lane '#{@from}' not declared") unless manifest.data.declared_lane_kinds.key?(@from)
+        return Failure(code: :usage_error, message: "from and to required") if from.nil? || to.nil? || from.empty? || to.empty?
+        return Failure(code: :usage_error, message: "data lane '#{from}' not declared") unless manifest.data.declared_lane_kinds.key?(from)
 
-        dest_dir = File.join(root, "data", @to)
-        raise UsageError.new("destination 'data/#{@to}' already exists") if File.exist?(dest_dir)
+        dest_dir = geom.lane_path(to)
+        return Failure(code: :usage_error, message: "destination 'data/#{to}' already exists") if File.exist?(dest_dir)
 
-        affected_keys = manifest.data.entries.select { |entry| entry.lane == @from }.map(&:key)
+        affected_keys = manifest.data.entries.select { |entry| entry.lane == from }.map(&:key)
 
-        steps = [{ "op" => "rename_zone", "from" => @from, "to" => @to }]
+        steps = [{ "op" => "rename_zone", "from" => from, "to" => to }]
         steps += affected_keys.map do |key|
-          { "op" => "mv", "from" => key, "to" => "#{@to}#{key[@from.length..]}" }
+          { "op" => "mv", "from" => key, "to" => "#{to}#{key[from.length..]}" }
         end
 
-        plan = Textus::Jobs::Plan.new(steps: steps, warnings: [])
-        return plan if @dry_run
+        plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: [])
+        return Success(plan) if dry_run
 
-        rewrite_manifest!(root)
-        FileUtils.mv(File.join(root, "data", @from), dest_dir)
-        plan
+        rewrite_manifest!(geom, from:, to:)
+        FileUtils.mv(geom.lane_path(from), dest_dir)
+        Success(plan)
       end
 
-      private
-
-      def rewrite_manifest!(root)
-        path = File.join(root, "manifest.yaml")
+      def self.rewrite_manifest!(geom, from:, to:)
+        path = geom.manifest_path
         raw = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: false)
-        raw["lanes"].each { |lane| lane["name"] = @to if lane["name"] == @from }
+        raw["lanes"].each { |lane| lane["name"] = to if lane["name"] == from }
         raw["entries"].each do |entry|
-          entry["lane"] = @to if entry["lane"] == @from
-          entry["key"] = entry["key"].sub(/\A#{Regexp.escape(@from)}(\.|\z)/, "#{@to}\\1")
-          entry["path"] = entry["path"].sub(%r{\A(data/)?#{Regexp.escape(@from)}(/|\z)}, "\\1#{@to}\\2")
+          entry["lane"] = to if entry["lane"] == from
+          entry["key"] = entry["key"].sub(/\A#{Regexp.escape(from)}(\.|\z)/, "#{to}\\1")
+          entry["path"] = entry["path"].sub(%r{\A(data/)?#{Regexp.escape(from)}(/|\z)}, "\\1#{to}\\2")
         end
         File.write(path, YAML.dump(raw))
       end