@staix/agent-hub 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.6.2
+
+- Address a peer's reply at whoever asked instead of broadcasting it, so one directed question no longer costs every attached peer a turn (#29).
+- Cap the priority a hub-native peer claims for itself: `[IMPORTANT]` on an unsolicited report no longer interrupts the other peers (#29).
+- A session whose peer id was taken over stands by and reclaims it once the hub reports the peer offline, instead of staying detached until the whole session is restarted (#30).
+- Show the command a Kimi tool call will run in its approval prompt, taken from the `tool_call` update when the permission request omits it; a prompt whose payload cannot be resolved says so and offers no session-wide grant (#31).
+- `ahub status` prints a namespaced backend alias once (`dgx/coding`, not `dgx/dgx/coding`) and names the backend Pi asked for on its last turn (#32).
+
+## 0.6.1
+
+- Preserve Pi session identity when handing an empty native session between headless and TUI modes (#27).
+- Keep recovery metadata and native terminal restoration bound to the verified project session.
+
 ## 0.6.0
 
 - Pi peer with managed local model routing, RPC and native terminal integration (#25).

package/README.md

@@ -4,7 +4,7 @@ Native multi-agent hub for one developer's machine: Claude Code, Codex, Kimi Cod
 hub-owned local-LLM worker collaborate as peers in independent project directories, with
 task-aware model routing (Switchyard) in front of a self-hosted gateway (OmniRoute).
 
-Status: 0.6.0. All six milestones of the design spec are implemented; the [smoke checklist](docs/smoke.md)
+Status: 0.6.2. All six milestones of the design spec are implemented; the [smoke checklist](docs/smoke.md)
 says what has and has not been verified against real agents.
 
 Version 0.5.0 adds [controlled upgrade and session recovery](docs/specs/2026-09-20-upgrade-recovery-design.md).
@@ -29,7 +29,7 @@ cd <your project> && ahub init && ahub up && ahub tail
 Or install the same version from GitHub:
 
 ```bash
-bun add -g github:STAIxBWLB/agent-hub#v0.6.0 && ahub setup
+bun add -g github:STAIxBWLB/agent-hub#v0.6.2 && ahub setup
 ```
 
 The installed commands remain `ahub` and `agent-hub`.
@@ -99,7 +99,9 @@ does not stop MLX. The relay can fall back from MLX to DGX before streaming
 starts. Inspect `ahub status` for requested routes and reported backend models.
 
 A project has one managed Pi session owner. Mode changes require the agent to
-settle and preserve the session file. Protocol 9 adds Pi recovery metadata;
+settle and preserve the session file. Before the first generation, a live source
+verified to be empty can instead retain its exact session ID without a file.
+Missing history from a nonempty session blocks handover. Protocol 9 adds Pi recovery metadata;
 protocol-8 hubs can use controlled upgrade, while protocols 5-7 still require
 their matching CLI and an attended bootstrap.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staix/agent-hub",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Native multi-agent hub: Claude Code, Codex, Kimi Code, Pi and local inference as peers in one project",
   "license": "MIT",
   "type": "module",

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

@@ -1,6 +1,6 @@
 {
   "name": "agent-hub",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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

@@ -15726,7 +15726,7 @@ class ControlClient {
 // package.json
 var package_default = {
   name: "@staix/agent-hub",
-  version: "0.6.0",
+  version: "0.6.2",
   description: "Native multi-agent hub: Claude Code, Codex, Kimi Code, Pi and local inference as peers in one project",
   license: "MIT",
   type: "module",
@@ -15839,14 +15839,24 @@ function roles() {
 }
 var MAX_RECONNECT_DELAY_MS = 30000;
 var TERMINAL_CLOSES = {
-  4000: `another session attached to the hub as "${peerId}"; this one is detached (restart it to take the peer back)`,
   4401: "the hub refused the control token",
   4404: "the hub belongs to a different project or instance; restart this session from the intended project",
   4403: `the hub refused the peer id "${peerId}" (reserved or malformed)`,
   4409: `the peer id "${peerId}" is taken by a hub-managed adapter`,
   4426: "wire version mismatch with the running hub: update the agent-hub plugin (ahub setup) and restart this session"
 };
+var HELD_CLOSE = 4000;
+var HELD = `another session is attached to the hub as "${peerId}"; this one is standing by and takes the peer back when that session leaves`;
 var INBOX_CAP = 200;
+function peerHeld() {
+  try {
+    const status = JSON.parse(readFileSync3(join3(stateDir, "status.json"), "utf8"));
+    const peer = status.peers?.[peerId];
+    return !!peer && (peer.state !== "offline" || peer.claiming === true);
+  } catch {
+    return false;
+  }
+}
 var INSTRUCTIONS = [
   "agent-hub connects you to other coding agents working in this project (for example codex, kimi, local) and to the hub console user.",
   'Their messages arrive as <channel source="agent-hub" ...> tags; meta.source names the sender and meta.message_id identifies the message.',
@@ -15895,7 +15905,12 @@ ${sanitize(e.body)}`).join(`
   }
 }
 async function connectLoop() {
+  let standingBy = false;
   for (let attempt = 0;; attempt++) {
+    if (standingBy && peerHeld()) {
+      await new Promise((r) => setTimeout(r, Math.min(1000 * 2 ** Math.max(attempt, 0), MAX_RECONNECT_DELAY_MS)));
+      continue;
+    }
     let code;
     try {
       const client = await ControlClient.connect(stateDir, {
@@ -15906,6 +15921,8 @@ async function connectLoop() {
       client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env]);
       hub = client;
       attempt = -1;
+      standingBy = false;
+      detached = undefined;
       log(`connected to hub as "${peerId}"`);
       code = await new Promise((r) => client.onClose = r);
       hub = undefined;
@@ -15919,6 +15936,12 @@ async function connectLoop() {
       detached = TERMINAL_CLOSES[code];
       return log(`stopped reconnecting: ${detached}`);
     }
+    if (code === HELD_CLOSE) {
+      if (!standingBy)
+        log(`standing by: ${HELD}`);
+      standingBy = true;
+      detached = HELD;
+    }
     await new Promise((r) => setTimeout(r, Math.min(1000 * 2 ** Math.max(attempt, 0), MAX_RECONNECT_DELAY_MS)));
   }
 }

package/src/adapters/acp.ts

@@ -1,6 +1,6 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { createInterface } from "node:readline";
-import { renderDigest, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
+import { renderDigest, replyAudience, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
 import { BasePeer } from "../hub/peers.ts";
 import { childEnv, stopOwnedProcess } from "../hub/child-process.ts";
 
@@ -30,12 +30,15 @@ export interface AcpOptions {
   preamble?: string;
   /** The session's running token total from `usage_update` (inferred shape: totalTokens, else input + output, else `used`). Cumulative, not a delta. */
   onTokens?: (sessionTotal: number) => void;
-  /** Resolve with an optionId, or undefined to cancel. Absent = every request is cancelled. */
+  /** Resolve with an optionId, or undefined to cancel. Absent = every request is cancelled.
+   *  A request whose payload could not be resolved is titled as such and carries no session-wide allow option. */
   onPermission?: (req: PermissionRequest) => Promise<string | undefined>;
   log?: (line: string) => void;
 }
 
 const HANDSHAKE_MS = 30_000;
+/** Tool calls whose arguments are remembered until their permission request arrives. */
+const TOOL_INPUT_CAP = 64;
 
 type Pending = { resolve: (v: any) => void; reject: (e: Error) => void };
 
@@ -46,6 +49,7 @@ export class AcpPeer extends BasePeer {
   private nextId = 1;
   private readonly pending = new Map<number, Pending>();
   private chunks: string[] = [];
+  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
 
@@ -108,7 +112,7 @@ export class AcpPeer extends BasePeer {
         this.primed = true;
         if (turn !== this.turn) return; // superseded: these chunks belong to a later turn
         const body = this.chunks.join("").trim();
-        if (body) this.onMessage?.(body, { inReplyTo: replyParent(envs) });
+        if (body) this.onMessage?.(body, { inReplyTo: replyParent(envs), to: replyAudience(envs) });
       })
       .catch((e: Error) => {
         this.opts.log?.(`[${this.id}] prompt failed: ${e.message}`);
@@ -144,6 +148,13 @@ export class AcpPeer extends BasePeer {
     if (msg.method === "session/update") {
       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
+      // console would be asked to approve a bare tool name. Keep what the call said it would run (issue #31).
+      else if ((u?.sessionUpdate === "tool_call" || u?.sessionUpdate === "tool_call_update") && typeof u.toolCallId === "string") {
+        if (u.rawInput !== undefined) this.toolInputs.set(u.toolCallId, u.rawInput);
+        if (u.status === "completed" || u.status === "failed") this.toolInputs.delete(u.toolCallId);
+        while (this.toolInputs.size > TOOL_INPUT_CAP) this.toolInputs.delete(this.toolInputs.keys().next().value as string);
+      }
       else if (u?.sessionUpdate === "usage_update" && this.opts.onTokens) {
         const f = { ...u, ...(typeof u.usage === "object" ? u.usage : {}) } as Record<string, unknown>;
         const num = (k: string) => (typeof f[k] === "number" ? (f[k] as number) : 0);
@@ -163,11 +174,14 @@ export class AcpPeer extends BasePeer {
   }
 
   private async answerPermission(msg: any): Promise<void> {
-    const options: PermissionOption[] = msg.params?.options ?? [];
     const call = msg.params?.toolCall ?? {};
-    // The approver has to see what runs, not only the tool's name ("Bash").
-    const input = call.rawInput === undefined ? "" : `: ${(typeof call.rawInput === "string" ? call.rawInput : JSON.stringify(call.rawInput)).slice(0, 600)}`;
-    const title: string = `${call.title ?? "tool call"}${input}`;
+    // The approver has to see what runs, not only the tool's name ("Bash"). The request itself carries it
+    // for some agents; for the rest it was on the `tool_call` update that announced the call.
+    const raw = call.rawInput ?? (typeof call.toolCallId === "string" ? this.toolInputs.get(call.toolCallId) : undefined);
+    const input = raw === undefined ? "" : `: ${(typeof raw === "string" ? raw : JSON.stringify(raw)).slice(0, 600)}`;
+    // An unknown payload is never dressed up as a description, and it must not buy a blanket grant.
+    const title: string = raw === undefined ? `${call.title ?? "tool call"} (payload not reported by the agent)` : `${call.title ?? "tool call"}${input}`;
+    const options: PermissionOption[] = (msg.params?.options ?? []).filter((o: PermissionOption) => raw !== undefined || o.kind !== "allow_always");
     const picked = await this.opts.onPermission?.({ peer: this.id, title, options }).catch(() => undefined);
     const valid = options.some((o) => o.optionId === picked);
     this.send({

package/src/adapters/claude-channel.ts

@@ -28,17 +28,36 @@ function roles(): Record<string, string[]> {
   }
 }
 const MAX_RECONNECT_DELAY_MS = 30_000;
-/** Close codes a retry cannot fix: another session took this peer id (4000), bad token, reserved or taken id, wire version. */
+/** Close codes a retry cannot fix: bad token, wrong project, reserved or taken id, wire version. */
 const TERMINAL_CLOSES: Record<number, string> = {
-  4000: `another session attached to the hub as "${peerId}"; this one is detached (restart it to take the peer back)`,
   4401: "the hub refused the control token",
   4404: "the hub belongs to a different project or instance; restart this session from the intended project",
   4403: `the hub refused the peer id "${peerId}" (reserved or malformed)`,
   4409: `the peer id "${peerId}" is taken by a hub-managed adapter`,
   4426: "wire version mismatch with the running hub: update the agent-hub plugin (ahub setup) and restart this session",
 };
+/** Another session attached under this peer id. Unlike the other closes this one ends on its own, so the
+ *  session stands by and takes the peer back once the hub reports it offline (issue #30). */
+const HELD_CLOSE = 4000;
+const HELD = `another session is attached to the hub as "${peerId}"; this one is standing by and takes the peer back when that session leaves`;
 const INBOX_CAP = 200;
 
+/**
+ * Whether a live session holds this peer id, per the daemon's own status file. The hub gives the id to
+ * whoever said hello last, so reconnecting blind would evict the session that just took it and the two
+ * would trade the peer forever. No readable status means no live hub holds it, and a connect can only fail.
+ */
+function peerHeld(): boolean {
+  try {
+    const status = JSON.parse(readFileSync(join(stateDir, "status.json"), "utf8")) as { peers?: Record<string, { state?: string; claiming?: boolean }> };
+    const peer = status.peers?.[peerId];
+    // `claiming`: a hello that has not finished its preface. It reads as offline but a session is arriving.
+    return !!peer && (peer.state !== "offline" || peer.claiming === true);
+  } catch {
+    return false;
+  }
+}
+
 const INSTRUCTIONS = [
   "agent-hub connects you to other coding agents working in this project (for example codex, kimi, local) and to the hub console user.",
   'Their messages arrive as <channel source="agent-hub" ...> tags; meta.source names the sender and meta.message_id identifies the message.',
@@ -89,7 +108,13 @@ async function push(envs: Envelope[]): Promise<void> {
 }
 
 async function connectLoop(): Promise<void> {
+  let standingBy = false;
   for (let attempt = 0; ; attempt++) {
+    // Standing by after a take-over: wait for the slot rather than evicting whoever holds it now.
+    if (standingBy && peerHeld()) {
+      await new Promise((r) => setTimeout(r, Math.min(1000 * 2 ** Math.max(attempt, 0), MAX_RECONNECT_DELAY_MS)));
+      continue;
+    }
     let code: number | undefined;
     try {
       const client = await ControlClient.connect(stateDir, { role: toolsOnly ? "tools" : "peer", peer: peerId,
@@ -97,6 +122,8 @@ async function connectLoop(): Promise<void> {
       client.onPush = (msg) => msg.t === "deliver" && void push(msg.envs ?? [msg.env]); // `env`: a daemon older than wire version 2
       hub = client;
       attempt = -1;
+      standingBy = false;
+      detached = undefined;
       log(`connected to hub as "${peerId}"`);
       code = await new Promise<number>((r) => (client.onClose = r));
       hub = undefined;
@@ -105,11 +132,16 @@ async function connectLoop(): Promise<void> {
       code = (e as { code?: number }).code;
       if (attempt === 0) log((e as Error).message);
     }
-    // Retrying these only fights another session or hammers a hub that will refuse again.
+    // Retrying these only hammers a hub that will refuse again.
     if (code !== undefined && TERMINAL_CLOSES[code]) {
       detached = TERMINAL_CLOSES[code];
       return log(`stopped reconnecting: ${detached}`);
     }
+    if (code === HELD_CLOSE) {
+      if (!standingBy) log(`standing by: ${HELD}`);
+      standingBy = true;
+      detached = HELD;
+    }
     await new Promise((r) => setTimeout(r, Math.min(1000 * 2 ** Math.max(attempt, 0), MAX_RECONNECT_DELAY_MS)));
   }
 }

package/src/adapters/codex-appserver.ts

@@ -344,6 +344,8 @@ export class CodexPeer extends BasePeer {
       const inReplyTo = this.injected;
       this.injected = undefined;
       this.deltas.clear();
+      // ponytail: the reply is addressed to the highest-hop sender only (newEnvelope's default). A digest that
+      // mixed senders answers the last of them; track the audience alongside `injected` if that starts to matter.
       if (this.lastAnswer) this.onMessage?.(this.lastAnswer, inReplyTo ? { inReplyTo } : {});
       this.lastAnswer = "";
       this.setState("idle");

package/src/adapters/local-worker.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { renderDigest, replyParent, STANDING_INSTRUCTION, USER, type Envelope, type EnvelopeOpts, type PeerId } from "../hub/envelope.ts";
+import { renderDigest, replyAudience, replyParent, STANDING_INSTRUCTION, USER, type Envelope, type EnvelopeOpts, type PeerId } from "../hub/envelope.ts";
 import { TASK_TOOL_NAMES, TASK_TOOLS } from "../hub/hub-tools.ts";
 import { BasePeer } from "../hub/peers.ts";
 import { profile } from "../local/sandbox.ts";
@@ -52,6 +52,7 @@ const system = (cwd: string, preamble = "") =>
 
 /** Hub-native agent loop: the hub owns every model call, so it can choose the model per call (L2) and the gateway (L3). */
 export class LocalPeer extends BasePeer {
+  readonly hubNative = true;
   private readonly history: ChatMessage[] = [];
   private readonly sessionId = `agent-hub-local-${randomUUID()}`;
   private turn = 0; // generation guard, as in acp.ts: a turn aborted by the watchdog must not touch the next one
@@ -96,7 +97,7 @@ export class LocalPeer extends BasePeer {
     const policy = this.opts.turnPolicy?.(envs);
     // A PII turn speaks to the console user only, and privately: its answer must not be broadcast to cloud-hosted peers.
     // The task id travels with it, so the board can keep the text (`ahub task show`) while tail and log show a stub.
-    const reply: EnvelopeOpts = { inReplyTo: replyParent(envs), ...(policy?.pii ? { to: [USER], private: true, priority: "important" as const, ...(policy.task ? { refs: { task: policy.task } } : {}) } : {}) };
+    const reply: EnvelopeOpts = { inReplyTo: replyParent(envs), to: replyAudience(envs), ...(policy?.pii ? { to: [USER], private: true, priority: "important" as const, ...(policy.task ? { refs: { task: policy.task } } : {}) } : {}) };
     this.run(envs, turn, msgs, progress, policy, reply)
       .then((answer) => {
         if (turn !== this.turn) return;
@@ -148,7 +149,7 @@ export class LocalPeer extends BasePeer {
       permit: this.opts.tools.permit,
       sandboxProfile: this.sandboxProfile,
       send: (text, to) => {
-        this.onMessage?.(text, policy?.pii ? reply : { inReplyTo: replyParent(envs), ...(to?.length ? { to } : {}) });
+        this.onMessage?.(text, policy?.pii ? reply : { inReplyTo: replyParent(envs), to: to?.length ? to : replyAudience(envs) });
         return policy?.pii ? "sent to the console user only (PII task)" : "sent";
       },
     };

package/src/adapters/pi.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, relative } from "node:path";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { renderDigest, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
+import { renderDigest, replyAudience, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
 import { BasePeer } from "../hub/peers.ts";
 import { stopOwnedProcess } from "../hub/child-process.ts";
 
@@ -20,6 +20,7 @@ export interface PiOptions {
 }
 export interface PiTuiLaunch { cmd: string; args: string[]; env: NodeJS.ProcessEnv; }
 type RpcMessage = { type?: string; id?: string | number; command?: string; success?: boolean; data?: any; [key: string]: any };
+type VerifiedEmptyResume = { sessionId: string };
 function processSignature(pid: number): string | undefined { try { const result = Bun.spawnSync(["ps", "-p", String(pid), "-o", "lstart=,comm="], { stdout: "pipe", stderr: "pipe" }); if (result.exitCode !== 0) return undefined; const text = result.stdout.toString().trim(); return text ? new Bun.CryptoHasher("sha256").update(text).digest("hex") : undefined; } catch { return undefined; } }
 function ownerStillAlive(pid: number, signature: string | undefined): boolean { const current = processSignature(pid); if (current !== undefined) return current === signature; try { process.kill(pid, 0); return true; } catch { return false; } }
 
@@ -32,6 +33,7 @@ const modelFor = (backend: PiOptions["backend"], models: PiModelDescriptor[]): s
 };
 
 export class PiPeer extends BasePeer {
+  readonly hubNative = true;
   private proc?: ChildProcessWithoutNullStreams;
   private server?: ReturnType<typeof Bun.serve>;
   private buffer = "";
@@ -43,6 +45,10 @@ export class PiPeer extends BasePeer {
   private currentReply?: Envelope;
   private sessionId = "";
   private sessionFile = "";
+  private emptyResumeVerified = false;
+  private verifiedEmptyResume?: VerifiedEmptyResume;
+  private activityObserved = false;
+  private persistedOnce = false;
   private activeEnvs: Envelope[] = [];
   private activeTools = 0;
   private agentRunning = false;
@@ -64,15 +70,60 @@ export class PiPeer extends BasePeer {
 
   constructor(id: PeerId, private readonly opts: PiOptions) { super(id, opts.watchdogMs); }
   get tuiLaunch(): PiTuiLaunch | undefined { return this._tuiLaunch; }
+  get pendingResume(): { sessionId?: string; sessionFile?: string } {
+    if (this.canReuseVerifiedEmptyResume()) return { sessionId: this.verifiedEmptyResume!.sessionId };
+    return { sessionId: this.opts.sessionId, sessionFile: this.opts.sessionFile };
+  }
   get acceptingTools(): boolean { return !this.stopping; }
   /** Idle verified owners can be stopped; uncertain live owners and pending launches stay fenced. */
   get recoveryReady(): boolean {
     if (this.state === "busy" || this.starting || this.activeTools) return false;
-    if (this.opts.mode === "headless") return this.state === "idle" || !this.proc || this.proc.exitCode !== null;
+    if (this.sessionFile && !existsSync(this.sessionFile) && (this.activityObserved || this.persistedOnce)) return false;
+    if (this.opts.mode === "headless") return this.state === "idle" || !this.proc || this.proc.exitCode !== null || this.proc.signalCode !== null;
     if (this.state === "idle") return this.ownerClaimed && !!this.ownerPid && processSignature(this.ownerPid) === this.ownerSignature;
     return this.stopping && !this.ownerClaimed && (!this.ownerPid || !ownerStillAlive(this.ownerPid, this.ownerSignature));
   }
-  recoveryMetadata(): Record<string, unknown> { return { launch: { kind: "pi", cwd: this.opts.cwd, mode: this.opts.mode, backend: this.opts.backend, ...(this.opts.model ? { model: this.opts.model } : {}), ...(this.sessionFile ? { sessionFile: this.sessionFile } : {}) }, ...(this.sessionId ? { sessionId: this.sessionId } : {}), ...(this.sessionFile ? { sessionFile: this.sessionFile } : {}) }; }
+  recoveryMetadata(): Record<string, unknown> {
+    const exists = !!this.sessionFile && existsSync(this.sessionFile);
+    if (exists) { this.persistedOnce = true; this.verifiedEmptyResume = undefined; }
+    const empty = this.emptyResumeVerified && !this.activityObserved && !this.persistedOnce;
+    const file = this.sessionFile && (exists || !empty) ? this.sessionFile : undefined;
+    return { launch: { kind: "pi", cwd: this.opts.cwd, mode: this.opts.mode, backend: this.opts.backend, ...(this.opts.model ? { model: this.opts.model } : {}), ...(file ? { sessionFile: file } : {}) }, ...(this.sessionId ? { sessionId: this.sessionId } : {}), ...(file ? { sessionFile: file } : {}) };
+  }
+
+  /** Verify the live source before choosing ID-only restoration. Never infer emptiness from a missing file. */
+  async captureResume(): Promise<Record<string, unknown>> {
+    if (this.state === "offline") {
+      if (this.canReuseVerifiedEmptyResume()) return this.recoveryMetadata();
+      if (this.recoveryReady && this.sessionFile && existsSync(this.sessionFile)) return this.recoveryMetadata();
+      throw new Error("Pi source session is offline and has no verified persisted resume state");
+    }
+    this.emptyResumeVerified = false;
+    if (this.state !== "idle" || this.stopping || this.activeTools) throw new Error("Pi must settle before session capture");
+    if (this.sessionFile && existsSync(this.sessionFile)) return this.recoveryMetadata();
+    const snapshot = this.opts.mode === "headless"
+      ? (await this.waitRpc("get_state", 15_000)).data
+      : await this.sendTui({ type: "get_session_state" });
+    if (this.state !== "idle" || this.activeTools || snapshot?.sessionId !== this.sessionId || snapshot?.sessionFile !== this.sessionFile) throw new Error("Pi source session changed during capture");
+    const empty = this.opts.mode === "headless"
+      ? snapshot.messageCount === 0 && snapshot.pendingMessageCount === 0 && snapshot.isStreaming === false && snapshot.isCompacting !== true && !snapshot.sessionName
+      : snapshot.empty === true && snapshot.idle === true;
+    if (!empty || this.activityObserved || this.persistedOnce) throw new Error("Pi session history is not persisted; refusing to recreate it");
+    this.emptyResumeVerified = true;
+    const captured = this.recoveryMetadata();
+    if (typeof captured.sessionId === "string" && !captured.sessionFile) this.verifiedEmptyResume = { sessionId: captured.sessionId };
+    return captured;
+  }
+
+  private canReuseVerifiedEmptyResume(): boolean {
+    return !!this.verifiedEmptyResume && this.recoveryReady && !this.activityObserved && !this.persistedOnce && this.sessionId === this.verifiedEmptyResume.sessionId && (!this.sessionFile || !existsSync(this.sessionFile));
+  }
+
+  private noteActivity(): void {
+    this.activityObserved = true;
+    this.emptyResumeVerified = false;
+    this.verifiedEmptyResume = undefined;
+  }
 
   async start(): Promise<void> {
     if (this.starting) return this.starting;
@@ -112,6 +163,7 @@ export class PiPeer extends BasePeer {
       }
       if (url.pathname === "/tool") {
         if (this.stopping || this.state === "offline") return Response.json({ text: "error: Pi owner is stopped" }, { status: 409 });
+        this.noteActivity();
         this.activeTools++;
         if (this.state === "idle") this.setState("busy");
         if (this.state === "busy") this.touch();
@@ -148,6 +200,7 @@ export class PiPeer extends BasePeer {
       throw new Error("Pi get_state session identity does not match the requested recovery session");
     }
     this.sessionId = state.data.sessionId; this.sessionFile = state.data.sessionFile;
+    this.persistedOnce = existsSync(this.sessionFile);
     if ((this.opts.sessionId && this.sessionId !== this.opts.sessionId) || (this.opts.sessionFile && this.sessionFile !== this.opts.sessionFile)) throw new Error("Pi startup session identity mismatch");
     this.setState("idle");
   }
@@ -194,6 +247,7 @@ export class PiPeer extends BasePeer {
     try {
       const requested = await this.opts.selectModel?.(envs);
       if (requested) await this.setRequestedModel(requested);
+      this.noteActivity();
       attempted = true;
       if (this.opts.mode === "tui") await this.sendTui({ type: "prompt", message: renderDigest(envs, true) });
       else await this.sendRpc({ type: "prompt", message: renderDigest(envs, true) });
@@ -235,7 +289,7 @@ export class PiPeer extends BasePeer {
       this.startOwnerMonitor(); if (this.opts.mode === "tui") this.setState("idle");
     }
     if (event.type === "session_shutdown") { this.stopping = true; this.ownerClaimed = false; this.clearOwnerMonitor(); this.resolveTuiExit?.(); this.resolveTuiExit = undefined; this.setState("offline"); }
-    if (event.type === "agent_start") { this.agentRunning = true; this.setState("busy"); }
+    if (event.type === "agent_start") { this.noteActivity(); this.agentRunning = true; this.setState("busy"); }
     if (event.type === "activity" && this.state === "busy") this.touch();
     if (event.type === "agent_end") {
       this.settledText = typeof event.text === "string" ? event.text : "";
@@ -247,9 +301,12 @@ export class PiPeer extends BasePeer {
       if (typeof event.text === "string" && event.text.trim()) this.settledText = event.text;
       const text = this.settledText.trim(); const error = this.settledError; const cancelled = this.settledCancelled;
       this.settledText = ""; this.settledError = ""; this.settledCancelled = false;
-      if (cancelled) this.onMessage?.("Pi turn cancelled; inspect any partial effects before continuing.", { inReplyTo: this.currentReply });
+      // Answer the peers this turn was for, not every peer on the bus (issue #29). activeEnvs still holds the
+      // whole delivery here, steered additions included.
+      const reply = { inReplyTo: this.currentReply, to: replyAudience(this.activeEnvs) };
+      if (cancelled) this.onMessage?.("Pi turn cancelled; inspect any partial effects before continuing.", reply);
       else if (error) void this.opts.onTurnFailure?.(this.activeEnvs, error);
-      else if (text) this.onMessage?.(text, { inReplyTo: this.currentReply });
+      else if (text) this.onMessage?.(text, reply);
       this.currentReply = undefined; this.activeEnvs = []; if (this.state === "busy" && !this.activeTools) this.setState("idle");
     }
   }

package/src/cli/main.ts

@@ -25,6 +25,8 @@ import { makeRecoveryDriver, makeUpgradePlan, preserveSource } from "./upgrade-r
 import { recordTerminalLaunch } from "./terminal-recovery.ts";
 import { ensureMlx, inspectMlx, stopMlx } from "../models/mlx.ts";
 
+import { backendLine, peerLine, type BackendRow, type PeerRow } from "./status-lines.ts";
+
 const USAGE = `agent-hub ${VERSION}: Claude Code, Codex and Kimi as peers in one project directory
 
   ahub --project <path|id> <command>  select a repository or worktree explicitly
@@ -570,10 +572,10 @@ const commands: Record<string, () => Promise<void> | void> = {
     const { status } = await hub.request({ t: "status" });
     hub.close();
     console.log(`hub pid ${status.pid}, control 127.0.0.1:${status.controlPort}, ${status.cwd}`);
-    const peers = Object.entries(status.peers as Record<string, { state: string; queued: number }>);
-    for (const [id, p] of peers) console.log(`  ${id.padEnd(8)} ${p.state.padEnd(8)} queued ${p.queued}${(p as any).paused ? `  (${(p as any).paused})` : ""}${(p as any).servedBy ? `  last call: ${(p as any).servedBy}` : ""}`);
-    const models = (status as any).models?.backends as any[] | undefined;
-    if (models?.length) for (const backend of models) console.log(`  model    ${backend.kind ?? "unknown"}/${backend.alias ?? "unknown"} ${backend.state ?? "unknown"} active ${backend.active ?? 0}${backend.requestedModel ? ` requested ${backend.requestedModel}` : ""}${backend.actualModel ? ` actual ${backend.actualModel}` : ""}${backend.provider ? ` provider ${backend.provider}` : ""}`);
+    const peers = Object.entries(status.peers as Record<string, PeerRow>);
+    for (const [id, p] of peers) console.log(peerLine(id, p));
+    const models = (status as any).models?.backends as BackendRow[] | undefined;
+    if (models?.length) for (const backend of models) console.log(backendLine(backend));
     if (status.switchyard) console.log(`  switchyard: ${status.switchyard}`);
     const counts = Object.entries(status.tasks ?? {}).map(([s, n]) => `${n} ${s}`).join(", ");
     if (counts) console.log(`  tasks: ${counts} (ahub board)`);

package/src/cli/status-lines.ts

@@ -0,0 +1,27 @@
+// What `ahub status` prints for a peer and for a model backend, kept pure so it can be checked.
+
+export interface PeerRow { state?: string; queued?: number; paused?: string; servedBy?: string; requestedModel?: string }
+export interface BackendRow { kind?: string; alias?: string; state?: string; active?: number; requestedModel?: string; actualModel?: string; provider?: string }
+
+/** Aliases are already namespaced ("dgx/coding"); only an alias that is not gets its kind in front of it. */
+export function backendLabel(backend: BackendRow): string {
+  const kind = backend.kind ?? "unknown";
+  const alias = backend.alias ?? "unknown";
+  return alias.startsWith(`${kind}/`) ? alias : `${kind}/${alias}`;
+}
+
+export function peerLine(id: string, p: PeerRow): string {
+  return `  ${id.padEnd(8)} ${(p.state ?? "unknown").padEnd(8)} queued ${p.queued ?? 0}` +
+    (p.paused ? `  (${p.paused})` : "") +
+    (p.servedBy ? `  last call: ${p.servedBy}` : "") +
+    // Which backend the peer asked for on its last turn: without it, telling a Pi DGX turn from an MLX one
+    // meant reading status.json by hand.
+    (p.requestedModel ? `  model: ${p.requestedModel}` : "");
+}
+
+export function backendLine(backend: BackendRow): string {
+  return `  model    ${backendLabel(backend)} ${backend.state ?? "unknown"} active ${backend.active ?? 0}` +
+    (backend.requestedModel ? ` requested ${backend.requestedModel}` : "") +
+    (backend.actualModel ? ` actual ${backend.actualModel}` : "") +
+    (backend.provider ? ` provider ${backend.provider}` : "");
+}

package/src/hub/bus.ts

@@ -1,4 +1,4 @@
-import { HUB, MAX_HOP, newEnvelope, parseMarker, type Envelope, type PeerId, type PeerState } from "./envelope.ts";
+import { DIGEST, HUB, MAX_HOP, newEnvelope, parseMarker, replyAudience, type Envelope, type EnvelopeOpts, type PeerId, type PeerState, type Priority } from "./envelope.ts";
 import type { PeerAdapter } from "./peers.ts";
 
 export type BusEvent =
@@ -30,6 +30,27 @@ export interface BusSnapshot {
 
 export const DEFAULT_BUS: BusOptions = { retryMs: 1000, batchMax: 3, batchMs: 15_000, queueCap: 200 };
 
+/**
+ * What a peer may claim for its own message. A hub-native peer writes `[IMPORTANT]` on routine status reports
+ * (issue #29), and `important` interrupts every recipient at once, so it only keeps it when answering an
+ * `important` request that was addressed to it. `fyi` and `status` are never capped.
+ */
+function capPriority(peer: PeerAdapter, priority: Priority, parent: EnvelopeOpts["inReplyTo"], delivery: Envelope[] | undefined): Priority {
+  if (!peer.hubNative || priority !== "important") return priority;
+  if (!parent) return "status"; // nothing was asked: an unsolicited report is never urgent enough to interrupt
+  // The whole delivery, not just `replyParent`: an important request addressed to the peer can share a hop with a
+  // later status item, and then the parent is that status item.
+  const asked = delivery ?? [parent];
+  return asked.some((e) => e.priority === "important" && !!e.to?.includes(peer.id)) ? "important" : "status";
+}
+
+/** `digest` is not a peer. A reply to a condensed delivery is for the senders that condensation replaced. */
+function resolveTo(to: PeerId[], originals: Envelope[] | undefined): PeerId[] {
+  if (!to.includes(DIGEST)) return to;
+  const senders = originals ? replyAudience(originals) : [];
+  return [...new Set(to.flatMap((id) => (id === DIGEST ? senders : [id])))];
+}
+
 const SEEN_CAP = 2048;
 const MAX_ATTEMPTS = 3;
 const DIGEST_MAX = 10;
@@ -66,7 +87,17 @@ export class Bus {
     if (!this.queues.has(peer.id)) this.queues.set(peer.id, []);
     peer.onMessage = (text, opts) => {
       const { priority, body } = parseMarker(text);
-      if (body) this.publish(newEnvelope(peer.id, body, { priority, ...opts }));
+      if (!body) return;
+      // What the peer was handed differs from what it stands for once a delivery was condensed; both the audience
+      // and the priority ceiling are about what it stands for.
+      const last = this.lastDelivery.get(peer.id);
+      const answers = opts?.inReplyTo?.id !== undefined && last?.out.some((e) => e.id === opts.inReplyTo!.id);
+      const originals = answers ? last!.originals : undefined;
+      this.publish(newEnvelope(peer.id, body, {
+        ...opts,
+        ...(opts?.to?.length ? { to: resolveTo(opts.to, originals) } : {}),
+        priority: opts?.priority ?? capPriority(peer, priority, opts?.inReplyTo, originals),
+      }));
     };
     peer.onFailed = (envs) => {
       // The adapter got the condensed list; what has to come back is what that list replaced.

package/src/hub/daemon.ts

@@ -131,6 +131,11 @@ class WsPeer extends BasePeer {
   claim(sock: Sock): void {
     this.claimed = sock;
   }
+  /** A hello that has not finished its preface yet. The peer reads as offline until then, and a session standing by
+   *  for the id must not take it from a claimant that is still arriving. */
+  get claiming(): boolean {
+    return !!this.claimed && this.claimed !== this.sock && this.claimed.readyState === WebSocket.OPEN;
+  }
   attach(sock: Sock): void {
     if (sock !== this.claimed) return void sock.close(4000, "replaced"); // a newer session said hello meanwhile
     this.sock?.close(4000, "replaced");
@@ -493,7 +498,7 @@ export async function startDaemon(opts: DaemonOptions) {
     ...(dashboard ? { uiOrigin: dashboard.origin } : {}),
     codexProxyPort: opts.codexProxyPort,
     peers: Object.fromEntries(
-      [...bus.peers].map(([id, p]) => [id, { state: bus.stateOf(id), queued: bus.queued(id), ...pausedNote(id), ...(p instanceof LocalPeer && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(p instanceof PiPeer ? { requestedModel: p.getRequestedModel(), backends: modelRelay?.status().backends ?? [] } : {}) }]),
+      [...bus.peers].map(([id, p]) => [id, { state: bus.stateOf(id), queued: bus.queued(id), ...pausedNote(id), ...(p instanceof LocalPeer && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(p instanceof WsPeer && p.claiming ? { claiming: true } : {}), ...(p instanceof PiPeer ? { requestedModel: p.getRequestedModel(), backends: modelRelay?.status().backends ?? [] } : {}) }]),
     ),
     ...(sidecar ? { switchyard: sidecar.status } : {}),
     ...(modelRelay ? { models: modelRelay.status() } : {}),
@@ -558,7 +563,7 @@ export async function startDaemon(opts: DaemonOptions) {
     }
     const existing = bus.peers.get(peer);
     if (peer === "pi" && existing instanceof PiPeer) {
-      const saved = existing.recoveryMetadata();
+      let saved = existing.recoveryMetadata();
       const launch = saved.launch as Record<string, unknown>;
       if ((args.sessionId && saved.sessionId && args.sessionId !== saved.sessionId) || (args.sessionFile && saved.sessionFile && args.sessionFile !== saved.sessionFile)) return { ok: false, error: "Pi already owns a different session; refusing to replace its identity" };
       const mode = args.mode ?? "headless";
@@ -566,17 +571,20 @@ export async function startDaemon(opts: DaemonOptions) {
       const unclaimed = existing.state === "offline" && !saved.sessionId && !saved.sessionFile;
       if (changesOwner && (existing.state === "busy" || (existing.state !== "offline" && !existing.recoveryReady))) return { ok: false, error: "Pi is busy; wait for agent_settled before changing mode/backend" };
       if (unclaimed) {
+        if (!args.sessionId && !args.sessionFile) args = { ...args, ...existing.pendingResume };
         // Revoke the previous launch bridge before issuing another launch. A late
         // process from the abandoned CLI cannot claim the replacement owner.
         await existing.stop();
       } else if (changesOwner) {
-        if (!saved.sessionId || !saved.sessionFile) return { ok: false, error: "Pi session identity is not ready for handover" };
-        args = { ...args, backend: args.backend ?? launch.backend as "auto" | "dgx" | "mlx", model: args.model ?? (args.backend === undefined && typeof launch.model === "string" ? launch.model : undefined), sessionId: String(saved.sessionId), sessionFile: String(saved.sessionFile) };
+        saved = await existing.captureResume();
+        if (!saved.sessionId) return { ok: false, error: "Pi session identity is not ready for handover" };
+        args = { ...args, backend: args.backend ?? launch.backend as "auto" | "dgx" | "mlx", model: args.model ?? (args.backend === undefined && typeof launch.model === "string" ? launch.model : undefined), sessionId: String(saved.sessionId), sessionFile: typeof saved.sessionFile === "string" ? saved.sessionFile : undefined };
         await existing.stop();
       } else if (existing.state !== "offline") {
         return mode === "tui" ? { ok: false, error: "Pi already owns a native terminal; use that terminal or switch to headless first" } : { ok: true, already: true };
-      } else if (saved.sessionId && saved.sessionFile) {
-        args = { ...args, backend: args.backend ?? launch.backend as "auto" | "dgx" | "mlx", model: args.model ?? (args.backend === undefined && typeof launch.model === "string" ? launch.model : undefined), sessionId: String(saved.sessionId), sessionFile: String(saved.sessionFile) };
+      } else if (saved.sessionId) {
+        saved = await existing.captureResume();
+        args = { ...args, backend: args.backend ?? launch.backend as "auto" | "dgx" | "mlx", model: args.model ?? (args.backend === undefined && typeof launch.model === "string" ? launch.model : undefined), sessionId: String(saved.sessionId), sessionFile: typeof saved.sessionFile === "string" ? saved.sessionFile : undefined };
       }
     }
     if (existing && existing.state !== "offline") {
@@ -847,6 +855,12 @@ export async function startDaemon(opts: DaemonOptions) {
   async function recoveryOp(msg: any): Promise<Record<string, unknown>> {
     if (typeof msg.op !== "string" || !["inspect", "prepare", "commit", "abort", "release"].includes(msg.op)) return recoveryError("unknown recovery operation");
     if (typeof msg.expectedInstanceId !== "string" || msg.expectedInstanceId !== instanceId) return recoveryError("expected daemon instance does not match");
+    if (msg.op === "inspect" || msg.op === "prepare" || msg.op === "commit") {
+      const pi = bus.peers.get("pi");
+      if (pi instanceof PiPeer && pi.state === "idle") {
+        try { await pi.captureResume(); } catch (error) { return recoveryError((error as Error).message); }
+      }
+    }
     if (msg.op === "inspect" && msg.operationId === undefined) return { t: "recovery", ok: true, recovery: recoveryView() };
     if (typeof msg.operationId !== "string" || msg.operationId.length < 1 || msg.operationId.length > 128) return recoveryError("operationId is required");
     const op = msg.operationId as string;
@@ -970,6 +984,7 @@ export async function startDaemon(opts: DaemonOptions) {
         if (!(peer instanceof WsPeer)) return sock.close(4409, "peer id is taken by a hub-managed adapter");
         const ws = peer;
         ws.claim(sock);
+        writeStatus(); // the claim has to be visible before the preface, or a standing-by session takes the id back
         void ensurePreface(c.peer).finally(() => {
           if (sock.readyState === WebSocket.OPEN) ws.attach(sock);
         });

package/src/hub/envelope.ts

@@ -25,13 +25,15 @@ export const MAX_HOP = 3;
 export const USER: PeerId = "user";
 /** The hub itself: sender of recall and workflow events. */
 export const HUB: PeerId = "hub";
+/** A hub-written condensation of several status messages. Not a peer: a reply to it is for the senders it replaced. */
+export const DIGEST: PeerId = "digest";
 
 export interface EnvelopeOpts {
   to?: PeerId[];
   kind?: Kind;
   priority?: Priority;
-  /** The envelope this one answers: inherits its trace, hop + 1. */
-  inReplyTo?: Pick<Envelope, "trace" | "hop">;
+  /** The envelope this one answers: inherits its trace, hop + 1, and - when `to` is absent - its sender as the addressee. */
+  inReplyTo?: Pick<Envelope, "trace" | "hop"> & Partial<Pick<Envelope, "id" | "from" | "to" | "priority">>;
   refs?: Envelope["refs"];
   private?: boolean;
 }
@@ -42,7 +44,10 @@ export function newEnvelope(from: PeerId, body: string, opts: EnvelopeOpts = {})
     trace: opts.inReplyTo?.trace ?? randomUUID(),
     hop: opts.inReplyTo ? opts.inReplyTo.hop + 1 : 0,
     from,
-    ...(opts.to?.length ? { to: opts.to } : {}),
+    // An answer goes back to whoever asked. Without this a reply carries no `to` and the bus fans it out to
+    // every peer, so one directed question costs every other agent a turn (issue #29). `user` and `hub` are not
+    // peers, so a reply to them reaches the console and the log and nobody's turn.
+    ...(opts.to?.length ? { to: opts.to } : opts.inReplyTo?.from ? { to: [opts.inReplyTo.from] } : {}),
     kind: opts.kind ?? "chat",
     priority: opts.priority ?? "status",
     body,
@@ -80,6 +85,11 @@ export function renderDigest(envs: Envelope[], primed: boolean): string {
   return primed ? items : `${STANDING_INSTRUCTION}\n\n${items}`;
 }
 
+/** Who a reply to a delivery is for: everyone whose message it answers, each once, in the order they arrived. */
+export function replyAudience(envs: Envelope[]): PeerId[] {
+  return [...new Set(envs.filter((e) => !(e.from === HUB && e.kind === "presence")).map((e) => e.from))];
+}
+
 /** What a reply to a delivery answers: the highest-hop item, so a digest cannot be used to reset the hop cap. */
 export function replyParent(envs: Envelope[]): Envelope {
   // Never the hub's own context block (it was not published, so nothing can resolve it); ties go to the later item.

package/src/hub/inference.ts

@@ -1,7 +1,7 @@
 import type { OmniRoute } from "../omniroute/client.ts";
 import type { Sidecar } from "../switchyard/sidecar.ts";
 import { CLASSES, type TaskClass } from "./board.ts";
-import { newEnvelope, type Envelope } from "./envelope.ts";
+import { DIGEST, newEnvelope, type Envelope } from "./envelope.ts";
 
 export interface InferenceConfig {
   enabled: boolean;
@@ -14,7 +14,7 @@ export interface InferenceConfig {
 export const DEFAULT_INFERENCE: InferenceConfig = { enabled: true, digest_min_items: 5, digest_min_chars: 8000, triage: true };
 
 /** Sender of a condensed digest. Not the hub's own id: replies to it must keep the hop count of what it replaced. */
-export const DIGEST = "digest";
+export { DIGEST };
 
 const TIMEOUT_MS = 8000;
 const BACKOFF_MS = 5 * 60_000;

package/src/hub/peers.ts

@@ -3,6 +3,8 @@ import type { Envelope, EnvelopeOpts, PeerId, PeerState } from "./envelope.ts";
 export interface PeerAdapter {
   readonly id: PeerId;
   readonly state: PeerState;
+  /** A peer the hub drives itself (Pi, the local worker). It cannot be trusted to rate its own urgency: the bus caps it. */
+  readonly hubNative?: boolean;
   /** Inject now, as one prompt. Only called while `state === "idle"`. Rejecting puts the envelopes back at the queue head. */
   deliver(envs: Envelope[]): Promise<void>;
   /** Optional: feed envelopes into the turn that is running now. Only called while `state === "busy"`. */

package/src/pi/extension.ts

@@ -39,6 +39,15 @@ async function poll(pi: ExtensionAPI): Promise<void> {
       try {
         if (command.type === "prompt" || command.type === "steer") {
           pi.sendMessage({ customType: "agent-hub", content: String(command.message ?? ""), display: true }, { triggerTurn: command.type === "prompt", deliverAs: command.type === "steer" ? "steer" : "followUp" });
+        } else if (command.type === "get_session_state") {
+          const entries = runtimeCtx.sessionManager.getEntries();
+          await post("/ack", { id: command.id, ok: true, result: {
+            sessionId: runtimeCtx.sessionManager.getHeader()?.id,
+            sessionFile: runtimeCtx.sessionManager.getSessionFile(),
+            idle: runtimeCtx.isIdle() === true,
+            empty: entries.every((entry: any) => ["model_change", "thinking_level_change"].includes(entry.type)),
+          } });
+          continue;
         } else if (command.type === "set_model") {
           const model = modelRegistry?.find(String(command.provider), String(command.modelId));
           if (!model || !(await (pi as any).setModel?.(model))) throw new Error("Pi model is not available");