textus 0.54.2 → 0.55.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53f01828833f9c5e6cb0249fe513b92d6afbb210d90cfca10f51c560c8b2e2ca
-  data.tar.gz: 1956232435c941479290225e20168979beb270a6e2f5874df37c302e170a43e7
+  metadata.gz: 27ac7fc2922b98c97c7873939781a13330e0765b7f0521449aa4871c414fc201
+  data.tar.gz: 055ed0684590d9ca8cf5e2ad49fc17ee05c70b8cbaa5f8b589b9bb9a3de99f0e
 SHA512:
-  metadata.gz: c086755b90faab7ecebdeebd722e9458dbede54c5efa9be212d6d861c999655093166a1f61826aa9e09ebee8cd1cf57996d958bd410c3b682763d911ed44abe5
-  data.tar.gz: aad04f9470c3de178ad6c762ef3102528cbdc94922fedb79d121ffbadc23acc5dd3f52871f6b3c0c75664afdb968c12fa814b88fbedcbd0d914161e4e1f337ab
+  metadata.gz: 437568a688e1ff1b6f9786d1965633e9dfa69be5b6f7450ffeeaecb3c0be5a6729e94851f2066a26e2d313f8d23335d2ff12b83ad5e73718b27e784887c9ceb4
+  data.tar.gz: a8f4167af7c3ce315301996d3d3fedc13139f8eae4804b445ec4ed930da0d284ec96cab3467af1169ce8f6a64288d6f1d805bbfad60c0acb949f62e03ce1322d

data/CHANGELOG.md

@@ -9,6 +9,43 @@ The **gem version** (`0.x.y`) is distinct from the **protocol version**
 bump is a breaking change that requires a store migration; the gem version
 tracks both additive improvements and breaking protocol bumps independently.
 
+## 0.55.1 — 2026-06-22 — CI fix: converge_now purges done jobs
+
+### Fixed
+
+- **publish_tree prune spec** — `converge_now` now purges "done" jobs before reseeding. The SQLite-backed job queue (`INSERT OR IGNORE`) was silently skipping re-enqueues for already-done jobs, so the second materialize never ran and the source-removed file was never pruned from the published tree.
+
+## 0.55.0 — 2026-06-22 — Architecture Deepening Phase 2
+
+**ADR-0119**: dry-monad actions, container split, geometry authority.
+
+### Added
+
+- **dry-monad Success/Failure actions** (PR #234): all 30 actions now return `Success(result)` or `Failure(code:, message:)` via `Dry::Monads`. `Value::Result.unwrap` converts Failure → `ActionError`. `be_success`/`be_failure` RSpec matchers replace `spec/unit/` tests.
+- **`Container::Infrastructure` / `Container::Coordination`** (PR #234): single `LazyContainer` replaced by two `Data.define` records — Infrastructure owns manifest, file_store, geometry; Coordination owns gate, compositor, workflows, audit_log. Wired at boot via `wire_gate!`.
+- **`Geometry` as sole path authority** (PR #234): `root`, `schemas_dir`, `hooks_dir`, `store_db_path` delegated to `Geometry`. Removed `root` from Infrastructure. High-value `File.join` callers converted (data_mv, ingest, base, loader, etag, schema/tools, 6 doctor checks).
+- **`bin/db` helper**: sqlite3 wrapper for `.textus/.state/store.db` — `bin/db "SELECT * FROM jobs"` or just `bin/db` for interactive shell.
+- **Centralized SQLite index** (PR #228, #233): `Store::Index::Builder` manages entries FTS index in `store.db`.
+
+### Changed
+
+- **Gate reads `Action::VERBS` directly** (PR #234): `Gate::VERB_ACTIONS` deleted. Gate dispatches via `Action::VERBS[cmd.verb]`.
+- **Composite actions** (PR #232): `Accept`, `Propose`, `Reject` separated as composite verbs with declarative `chain` steps, never instantiating sibling action classes directly.
+- **`knowledge.decisions` → keyless nested mode**: decision files no longer enumerate in `list`; accessible via `get` with full key.
+
+### Fixed
+
+- **CLI `--args` JSON parsing** (PR #233): `Runner.coerce` now `JSON.parse(raw)` for `Hash`-typed args — fixes `textus enqueue --args='{"key":"..."}'` which previously passed the raw JSON string to `Queue::Job`.
+- **adr-log workflow convention drift** (PR #233): `Get.new(key:).call(...)` → `Get.call(key: k, ...)` — the old pattern raised silently since actions became class-method-only.
+- **RuboCop `Lint/NoReturnInBeginEndBlocks`**: enqueue action restructured with method-level `rescue`.
+
+### Removed
+
+- `Gate::VERB_ACTIONS` constant (replaced by `Action::VERBS`)
+- `LazyContainer` (replaced by `Container::Infrastructure`/`Coordination`)
+- `spec/unit/` directory + `spec/support/spec_layout.rb` (378 examples removed)
+- Orphaned `.textus/.state/jobs.sqlite3` database file
+
 ## 0.54.2 — 2026-06-18 — ingest dedup, .run → .state rename
 
 ### Added

data/README.md

@@ -1,4 +1,5 @@
-<!-- Generated from .textus/data/knowledge/readme.md — edit there, then run `textus drain`. Do not hand-edit README.md (it is clobbered on drain and flagged by doctor). ADR 0103. -->
+<!-- Generated from knowledge.readme.* fragments by the artifacts.docs.readme workflow. Edit the fragments under .textus/data/knowledge/readme/ and run `textus drain`. -->
+<!-- This is a fragment of the README. Edit here; the README is composed from fragments by a workflow. -->
 <p align="center">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="assets/branding/wordmark-dark.png">
@@ -18,6 +19,8 @@
 
 *textus* is Latin for "the fabric a text is woven from" — same root as *context*, from *con-texere*, "to weave together."
 
+
+<!-- This is a fragment of the README. Edit here; the README is composed from fragments by a workflow. -->
 ## The idea
 
 Three actors write to your repo today:
@@ -90,6 +93,8 @@ An agent that tries to write directly into `knowledge/` gets `write_forbidden`.
 
 That's the load-bearing claim: **coordination is a protocol invariant, not a library convenience.**
 
+
+<!-- This is a fragment of the README. Edit here; the README is composed from fragments by a workflow. -->
 ## See it in four commands
 
 ```sh
@@ -316,3 +321,5 @@ Lefthook hooks (`brew bundle install` then `lefthook install`) run rubocop on `p
 ## License
 
 [MIT](LICENSE)
+
+

data/SPEC.md

@@ -438,6 +438,22 @@ textus ingest url agentskills-io-brainstorming \
 
 A `get` on a raw entry is a pure read — it returns the entry as stored and never re-fetches (ADR 0089).
 
+**Raw entry shape.** Every raw-lane entry has a set of required fields
+enforced by the format layer on write:
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `ingested_at` | yes | ISO-8601 timestamp of ingestion |
+| `content_hash` | yes | `sha256:<hex>` of the source content |
+| `source.kind` | yes | One of `url`, `file`, `asset` |
+| `source.url` | conditional | Required when `kind=url` |
+| `source.label` | no | Human-readable label |
+| `body` | no | Present only for `kind=file` |
+| `asset` | no | Present only for `kind=asset` |
+
+Tombstone entries (carrying `superseded_by:`) are exempt from shape
+validation — they are stripped-down records pointing to the live entry.
+
 ### 5.5 Pending / accept workflow
 
 Proposal entries are full patches authored into the `proposals` queue lane (writable by `propose`-holders: `agent` and `human` by default) — `proposals` in the default scaffold (Setup-1) — typically by agents. The entry's frontmatter describes the patch it proposes against another lane:
@@ -646,6 +662,13 @@ The frontmatter `name:` field, when present, must match the file's basename (wit
 - Existing files without a uid continue to work. The envelope shows `"uid": null` until a put mints one.
 - `text` entries have no metadata channel and therefore no uid; their envelope always shows `"uid": null`.
 
+**`sources:` (Source references).** Entries MAY carry a `sources` array in
+their frontmatter to declare external provenance. Each element is a raw-lane
+key string (starting with `raw.`). The array is preserved on write —
+existing sources carry forward if no new `sources` are provided. The
+envelope returns `sources` as a top-level array when non-empty; omitted
+when absent.
+
 Entries in a `produced` lane SHOULD additionally carry the `generated:` block defined in §5.2. Implementations MUST treat unknown frontmatter fields as warnings, not errors, so build tooling can extend the metadata without breaking conformance.
 
 ## 8. Envelope (the wire format)
@@ -665,6 +688,9 @@ Every successful CLI response (`--output=json`) is a single JSON envelope:
   "etag": "sha256:8f3c…",
   "schema_ref": "person",
   "uid": "a1b2c3d4e5f60718",
+  "sources": [
+    "raw.2026.06.20.url-mcp-spec"
+  ],
   "stale": false,
   "stale_reason": null,
   "fetching": false
@@ -682,6 +708,7 @@ Every successful CLI response (`--output=json`) is a single JSON envelope:
 - `etag` MUST be `sha256:<hex>` of the raw file bytes, computed identically for every format.
 - `schema_ref` MAY be `null` for entries in subtrees with `schema: null`.
 - `uid` is the stable Textus UID (§7) if the entry carries one, else `null`. Always present in the envelope.
+- `sources` is an array of raw-lane key strings. Present only when non-empty. Each string starts with `raw.`.
 - `stale` is `true` when the entry's `source.ttl` has elapsed and the entry has not yet been re-materialised; `false` otherwise. Only populated for produced entries with a declared `ttl`; always `false` for other entries.
 - `stale_reason` is a short human-readable string describing why the entry is stale (e.g. `"ttl_exceeded"`, `"never_fetched"`), or `null` when `stale` is `false`.
 - `fetching` is `true` when a background re-pull is in flight for this entry; `false` otherwise. Callers observing `stale: true, fetching: true` SHOULD retry after a short delay.

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

@@ -126,7 +126,7 @@ 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(lane)`, `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.
+- **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/4`) are unchanged.

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