@staix/agent-hub 0.12.19 → 0.12.20

package/src/hub/bus.ts

@@ -715,13 +715,69 @@ export class Bus {
     finally { this.steering--; this.onQueues?.(); }
   }
 
+  /** Holds on a peer's queue, for a drain and a pull alike: recovery, an uncertain delivery, a pause (console, budget, conductor). */
+  private held(id: PeerId): boolean {
+    return this.recoveryHeld || this.recoveryHeldPeers.has(id) || this.paused.has(id);
+  }
+
+  /** What a peer was just handed stays resolvable for `reply_to`: moved to the newest end, the stored envelope kept. */
+  private remember(envs: Envelope[]): void {
+    for (const e of envs) { const kept = this.seen.get(e.id) ?? e; this.seen.delete(e.id); this.seen.set(e.id, kept); }
+    while (this.seen.size > SEEN_CAP) this.seen.delete(this.seen.keys().next().value as string);
+  }
+
+  /** A push may go out now: nothing holds the queue, the peer is idle, and its session shows pushes (issue #205). */
+  private deliverable(id: PeerId): boolean {
+    return !this.held(id) && this.stateOf(id) === "idle" && !this.peers.get(id)?.pullOnly;
+  }
+
+  /**
+   * What one push delivery would take (the preface, then `take`'s batch), handed to a pull-only peer and recorded as
+   * completed: the tool result that returns it is the readback, so nothing waits for settlement and nothing is ever
+   * `accepted` (issue #205). It is checkpointed like a push, so queued rows of the same envelopes (an operator retry)
+   * are grouped into it, and registered for `reply_to` like a push. Undefined while held. A failed journal write puts
+   * back only this peer's queue and preface (every pause stays) and stops the bus like any other journal failure.
+   * ponytail: recorded completed at hand-out, before anything shows the model saw it: a reply lost on the way, a tool
+   * call cancelled (Esc) or a plugin that dies loses the batch, and `ahub queue resolve --action retry` refuses a
+   * terminal row. The completed row keeps the envelopes (`ahub queue show <id>`) to resend by hand; take/confirm in two
+   * steps if loss is ever observed.
+   */
+  pull(id: PeerId): Envelope[] | undefined {
+    if (this.storageError) throw new Error("delivery journal unavailable");
+    if (this.held(id)) return undefined;
+    const queue = this.queues.get(id) ?? [];
+    this.dropIrrelevant(id, queue);
+    const preface = this.prefaces.get(id);
+    if (!preface && !queue.length) return [];
+    const queued = [...queue];
+    const batch = [...(preface ? [preface] : []), ...this.take(id, queue)];
+    this.prefaces.delete(id);
+    // Before the checkpoint, as in a drain, so the persisted snapshot carries it; on a failure the bus stops anyway.
+    this.remember(batch);
+    try {
+      const deliveryId = crypto.randomUUID();
+      this.journal?.transaction(() => {
+        this.durableHandoff(id, deliveryId, batch, batch); // its bus snapshot is the queue after this pull
+        this.journal!.transition(deliveryId, "completed", "read through hub_inbox");
+      });
+    } catch (error) {
+      queue.splice(0, queue.length, ...queued);
+      if (preface) this.prefaces.set(id, preface);
+      this.storageError = "delivery journal unavailable";
+      throw error;
+    }
+    this.failureStreak.delete(id); this.lastFailure.delete(id); // read, as a completed push receipt clears them
+    this.onQueues?.();
+    return batch;
+  }
+
   private async drain(id: PeerId): Promise<void> {
     if (this.storageError || this.draining.has(id) || !this.peers.has(id)) return;
     this.draining.add(id);
     try {
       const peer = this.peers.get(id)!;
       const queue = this.queues.get(id)!;
-      while (!this.storageError && !this.recoveryHeld && !this.recoveryHeldPeers.has(id) && queue.length && this.stateOf(id) === "idle") {
+      while (!this.storageError && queue.length && this.deliverable(id)) {
         if (this.dropIrrelevant(id, queue) && !queue.length) break;
         const delay = this.wait(queue);
         if (delay > 0) { this.arm(id, delay); break; }
@@ -736,7 +792,8 @@ export class Bus {
         this.condensing += mayCondense ? 1 : 0;
         const out = mayCondense ? await this.opts.condense!(delivery).catch(() => delivery) : delivery;
         this.condensing -= mayCondense ? 1 : 0;
-        if (this.recoveryHeld || this.recoveryHeldPeers.has(id) || this.stateOf(id) !== "idle") {
+        // A session that cannot show pushes may have taken the peer while this was condensed (issue #205).
+        if (!this.deliverable(id)) {
           if (!this.journal) { if (preface) this.restorePreface(id, preface); queue.unshift(...batch.filter((e) => !this.withdrawn.has(e.id))); }
           break;
         }
@@ -751,8 +808,7 @@ export class Bus {
           for (const env of batch) queue.splice(queue.findIndex((item) => item.id === env.id), 1);
           this.prefaces.delete(id);
         }
-        for (const e of out) if (!this.seen.has(e.id)) this.seen.set(e.id, e);
-        while (this.seen.size > SEEN_CAP) this.seen.delete(this.seen.keys().next().value as string);
+        this.remember(out);
         this.lastDelivery.set(id, { out, originals: delivery });
         this.preparing.delete(id); // from here on the transport/journal owns settlement
         const deliveryId = crypto.randomUUID();

package/src/hub/child-process.ts

@@ -17,6 +17,7 @@ export function peerChildEnv(peer: string, source: NodeJS.ProcessEnv = process.e
   delete env.CLAUDECODE;
   delete env.CLAUDE_CODE_SESSION_ID;
   delete env.CODEX_THREAD_ID;
+  delete env.AGENTHUB_CHANNEL;
   delete env.AGENTHUB_PEER_ID;
   env.AGENTHUB_PEER_ID = peer;
   return env;

package/src/hub/conductor.ts

@@ -1,6 +1,8 @@
 import { Database } from "bun:sqlite";
 import type { Task } from "./board.ts";
 import { CONDUCTOR_TOOL_NAMES } from "./hub-tools.ts";
+import { HUB, USER } from "./envelope.ts";
+import { OWNERSHIP_EVENTS } from "./tasks.ts";
 import type { HubEvent } from "./events.ts";
 import type { SupervisionFeed } from "./supervision.ts";
 import type { Budget } from "./budget.ts";
@@ -45,10 +47,14 @@ export function conductorPeer(roles: unknown): string | null {
 /** The role check always comes first; default-allow capabilities cannot grant a role. */
 export function requireConductor(peer: string, roles: unknown, capabilities: Record<string, unknown> = {}, assign = false): void {
   if (conductorPeer(roles) !== peer) throw new Error("this operation requires the explicit conductor role");
-  if (assign && Object.hasOwn(capabilities, peer)) {
-    const caps = capabilities[peer];
-    if (!Array.isArray(caps) || !caps.includes("assign")) throw new Error(`${peer} requires assign capability for this operation`);
-  }
+  if (assign) requireAssign(peer, capabilities);
+}
+
+/** A peer with an explicit capabilities list needs `assign` in it to move work. */
+function requireAssign(peer: string, capabilities: Record<string, unknown>): void {
+  if (!Object.hasOwn(capabilities, peer)) return;
+  const caps = capabilities[peer];
+  if (!Array.isArray(caps) || !caps.includes("assign")) throw new Error(`${peer} requires assign capability for this operation`);
 }
 
 export interface ConductorHold { peer: string; actor: string; since: number }
@@ -154,10 +160,35 @@ export interface ConductorHooks {
   audit(event: ConductEvent): void;
 }
 
+/** A task id as `Tasks.need()` takes it: a whole number or a digit string. */
+const taskId = (v: unknown): number | undefined => {
+  const n = typeof v === "number" ? v : typeof v === "string" && /^\s*\d+\s*$/.test(v) ? Number(v) : NaN;
+  return Number.isSafeInteger(n) && n > 0 ? n : undefined;
+};
+
 export class Conductor {
   constructor(private readonly holds: ConductorHolds, private readonly hooks: ConductorHooks) {}
   async execute(actor: string, tool: string, args: Record<string, unknown>): Promise<unknown> {
     if (!CONDUCTOR_TOOL_NAMES.has(tool)) throw new Error("unknown conductor tool");
+    if ((tool === "hub_task_show" || tool === "hub_task_assign") && conductorPeer(this.hooks.roles()) !== actor) {
+      const id = taskId(args.id);
+      const task = id === undefined ? undefined : this.hooks.task(id);
+      // A task's current owner and reviewer read its public view without the role (#208); nobody else does.
+      if (task && tool === "hub_task_show" && (task.owner === actor || task.reviewer === actor)) return publicConductorTask(task, this.hooks.publicView);
+      // Its proposer (the first history entry) redirects it while nobody ever accepted it (#207: a decline or a release puts
+      // worked tasks back in proposed); work that waits gets a reserved owner. Never over the person: a console assign or
+      // reservation stands until the conductor or the console moves it, also once the hub carried it out (the hub's own
+      // moves are not decisions).
+      const moved = task?.history.findLast((h) => h.by !== HUB && (OWNERSHIP_EVENTS.has(h.event) || h.event === "reserved"));
+      const accepted = task?.history.some((h) => h.event === "accepted");
+      if (task && tool === "hub_task_assign" && task.history[0]?.by === actor && task.state === "proposed" && !accepted && moved?.by !== USER) {
+        const peer = peerId(args.peer);
+        if (peer !== actor) requireAssign(actor, this.hooks.capabilities());
+        await this.hooks.assign(actor, task.id, peer);
+        const updated = this.hooks.task(task.id);
+        return updated ? publicConductorTask(updated, this.hooks.publicView) : { id: task.id };
+      }
+    }
     requireConductor(actor, this.hooks.roles(), this.hooks.capabilities(), tool === "hub_task_assign" || tool === "hub_task_escalate");
     const action = tool.slice(4);
     const emit = (extra: Pick<ConductEvent, "task" | "peer"> = {}) => {
@@ -165,8 +196,9 @@ export class Conductor {
     };
     if (tool === "hub_status") { const result = publicConductorStatus(this.hooks.status()); emit(); return result; }
     if (tool.startsWith("hub_task_")) {
-      if (typeof args.id !== "number" || !Number.isSafeInteger(args.id) || args.id <= 0) throw new Error("id must be a positive integer");
-      const task = this.hooks.task(args.id);
+      const id = taskId(args.id);
+      if (id === undefined) throw new Error("id must be a positive integer");
+      const task = this.hooks.task(id);
       if (!task) throw new Error(`no task #${args.id}`);
       if (tool === "hub_task_show") { const result = publicConductorTask(task, this.hooks.publicView); emit({ task: task.id }); return result; }
       if (tool === "hub_task_assign") {

package/src/hub/control-client.ts

@@ -6,15 +6,17 @@ export function stateDirFor(cwd: string): string {
   return projectContext(cwd).stateDir;
 }
 
-/** Control WS wire version. 2 = `deliver` carries `envs` (digests); 3 = `tools` role and task messages; 4 = budget messages and `hub_checkpoint`; 5 = `ask`; 6 = console-only `ui` session bootstrap; 8 = controlled recovery; 9 = Pi bridge metadata; 10 = durable delivery receipts; 11 = queue hold diagnostics; 12 = generation-bound channel settlement and execution budgets; 13 = turn-free facts (`facts` with tool, session and transcript binding, `silenced`) and per-recipient send results (issue #108). 14 = native context-window status and session-bound context checkpoint request ids (issue #185). 15 = conductor tools and permission deadlines/closed events (issues #190, #194). The plugin is installed apart from the daemon, so they can drift. */
-export const PROTOCOL = 15;
+/** Control WS wire version. 2 = `deliver` carries `envs` (digests); 3 = `tools` role and task messages; 4 = budget messages and `hub_checkpoint`; 5 = `ask`; 6 = console-only `ui` session bootstrap; 8 = controlled recovery; 9 = Pi bridge metadata; 10 = durable delivery receipts; 11 = queue hold diagnostics; 12 = generation-bound channel settlement and execution budgets; 13 = turn-free facts (`facts` with tool, session and transcript binding, `silenced`) and per-recipient send results (issue #108). 14 = native context-window status and session-bound context checkpoint request ids (issue #185). 15 = conductor tools and permission deadlines/closed events (issues #190, #194). 16 = a Claude session without channel evidence: hello `channel: false` and `inbox` (issue #205). The plugin is installed apart from the daemon, so they can drift. */
+export const PROTOCOL = 16;
 /** Protocols a current coordinator may authenticate while upgrading a running source. */
-export const RECOVERY_SOURCE_PROTOCOLS = [9, 10, 11, 12, 13, 14, PROTOCOL] as const;
+export const RECOVERY_SOURCE_PROTOCOLS = [9, 10, 11, 12, 13, 14, 15, PROTOCOL] as const;
 
 export interface Hello {
   /** `tools`: acts for `peer` (task tools, hub_send) without being a delivery target: the MCP server Kimi and Codex run. */
   role: "peer" | "console" | "tools";
   peer?: string;
+  /** `peer` only: false when the session cannot show channel pushes; its queue then waits for `inbox` (issue #205). */
+  channel?: boolean;
   projectId?: string;
   instanceId?: string;
   projectRoot?: string;

package/src/hub/daemon.ts

@@ -18,7 +18,7 @@ import { AcpPeer, type PermissionRequest } from "../adapters/acp.ts";
 import { CodexPeer } from "../adapters/codex-appserver.ts";
 import { PiPeer } from "../adapters/pi.ts";
 import { startModelRelay, type ModelRelay } from "../models/relay.ts";
-import type { MlxOptions } from "../models/mlx.ts";
+import { ensureMlx, type MlxOptions } from "../models/mlx.ts";
 import { PiToolReceipts } from "../pi/tool-receipts.ts";
 import { profile, proxyEnv, type SandboxNetwork } from "../local/sandbox.ts";
 import { DEFAULT_NETWORK_ALLOW, startEgressProxy, type EgressProxy } from "../local/proxy.ts";
@@ -42,7 +42,7 @@ import { SupervisionFeed } from "./supervision.ts";
 import { drainCliAudits } from "../cli/identity-audit.ts";
 import { launcherPreview } from "../cli/preview.ts";
 import { Tasks } from "./tasks.ts";
-import { DEFAULT_INFERENCE, DIGEST, Inference, type InferenceConfig } from "./inference.ts";
+import { DEFAULT_INFERENCE, DIGEST, Inference, screenPii, type InferenceConfig } from "./inference.ts";
 import { ask, ASK_NOTE_TITLE, RUN_START } from "./ask.ts";
 import { currentRouting, detectSignals } from "./routing.ts";
 import { Bus } from "./bus.ts";
@@ -61,7 +61,7 @@ import { crashPlan, lossNotice, readSessions, removeSessions, writeSessions, typ
 import type { JournalDelivery } from "./delivery-journal.ts";
 import { DEFAULT_LIMITS, Limiter, PROJECT_LIMITS, type LimitsConfig } from "./limits.ts";
 import { changedPaths, repoOf, snapshot, Turns, type TurnRecord } from "./snapshots.ts";
-import { archiveRestartSnapshot, readRestartSnapshot, removeRestartSnapshot, restartPath, writeRestartSnapshot, type RecoveryPhase, type RestartPeerSnapshot, type RestartSnapshot } from "./restart.ts";
+import { archiveRestartSnapshot, readRecoveryWaivers, readRestartSnapshot, removeRestartSnapshot, restartPath, writeRestartSnapshot, type RecoveryPhase, type RestartPeerSnapshot, type RestartSnapshot } from "./restart.ts";
 
 import { ContextWindows, DEFAULT_CONTEXT, claudeContext, type ContextConfig } from "./context-window.ts";
 
@@ -306,10 +306,18 @@ class WsPeer extends BasePeer {
   private claimed: Sock | undefined;
   private nativeSession: string | undefined;
   private nativeActive = false;
+  /** The attached session said it cannot show channel pushes (issue #205): the bus keeps its queue for `inbox`. */
+  pullOnly = false;
+  private claimedPullOnly = false;
   /** Called at hello, before the async preface: the newest hello wins even if an older one's recall finishes last. */
-  claim(sock: Sock): void {
+  claim(sock: Sock, pullOnly = false): void {
     this.claimGeneration = crypto.randomUUID();
     this.claimed = sock;
+    this.claimedPullOnly = pullOnly;
+  }
+  /** A session that shows pushes holds the peer or is arriving: a session without them must not take it (issue #205). */
+  get channelHeld(): boolean {
+    return (!!this.sock && !this.pullOnly) || (this.claiming && !this.claimedPullOnly);
   }
   /** 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. */
@@ -325,12 +333,14 @@ class WsPeer extends BasePeer {
     this.delivered.clear();
     this.nativeSession = undefined;
     this.nativeActive = false;
+    this.pullOnly = this.claimedPullOnly; // before idle: the idle transition drains
     this.setState("idle");
   }
   detach(sock: Sock): void {
     if (this.sock !== sock) return;
     this.sock = undefined;
     this.nativeActive = false;
+    this.pullOnly = false;
     this.setState("offline");
   }
   async deliver(envs: Envelope[], deliveryId?: string): Promise<void> {
@@ -663,6 +673,9 @@ export async function startDaemon(opts: DaemonOptions) {
       }
     },
     triage: { classify: (title, detail) => inference?.triage(title, detail) ?? Promise.resolve(undefined), onCampus: () => onCampus() },
+    // The PII screen (issue #198): the model on this machine when MLX/Ollama is enabled, else the gateway on campus only.
+    piiScreen: (text) => screenPii(text, { ...(config.mlx.enabled === false ? {} : { device: () => ensureMlx(config.mlx) }), onCampus, omni, fixedModel: () => currentRouting(opts.cwd, log).local.fixed_model }),
+    recordScreen: (record) => event({ type: "pii_screen", ...record }),
     quota: (): ReturnType<Budget["headroom"]> => budget.headroom(), // budget is built below; this runs at assignment time
     review: config.review,
     sweep: taskSweepConfig(config.task_sweep),
@@ -1280,6 +1293,11 @@ export async function startDaemon(opts: DaemonOptions) {
     const r = budget.record(id); // one read per peer: status.json is rewritten on every bus event
     return r ? { paused: `budget: ${r.reason}, resets ${new Date(r.resetsAt).toLocaleTimeString()}` } : manualPaused.has(id) && bus.stateOf(id) === "offline" ? { paused: "manual" } : {};
   };
+  /** Why a paused peer gets nothing; the bus pause itself is the hold. */
+  const pauseReason = (id: PeerId) => {
+    const r = budget.record(id), hold = conductorHolds.get(id);
+    return r ? `paused by the budget coordinator: ${r.reason}; to override: ahub budget resume ${id}` : manualPaused.has(id) ? `paused by the console user; ahub resume ${id}` : hold ? `held by the conductor ${hold.actor}; it releases it with hub_peer_release, or the console user with ahub resume ${id}` : "paused";
+  };
   let releasing = false; // gone-owner release (#6) and the ready sweep (#34): one run at a time, and a recovery commit waits for it
   const recoveryReady = () => {
     if (!recoveryActive() || releasing || taskOpsInFlight !== 0 || tasks.checksPending() !== 0 || (piReceipts?.inFlight ?? 0) !== 0 || permissions.size !== 0 || starting.size !== 0 || !budget.recoverySettled || [...bus.peers.values()].some((peer) => peer.state === "busy" || (peer instanceof PiPeer && !peer.recoveryReady))) return false;
@@ -1293,7 +1311,10 @@ export async function startDaemon(opts: DaemonOptions) {
       // online at the snapshot is still offline, so skipping the comparison cannot hide an
       // identity change - it only keeps a detach from wedging readiness forever.
       if (now.state === "offline") return true;
-      if (saved.threadId && saved.threadId !== now.threadId) return false;
+      // The coordinator waived this peer's id on the target: an unmanaged Claude session reconnects and can never report
+      // the saved id here (#206), or the operator moved the peer to a fresh session (#215). It still has to reattach.
+      const waived = () => recoveryPhase === "restored" && !!readRecoveryWaivers(opts.stateDir, recoveryOperationId!)[saved.id];
+      if (saved.threadId && saved.threadId !== now.threadId && !waived()) return false;
       // Kimi/local rebuild a fresh worker with task context on the target; native
       // Claude and Pi sessions must keep their exact identities across restoration.
       const freshWorker = recoveryPhase === "restored" && (saved.id === "kimi" || saved.id === "local");
@@ -1302,7 +1323,7 @@ export async function startDaemon(opts: DaemonOptions) {
         // restore gate accepted a fresh session and nothing it stood for is lost. Snapshots
         // written before this flag existed are re-derived from disk.
         const unpersistedClaude = saved.id === "claude" && (saved.sessionPersisted === false || (saved.sessionPersisted === undefined && !claudeTranscriptPersisted(saved.sessionId)));
-        if (!unpersistedClaude) return false;
+        if (!unpersistedClaude && !waived()) return false;
       }
       return true;
     });
@@ -1448,7 +1469,7 @@ export async function startDaemon(opts: DaemonOptions) {
     ...(dashboard ? { uiOrigin: dashboard.origin } : {}),
     codexProxyPort: opts.codexProxyPort,
     peers: Object.fromEntries(
-      bus.knownPeers().map((id) => { const p = bus.peers.get(id); const summary = bus.queueSummary(id); const context = contexts.view(id, contextSession(id), !!p && ["idle", "busy", "paused"].includes(bus.stateOf(id))); return [id, { state: bus.stateOf(id), ...(context.source !== null || context.measuredAt !== null ? { context } : {}), queued: bus.queued(id), ...(p ? {} : { attached: false }), ...(summary.needsReview ? { needsReview: summary.needsReview } : {}), ...(summary.liveAccepted ? { liveAccepted: summary.liveAccepted, settlementNote: "awaiting adapter completion (Claude: correlated reply or hub_delivery_done); task state is independent" } : {}), ...queueHoldStatus(id, summary.heldBy), ...(summary.oldestQueuedAt !== undefined ? { oldestQueuedAt: summary.oldestQueuedAt } : {}), ...(bus.queuedImportant(id) ? { queuedImportant: bus.queuedImportant(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 ?? [] } : {}) }]; }),
+      bus.knownPeers().map((id) => { const p = bus.peers.get(id); const summary = bus.queueSummary(id); const context = contexts.view(id, contextSession(id), !!p && ["idle", "busy", "paused"].includes(bus.stateOf(id))); return [id, { state: bus.stateOf(id), ...(context.source !== null || context.measuredAt !== null ? { context } : {}), queued: bus.queued(id), ...(p ? {} : { attached: false }), ...(summary.needsReview ? { needsReview: summary.needsReview } : {}), ...(summary.liveAccepted ? { liveAccepted: summary.liveAccepted, settlementNote: "awaiting adapter completion (Claude: correlated reply or hub_delivery_done); task state is independent" } : {}), ...queueHoldStatus(id, summary.heldBy), ...(summary.oldestQueuedAt !== undefined ? { oldestQueuedAt: summary.oldestQueuedAt } : {}), ...(bus.queuedImportant(id) ? { queuedImportant: bus.queuedImportant(id) } : {}), ...pausedNote(id), ...(p instanceof LocalPeer && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(p instanceof WsPeer && p.claiming ? { claiming: true } : {}), ...(p instanceof WsPeer && p.pullOnly ? { toolsOnly: "tools-only: messages wait for hub_inbox; for pushes restart Claude with ahub claude" } : {}), ...(p instanceof PiPeer ? { requestedModel: p.getRequestedModel(), backends: modelRelay?.status().backends ?? [] } : {}) }]; }),
     ),
     ...(sidecar ? { switchyard: sidecar.status } : {}),
     ...(modelRelay ? { models: modelRelay.status() } : {}),
@@ -1501,6 +1522,7 @@ export async function startDaemon(opts: DaemonOptions) {
     releasing = true;
     try {
       await tasks.releaseReady(); // #34: dependents a stop cut off between an approval and their assignment
+      await tasks.rescreen().catch((e: Error) => log(`PII re-screen failed: ${e.message}`)); // #198: no verdict yet, nobody has it
       if (limit > 0) await releaseOwners(limit);
     } finally {
       releasing = false;
@@ -1908,6 +1930,8 @@ export async function startDaemon(opts: DaemonOptions) {
       const codex = new CodexPeer("codex", {
         onTokens: (added) => void addTokens("codex", added),
         onContext: (reading) => contexts.report("codex", reading, contextSession("codex")),
+        // #215: before the thread's first turn_start, so the planner can tell which turns belong to which thread.
+        onThread: (thread, fresh) => event({ type: "native_thread", peer: "codex", thread, fresh }),
         onTurn: (native) => {
           const open = turns.get("codex");
           if (open) turnLog?.native(open.id, native);
@@ -1975,7 +1999,14 @@ export async function startDaemon(opts: DaemonOptions) {
       if (problem) return { ok: false, error: problem };
       modelRelay ??= await startModelRelay({ omni, admitRequest: admitPiRequest, dgxMaxInputTokens: currentRouting(opts.cwd, log).pi.dgx_max_context_tokens, allowedDGXmodels: { "dgx/coding": config.pi.dgx_coding, "dgx/fast": config.pi.dgx_fast }, mlx: config.mlx.enabled === false ? undefined : config.mlx, mlxAlias: "mlx/fast", fallbackDGXAlias: "dgx/fast", enableHubAuto: true,
         routeSessionKey: () => { const session = bus.peers.get("pi")?.recoveryMetadata?.().sessionId; return typeof session === "string" ? session : undefined; },
+        staySwitch: () => currentRouting(opts.cwd, log),
         onRoute: record => event({ type: "route", peer: "pi", ...record }),
+        efficientWaitMs: currentRouting(opts.cwd, log).pi.efficient_wait_ms,
+        underBudget: () => { const current = bus.peers.get("pi"); return current instanceof PiPeer && tasks.budgetApplies(current.budgetEnvelopes, "pi"); },
+        onCooldown: record => {
+          log(`model ${record.alias}: ${record.event === "start" ? `cooling down for ${Math.round(record.ms! / 1000)} s after ${record.failures} transport or startup failures` : "cooldown ended"}`);
+          event({ type: "cooldown", peer: "pi", ...record });
+        },
       });
       piReceipts ??= new PiToolReceipts(join(opts.stateDir, "hub.db"));
       let piReply: Envelope | undefined;
@@ -2119,6 +2150,7 @@ export async function startDaemon(opts: DaemonOptions) {
         ...(route ? { route } : {}),
         ...(sidecar && route && !route.startsWith("hub/") ? { sidecar } : {}),
         hubRoutes: () => currentRouting(opts.cwd, log).hub_routes ?? {},
+        staySwitch: () => currentRouting(opts.cwd, log),
         onRoute: record => event({ type: "route", peer: "local", ...record }),
         onAdvisor: record => event({ type: "advisor", peer: "local", ...record }),
         onRouteOutcome: record => event({ type: "route_outcome", peer: "local", ...record }),
@@ -2484,7 +2516,9 @@ export async function startDaemon(opts: DaemonOptions) {
         if (!peer) bus.add((peer = new WsPeer(c.peer)));
         if (!(peer instanceof WsPeer)) return sock.close(4409, "peer id is taken by a hub-managed adapter");
         const ws = peer;
-        ws.claim(sock);
+        // Without pushes it stands by, as a replaced session does, and never strands a channel session's deliveries.
+        if (msg.channel === false && ws.channelHeld) return sock.close(4000, "a session with channel pushes holds this peer");
+        ws.claim(sock, msg.channel === false);
         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);
@@ -2516,9 +2550,22 @@ export async function startDaemon(opts: DaemonOptions) {
       case "delivery_receipt": {
         const peer = c.peer ? bus.peers.get(c.peer) : undefined;
         if (c.role !== "peer" || !(peer instanceof WsPeer) || typeof msg.deliveryId !== "string" || !peer.ownsDelivery(sock, msg.generation, msg.deliveryId) || !["accepted", "needs_review"].includes(msg.state)) return void reply({ ok: false, error: "invalid delivery receipt" });
-        bus.deliveryReceipt(peer.id, { id: msg.deliveryId, state: msg.state, ...(msg.state === "needs_review" ? { reason: "Claude bridge could not confirm notification delivery" } : {}) });
+        const reason = typeof msg.reason === "string" ? sanitize(msg.reason).replace(/\s+/g, " ").trim().slice(0, 300) : "";
+        bus.deliveryReceipt(peer.id, { id: msg.deliveryId, state: msg.state, ...(msg.state === "needs_review" ? { reason: reason || "Claude bridge could not confirm notification delivery" } : {}) });
         return void reply({ ok: true });
       }
+      case "inbox": {
+        // A Claude session that cannot show channel pushes reads its queue here; nothing it reads is ever `accepted` (issue #205).
+        const peer = c.peer ? bus.peers.get(c.peer) : undefined;
+        if (c.role !== "peer" || !(peer instanceof WsPeer) || !peer.owns(sock)) return void reply({ ok: false, error: "not attached to the hub yet; retry hub_inbox in a moment" });
+        if (!peer.pullOnly) return void reply({ ok: false, error: "messages are pushed to this session; hub_inbox only drains failed pushes" });
+        try {
+          const envs = bus.pull(peer.id);
+          if (!envs) return void reply({ ok: false, error: queueHold(peer.id) ?? (bus.isRecoveryHeld ? "recovery is holding deliveries" : pauseReason(peer.id)) });
+          if (envs.length) log(`${peer.id} read ${envs.length} queued message(s) through hub_inbox`);
+          return void reply({ ok: true, envs, waiting: bus.queued(peer.id) });
+        } catch { return void reply({ ok: false, error: "delivery journal unavailable" }); }
+      }
       case "delivery_complete": {
         const peer = c.peer ? bus.peers.get(c.peer) : undefined;
         if (c.role !== "peer" || !(peer instanceof WsPeer) || typeof msg.deliveryId !== "string" || !peer.ownsDelivery(sock, msg.generation, msg.deliveryId)) return void reply({ ok: false, error: "delivery does not belong to this connection generation" });

package/src/hub/events.ts

@@ -1,5 +1,7 @@
 import { appendFileSync, closeSync, existsSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
 import type { TaskAttribution } from "./attribution.ts";
+import type { SwitchTrace } from "../models/route/stage.ts";
+import type { ScreenRecord } from "./inference.ts";
 
 /** Bumped whenever a field changes meaning or goes away; new fields and new types do not bump it. */
 export const EVENTS_SCHEMA = 1;
@@ -15,7 +17,8 @@ export type HubEvent =
   | { type: "quiet"; id: string; from: string; peers: string[] }
   | { type: "fact"; peer: string; id: string; files: number; plans: number; unknown: number; named: number; bytes: number; via: "hook" | "steer" | "done"; ms?: number; hookMs?: number; rttMs?: number; accepted?: boolean; unanswered?: boolean; probe?: boolean; coverage?: boolean }
   | { type: "fact_ack"; peer: string; id: string; via: string; ms: number }
-  | { type: "route"; peer: string; route: string; tier: string; source: "override" | "dimensions" | "hold" | "classifier" | "default"; score: number; ms: number; decision?: string; turn?: string; task?: number; pii?: boolean; severity?: number; spinning?: number; exploring?: number; production?: number }
+  | ({ type: "route"; peer: string; route: string; tier: string; source: "override" | "dimensions" | "hold" | "classifier" | "default" | "load" | "cooldown" | "pin"; score: number; ms: number; stateless?: boolean; decision?: string; turn?: string; task?: number; pii?: boolean; severity?: number; spinning?: number; exploring?: number; production?: number } & Partial<SwitchTrace>)
+  | { type: "cooldown"; peer: string; alias: string; event: "start" | "end"; failures: number; ms?: number }
   | { type: "route_outcome"; peer: string; decision: string; turnId: string; turn: "completed" | "failed"; task?: number; pii: boolean; latched: boolean; next?: { severity: number; tests: "pass" | "fail" | "none"; repeat: boolean }; advisor?: "approve" | "redo" | "failed" }
   | { type: "advisor"; peer: string; route: string; trigger: string; verdict: "approve" | "redo" | "failed"; discardedChars: number }
   | { type: "progress"; peer: string; task: number; severity: number; spinning: number; exploring: number; production: number }
@@ -24,6 +27,7 @@ export type HubEvent =
   | { type: "split"; task: number; where?: "routing" | "cohort"; verdict: "split" | "single" | "unknown"; single?: string; splitS?: number; singleS?: number; reason?: string; trace?: string[] }
   | { type: "state"; peer: string; state: string }
   | { type: "turn_start"; peer: string; turn: string }
+  | { type: "native_thread"; peer: string; thread: string; fresh: boolean }
   | ({ type: "turn_end"; peer: string; turn: string; ms: number; tokens?: number; files?: number; snapshotMs?: number } & Partial<TaskAttribution>)
   | { type: "native_turn_end"; peer: string; id?: string }
   | { type: "conduct"; peer: string; action: string; task?: number; target?: string }
@@ -37,6 +41,8 @@ export type HubEvent =
   | ({ type: "usage"; peer: string; source: "omniroute" | "claude_transcript"; id: string; measuredAt?: string; requestedModel?: string; servedModel?: string; provider?: string; inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number; totalTokens?: number } & Partial<TaskAttribution>)
   | { type: "task"; id: number; event: string; by: string; state: string; owner: string | null; reviewer: string | null; class: string; pii: boolean }
   | { type: "overlap"; task: number; owner: string; others: { task: number; owner: string; paths: string[]; symbols?: string[] }[] }
+  /** A PII screen verdict (issue #198): what was screened and the closed label, source and category, never the text. */
+  | ({ type: "pii_screen" } & ScreenRecord)
   | { type: "conflict"; peer: string; task?: number; other: number; owner: string; paths: string[]; concurrent: boolean; turns?: [string, string] }
   | { type: "context_pressure"; peer: string; source: string; measuredAt: number; used: number; window: number | null }
   | { type: "quota"; peer: string; windows: { id: string; used: number; resetsAt?: number }[]; hard: boolean; measuredAt?: string };

package/src/hub/execution-budget.ts

@@ -83,16 +83,25 @@ export class ExecutionBudget {
     return this.admitTasks(taskId === undefined ? [] : [taskId], peer, unit, amount);
   }
 
+  /** Whether any budget meters this peer's work on these tasks. It only reads: nothing is admitted or counted. */
+  applies(taskIds: number[], peer: string): boolean {
+    return this.scopes(taskIds, peer).length > 0;
+  }
+
+  private scopes(taskIds: number[], peer: string): BudgetRow[] {
+    const ids = [...new Set(taskIds.filter((id) => Number.isSafeInteger(id) && id > 0))];
+    const taskRows = ids.length
+      ? this.db.query(`SELECT * FROM execution_budgets WHERE kind='task' AND task_id IN (${ids.map(() => "?").join(",")}) AND EXISTS (SELECT 1 FROM json_each(peers) WHERE value=?)`).all(...ids, peer) as BudgetRow[]
+      : [];
+    const runRows = this.db.query("SELECT * FROM execution_budgets WHERE kind='run' AND EXISTS (SELECT 1 FROM json_each(peers) WHERE value=?)").all(peer) as BudgetRow[];
+    return [...taskRows, ...runRows];
+  }
+
   admitTasks(taskIds: number[], peer: string, unit: ExecutionUnit, amount = 1): ExecutionBudgetDecision[] {
     if (!UNITS.has(unit) || !Number.isSafeInteger(amount) || amount <= 0) throw new Error("execution budget admission is invalid");
     const transaction = this.db.transaction(() => {
       // Read scopes only after BEGIN IMMEDIATE so a concurrent configure/admission cannot evade a scope or overdraw it.
-      const ids = [...new Set(taskIds.filter((id) => Number.isSafeInteger(id) && id > 0))];
-      const taskRows = ids.length
-        ? this.db.query(`SELECT * FROM execution_budgets WHERE kind='task' AND task_id IN (${ids.map(() => "?").join(",")}) AND EXISTS (SELECT 1 FROM json_each(peers) WHERE value=?)`).all(...ids, peer) as BudgetRow[]
-        : [];
-      const runRows = this.db.query("SELECT * FROM execution_budgets WHERE kind='run' AND EXISTS (SELECT 1 FROM json_each(peers) WHERE value=?)").all(peer) as BudgetRow[];
-      const rows = [...taskRows, ...runRows].sort((a, b) => a.created_at - b.created_at || a.id.localeCompare(b.id));
+      const rows = this.scopes(taskIds, peer).sort((a, b) => a.created_at - b.created_at || a.id.localeCompare(b.id));
       const pending: { cfg: ExecutionBudgetStatus; updates: Partial<Record<ExecutionUnit, number>>; decisions: ExecutionBudgetDecision[] }[] = rows.map((row) => {
         const cfg = fromRow(row), updates: Partial<Record<ExecutionUnit, number>> = {}, decisions: ExecutionBudgetDecision[] = [];
         const now = Date.now(), elapsedLimit = cfg.limits.elapsed_ms;

package/src/hub/hub-tools.ts

@@ -35,12 +35,12 @@ const tool = (name: string, description: string, properties: Record<string, unkn
 });
 
 export const TASK_TOOLS: HubTool[] = [
-  tool("hub_task_propose", "Put a piece of work on the shared task board. The hub assigns an owner by class (routing.toml) unless you name one. Classes: plan, implement, bulk_edit, test, review, summarize, triage. Name the class when you know it; without one the hub tries to pick it. Name yourself as owner to claim work nobody assigned you: it starts in progress. Put the paths the work touches in refs, and when you claim work, a plan; the hub says when they overlap another open task.", { title: str, class: { type: "string", enum: ["plan", "implement", "bulk_edit", "test", "review", "summarize", "triage"] }, detail: str, refs, plan, owner: { type: "string", description: "peer id; yours to claim the work, omit to let the hub route it" }, after: { type: "array", items: { type: "integer" }, description: "ids of tasks that must be approved first; until then this one waits, offered to nobody, and cannot be claimed" }, urgent: { type: "boolean", description: "hand it over even when its owner is paused for quota only briefly" } }, ["title"]),
+  tool("hub_task_propose", "Put a piece of work on the shared task board. The hub assigns an owner by class (routing.toml) unless you name one. Classes: plan, implement, bulk_edit, test, review, summarize, triage. Name the class when you know it; without one the hub tries to pick it. Name yourself as owner to claim work nobody assigned you: it starts in progress. Put the paths the work touches in refs, and when you claim work, a plan; the hub says when they overlap another open task.", { title: str, class: { type: "string", enum: ["plan", "implement", "bulk_edit", "test", "review", "summarize", "triage"] }, detail: str, refs, plan, owner: { type: "string", description: "peer id; yours to claim the work, omit to let the hub route it. With after, the owner is reserved: offered the task first once it is ready" }, after: { type: "array", items: { type: "integer" }, description: "ids of tasks that must be approved first; until then this one waits, offered to nobody, and cannot be claimed" }, urgent: { type: "boolean", description: "hand it over even when its owner is paused for quota only briefly" } }, ["title"]),
   tool("hub_task_accept", "Take a task that was assigned to you, with your plan for it.", { id, plan }, ["id"]),
   tool("hub_task_decline", "Pass on a task assigned to you; the hub offers it to the next peer.", { id, reason: str }, ["id"]),
   tool("hub_task_done", "Mark your task finished. It goes to its reviewer with your summary and refs. When the project configures a check for its class, the hub runs it first and the result comes as a task message: a failed check keeps the task with you.", { id, summary: { type: "string", description: "what changed, why, and the check you ran with its result" }, refs }, ["id", "summary"]),
   tool("hub_task_list", "The task board. PII tasks show as [pii].", { state: { type: "string", enum: ["proposed", "in_progress", "in_review", "approved", "changes_requested"] }, ready: { type: "boolean", description: "only proposed tasks with nothing left to wait for" } }),
-  tool("hub_review", "Give your verdict on a task you were asked to review: map the changed signatures and call sites to the task's plan or detail, read the check result, and list what is unmet. Two changes_requested in a row move the task to another peer.", { id, verdict: { type: "string", enum: ["approved", "changes_requested"] }, note: str, unmet: { type: "array", items: str, description: "each requirement of the plan or detail that the change does not meet" } }, ["id", "verdict"]),
+  tool("hub_review", "Give your verdict on a task you were asked to review: map the changed signatures and call sites to the task's plan or detail, read the check result (hub_task_show has it, with the done summary), and list what is unmet. Two changes_requested in a row move the task to another peer.", { id, verdict: { type: "string", enum: ["approved", "changes_requested"] }, note: str, unmet: { type: "array", items: str, description: "each requirement of the plan or detail that the change does not meet" } }, ["id", "verdict"]),
   tool("hub_checkpoint", "Answer a checkpoint request from the hub (quota or context window pressure): what you were doing, what is half done, what whoever continues must know. Write the same to .agenthub/checkpoint.md first if you can.", { summary: str, request_id: { type: "string", description: "The request id supplied by a context checkpoint request; required for context checkpoints" } }, ["summary"]),
   tool("hub_remember", "Save a decision, finding, contract or fail to the memory all agents share (claude-mem); the other agents also get it with their next message. A fail is an approach you tried that does not work, and why: the most useful note, it stops the others spending their quota on it. Do not retry what a fail note rules out without new evidence. Conclusions worth recalling, not chatter.", { text: str, title: str, kind: { type: "string", enum: [...NOTE_KINDS] }, task: id }, ["text"]),
 ];
@@ -50,8 +50,8 @@ export const TASK_TOOL_NAMES = new Set(TASK_TOOLS.map((t) => t.name));
 /** Separately published: serving a schema grants no authority, only the daemon's explicit role does. */
 export const CONDUCTOR_TOOLS: HubTool[] = [
   tool("hub_status", "Inspect public team state, holds, quota windows, task counts and pending approval peer/tool/age. Only the configured conductor may use this tool.", {}),
-  tool("hub_task_show", "Read a task's public view and history. PII tasks remain stubs. Only the conductor may use this tool.", { id }, ["id"]),
-  tool("hub_task_assign", "Move a task to another peer, as the conductor. Requires assign capability when the conductor has an explicit capabilities list.", { id, peer: str }, ["id", "peer"]),
+  tool("hub_task_show", "Read a task's public view and history, its done summary and check result included. PII tasks remain stubs. Only the conductor and the task's current owner and reviewer may use this tool.", { id }, ["id"]),
+  tool("hub_task_assign", "Move a task to another peer, as the conductor, or redirect a task you proposed while it is proposed and nobody accepted it. A task that still waits gets the peer as its reserved owner. When you have an explicit capabilities list, the conductor needs assign capability for any assign, the proposer only to hand the task to another peer.", { id, peer: str }, ["id", "peer"]),
   tool("hub_task_escalate", "Escalate a task through the normal task flow, as the conductor. Requires assign capability when explicitly listed.", { id }, ["id"]),
   tool("hub_peer_start", "Start local, kimi or headless pi. Claude, Codex and Pi TUI requests return a command for the person to run, without launching a terminal.", { peer: { type: "string", enum: ["local", "kimi", "pi", "claude", "codex"] }, mode: { type: "string", enum: ["headless", "tui"] } }, ["peer"]),
   tool("hub_peer_hold", "Hold a peer's deliveries as the conductor. This hold is separate from the person's hold and budget pauses.", { peer: str }, ["peer"]),