ace-herdr 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e0747847d9a56e36a452fd156063284154be0c5eb6464b9acca559fba504750
-  data.tar.gz: 2dd3be6a92a0217c2ec0d194a83714c0b6cbc22856c4df0ba7bb99f4f0a02810
+  metadata.gz: 00422d9f6820e48b0ea45698e4663f7ecaeb9b5b01ddf1626ab86aed50adcbfd
+  data.tar.gz: 2632e4056271d3c022056a70fa5f3b95e2f69ae08544bf70f2577bc11fbac4f7
 SHA512:
-  metadata.gz: dc0422a8f818acfb8ad055543ef95938bd41bc988622e527dcffccbf0e757456f4b9aef47ab141eda71eb97fd1d55311d836b2f0f6fc2f04d6ac2f50f56a5c80
-  data.tar.gz: 98c840541c5d15bc6241f1a7bf0535567b34386fe441fdb14c97be8d1a98413a9777151807d4f142504d725871905b77144d89a2622b64f32e85e384b74daaa1
+  metadata.gz: c6626094540195dadf06116add8bd27708934b809347c12cb0bc355cb6c03d5ff32e30e3e63870e158316cf9c80de7e2bdd5cad5f731cea4fef11303c1c9bd8a
+  data.tar.gz: 7b4e02b683be089a602d10c7fafcb09abc134a9f5b60e5a58a8d0ef42b35bb0ec18555700e0c316ec5de12aae7e5c01a4f0ffede12e26597f1a881fcbb5d50af

data/.ace-defaults/herdr/config.yml

@@ -19,10 +19,6 @@ timeouts:
 # Delivery record root (ADR-029 short-name layout), relative to project root
 deliveries_dir: .ace-local/herdr/deliveries
 
-# Absolute path to the supervisor-managed receipt verification key. Configure
-# before enqueue; each event pins this key's fingerprint for reconciliation.
-inbox_receipt_public_key:
-
 # Tidy (spec 8wq.t.1w0): archive delivered records strictly older than this
 # many days (age = record updated_at); failed/retryable/pending are never
 # touched

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.1] - 2026-10-10
+
+### Fixed
+
+- Require the published producer and consumer patch versions containing the protected context and managed-attempt APIs; exclude incompatible prior dependency graphs.
+
+## [0.5.0] - 2026-10-08
+
+### Changed
+
+- Submit Codex answers through the existing Herdr prompt command to the original live terminal. A successful send means submitted, not read; retain unknown sends without automatic resend.
+- Remove dedicated Codex app-server selection, message-read observation, signing keys and consumed/superseded reconciliation APIs.
+- Keep authenticated original-context admission and actual scoped effects without a second current-state projection.
+
+### Fixed
+
+- Load bounded process/error primitives directly and preserve bounded cleanup of the original process after execution uncertainty.
+
 ## [0.4.0] - 2026-10-05
 
 ### Fixed

data/docs/usage.md

@@ -14,7 +14,7 @@ ace-docs:
 ## Command Surface
 
 - `ace-herdr deliver [OPTIONS]`
-- `ace-herdr inbox enqueue|status|deliver|reconcile [OPTIONS]`
+- `ace-herdr inbox enqueue|status|deliver [OPTIONS]`
 - `ace-herdr dispatch [OPTIONS]`
 - `ace-herdr list [--panes|--tabs|--workspaces] [--workspace ID] [--quiet]`
 - `ace-herdr send [--cmd TEXT] [--msg TEXT...] [--key NAME...] --pane ID [--quiet]`
@@ -53,7 +53,7 @@ remain valid; the codec also preserves paired native tmux IDs (`$0`/`%0`) when
 carried by managed metadata. Mixed native/token or cross-field IDs refuse.
 Wire and persisted references must be canonical. Syntax acceptance does not add
 tmux execution to this Herdr controller or replace its exact native ownership,
-target and signed receipt checks.
+target and submission checks.
 
 ```bash
 ace-herdr inbox enqueue --event inb-12345678 --attempt ATTEMPT --ref ref.json --file prompt.txt
@@ -61,39 +61,22 @@ ace-herdr inbox status --event inb-12345678 --format json
 ace-herdr inbox deliver --event inb-12345678
 ```
 
-`enqueue` checks the live pane, durable terminal, agent kind, and native thread identity. Managed API callers must supply `expected_target`, projected from the accepted runtime owner with `Inbox#target_from_owner`; the live observation must equal that original session/pane/terminal/agent/thread identity under the event lock. The immutable `origin_target` survives retries and signed replacement of the current target. Managed payloads are checked for secret shapes before persistence, including envelopes without a nested message. Repeating the same event, attempt, target, and payload returns its existing record; a changed value is an error. `deliver` claims the record once. Idle and busy Codex or Pi agents receive an exact-session native queue submission. After an accepted idle submission, Herdr sends a generic wake prompt without the inbox payload. A pane replacement can receive at most that generic wake, never the payload. The JSON result includes `state`, `claim_generation`, `binding`, `last_error`, and any submission receipt.
+`enqueue` checks the live pane, terminal and original agent-session identity.
+Managed callers supply `expected_target` from the accepted runtime owner. Reusing
+an event with identical attempt, target and payload returns its original record;
+changed input refuses. `deliver` records one submission intent before sending.
 
-`queued` can be retried after a proven pre-submission rejection. `delivered` means native submission was accepted; it does not mean the agent consumed the message. A crash after claim, changed target identity, or a native result without a verified acceptance receipt is `uncertain`; another `deliver` call does not resend it. A `completed` record has a positively verified consumption receipt. A superseded uncertain record can return to `queued` only after positive nonconsumption proof.
+Codex delivery uses the existing Herdr terminal prompt; Pi uses its maintained
+queue boundary. `delivered` means the submission was accepted, not that the
+agent read it or completed the task. A known pre-submission refusal stays queued.
+A lost response, process interruption after intent, or changed target is uncertain;
+a later `deliver` does not automatically resend or select a replacement terminal.
 
-```bash
-ace-herdr inbox reconcile --event inb-12345678 --receipt proof.json
-```
-
-The receipt is a file supplied from an operator or supervisor observation of the native outcome. Codex and Pi expose submission but no queryable consumption or eviction proof, so `reconcile` never polls the native queue or infers an outcome from age. Before enqueue, the supervisor sets `inbox_receipt_public_key` in `.ace/herdr/config.yml` to the absolute path of its trusted RSA public key. Each event pins that key's fingerprint; a later process cannot substitute a different key. Protect this configuration from delivery requesters. The receipt file must have a detached SHA-256 RSA signature at `FILE.sig`. The private key stays with the operator or supervisor. Its JSON must include the recorded event, attempt, claim generation, payload digest, and complete binding, plus an outcome (`consumed` or `superseded`), an identified observer, and a native observation reference:
-
-```json
-{
-  "event_id": "inb-12345678",
-  "attempt_id": "ATTEMPT",
-  "claim_generation": 1,
-  "payload_sha256": "<digest from inbox status>",
-  "binding": {"session": "<exact binding from inbox status>"},
-  "outcome": "consumed",
-  "observer": {"role": "operator", "id": "operator-id"},
-  "evidence": {"kind": "consumed_acknowledged", "native_reference": "session-log:42", "observation": "message consumed and acknowledged"}
-}
-```
-
-Copy the **entire** `binding` object from `inbox status`; the shortened object above only illustrates the field. `consumed` requires `evidence.kind: consumed_acknowledged`. `superseded` requires `queue_evicted`, `queue_expired`, or `thread_replaced`, with an observation that the old queue entry cannot be consumed. A matching receipt changes `uncertain` to `completed` for consumption, or to `queued` for proven supersession. The original target binding stays pinned. To authorize a replacement native session, include `replacement_target` in the signed receipt with the complete target identity from a fresh Herdr pane observation; reconciliation verifies its session, pane, terminal, agent, and thread against that live replacement address before saving it. Without that field, a new claim can only use the original target. A missing or mismatched receipt returns JSON with unchanged `state: uncertain` and `reconciliation_refusal`; it does not resend. Keep the observation record with the receipt. Signature validation authenticates the configured key; the operator or supervisor remains responsible for checking the cited native outcome before signing.
-
-After inspecting the native outcome and writing `proof.json`, the trusted operator signs the exact bytes:
-
-```bash
-openssl dgst -sha256 -sign operator-private.pem -out proof.json.sig proof.json
-ace-herdr inbox reconcile --event inb-12345678 --receipt proof.json
-```
-
-The command verifies the detached signature against the configured public key before any transition. Missing, malformed, or self-signed receipts leave the event uncertain and return a machine-readable refusal. Keep the signed receipt and source observation for audit.
+Inspect current progress directly through `ace-herdr capture` or the native pane.
+Inbox status is transport history, not a cached projection of current agent state.
+No agent-read proof, signing key, reconciliation command or dedicated Codex
+app-server is required. Actual task results and scoped service effects retain
+their independent authorization and verification.
 
 ## tmux-intent ↔ herdr-command parity
 
@@ -372,6 +355,45 @@ Commands raise a CLI error (non-zero exit) carrying herdr's machine code where o
 
 Exit `0` means success (including an explicit empty `list` result or a satisfied wait).
 
-An identical signed reconciliation receipt may be verified again after a consumed/superseded settlement, without another transition. This lets an assignment consumer recover a crash before journaling its verified observation reference. Re-verification preserves the original pinned key, complete binding and generation checks; a later claim's generation rejects the old proof. It never resubmits the payload. Runtime recovery additionally exposes the read-only `process_binding(pane:, caller_pid:)` adapter operation, which requires OS ancestry under the native shell, a matching foreground owner and immutable agent-session identity.
+Runtime recovery exposes the read-only `process_binding(pane:, caller_pid:)`
+adapter operation, which checks OS ancestry, foreground ownership and the
+original agent-session identity. Message submission is never task completion.
+
+## Packaged guarded native source
+
+`ace-herdr native-source selection` describes the source selection and patch shipped by this gem. These assets live under `lib/ace/herdr/native_source`; installed consumers do not need task directories. This source retains native version 0.9.3 and protocol 22; its exact source commit and patch digest identify the guarded producer. No upstream release or publication is implied.
+
+An explicit nonroot build owner can run:
+
+```sh
+ace-herdr native-source build --source /absolute/clean/local/herdr-checkout --output /absolute/new/artifact-directory --target x86_64-unknown-linux-musl
+ace-herdr native-source verify --artifact /absolute/artifact-directory
+```
+
+The build requires a matching native Linux host (x86_64 or aarch64), the selected Rust and Zig versions, and a native `musl-gcc` toolchain already provisioned by the build owner. Cross builds are unsupported. The output must be new. The builder reproduces the exact baseline plus shipped patch in an isolated checkout, checks the commit/tree/lock/toolchain bytes, pins resolved Rust/Zig/linker paths, invokes the locked release build, and records observed executable/tool digests. It never runs the resulting Herdr binary, changes global tool defaults, contacts a running Herdr server, or publishes an artifact. Locked dependency fetching by Cargo may require network access. Failed builds retain their output claim; a partial directory does not verify.
+
+Verification checks bounded strict provenance against this gem's source selection and the observed ELF bytes/architecture. It provides byte provenance, not deployment authorization. The trusted Lab deployment owner separately selects the gem, source selection, artifact and receipt digests before installing the fixed Lab binary. Protected runtime replacement must also use the canonical maintenance admission/release owner. That operational installer join remains required source work; these commands alone do not activate the producer or complete installed acceptance.
+
+The selected source also provides `terminal.inhibit_input` for an exact original terminal/origin. Its successful `terminal_input_drained` reply proves permanent input inhibition and zero queued input, including terminal replies; it does not prove child exit or canonical scope cleanup. Lost acknowledgement may be retried only against the same original actor. Source fixtures validate this contract without running a native binary; actual Lab installation and N2 consumption remain required.
+
+The inbox context source owner supplies durable operation admission and exclusive key rotation through a fixed authenticated exchange. A lost begin reply recovers the same original process's grant; unknown effects, owner restart and incomplete installation retain blocking state. Replacement and rollback each require an attestation from the actual configured signer plus protected public/config readback. This core does not yet activate a context CLI/server, migrate Assign/private-store consumers, or authorize orphan reclamation. Existing protected mutations must all be migrated before this becomes an accepted end-to-end rotation path; installation and private-key pair handling remain the trusted provisioner's responsibility.
+
+### Trusted bounded descriptor handoff
+
+Internal source installers using `BoundedProcess.call` may supply
+`descriptor_mapping: {4 => authenticated_readonly_file}` together with bounded
+`stdin_data` carrying exact selected source bytes. The mapping has at most16
+entries; child descriptor keys are strict Integers3..63 and handles must be live
+read-only regular files. Stdio overwrite, writable/closed/nonregular handles and
+ambient descriptor/path fallback refuse before spawn. Standard Open3 spawn maps
+only explicit descriptors; `close_others: true` excludes all other descriptors.
+The supplying verification owner keeps the handle scoped and authenticates the
+selected inode; the runner does not confer authority or authenticate arbitrary
+files. Actual installed privilege-transition/PAM preservation is a separate
+installed acceptance check, not established by controlled file/child tests.
+
+### Bounded subprocess cleanup
+
+`BoundedProcess.call` retains capped stdout/stderr and uses an execution deadline plus at most one additional second of cleanup. `stderr_limit:` defaults to `output_limit:`. Unconfirmed cleanup raises `PostLaunchError` and transfers only the still-owned original child to an eventual reaper; no success or absence proof follows. Generic successful calls do not newly signal process groups.
 
-Recovery consumers with a separately accepted journal registration pass `expected_registration:` to `Inbox#reconcile`. The exact `event_id`, `attempt_id`, `payload_sha256` and `receipt_key_sha256` map is checked inside the event lock before signature verification or settlement. A prior `status` call alone does not establish this precondition. A mismatch raises `ValidationError` without settling the event.
+The fixed protected handler selects `cleanup_group: true`: stream EOF alone never triggers termination. Nonreaping observation must establish the original leader exited before its group is signalled and the leader reaped. Loss of original child ownership refuses further signalling. Controlled source checks cover ownership/IO boundaries; installed native/descendant effectiveness belongs to gad.2.

data/lib/ace/herdr/cli/commands/inbox.rb

@@ -4,6 +4,10 @@ require "json"
 require "openssl"
 require "ace/support/cli"
 require_relative "support"
+require_relative "../../molecules/protected_inbox_selection"
+require_relative "../../molecules/inbox_context_client"
+require_relative "../../molecules/inbox_cli_input"
+require_relative "../../molecules/inbox_direct_effect_binding"
 
 module Ace
   module Herdr
@@ -13,25 +17,40 @@ module Ace
           include Ace::Support::Cli::Base
           include Runtime
 
-          desc "Enqueue, inspect, deliver, or reconcile a durable agent inbox event"
-          argument :operation, desc: "enqueue, status, deliver, or reconcile"
+          desc "Enqueue, inspect, or deliver a durable agent inbox event"
+          argument :operation, desc: "enqueue, status, or deliver"
+          option :project, type: :string, desc: "Installed project ID"
+          option :mapping, type: :string, desc: "Installed mapping ID"
+          option :inbox_context, type: :string, desc: "Installed inbox context ID"
+          option :claim_generation, type: :integer, desc: "Original expected claim generation"
+          option :assignment, type: :string, desc: "Original assignment ID"
           option :event, type: :string, desc: "Stable event ID"
           option :attempt, type: :string, desc: "Assignment attempt ID"
           option :ref, type: :string, desc: "Herdr reverse-address JSON file"
           option :file, type: :string, desc: "Payload file"
-          option :receipt, type: :string, desc: "Native proof JSON file"
           option :format, type: :string, desc: "Output format (json)"
 
-          def initialize(executor: nil, native: nil)
+          def initialize(executor: nil, native: nil, selection: Molecules::ProtectedInboxSelection.new,
+            context_client_factory: Molecules::InboxContextClient.method(:selected),
+            kernel: Ace::Runtime::Molecules::ProtectedLinux.new)
             @executor = executor
             @native = native
+            @selection, @context_client_factory, @kernel = selection, context_client_factory, kernel
           end
 
           def call(operation: nil, **options)
             inbox = nil
             translate_errors do
+              cli_error("unsupported inbox operation") unless %w[enqueue status deliver].include?(operation)
               cli_error("--event is required") if options[:event].to_s.empty?
               cli_error("only --format json is supported") if options[:format] && options[:format] != "json"
+              protected = false
+              @selection.with(options) do |selected|
+                next unless selected
+                puts JSON.generate(protected_call(operation, options, selected))
+                protected = true
+              end
+              next if protected
               inbox = Organisms::Inbox.from_config(config: config, executor: executor,
                 native: @native || Molecules::NativeQueueExecutor.new,
                 root: Dir.pwd)
@@ -44,24 +63,8 @@ module Ace
                 inbox.status(event: options[:event])
               when "deliver"
                 inbox.deliver(event: options[:event])
-              when "reconcile"
-                path = options[:receipt]
-                begin
-                  bytes = path.to_s.empty? ? nil : File.binread(path)
-                  receipt = bytes && JSON.parse(bytes)
-                  signature = bytes && File.binread("#{path}.sig")
-                rescue SystemCallError, JSON::ParserError => e
-                  # Receipt input is caller-owned: unreadable or malformed
-                  # proof files surface as the documented refusal, never as
-                  # command failures.
-                  puts JSON.generate(inbox.status(event: options[:event]).merge(
-                    "reconciliation_refusal" => "invalid receipt: #{e.message}"))
-                  return
-                end
-                inbox.reconcile(event: options[:event], receipt: receipt,
-                  signed_bytes: bytes, signature: signature)
               else
-                cli_error("operation must be enqueue, status, deliver, or reconcile")
+                cli_error("operation must be enqueue, status, or deliver")
               end
               puts JSON.generate(result)
             end
@@ -69,6 +72,65 @@ module Ace
             raise Ace::Support::Cli::Error, e.message
           end
 
+
+          private
+
+          def protected_call(operation, options, selected)
+            %i[event attempt assignment].each { |key| cli_error("--#{key} is required") if options[key].to_s.empty? }
+            unless %w[enqueue status deliver].include?(operation)
+              cli_error("protected operation requires its maintained direct handler")
+            end
+            allowed = %i[project mapping inbox_context event attempt assignment format]
+            allowed += %i[ref file] if operation == "enqueue"
+            allowed += %i[claim_generation] if %w[deliver].include?(operation)
+            if options.any? { |key, value| !value.nil? && !allowed.include?(key) }
+              cli_error("protected inbox operation options differ")
+            end
+            context = selected.fetch("context")
+            client = @context_client_factory.call(context_id: selected.fetch("inbox_context_id"),
+              socket_path: context.fetch("control_socket_path"), owner_credentials: context.fetch("owner_credentials"))
+            if operation == "status"
+              return client.request("status_context", {"event_id" => options.fetch(:event), "attempt_id" => options.fetch(:attempt), "original" => direct_original(selected, options)}).fetch("record")
+            end
+            if operation == "deliver"
+              unless options[:claim_generation].is_a?(Integer) && options[:claim_generation] >= 0
+                cli_error("--claim-generation must be an explicit nonnegative integer")
+              end
+              admission = direct_admission(client, selected, options, "deliver")
+              result = client.request("deliver_context", {"operation_id" => admission.fetch("operation_id"),
+                "key_generation" => admission.fetch("key_generation"), "event_id" => options.fetch(:event),
+                "attempt_id" => options.fetch(:attempt), "original" => direct_original(selected, options), "expected_claim_generation" => options.fetch(:claim_generation)})
+              unless %w[idle unknown].include?(result["admission_state"])
+                cli_error("direct delivery admission observation differs")
+              end
+              client.request("end_context_operation", {"operation_id" => admission.fetch("operation_id")}) if result.fetch("admission_state") == "idle"
+              return result.fetch("record").merge("admission_state" => result.fetch("admission_state"))
+            end
+            %i[ref file].each { |key| cli_error("--#{key} is required") if options[key].to_s.empty? }
+            reverse = Molecules::InboxCliInput.reverse(options.fetch(:ref))
+            payload = Molecules::InboxCliInput.read(options.fetch(:file), limit: 65_536).dup.force_encoding(Encoding::UTF_8)
+            cli_error("payload encoding differs") unless payload.valid_encoding? && !payload.include?("\0")
+            admission = direct_admission(client, selected, options, "enqueue")
+            result = client.request("enqueue_context", {"operation_id" => admission.fetch("operation_id"),
+              "key_generation" => admission.fetch("key_generation"), "event_id" => options.fetch(:event),
+              "attempt_id" => options.fetch(:attempt), "original" => direct_original(selected, options), "reverse" => reverse, "payload_bytes" => payload.bytesize,
+              "payload_sha256" => Digest::SHA256.hexdigest(payload)}, payload: payload)
+            client.request("end_context_operation", {"operation_id" => admission.fetch("operation_id")})
+            result.fetch("record").merge("admission_state" => result.fetch("admission_state"))
+          end
+
+          def direct_original(selected, options)
+            value = selected.slice("project_id", "mapping_id", "inbox_context_id").merge("assignment_id" => options.fetch(:assignment))
+            Molecules::InboxDirectEffectBinding.original!(value)
+          end
+
+          def direct_admission(client, selected, options, purpose)
+            peer = @kernel.capture(Process.pid)
+            client.request("begin_context_operation", {"context_id" => selected.fetch("inbox_context_id"),
+              "purpose" => purpose, "event_id" => options.fetch(:event), "process_binding" => peer,
+              "original" => direct_original(selected, options).merge("attempt_id" => options.fetch(:attempt))})
+          end
+
         end
       end
     end

data/lib/ace/herdr/cli/commands/native_source.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "json"
+require "ace/support/cli"
+require_relative "support"
+require_relative "../../molecules/native_source"
+require_relative "../../organisms/native_source_builder"
+
+module Ace
+  module Herdr
+    module CLI
+      module Commands
+        class NativeSource < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+          include Runtime
+
+          desc "Describe, build, or verify the packaged guarded native source without running Herdr"
+          argument :operation, desc: "selection, build, or verify"
+          option :source, type: :string, desc: "Clean local Git checkout containing the pinned baseline"
+          option :output, type: :string, desc: "New build artifact directory"
+          option :target, type: :string, desc: "Selected Linux target"
+          option :artifact, type: :string, desc: "Build artifact directory to verify"
+
+          def initialize(selection: nil, builder: nil)
+            @selection = selection
+            @builder = builder
+          end
+
+          def call(operation: nil, **options)
+            selection = @selection || Molecules::NativeSource.new
+            supplied = options.select { |key, value| %i[source output target artifact].include?(key) && !value.nil? }.keys
+            result = case operation
+            when "selection"
+              cli_error("selection accepts no build/artifact options") unless supplied.empty?
+              selection.description
+            when "verify"
+              cli_error("verify requires only --artifact") unless supplied == [:artifact] && !options[:artifact].empty?
+              selection.verify_artifact(directory: options.fetch(:artifact))
+            when "build"
+              unless supplied.sort == %i[output source target] && supplied.all? { |key| !options[key].empty? }
+                cli_error("build requires --source, --output and --target")
+              end
+              builder = @builder || Organisms::NativeSourceBuilder.new(selection: selection)
+              builder.build(source: options.fetch(:source), output: options.fetch(:output), target: options.fetch(:target))
+            else
+              cli_error("native-source operation must be selection, build, or verify")
+            end
+            puts JSON.generate(result)
+          rescue Molecules::NativeSource::Error => error
+            raise Ace::Support::Cli::Error, error.message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/herdr/cli.rb

@@ -15,6 +15,7 @@ require_relative "cli/commands/capture"
 require_relative "cli/commands/workspace"
 require_relative "cli/commands/tab"
 require_relative "cli/commands/list_presets"
+require_relative "cli/commands/native_source"
 
 module Ace
   module Herdr
@@ -29,6 +30,7 @@ module Ace
         ["deliver", "Push an answer to an agent pane (ace-hitl delivery contract)"],
         ["inbox", "Durable agent message queue and reconciliation"],
         ["dispatch", "Start an agent in one command: tab + agent + prompt"],
+        ["native-source", "Describe, build, or verify the packaged guarded native source"],
         ["list", "List live panes, tabs, or workspaces as one JSON line"],
         ["send", "Send a command, raw text, or named keys to a pane"],
         ["capture", "Print recent pane output as raw text"],
@@ -69,6 +71,7 @@ module Ace
       register "deliver", CLI::Commands::Deliver.new
       register "inbox", CLI::Commands::Inbox.new
       register "dispatch", CLI::Commands::Dispatch.new
+      register "native-source", CLI::Commands::NativeSource.new
       register "list", CLI::Commands::List.new
       register "send", CLI::Commands::Send.new
       register "capture", CLI::Commands::Capture.new

data/lib/ace/herdr/errors.rb

@@ -2,6 +2,29 @@
 
 module Ace
   module Herdr
+    class Error < StandardError; end
+
+    # Raised when the caller's herdr workspace/session/pane cannot be resolved
+    class TargetResolutionError < Error; end
+
+    # Raised when arguments or refs fail validation
+    class ValidationError < Error; end
+
+    # Raised when a bounded wait exceeds its timeout
+    class WaitTimeoutError < Error; end
+
+    # Raised when a preset tab was created natively but a later
+    # materialization step (splits, commands, agents) failed; carries the
+    # created tab id so the owner can roll back exactly that tab.
+    class TabMaterializationError < Error
+      attr_reader :tab_id
+
+      def initialize(tab_id:, message:)
+        @tab_id = tab_id
+        super(message)
+      end
+    end
+
     # Base for herdr CLI executor failures; retry classification drives the
     # ace-hitl DeliverResult state mapping (retryable vs terminal).
     class ExecutorError < Error