@staix/agent-hub 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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).

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.1. 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.1 && ahub setup
+bun add -g github:STAIxBWLB/agent-hub#v0.6.2 && ahub setup
 ```
 
 The installed commands remain `ahub` and `agent-hub`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staix/agent-hub",
-  "version": "0.6.1",
+  "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.1",
+  "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.1",
+  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";
 
@@ -33,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 = "";
@@ -300,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() } : {}),
@@ -979,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"`. */