@staix/agent-hub 0.6.4 → 0.7.1

package/docs/specs/2026-09-19-multi-project-design.md

@@ -0,0 +1,95 @@
+# Concurrent projects and a unified local dashboard
+
+Status: Approved for implementation on `feat/multi-project-management`
+Date: 2026-09-19
+
+## Problem
+
+Verified against 0.3.2: inherited `AGENTHUB_STATE_DIR` routes commands in a second
+project to the first hub. The unlocked JSON port registry also loses updates:
+32 parallel allocations produced two unique ports and one surviving registration.
+The baseline gate passes 162 tests, but does not cover these scenarios.
+
+## Existing assets
+
+Each daemon already owns its bus, task database, adapters, control token and local
+dashboard. Bun provides SQLite without another runtime dependency. Reuse existing
+console authorization, dashboard validation and PII redaction.
+
+## Design
+
+### Project context
+
+- Resolve real paths and the nearest initialized ahub directory without crossing
+  the nearest Git working-tree root. Otherwise use that root or the non-Git cwd.
+- Each worktree/submodule is independent. A global CLI prefix,
+  `ahub --project <path|id> <command>`, selects another registered project or path.
+- Only accept an inherited state directory when its recorded project matches.
+  Pass the validated root and state directory to children and MCP servers.
+  For initial custom-state setup, an explicit matching `AGENTHUB_PROJECT_DIR` pair
+  is accepted only when no contradictory marker exists. Startup records a persistent
+  project marker. Native MCP sessions stay pinned to their launcher-supplied state
+  directory, while their control handshake verifies the manifest identity.
+- Native memory identity remains separate: preserve native claude-mem aliases,
+  including parent and parent/worktree names. Show shared-alias warnings; do not
+  change global hooks or historical records.
+
+### Registry and lifecycle
+
+- Use `~/.agenthub/registry.db` (override root with `AGENTHUB_HOME` for tests).
+  Register on init/up. Store opaque ID, canonical root, state directory, ports and
+  runtime ownership. Import legacy ports.json transactionally and conservatively.
+- Serialize allocation and per-project startup claims. Retain base 4600/stride 10;
+  retry available ranges on startup port conflicts. Never terminate foreign listeners.
+- Publish readiness only after binding. Authenticated status carries project ID,
+  instance ID, version and protocol; bounded clients verify the requested identity.
+- Only the owning instance removes runtime files or releases a claim. Stop waits
+  for owned children; uncertain ownership and incomplete shutdown are explicit errors.
+- Expose `projects`, `status --all`, and `projects remove <id>` (stopped metadata
+  only). Moved roots are new registrations; never merge by basename.
+
+### Unified dashboard
+
+- `ui --all [--no-open]` starts a separate lazy manager, usable outside projects.
+  `ui --all --stop` stops only the manager. Existing project-local ui remains.
+- List roots, status, peers, queues and task counts. Selecting a project exposes
+  existing stream, board, messages, approvals and budgets.
+- Start/stop registered hubs; stop confirmation names the project. Native TUI
+  launch remains CLI-only. Manager starts are attended and use project config and
+  credential files, not another project's gateway/state/unattended environment.
+- Manager uses console-only authenticated snapshot/action RPCs. Browser input
+  selects registry IDs, never arbitrary filesystem paths, PIDs, ports or tokens.
+  Mutations carry expected daemon instance. No automatic mutation retries.
+- Scope cursors/drafts by project, discard stale responses across switches and
+  restarts, and maintain bounded redacted event buffers in each daemon.
+- Preserve exact Host/Origin checks, loopback-only listeners, one-time tickets,
+  expiring HttpOnly sessions, CSP and terminal-only private approvals.
+- Bump the control protocol and rebuild the plugin. Incompatible hubs get explicit
+  upgrade/restart guidance, never automatic restart.
+- One active Codex TUI per hub; reject a second attachment. Quota windows may be
+  account-wide and must not be added together across projects.
+
+## Testing and acceptance criteria
+
+- Root discovery: nested directory/project, symlink, submodule, worktree, same
+  basename, invalid target, and inherited context from another project.
+- 32 simultaneous allocations retain all entries with unique ports. Concurrent
+  starts of one project produce one daemon. Migration, occupied ports and startup
+  recovery preserve existing data and live processes.
+- Two hubs with fake native/model services isolate boards, messages, approvals,
+  quota files, sidecars and shutdown. Test stale tokens, PID reuse, old protocols,
+  partial startup, instance changes and owned cleanup.
+- Browser: start with no hub, start two projects, switch/action/stop one and keep
+  using the other. Cover late responses, identical task IDs, expired approvals,
+  session expiry and PII redaction.
+- Run scripts/check.sh and record real two-project smoke evidence separately.
+
+## Delivery
+
+Implementation issue and feature branch, spec/docs updates, independently reviewed
+and verified PR. Preserve pre-existing instruction-file changes.
+
+## Out of scope
+
+Cross-project task routing, fully isolated native memory, new runtime dependencies,
+visual redesign, automatic merging and npm publication.

package/docs/specs/2026-09-20-durable-delivery-design.md

@@ -0,0 +1,67 @@
+# Durable delivery and supervised operations
+
+Status: Implemented on `feat/durable-delivery-operations`; release application pending
+Date: 2026-09-20
+Target: 0.7.0, protocol 10
+
+## Intent and acceptance
+
+Make ahub suitable for supervised daily development: expose disconnected recipients' pending work, survive daemon termination without silently losing accepted queued messages, and make uncertain execution an explicit operator decision. Publish an English operations guide and verify the release before applying it to the current installation.
+
+The user chose conservative recovery and deployment through production application. Never automatically replay uncertain or partially executed work. Exactly-once external effects, automatic rollback, and unattended native approval handling remain outside this release. Infrastructure prerequisites in issue #12 remain pending unless independently available; never manufacture quota exhaustion or disconnect the user's network.
+
+## Delivery model
+
+- Journal delivery state in the private project SQLite database with WAL, synchronous FULL, instance fencing, and private file permissions.
+- Commit fan-out recipients before acknowledging submission or dispatching any recipient. Preserve original envelopes and condensed-delivery mappings, IDs, priority/order, trace/hops, attempts, withdrawal state, prefaces and manual pauses.
+- States: queued, dispatching, accepted, completed, needs_review, failed, discarded. Persist handoff before invoking native delivery/steering. Adapter acceptance is not execution completion.
+- Recover queued messages automatically. Unsettled dispatching/accepted records become needs_review after an unplanned stop. Hold subsequent deliveries for that recipient until review is resolved.
+- Automatic retry requires positive evidence that delivery was not accepted or execution caused no effects. Timeouts, disconnects, cancellation and partial effects are uncertain.
+- Claude bridge acknowledgement only confirms bridge receipt. Socket writes, bridge submission and idle state never prove execution completion. Native completion or an explicit correlated reply may settle a receipt.
+- Persist failure/overflow outcomes; retain unresolved records indefinitely and bound resolved history with the existing deduplication window. A persistence fault stops dispatch and rejects successful-submission claims.
+
+## Interfaces
+
+- Peer delivery and steering receive an optional delivery ID. Adapters emit correlated accepted/completed/failed_safe/needs_review receipts separately from their state or answer.
+- Queue-only recipients appear offline in status with pending, important, needs-review counts and oldest queued timestamp. Broadcast and automatic assignment remain attached-peer operations; explicit known offline recipients can queue work.
+- Console commands: `ahub queue list [--peer <id>] [--json]`, `queue show <delivery-id>`, `queue resolve <delivery-id> --action completed|retry|discard --reason <text>`.
+- Resolution uses an observed revision, records the operator assertion and reason, and is idempotent. Retry closes the old record and creates exactly one linked attempt. Stale or conflicting resolutions fail.
+- New public status/recovery surfaces expose metadata; detailed console inspection follows existing private-envelope/PII redaction. No private body enters shared memory or public logs.
+
+## Recovery compatibility
+
+Protocol 10 carries the receipt contract. The new coordinator supports authenticated protocol 9 sources and protocol 10 targets, plus protocol 10 restarts. Unsupported combinations are rejected before shutdown; legacy protocols use their matching documented bootstrap.
+
+A legacy controlled-restart snapshot is imported exactly once into an uninitialized journal. An initialized journal remains authoritative; repeated starts and released snapshots cannot resurrect work. New snapshots carry the journal revision/state needed to validate preservation. Unsupported downgrade is refused before mutation.
+
+Stage the verified 0.7.0 artifact and run its retained coordinator for the initial 0.6.4-to-0.7.0 transition. Promote the global CLI only after verification. Preserve existing queued Codex envelopes, tasks, pauses and native session identity. Do not start hwp-cli or rewrite the divergent ai-workspace history.
+
+Recovery diagnostics distinguish missing session identity, terminal ownership uncertainty, confirmation pending and delivery reconciliation. Report the affected peer, verified terminal reference and next action; never fabricate receipts, bypass approval dialogs, or blindly create another terminal.
+
+## Documentation
+
+Update README and quickstart, add an English operations guide covering installation, managed launchers, a two-agent task/review workflow, targeted messages and priorities, approvals, queue resolution, graceful shutdown, upgrades, crash recovery and partial effects. Record real measurements separately from synthetic tests. Remove stale version pins and outdated compatibility statements.
+
+## Verification
+
+- Subprocess fault injection at durable enqueue, condensation, handoff, steering, acknowledgement and completion boundaries; only disposable processes may be killed.
+- Ordering, fan-out independence, overflow, retry exhaustion, withdrawal, dedupe, manual pauses, storage failure, corruption, stale-instance callbacks and migration interruption.
+- Idempotent resolution and snapshot import; no uncertain effect automatically repeated. Verify every adapter's receipt semantics, including silent completion and bridge failure.
+- CLI/dashboard parity for queue-only peers and redaction/access-control checks.
+- Full repository gate and Ubuntu/macOS CI, fresh-install documented workflow, real MLX/DGX/Kimi tests and attended Claude recovery.
+- Actual 0.6.4 package transition to protocol 10, then production application with version, session, queue, task and budget readback and a read-only Pi probe.
+
+## Work items
+
+- [x] Durable journal and bus recovery.
+- [x] Adapter delivery receipts and safe failure classification.
+- [x] Queue operator controls and status/dashboard visibility.
+- [x] Cross-version recovery compatibility and actionable diagnostics.
+- [x] English guides and recorded live evidence.
+- [ ] Fault tests, independent review, CI, release and verified application.
+
+## Integration decision
+
+The journal, adapter receipt contract and wire change are delivered in one coherent implementation PR, reviewed by subsystem. Shipping intermediate incompatible interfaces would leave a falsely durable runtime. The queue remains a durable snapshot until handoff; receipt rows retain handoff and resolution history. An operator retry atomically links a queued attempt and updates the bus snapshot.
+
+An identical operator action/reason may be repeated with its original observed revision or the freshly read terminal revision. Both return the existing result without another audit transition or retry enqueue. Conflicting actions/reasons and unrelated stale revisions are refused.

package/docs/specs/2026-09-20-pi-local-models-design.md

@@ -0,0 +1,40 @@
+# Pi with DGX and MLX
+
+Issue: #25. Pi is a managed project peer for implementation, edits, tests, summaries and triage. Claude/Codex retain planning and final review. Existing local-worker PII ownership does not change.
+
+## Runtime boundary
+
+- One managed Pi session owns each project, in headless RPC or native TUI mode.
+- Mode changes preserve the session ID/file and stop the previous owner before starting a replacement.
+- Only `agent_settled` completes a turn. Important chat can steer; task/review and private envelopes queue.
+- Native tools, extension discovery, skills and prompt templates are disabled. The explicit hub extension delegates file, shell and task tools back to the daemon.
+- The daemon retains existing path guards, sandbox and terminal approvals. A session/tool-call ledger records pending effects before execution and cached results afterward. Uncertain effects are never automatically replayed.
+- Native process identities and bridge credentials are separate from model credentials. Pi receives only the relay token, not gateway credentials.
+
+## Inference
+
+- `dgx/coding` and `dgx/fast` resolve through the project's existing OmniRoute configuration.
+- `mlx/fast` resolves to the machine-shared loopback MLX server.
+- Apple Silicon setup pins Python 3.12, `mlx-lm==0.31.3`, and `Qwen/Qwen3-8B-MLX-4bit` revision `383413e909f3bc5303ce195ebbdf0339c5a1a2a3`.
+- The MLX input estimate is capped at 16,000 tokens; decode and prompt concurrency are one. DGX's default input estimate cap is 262,144 tokens.
+- The relay authenticates every call, rejects browser origins and unknown model aliases, and preserves streamed bytes. It records the requested route and model reported by the backend.
+- MLX may fall back to DGX before response streaming begins. Failed non-PII tasks can escalate to configured cloud peers with an explicit warning to reconcile partial effects.
+- Runtime ownership includes process start identity. Project shutdown releases its relay, while explicit `ahub models stop` controls the shared MLX process.
+
+## Recovery and rollout
+
+Protocol 9 carries Pi session/launch metadata. Supported controlled upgrades read protocol-8 source contracts and restore protocol-9 targets. Legacy protocols 5-7 still require a matching CLI and attended bootstrap. No active session is forcibly interrupted to satisfy a deployment deadline.
+
+Public templates keep Pi disabled until the optional executable and model runtime are configured. Existing custom routing files remain authoritative and require explicit Pi class preferences when adopting this feature.
+
+## Verification
+
+The release gate is `scripts/check.sh`. Live acceptance additionally requires Pi tool roundtrips through DGX and MLX, native/RPC session handover, and canonical runtime status readback. Unit tests alone do not prove operational cutover.
+
+## Empty session handover (#27)
+
+Pi may report a session file before writing it. Before stopping an idle source,
+the hub queries its live session state. Only a verified empty source with no
+observed activity or persisted history may resume by exact session ID alone.
+Persisted conversations retain their exact file; missing nonempty history blocks
+handover. A failed target launch retains the verified resume identity for retry.

package/docs/specs/2026-09-20-upgrade-recovery-design.md

@@ -0,0 +1,151 @@
+# Controlled upgrade and session recovery
+
+Status: Implementation on `feat/upgrade-recovery`, issue #21
+Date: 2026-09-20
+
+## Problem and decisions
+
+Version 0.4.0 added project isolation but upgrading still required a separate
+restart script. Queued messages and manual pauses lived only in memory, and
+native terminal identity was not recorded. A successful package installation
+therefore did not prove that conversations or pending work survived.
+
+Protocol 8 adds a controlled-restart contract. Package installation, daemon
+readiness, native conversation recovery and queue release are separately
+verified. Existing protocols 5–7 require a manual maintenance bootstrap with
+their matching CLI; the new coordinator never guesses a PID to terminate.
+
+## Commands
+
+- `ahub upgrade --to <exact-version> --dry-run`: inspect the running registered
+  projects, release identity, native session mappings and blockers.
+- `ahub upgrade --to <exact-version> [--yes]`: review the plan, revalidate it and
+  schedule an independent recovery process. `--yes` accepts the displayed scope;
+  it never overrides blockers.
+- `ahub --project <path|id> restart [--dry-run] [--yes]`: recover one project using
+  the current package, without changing the global installation or plugin.
+- `ahub recovery status|resume <operation-id>`: read redacted progress or resume
+  the recorded operation after checking live ownership.
+- `ahub recovery abort <operation-id>`: cancel a preflight and release its lock
+  only before a runtime has stopped or a terminal mutation has been attempted.
+
+Upgrade uses all affected running registrations. Stopped projects stay stopped.
+An incompatible or unavailable active registration blocks apply. No global
+installation, plugin changes, runtime shutdown or terminal mutation occurs in
+dry-run. No lifecycle mutation is retried solely because a subprocess exited.
+
+## Runtime and coordinator
+
+The daemon exposes console-only `recovery` RPCs: inspect, prepare, commit, abort
+and release. Mutations are pinned to the expected instance and operation. Prepare
+holds deliveries while current turns and approvals finish. A ten-minute source
+preparation timeout aborts the hold without stopping the source. The replacement
+remains held until explicit verified release.
+Budget expiry, pause and handoff transitions are held with message delivery;
+in-flight budget work must settle before commit. Deferred quota readings are
+evaluated after release or abort, preserving hard-limit semantics.
+
+Commit writes a private, atomic project snapshot of queued envelopes, IDs,
+parents/hops, retries, dedupe state, prefaces, manual pauses and peer descriptors.
+The existing task and budget databases remain authoritative. A mismatched or
+corrupt snapshot blocks startup. Snapshot restoration precedes peer attachment;
+release is idempotent and retires replayable snapshot state before delivery.
+Release atomically moves that snapshot to a private per-operation archive before
+lifting the hold. Archives retain evidence for an uncertain release and are never
+automatically replayed. Preparation freezes the peer roster; a new unplanned peer
+cannot attach until recovery ends.
+
+The coordinator has an exclusive machine operation lock and an exclusive runner
+claim. Lifecycle commands and the manager respect that lock. Package versions
+are staged in a retained directory, with exact registry integrity and local
+runtime digest checks. The coordinator runs from a preserved source tree so
+replacing the global executable cannot kill its own recovery logic.
+Recovery authority is removed from native agent and app-server child environments.
+The reviewed fingerprint retains active-versus-offline peer membership, while
+normalizing transient idle/busy/paused changes.
+
+Projects transition sequentially. Source terminal ownership and idle state are
+verified before closing only the captured terminals. New daemons restore with
+delivery held, then Codex and hub-owned workers reconnect. The shared Claude
+plugin is installed in a final common phase, followed by the original Claude
+sessions. Verified projects release queues; the global CLI is promoted last.
+There is no automatic rollback of projects that have resumed work.
+
+An interrupted operation re-reads actual daemon identity, package digests,
+terminal mappings and phase receipts. Lost commit/start replies can be reconciled.
+Mutable receipts are reloaded under the exclusive runner claim, and saved terminal
+bindings are checked again before release. An ordinary startup ignores a completed
+operation ID inherited from a restored agent session.
+An uncertain terminal creation is not repeated: the original session must be
+found and verified, or the operation stays blocked for manual recovery.
+
+## Native session boundaries
+
+- Codex resumes the exact captured thread, with authenticated adapter readback.
+- Claude resumes the captured session after the shared plugin transition.
+- Kimi/local start new sessions using preserved routing selection and task context.
+- Orca terminal bindings use exact project, worktree, handle and incarnation.
+  Newly launched `ahub codex`/`ahub claude` wrappers record private ownership
+  metadata when Orca omits session identity. Only account-home references are
+  retained from their launch environment; credentials and arbitrary environment
+  values are excluded.
+- Other terminals or unverifiable bindings are `manual-required`. No terminal
+  title, generic process-name match or shell-input guess authorizes a restart.
+
+The initial coordinator supports protocol 8 source and target packages. A target
+with another control protocol requires a compatible coordinator and is rejected
+before shutdown. Fully general crash recovery and exactly-once external tool
+effects are not claimed.
+
+## Verification and release
+
+Test two-project ordering, queue and pause preservation, active turns/approvals,
+changed identities, stale terminal handles, PID reuse, interrupted steps,
+uncertain subprocess outcomes, corrupt snapshots and post-release normal use.
+Run `scripts/check.sh` on macOS and Ubuntu. Fake services and isolated detached
+CLI tests are distinct from an attended real Orca/native-account smoke.
+
+Protocol 5–7 bootstrap, real account smoke, production deployment and npm
+publication remain explicit release activities; this implementation does not
+silently restart the developer's currently running project sessions.
+The bootstrap includes an incompatible dashboard manager, which must also be
+stopped with its matching CLI before a protocol-8 manager is launched.
+
+## Current 0.7.0 correction and recovery contract
+
+The earlier sections record the protocol-8 implementation history. The current
+release is 0.6.4 with protocol 9; the next target is 0.7.0 with protocol 10.
+This correction supersedes the earlier protocol-8 source/target statement for
+the planned transition while retaining that historical evidence.
+
+The 0.7.0 coordinator accepts a verified protocol-9 source and starts a
+protocol-10 target. It must stage the exact package, preserve the source
+coordinator, and promote the global CLI only after the target has passed its
+readback. The transition is sequential per project and uses native managed
+launchers. Claude requires manual confirmation of the captured session before
+resume; the coordinator must never create a second Claude terminal when
+ownership is uncertain. Kimi and local-worker sessions may start fresh with
+preserved routing and task context. hwp-cli is outside this transition.
+
+Protocol 10 adds durable delivery receipts with the states
+`queued`, `dispatching`, `accepted`, `completed`, `needs_review`, `failed`,
+and `discarded`. An accepted bridge handoff is not task completion. An
+unsettled `dispatching` or `accepted` record after an unplanned stop becomes
+`needs_review`; timeout, disconnect, cancellation, and partial effects are
+uncertain and are never replayed automatically. Queue resolution records the
+observed revision and operator reason. A retry closes the old record and makes
+one linked attempt; stale or conflicting resolutions fail.
+
+The target console commands are `ahub queue list [--peer <id>] [--json]`,
+`ahub queue show <delivery-id>`, and `ahub queue resolve <delivery-id>
+--action completed|retry|discard --reason <text>`. They are a 0.7.0 target and
+remain unavailable in the released 0.6.4 CLI until implementation and live
+verification complete.
+
+The documented verification sequence is: run a dry-run, verify package and
+session identity, manually confirm Claude recovery, read back version, session,
+queue, task, and budget state, then release the held queues. Do not claim a
+successful 0.7.0 cutover from tests, synthetic approvals, or package
+installation alone. Issue [#12](https://github.com/STAIxBWLB/agent-hub/issues/12)
+remains open for off-campus Access credentials and a natural near-limit budget
+pause.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staix/agent-hub",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "description": "Native multi-agent hub: Claude Code, Codex, Kimi Code, Pi and local inference as peers in one project",
   "license": "MIT",
   "type": "module",
@@ -26,6 +26,7 @@
     "src",
     "plugins",
     "templates",
+    "docs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/plugins/agent-hub/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-hub",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "description": "Channel between Claude Code and the agent-hub daemon: peer messages from Codex, Kimi and the local worker arrive as channel events; hub_send replies.",
   "author": {
     "name": "Young Joon Lee",

package/plugins/agent-hub/server.js

@@ -15615,7 +15615,8 @@ function projectContext(cwd, env = process.env) {
 function stateDirFor(cwd) {
   return projectContext(cwd).stateDir;
 }
-var PROTOCOL = 9;
+var PROTOCOL = 10;
+var RECOVERY_SOURCE_PROTOCOLS = [9, PROTOCOL];
 function readControl(stateDir) {
   try {
     const status = JSON.parse(readFileSync2(join2(stateDir, "status.json"), "utf8"));
@@ -15646,7 +15647,7 @@ class ControlClient {
     this.ws = ws;
   }
   static connect(stateDir, hello, timeoutMs = 3000, protocol = PROTOCOL) {
-    if (protocol !== 8 && protocol !== PROTOCOL)
+    if (!RECOVERY_SOURCE_PROTOCOLS.includes(protocol))
       return Promise.reject(new Error(`unsupported recovery source protocol ${protocol}`));
     const control = readControl(stateDir);
     if (!control)
@@ -15726,7 +15727,7 @@ class ControlClient {
 // package.json
 var package_default = {
   name: "@staix/agent-hub",
-  version: "0.6.4",
+  version: "0.7.1",
   description: "Native multi-agent hub: Claude Code, Codex, Kimi Code, Pi and local inference as peers in one project",
   license: "MIT",
   type: "module",
@@ -15752,6 +15753,7 @@ var package_default = {
     "src",
     "plugins",
     "templates",
+    "docs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -15879,7 +15881,7 @@ var inbox = [];
 var hub;
 var detached;
 var offline = () => detached ?? "hub is not running for this project (start it with: ahub up).";
-async function push(envs) {
+async function push(envs, deliveryId) {
   const parent = replyParent(envs);
   const single = envs.length === 1;
   const content = single ? parent.body : envs.map((e) => `--- from ${e.from} (id ${e.id}, kind ${e.kind}) ---
@@ -15896,12 +15898,31 @@ ${sanitize(e.body)}`).join(`
   };
   try {
     await server.notification({ method: "notifications/claude/channel", params: { content, meta: meta2 } });
+    if (deliveryId && hub) {
+      try {
+        const receipt = await hub.request({ t: "delivery_receipt", deliveryId, state: "accepted" });
+        if (!receipt.ok)
+          log(`delivery receipt rejected by hub: ${receipt.error}`);
+      } catch (e) {
+        log(`channel delivery accepted but receipt could not be sent: ${e.message}`);
+      }
+    }
   } catch (e) {
-    log(`channel push failed, queued for hub_inbox: ${e.message}`);
-    for (const env of envs)
-      inbox.push(frame(env));
-    while (inbox.length > INBOX_CAP)
-      inbox.shift();
+    log(`channel push failed${deliveryId ? ", delivery requires review" : ", queued for hub_inbox"}: ${e.message}`);
+    if (deliveryId) {
+      if (hub) {
+        const receipt = await hub.request({ t: "delivery_receipt", deliveryId, state: "needs_review", reason: e.message });
+        if (!receipt.ok)
+          log(`delivery receipt rejected by hub: ${receipt.error}`);
+      } else {
+        log(`channel push failed while hub was unavailable; delivery ${deliveryId} remains unresolved`);
+      }
+    } else {
+      for (const env of envs)
+        inbox.push(frame(env));
+      while (inbox.length > INBOX_CAP)
+        inbox.shift();
+    }
   }
 }
 async function connectLoop() {
@@ -15918,7 +15939,7 @@ async function connectLoop() {
         peer: peerId,
         ...process.env.AGENTHUB_PROJECT_DIR ? { projectRoot: projectRoot2 } : {}
       });
-      client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env]);
+      client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env], msg.deliveryId);
       hub = client;
       attempt = -1;
       standingBy = false;

package/src/adapters/acp.ts

@@ -52,6 +52,8 @@ export class AcpPeer extends BasePeer {
   private readonly toolInputs = new Map<string, unknown>();
   private primed = false;
   private turn = 0; // generation: a prompt cancelled by the watchdog must not touch the turn that followed it
+  private activeDeliveryId: string | undefined;
+  private deliveryAccepted = false;
 
   constructor(
     id: PeerId,
@@ -94,6 +96,8 @@ export class AcpPeer extends BasePeer {
   }
 
   async stop(): Promise<void> {
+    if (this.activeDeliveryId) this.delivery({ id: this.activeDeliveryId, state: "needs_review", reason: "ACP session stopped before settlement" });
+    this.activeDeliveryId = undefined;
     const proc = this.proc;
     if (!proc || proc.exitCode !== null) return;
     await stopOwnedProcess(proc);
@@ -101,38 +105,64 @@ export class AcpPeer extends BasePeer {
   }
 
   /** Resolves once the prompt is in flight; the turn result arrives on its own. */
-  async deliver(envs: Envelope[]): Promise<void> {
-    if (this.state !== "idle") throw new Error(`${this.id} is ${this.state}`);
+  async deliver(envs: Envelope[], deliveryId?: string): Promise<void> {
+    if (this.state !== "idle") {
+      if (deliveryId) this.delivery({ id: deliveryId, state: "failed_safe", reason: `${this.id} is ${this.state}` });
+      throw new Error(`${this.id} is ${this.state}`);
+    }
     const turn = ++this.turn;
+    this.activeDeliveryId = deliveryId;
+    this.deliveryAccepted = false;
     this.chunks = [];
     this.setState("busy");
     // session/prompt answers only when the turn ends, so deliver resolves now and failures come back through onFailed.
-    this.request("session/prompt", { sessionId: this.sessionId, prompt: [{ type: "text", text: this.primed || !this.opts.preamble ? renderDigest(envs, this.primed) : `${this.opts.preamble}\n\n${renderDigest(envs, false)}` }] })
-      .then(() => {
-        this.primed = true;
+    const prompt = this.request("session/prompt", { sessionId: this.sessionId, prompt: [{ type: "text", text: this.primed || !this.opts.preamble ? renderDigest(envs, this.primed) : `${this.opts.preamble}\n\n${renderDigest(envs, false)}` }] });
+    prompt
+      .then((result) => {
         if (turn !== this.turn) return; // superseded: these chunks belong to a later turn
+        this.primed = true;
         const body = this.chunks.join("").trim();
         if (body) this.onMessage?.(body, { inReplyTo: replyParent(envs), to: replyAudience(envs) });
+        if (deliveryId && this.activeDeliveryId === deliveryId) {
+          this.acceptDelivery();
+          this.delivery({ id: deliveryId, state: result?.stopReason === "end_turn" ? "completed" : "needs_review", ...(result?.stopReason === "end_turn" ? {} : { reason: "ACP prompt ended without normal completion" }) });
+        }
       })
       .catch((e: Error) => {
         this.opts.log?.(`[${this.id}] prompt failed: ${e.message}`);
-        this.onFailed?.(envs);
+        if (deliveryId && this.activeDeliveryId === deliveryId) this.delivery({ id: deliveryId, state: "needs_review", reason: e.message });
+        else if (!deliveryId) this.onFailed?.(envs);
       })
       .finally(() => {
         if (turn === this.turn && this.state === "busy") this.setState("idle");
+        if (turn === this.turn && this.activeDeliveryId === deliveryId) this.activeDeliveryId = undefined;
       });
   }
 
   protected override onWatchdog(): void {
+    const durable = !!this.activeDeliveryId;
+    if (this.activeDeliveryId) this.delivery({ id: this.activeDeliveryId, state: "needs_review", reason: "ACP turn watchdog timeout" });
+    this.activeDeliveryId = undefined;
     this.notify("session/cancel", { sessionId: this.sessionId });
     this.turn++; // whatever the cancelled prompt still reports is stale
-    super.onWatchdog();
+    // ACP updates carry only a session ID, not a turn ID. After a durable turn times out,
+    // keep the adapter offline until it is restarted so late chunks cannot contaminate a new turn.
+    if (durable) this.setState("offline");
+    else super.onWatchdog();
+  }
+
+  private acceptDelivery(): void {
+    if (!this.activeDeliveryId || this.deliveryAccepted) return;
+    this.deliveryAccepted = true;
+    this.delivery({ id: this.activeDeliveryId, state: "accepted" });
   }
 
   private down(reason: string): void {
     this.opts.log?.(`[${this.id}] ${reason}`);
     for (const p of this.pending.values()) p.reject(new Error(reason));
     this.pending.clear();
+    if (this.activeDeliveryId) this.delivery({ id: this.activeDeliveryId, state: "needs_review", reason });
+    this.activeDeliveryId = undefined;
     this.setState("offline");
   }
 
@@ -146,6 +176,9 @@ export class AcpPeer extends BasePeer {
     if (this.state === "busy") this.touch();
 
     if (msg.method === "session/update") {
+      if (msg.params?.sessionId && msg.params.sessionId !== this.sessionId) return;
+      if (this.state !== "busy") return;
+      this.acceptDelivery();
       const u = msg.params?.update;
       if (u?.sessionUpdate === "agent_message_chunk" && u.content?.type === "text") this.chunks.push(u.content.text);
       // The permission request that follows may carry no `rawInput` (Kimi 2.0.1 does not), and then the

package/src/adapters/claude-channel.ts

@@ -86,7 +86,7 @@ let detached: string | undefined; // why this server stopped reconnecting; tool
 const offline = () => detached ?? "hub is not running for this project (start it with: ahub up).";
 
 /** One delivery = one notification, because every notification can cost Claude a turn. */
-async function push(envs: Envelope[]): Promise<void> {
+async function push(envs: Envelope[], deliveryId?: string): Promise<void> {
   const parent = replyParent(envs); // reply_to on this id keeps the hop count honest
   const single = envs.length === 1;
   const content = single ? parent.body : envs.map((e) => `--- from ${e.from} (id ${e.id}, kind ${e.kind}) ---\n${sanitize(e.body)}`).join("\n\n");
@@ -100,10 +100,27 @@ async function push(envs: Envelope[]): Promise<void> {
   };
   try {
     await server.notification({ method: "notifications/claude/channel", params: { content, meta } });
+    if (deliveryId && hub) {
+      try {
+        const receipt = await hub.request({ t: "delivery_receipt", deliveryId, state: "accepted" });
+        if (!receipt.ok) log(`delivery receipt rejected by hub: ${receipt.error}`);
+      } catch (e) {
+        log(`channel delivery accepted but receipt could not be sent: ${(e as Error).message}`);
+      }
+    }
   } catch (e) {
-    log(`channel push failed, queued for hub_inbox: ${(e as Error).message}`);
-    for (const env of envs) inbox.push(frame(env)); // same sanitized header as everywhere else
-    while (inbox.length > INBOX_CAP) inbox.shift();
+    log(`channel push failed${deliveryId ? ", delivery requires review" : ", queued for hub_inbox"}: ${(e as Error).message}`);
+    if (deliveryId) {
+      if (hub) {
+        const receipt = await hub.request({ t: "delivery_receipt", deliveryId, state: "needs_review", reason: (e as Error).message });
+        if (!receipt.ok) log(`delivery receipt rejected by hub: ${receipt.error}`);
+      } else {
+        log(`channel push failed while hub was unavailable; delivery ${deliveryId} remains unresolved`);
+      }
+    } else {
+      for (const env of envs) inbox.push(frame(env)); // same sanitized header as everywhere else
+      while (inbox.length > INBOX_CAP) inbox.shift();
+    }
   }
 }
 
@@ -119,7 +136,7 @@ async function connectLoop(): Promise<void> {
     try {
       const client = await ControlClient.connect(stateDir, { role: toolsOnly ? "tools" : "peer", peer: peerId,
         ...(process.env.AGENTHUB_PROJECT_DIR ? { projectRoot } : {}) });
-      client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env]); // `env`: a daemon older than wire version 2
+      client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env], msg.deliveryId); // `env`: a daemon older than wire version 2
       hub = client;
       attempt = -1;
       standingBy = false;