@staix/agent-hub 0.12.39 → 0.12.40

package/src/hub/daemon.ts

@@ -20,7 +20,7 @@ import { buildReviewBrief } from "./review-brief.ts";
 import { profileName, projectProfile, resolveProfile, mergeProfileOverrides, type ProfileName } from "./profiles.ts";
 import { catalogAssignments, loadRoleCatalog, selectedRoles, roleIdentity } from "./roles.ts";
 import { ActivityRing } from "./activity.ts";
-import { JcodePeer } from "../adapters/jcode.ts";
+import { JcodeOptionMismatch, JcodePeer } from "../adapters/jcode.ts";
 import { jcodeMcpReady } from "../cli/jcode-mcp.ts";
 import { loadSdlc, readSpecEdit, sdlcGh } from "./sdlc.ts";
 import { claudeStateFile, ownTerminalRow, pathEvidence, transcriptPersisted } from "./claude-state.ts";
@@ -45,7 +45,7 @@ import { childEnv } from "./child-process.ts";
 import { runCheck } from "./checks.ts";
 import { DEFAULT_TASK_SWEEP, taskSweepConfig, type TaskSweepConfig } from "./task-sweep.ts";
 import { ALL_MACHINE_LOCAL, configRepositoryPresent, configTracked, stripUntrusted } from "./config-trust.ts";
-import { authorizeConfigLeaf, configApply, configChanges, validateEffectiveConfig } from "./config-apply.ts";
+import { authorizeConfigLeaf, configApply, configChanges, validateEffectiveConfig, validatePetConfig } from "./config-apply.ts";
 import { resolveSettledRoles } from "./settled-roles.ts";
 import { CONFIG_SOURCE_FILES, configFingerprint, configSourceTexts, parseConfigSources, type ConfigSources } from "./config-reload.ts";
 import { eventLog, readEvents, tokenDeltas, type RoleIdentity } from "./events.ts";
@@ -71,7 +71,6 @@ import { reviewerPoolConfig } from "./reviewer-pool-config.ts";
 import { reviewDiff } from "../adapters/claude-print.ts";
 import { Capture, skipTools } from "../memory/capture.ts";
 import { DEFAULT_OMNIROUTE, OmniRoute, type OmniRouteConfig } from "../omniroute/client.ts";
-import { Sidecar } from "../switchyard/sidecar.ts";
 import { Briefs } from "../memory/brief.ts";
 import { Board, isClosedTaskState, taskProposalAt, taskHasStarted, CLASSES, type Task, type TaskClass } from "./board.ts";
 import { Budget, claudeWindows, codexWindows, DEFAULT_BUDGET, type BudgetConfig } from "./budget.ts";
@@ -81,7 +80,8 @@ import { closeSync, constants as fsConstants, openSync, lstatSync, readSync, sta
 import { basename, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { realPath, hubHome } from "./project.ts";
-import type { BusEvent } from "./bus.ts";
+import { mainCheckoutWarning } from "./main-checkout.ts";
+import type { BusEvent, PublishResult } from "./bus.ts";
 import { CONDUCTOR_TOOLS, CONDUCTOR_TOOL_NAMES, DEFAULT_ROLES, roleContract, TASK_TOOL_NAMES, TASK_TOOLS, BOUNDED_TASK_TOOLS, profileTaskTools } from "./hub-tools.ts";
 import { Conductor, ConductorHolds, conductorPeer, conductorProgressSink, publicConductorTask, publicPeerBudget, type ConductEvent } from "./conductor.ts";
 import { SupervisionFeed } from "./supervision.ts";
@@ -90,7 +90,7 @@ import { launcherPreview } from "../cli/preview.ts";
 import { AssignmentUndeliveredError, ESCALATE_AFTER, Tasks } from "./tasks.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, OVERLAY_FILE, overlayToml, parseRouting, routingText, type Routing } from "./routing.ts";
+import { currentRouting, loadRouting, detectSignals, OVERLAY_FILE, overlayToml, parseRouting, routingText, type Routing } from "./routing.ts";
 import { projectSettings, checkSettingValue, ignoredLine, pendingUndo, pendingUndoIdentity, readOverlay, restoredValue, routingCandidate, storedLocally, settingDef as instanceSettingDef, settingRefusal, settingRows, settingText, undoSetting, valueAt, writeConfigSetting, writeRoutingSetting, type SettingAuthority, type SettingDef, type SettingRow, type SettingValue, type UndoIdentity } from "./settings.ts";
 import { Bus } from "./bus.ts";
 import { attribute, deliveryTask, type TaskAttribution } from "./attribution.ts";
@@ -113,7 +113,8 @@ import { DEFAULT_LIMITS, Limiter, PROJECT_LIMITS, type LimitsConfig } from "./li
 import { changedPaths, hasTree, repoOf, snapshot, Turns, type TurnRecord } from "./snapshots.ts";
 import { archiveRestartSnapshot, readRecoveryWaivers, readRestartSnapshot, removeRestartSnapshot, restartPath, writeRestartSnapshot, type RecoveryPhase, type RestartPeerSnapshot, type RestartSnapshot } from "./restart.ts";
 import { consumeRecoveryContinuity, readRecoveryContinuity, retireRecoveryContinuity } from "./recovery-continuity.ts";
-import { shellQuote } from "../cli/terminal-recovery.ts";
+import { shellQuote, publishTerminalLaunch, terminalLaunchCandidate } from "../cli/terminal-recovery.ts";
+import { TerminalLaunches, terminalOwnerReads } from "./terminal-launch.ts";
 
 import { peerStartConfig, PEER_START_RETRY_MS, startModeOf, terminalTemplate, type PeerStartConfig, type StartMode } from "./start-mode.ts";
 import { hasKimiHubMcp } from "../cli/kimi-mcp.ts";
@@ -201,6 +202,8 @@ export interface HubConfig {
   coordination: "advisory" | "turn-free";
   /** Switches for controlled ablations only (issue #110): `stale_notices: "deliver"` turns #106's dropping off. */
   experiments?: { stale_notices?: "drop" | "deliver" };
+  /** Console-local character and window presentation (#280, #483); grants no authority. */
+  pet?: false | Record<string, unknown>;
   /** Machine-local fields a config file set but git could not vouch for, and why (issue #17). */
   ignored?: string[];
   /** Settings that were removed or are about to be (issue #83): what each does now, for `hub.log` and `ahub doctor`. */
@@ -254,7 +257,7 @@ const PEER_ID = /^[a-z][a-z0-9-]{0,31}$/;
 /** The shared project config, then the machine's own file, which overrides it block by block (issue #17). */
 const CONFIG_FILES = INSTANCE_CONFIG_FILES;
 export interface ConfigLayer { name: typeof CONFIG_FILES[number]; raw: Record<string, any> }
-const CONFIG_BLOCKS = ["memory", "roster", "roles", "catalog_roles", "pii", "data", "conductor", "budget", "context", "inference", "omniroute", ...NATIVE_CONFIG_BLOCKS, "approvals", "tasks", "task_sweep", "checks", "snapshots", "research", "bench", "limits", "review", "recovery", "capabilities", "mlx", "permission_modes", "peers", "terminal"];
+const CONFIG_BLOCKS = ["memory", "roster", "roles", "catalog_roles", "pii", "data", "conductor", "budget", "context", "inference", "omniroute", ...NATIVE_CONFIG_BLOCKS, "approvals", "tasks", "task_sweep", "checks", "snapshots", "research", "bench", "limits", "review", "recovery", "capabilities", "mlx", "permission_modes", "peers", "terminal", "pet"];
 
 /** Connection-time policy refresh reads role/feed fields only, never launches or machine-local configuration. */
 export function loadConductorPolicy(cwd: string, layers?: readonly ConfigLayer[]): { roles: Record<string, string[]>; conductor: HubConfig["conductor"]; planner?: string; notices?: string[] } {
@@ -309,7 +312,13 @@ function syncMinutes(v: unknown): number {
   return v;
 }
 
-export function loadConfig(cwd: string, layers?: readonly ConfigLayer[]): HubConfig {
+/** Routing diagnostics must not make independent config reads depend on valid routing. */
+function retiredRoutingSettings(cwd: string): readonly string[] {
+  try { return loadRouting(cwd).retired ?? []; }
+  catch { return []; } // Routing admission and reload report parse errors using their own last-good state.
+}
+
+export function loadConfig(cwd: string, layers?: readonly ConfigLayer[], routingRetired: readonly string[] = retiredRoutingSettings(cwd)): HubConfig {
   const captured = layers ?? readInstanceConfigLayers(cwd);
   const instanceConfig = readInstanceConfig(cwd, captured);
   const instances = instanceConfig.instances;
@@ -344,13 +353,15 @@ export function loadConfig(cwd: string, layers?: readonly ConfigLayer[]): HubCon
     peerStartConfig(file.peers, instances);
     if (file.terminal != null && (typeof file.terminal !== "object" || Array.isArray(file.terminal))) throw new Error("terminal must be an object");
     terminalTemplate(file.terminal?.open);
+    if (file.pet !== undefined) validatePetConfig(file.pet, "config.pet");
+    if (file.pet && typeof file.pet === "object" && !Object.keys(file.pet).length) delete file.pet;
     delete file.permission_default_sources; // provenance is loader-owned, never a file claim
     const why = stripUntrusted(file, DEFAULT_CONFIG, cwd, name);
     if (why) ignored.push(why);
     for (const [peer, mode] of Object.entries(permissionDefaults(file.permission_modes, instances))) appliedPermissionSources[peer] = { mode, source: `.agenthub/${name}` };
     return [file];
   });
-  if (!files.length) return DEFAULT_CONFIG;
+  if (!files.length) return routingRetired.length ? { ...DEFAULT_CONFIG, retired: [...routingRetired] } : DEFAULT_CONFIG;
   const file = files.reduce((a, b) => ({ ...a, ...b, ...Object.fromEntries(CONFIG_BLOCKS.filter((k) => a[k] !== undefined && b[k] !== undefined).map((k) => [k, { ...a[k], ...b[k] }])) }));
   const wipLayers = files.filter(layer => layer.tasks?.wip_limits !== undefined);
   if (wipLayers.length) file.tasks = { ...file.tasks, wip_limits: wipLayers.reduce((prior, layer) => ({ ...prior, ...planningWipLimits(layer.tasks.wip_limits) }), {} as Record<string, number>) };
@@ -361,7 +372,7 @@ export function loadConfig(cwd: string, layers?: readonly ConfigLayer[]): HubCon
   delete file.retired;
   // Escape hatches with a stated end (issue #83). A removed one is ignored, never an error: an old config.local.json
   // must not stop a hub from starting.
-  const retired: string[] = [];
+  const retired: string[] = [...routingRetired];
   if (file.local?.sandbox !== undefined) {
     if (file.local.sandbox === "allow-default") retired.push('local.sandbox "allow-default" was removed in 0.12.0: the deny-default sandbox applies (local.read_allow adds paths)');
     file.local = { ...file.local };
@@ -463,9 +474,6 @@ export interface DaemonOptions {
   controlPort: number;
   codexAppPort: number;
   codexProxyPort: number;
-  /** 0 disables the Switchyard sidecar. */
-  switchyardPort?: number;
-  switchyardBin?: string;
   config?: HubConfig;
   /** #269: the terminal providers for a TUI start the hub makes itself, built from `terminal.open`. Absent: none, and such a start is refused. */
   terminal?: (template: string[]) => TerminalOpener;
@@ -496,6 +504,7 @@ interface Client {
   authed: boolean;
   role?: "peer" | "console" | "tools";
   peer?: PeerId;
+  launchId?: string;
   tail?: () => void;
   watch?: () => void;
   /** The one-launch Kimi TUI admission this socket attached under; its close clears only that admission. */
@@ -509,6 +518,10 @@ class WsPeer extends BasePeer {
   // Checkpoints become stale at hello/claim, before asynchronous recall finishes and attach changes delivery generation.
   private claimGeneration = crypto.randomUUID();
   get sessionGeneration(): string { return this.claimGeneration; }
+  terminalOwner(launchId: string): { generation: string } | undefined {
+    return this.sock?.readyState === WebSocket.OPEN && this.sock.data.launchId === launchId && this.state !== "offline" && !this.claiming
+      ? { generation: this.claimGeneration } : undefined;
+  }
   private delivered = new Set<string>();
   private sock: Sock | undefined;
   private claimed: Sock | undefined;
@@ -539,6 +552,10 @@ class WsPeer extends BasePeer {
   get channelHeld(): boolean {
     return (!!this.sock && !this.pullOnly) || (this.claiming && !this.claimedPullOnly);
   }
+  /** Status-file observations are advisory; a replaced client cannot evict a live socket or pending claim. */
+  standbyHeld(pullOnly: boolean): boolean {
+    return this.claiming || (!!this.sock && this.sock.readyState === WebSocket.OPEN && (pullOnly || !this.pullOnly));
+  }
   /** 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 {
@@ -1199,14 +1216,9 @@ export async function startDaemon(opts: DaemonOptions) {
     } finally { for (const listener of held) listener.stop(true); }
   };
   const piCallsInFlight = () => [...piReceiptLedgers.values()].reduce((n, ledger) => n + ledger.inFlight, 0);
-  /**
-   * PII decisions need a positive answer about the path a hub-owned model call will really take: a gateway that
-   * answered and is not behind Access, and no sidecar that was generated against the off-campus URL. Unknown is no.
-   */
-  const onCampus = async (): Promise<boolean> => (await omni.onCampus()) && !(sidecar?.upstream && omni.isAccessHost(sidecar.upstream));
-  let sidecar: Sidecar | undefined; // L2, started by the first hub-owned model call, stopped with the hub
-  let sidecarRouting = "";
-  inference = new Inference(config.inference, { omni, sidecar: () => sidecar, route: "sy/fast", fixedModel: () => activeRouting().local.fixed_model, log });
+  /** PII needs a positively confirmed campus gateway; unknown never counts as on campus. */
+  const onCampus = (): Promise<boolean> => omni.onCampus();
+  inference = new Inference(config.inference, { omni, fixedModel: () => activeRouting().local.fixed_model, log });
 
   let dashboard: ReturnType<typeof startDashboard> | undefined;
   const uiEvents: { seq: number; event: BusEvent }[] = [];
@@ -1960,6 +1972,24 @@ export async function startDaemon(opts: DaemonOptions) {
   let claudeUsageSeen = 0;
   const claudeContextSeen = new Map<string, string>();
   const contextTailSeen = new Map<PeerId, string>();
+  const retainedCliAudits = new Set<string>();
+  function drainCliAuditsNow(): void {
+    for (const audit of drainCliAudits(opts.stateDir)) {
+      const delegated = audit.outcome === "delegated";
+      const refused = audit.outcome !== "run" && !delegated;
+      if (!event({ type: "agent_cli", peer: audit.peer, command: audit.command, refused, ...(delegated ? { delegated: true } : {}) })) {
+        throw new Error("CLI audit event was not retained");
+      }
+      retainedCliAudits.add(audit.id); // Only after the event append succeeded.
+      // ponytail: 4096 live-instance acknowledgements; eviction or restart fails closed. Durable keyed receipts can extend this window.
+      if (retainedCliAudits.size > 4096) retainedCliAudits.delete(retainedCliAudits.values().next().value!);
+      try {
+        notify(refused ? `${audit.peer} refused ahub ${audit.command}` : delegated
+          ? `${audit.peer} ran ahub ${audit.command} with delegated live-test console authority`
+          : `${audit.peer} ran ahub ${audit.command} as ${audit.peer}`);
+      } catch { /* The audit event is retained even if its advisory notice cannot be delivered. */ }
+    }
+  }
   const intervals = [
     setInterval(() => {
       void refreshRunner().catch(() => {});
@@ -1970,14 +2000,7 @@ export async function startDaemon(opts: DaemonOptions) {
       feedBudgetPauses();
       supervision.checkRound();
       try {
-        for (const audit of drainCliAudits(opts.stateDir)) {
-          const delegated = audit.outcome === "delegated";
-          const refused = audit.outcome !== "run" && !delegated;
-          event({ type: "agent_cli", peer: audit.peer, command: audit.command, refused, ...(delegated ? { delegated: true } : {}) });
-          notify(refused ? `${audit.peer} refused ahub ${audit.command}` : delegated
-            ? `${audit.peer} ran ahub ${audit.command} with delegated live-test console authority`
-            : `${audit.peer} ran ahub ${audit.command} as ${audit.peer}`);
-        }
+        drainCliAuditsNow();
       } catch { log("CLI audit outbox unavailable; inspect state before retrying an agent command"); }
       for (const peer of bus.knownPeers()) {
         contexts.retry(peer, contextSession(peer));
@@ -2121,7 +2144,7 @@ export async function startDaemon(opts: DaemonOptions) {
     if (piiTurn && (MEMORY_READ_TOOLS.has(op) || op === "hub_memory_correct" || op === "hub_remember" || op === "hub_task_propose" || op === "hub_sdlc_record" || op === "hub_plan_review" || op === "hub_sdlc_costs" || op.startsWith("hub_release_") || op === "hub_backlog_return_untouched" || op === "hub_backlog_plan" || op === "hub_backlog_undo" || op === "hub_backlog_pull" || op === "hub_backlog_split" || op === "release_new")) throw new PreEffectToolRefusal(`${op} is not available while working on a PII task: its text must not leave this machine`);
     // The same words attached to an ordinary task would reach its reviewer, its owner, overlapping owners (a plan, the
     // completed-change notice) and claude-mem. A turn that holds a PII task acts on ordinary tasks in a turn of its own.
-    if (piiTurn && (op === "hub_task_done" || op === "hub_review" || (op === "hub_task_accept" && a.plan != null))) {
+    if (piiTurn && (op === "hub_task_done" || op === "hub_review" || (op === "hub_task_accept" && (a.plan != null || a.refs != null)))) {
       const target = board.get(Number(a.id));
       if (target && !tasks.isPii(target)) throw new PreEffectToolRefusal(`${op} on task #${target.id} is not available while working on a PII task: its text would reach other peers; do it in a turn without the PII task`);
     }
@@ -2275,10 +2298,10 @@ export async function startDaemon(opts: DaemonOptions) {
       }
       case "hub_task_accept": {
         // S1 spec acceptance and S9 plan review are checked against one task snapshot before acceptance.
-        const t = await tasks.acceptReviewed(by, a.id, a.plan);
+        const t = await tasks.acceptReviewed(by, a.id, a.plan, a.refs);
         // A silent cohort (issue #107): the owners' plans come with every accept, as what the newcomer works from.
         const silent = tasks.silentFor(t.id);
-        const overlap = a.plan == null && !silent ? "" : tasks.overlaps(t);
+        const overlap = a.plan == null && a.refs == null && !silent ? "" : tasks.overlaps(t);
         if (silent && factsOn()) factsFor(by).sawPlans(by, tasks.overlapTasks(t)); // the plans in this answer need no fact later
         return [line(t), overlap, tasks.planGuardText(t)].filter(Boolean).join("\n");
       }
@@ -2291,7 +2314,7 @@ export async function startDaemon(opts: DaemonOptions) {
         return JSON.stringify(tasks.publicView(await tasks.cancel(a.id, by, { reason: a.reason, supersededBy: a.superseded_by, expectedFlowRevision: a.revision })));
       }
       case "hub_task_decline":
-        return line(await tasks.decline(by, a.id, a.reason));
+        return line(await tasks.decline(by, a.id, a.reason, a.capacity === true));
       case "hub_task_done": {
         const t = await tasks.done(by, a.id, a.summary, a.refs);
         const completion = t.history.findLast(h => h.by === by && (h.event === "done" || h.event === "done (checking)"));
@@ -2301,7 +2324,7 @@ export async function startDaemon(opts: DaemonOptions) {
         // A silent cohort (issue #107): the member that integrates is asked to check its work first; no done yet.
         const last = t.history.at(-1);
         if (last?.event === "integration requested" && last.by === HUB) return last.note ?? "";
-        const extra = tasks.takeDoneNote(t.id); // the notices a silence held, when no integration step ran
+        const extra = [tasks.takeDoneNote(t.id), tasks.checkoutNote()].filter(Boolean).join("\n"); // held silence notices, then the #572 checkout advisory
         const result = tasks.isChecking(t.id) ? `${line(t)}; its check is queued or running, and the result comes as a task message` : line(t);
         return extra ? `${result}\n${extra}` : result;
       }
@@ -2475,11 +2498,41 @@ export async function startDaemon(opts: DaemonOptions) {
   const claudePermissionGenerations = new Map<string, string>();
   const permissions = new Map<string, { push: string; peer: string; tool?: string; createdAt: number; expiresAt: number; done: (optionId: string | undefined, surface?: "console" | "dashboard" | "terminal", reason?: "expired" | "cancelled") => boolean }>();
   let stopping = false;
+  const terminalReads = terminalOwnerReads();
+  const terminalLaunches = new TerminalLaunches({
+    owner: row => {
+      const owner = bus.peers.get(row.peer), proof = owner?.terminalOwner?.(row.launchId);
+      if (!proof) return undefined;
+      return { ...proof, isCurrent: () => {
+        if (stopping || !membershipAllowed(row.peer) || bus.peers.get(row.peer) !== owner) return false;
+        const current = owner?.terminalOwner?.(row.launchId);
+        return current?.generation === proof.generation && current?.nativePid === proof.nativePid;
+      } };
+    },
+    publish: (row, current) => publishTerminalLaunch(opts.stateDir, row, current, { runner: terminalReads.run }),
+    log,
+  });
+  const terminalLaunchTimer = setInterval(() => { void terminalLaunches.reconcile(); }, 1_000);
+  terminalLaunchTimer.unref();
+  intervals.push(terminalLaunchTimer);
+  startupCleanup.push(() => terminalLaunches.clear());
 
   const pausedNote = (id: PeerId) => {
     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" } : {};
   };
+  /**
+   * #572 AC1: an ACP peer's turn cannot take a message mid-turn unless its adapter has a `steer` (jcode's does; headless Kimi
+   * and Qwen do not). The hub never cancels a turn to deliver, so an `important` message waits in the queue; once it has
+   * waited past `budget.stale_min` the status says so, and the person decides. Read-only.
+   */
+  const importantWaitingStatus = (id: PeerId, peer: PeerAdapter | undefined): Record<string, unknown> => {
+    if (!(peer instanceof AcpPeer) || (peer as PeerAdapter).steer || bus.stateOf(id) !== "busy") return {};
+    const since = bus.oldestQueuedImportantAt(id);
+    if (since === undefined || Date.now() - since < config.budget.stale_min * 60_000) return {};
+    const count = bus.queuedImportant(id), minutes = Math.floor((Date.now() - since) / 60_000);
+    return { importantWaitingSince: since, importantWaitingNote: `${count} important message${count === 1 ? "" : "s"} waiting on a busy ACP peer for ${minutes} min; its turn is never cancelled to deliver, so decide whether to stop it` };
+  };
   /** 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);
@@ -2693,6 +2746,7 @@ export async function startDaemon(opts: DaemonOptions) {
     pluginBundle: SERVER_JS,
     pendingRestart,
     retainedConfig,
+    ...(() => { const warning = mainCheckoutWarning(opts.cwd, tasks.publicMetadataText); return warning ? { mainCheckout: warning } : {}; })(),
     startModes: Object.fromEntries(START_MODE_PEERS.map(peer => [peer, startModeOf(config.peers, peer, declarations)])),
     memoryProfile: memoryProfileStatus(includeAttentionItems),
     lifecycleStages: [...lifecycleConfig.stages],
@@ -2711,14 +2765,13 @@ export async function startDaemon(opts: DaemonOptions) {
     ...(dashboard ? { uiOrigin: dashboard.origin } : {}),
     codexProxyPort: opts.codexProxyPort,
     peers: Object.fromEntries(
-      peerIds.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), ...(!membershipAllowed(id) ? { rostered: false, rosterNote: "off roster" } : {}), ...permissionStatus(id, p), ...(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 ? { pullOnly: true, toolsOnly: definitionOf(id)?.attach?.pullOnlyNotice ?? "tools-only: messages wait for hub_inbox; for pushes restart Claude with ahub claude", lastInboxAt: p.lastInboxAt ?? null } : {}), ...(p instanceof PiPeer ? { requestedModel: p.getRequestedModel(), backends: modelRelays.get(id)?.status().backends ?? [] } : {}) }]; }),
+      peerIds.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), ...(!membershipAllowed(id) ? { rostered: false, rosterNote: "off roster" } : {}), ...permissionStatus(id, p), ...(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) } : {}), ...importantWaitingStatus(id, p), ...pausedNote(id), ...(p instanceof LocalPeer && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(p instanceof WsPeer && p.claiming ? { claiming: true } : {}), ...(p instanceof WsPeer && p.pullOnly ? { pullOnly: true, toolsOnly: definitionOf(id)?.attach?.pullOnlyNotice ?? "tools-only: messages wait for hub_inbox; for pushes restart Claude with ahub claude", lastInboxAt: p.lastInboxAt ?? null } : {}), ...(p instanceof PiPeer ? { requestedModel: p.getRequestedModel(), backends: modelRelays.get(id)?.status().backends ?? [] } : {}) }]; }),
     ),
     taskWip: Object.fromEntries(peerIds.map(id => [id, { wip: tasks.wip(id), wipLimit: tasks.wipLimit(id) }])),
     boardReadCapabilities: { releaseFilter: true, columnMetadata: true },
     roleInfo: Object.fromEntries(peerIds.map(id => [id, { flowRoles: config.roles[id] ?? [], catalogRoles: roleState(id), ...(config.roles[id]?.includes("planner") ? { planner: plannerSource } : {}) }])),
     planner: { peers: plannerPeers(), source: plannerSource },
     ...(pendingPermissionDefaults.size ? { permissionDefaults: [...pendingPermissionDefaults].map(([peer, source]) => ({ peer, mode: "never-ask", source })) } : {}),
-    ...(sidecar ? { switchyard: sidecar.status } : {}),
     ...(modelRelay ? { models: modelRelay.status() } : {}),
     isolatedChecks: { pending: checkPending.size, orphans: orphanChecks, unknownReceipts: checkRunner.unknownReceipts ?? [], maintenanceUnavailable: checkRunner.maintenanceUnavailable === true },
     taskCapabilities: peerCapabilities(),
@@ -3322,7 +3375,9 @@ export async function startDaemon(opts: DaemonOptions) {
       if (owner instanceof PiPeer && owner.state !== "offline" && owner.mode === "tui") return { ok: false, error: "Pi runs in a terminal; end it there before starting a headless one", command: "ahub pi --headless" };
       return startPeer(peer, definitionOf(peer)?.start.explicitHeadlessMode ? { mode: "headless", ...(resume ?? {}) } : {});
     }
-    if (owner && owner.state !== "offline" && definitionOf(peer)?.start.daemonPort !== "owned-acp") return { ok: true, already: true, mode };
+    // #559 N1: only the console's own start reopens a frontend on an attached owned-ACP peer. The conductor and the
+    // dashboard answer `already`, so a repeated call never adds another TUI writer to the live session.
+    if (owner && owner.state !== "offline" && !(definitionOf(peer)?.start.daemonPort === "owned-acp" && by === "the console")) return { ok: true, already: true, mode };
     const words = [...startWords(peer, mode)];
     if (resume) words.push(...(resume.sessionFile ? ["--session-file", resume.sessionFile] : ["--session-id", resume.sessionId]), ...(resume.backend ? ["--backend", resume.backend] : []), ...(resume.model ? ["--model", resume.model] : []));
     const command = `ahub ${resume ? words.map(shellQuote).join(" ") : words.join(" ")}`;
@@ -3712,8 +3767,10 @@ export async function startDaemon(opts: DaemonOptions) {
         permit: async () => false, // Pi's calls ask through piPermit in executeTool, which knows the tool's name
         send: (text, to) => {
           if (to?.some((id) => !bus.peers.has(id) && id !== USER)) return "error: unknown peer";
-          const refused = pi.onMessage?.(text, { inReplyTo: piReply, ...(to?.length ? { to } : {}) });
-          return typeof refused === "string" ? `not sent: ${refused}` : "sent";
+          const result = pi.onMessage?.(text, { inReplyTo: piReply, ...(to?.length ? { to } : {}) }) as PublishResult | string | undefined;
+          if (typeof result === "string") return `not sent: ${result}`;
+          if (result?.dropped === "hop") return `not delivered: reply chain reached the hop cap (${MAX_HOP}); send a new message without reply_to`;
+          return "sent";
         },
       };
       const routing = activeRouting();
@@ -3834,9 +3891,9 @@ export async function startDaemon(opts: DaemonOptions) {
     }
     if (adapter?.start.daemonPort === "local-worker") {
       const routing = activeRouting();
-      // `--model` pins a model on OmniRoute and skips L2; `--route` picks another Switchyard route.
+      // `--model` pins a gateway alias; `--route` selects an in-process policy or a legacy fixed fallback.
       const route = args.model ? undefined : (args.route ?? routing.local.route);
-      if (route && !(route.startsWith("hub/") ? routing.hub_routes?.[route] : routing.routes[route])) return { ok: false, ...(existing && existing.state !== "offline" ? { already: true } : {}), error: `routing.toml has no route "${route}"` };
+      if (route && route.startsWith("hub/") && !routing.hub_routes?.[route]) return { ok: false, ...(existing && existing.state !== "offline" ? { already: true } : {}), error: `routing.toml has no route "${route}"` };
       const fixedModel = args.model ?? routing.local.fixed_model;
       // A manually paused recovery roster must be reconstructible while its gateway is unavailable.
       // It stays held; holdPeer validates the restored choice before an operator can resume it.
@@ -3845,16 +3902,6 @@ export async function startDaemon(opts: DaemonOptions) {
       // Validation can await network: a queued delivery may have started meanwhile.
       if (existing?.state === "busy") return { ok: false, error: "local is busy; retry when it is idle" };
       if (existing) { mute(existing); await existing.stop(); }
-      // The sidecar serves the routes it was generated from: a changed routing.toml needs a new one.
-      const routingKey = JSON.stringify([routing.targets, routing.routes]);
-      if (sidecar && routingKey !== sidecarRouting) {
-        await sidecar.stop();
-        sidecar = undefined;
-      }
-      if (route && !route.startsWith("hub/") && opts.switchyardPort) {
-        sidecarRouting = routingKey;
-        sidecar ??= new Sidecar({ routing, omni, stateDir: opts.stateDir, port: opts.switchyardPort, log, ...(opts.switchyardBin ? { bin: opts.switchyardBin } : {}) });
-      }
       const capture = config.memory.enabled
         ? new Capture(memory, { project: chain.at(-1)!, cwd: executionCwd, skip: skipTools(), deny: config.local.deny })
         : undefined;
@@ -3879,7 +3926,6 @@ export async function startDaemon(opts: DaemonOptions) {
         onUsage: record => event({ type: "usage", peer, source: "omniroute", id: record.id, ...record.usage, ...taskAttribution(peer, record.task), requestedModel: record.requestedModel, ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.provider ? { provider: record.provider } : {}), measuredAt: record.at }),
         admitBudget: async (envs, unit) => tasks.admitExecutionEnvelopes(envs, peer, unit),
         ...(route ? { route } : {}),
-        ...(sidecar && route && !route.startsWith("hub/") ? { sidecar } : {}),
         hubRoutes: () => activeRouting().hub_routes ?? {},
         staySwitch: () => activeRouting(),
         onRoute: record => event({ type: "route", peer, ...record }),
@@ -3977,19 +4023,14 @@ export async function startDaemon(opts: DaemonOptions) {
 
   async function validateLocalChoice(route: string | undefined, fixedModel: string): Promise<void> {
     const routing = activeRouting();
-    if (route && !(route.startsWith("hub/") ? routing.hub_routes?.[route] : routing.routes[route])) throw new Error(`routing.toml has no route "${route}"`);
+    if (route && route.startsWith("hub/") && !routing.hub_routes?.[route]) throw new Error(`routing.toml has no route "${route}"`);
     const models = await omni.models();
     const required = new Set([fixedModel]);
-    const visit = (value: unknown): void => {
-      if (typeof value === "string" && routing.targets[value]) required.add(routing.targets[value]!.id);
-      else if (Array.isArray(value)) value.forEach(visit);
-      else if (value && typeof value === "object") Object.values(value).forEach(visit);
-    };
     if (route?.startsWith("hub/")) {
       const policy = routing.hub_routes![route]!;
       required.add(policy.efficient ?? "fast"); required.add(policy.capable ?? "coding");
       if (policy.judge) required.add(policy.judge);
-    } else if (route) visit(routing.routes[route]);
+    }
     for (const model of required) await omni.checkModel(model, models);
   }
 
@@ -4201,12 +4242,18 @@ export async function startDaemon(opts: DaemonOptions) {
     const parts = key.split(".");
     if (parts.some(part => ["__proto__", "constructor", "prototype"].includes(part))) throw new Error("unsafe configuration path");
     let node = target as Record<string, unknown>;
+    const trail: [Record<string, unknown>, string][] = [];
     for (const part of parts.slice(0, -1)) {
       if (!Object.hasOwn(node, part) || !node[part] || typeof node[part] !== "object" || Array.isArray(node[part])) node[part] = {};
+      trail.push([node, part]);
       node = node[part] as Record<string, unknown>;
     }
-    if (value === undefined) delete node[parts.at(-1)!];
-    else node[parts.at(-1)!] = structuredClone(value);
+    if (value === undefined) {
+      delete node[parts.at(-1)!];
+      for (const [parent, part] of trail.reverse()) {
+        if (!Object.hasOwn(DEFAULT_CONFIG, part) && !Object.keys(parent[part] as object).length) delete parent[part];
+      }
+    } else node[parts.at(-1)!] = structuredClone(value);
   }
   function changedRawPaths(before: unknown, after: unknown, prefix = ""): string[] {
     const object = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
@@ -4217,8 +4264,9 @@ export async function startDaemon(opts: DaemonOptions) {
     return JSON.stringify(before) === JSON.stringify(after) ? [] : [prefix];
   }
   function declaredPaths(value: unknown, prefix = ""): string[] {
-    // Switchyard dictionaries have opaque keys (including dots); publish each dictionary as one value.
-    if (["routing.targets", "routing.routes", "routing.hub_routes"].includes(prefix)) return [prefix];
+    // Retired dictionaries never enter active publication; hub ids remain opaque keys.
+    if (prefix === "routing.targets" || prefix === "routing.routes") return [];
+    if (prefix === "routing.hub_routes") return [prefix];
     if (value && typeof value === "object" && !Array.isArray(value)) return Object.entries(value).flatMap(([key, child]) => declaredPaths(child, prefix ? `${prefix}.${key}` : key));
     return prefix ? [prefix] : [];
   }
@@ -4230,7 +4278,7 @@ export async function startDaemon(opts: DaemonOptions) {
     return { planners: settled.planners, conductors: Object.keys(candidate.roles).filter(peer => candidate.roles[peer]!.includes("conductor")).sort() };
   }
   function prepareConfiguration(sources: ConfigSources, authority: SettingAuthority, scope?: string, confirmed: readonly string[] = []) {
-    const fileConfig = loadConfig(opts.cwd, sources.layers);
+    const fileConfig = loadConfig(opts.cwd, sources.layers, sources.routing.retired ?? []);
     validateEffectiveConfig(fileConfig);
     const candidate = structuredClone(desiredConfig), routing = structuredClone(desiredRouting);
     const accepted: string[] = [], rejected: { key: string; reason: string }[] = [], guarded: string[] = [];
@@ -4320,9 +4368,12 @@ export async function startDaemon(opts: DaemonOptions) {
       for (const item of rejected) if (guarded.includes(item.key)) item.reason += "; combined confirmation preview exceeds its 128 KiB bound; split this edit";
       guarded.length = 0; previews.length = 0;
     }
+    candidate.retired = fileConfig.retired;
+    routing.retired = sources.routing.retired;
     const changes = configChanges({ ...config, roles: policyRoles }, candidate);
     const running = structuredClone({ ...config, roles: policyRoles });
     for (const change of changes) if (change.applies !== "restart") putConfig(running, change.key, change.after);
+    running.retired = fileConfig.retired;
     validateEffectiveConfig(running);
     conductorPeer(running.roles);
     for (const peer of Object.keys(running.catalog_roles ?? {})) selectedRoles(peer, running.roles, { ...resolvedProfile.catalog_roles, ...catalogAssignments(running.catalog_roles) }, catalog);
@@ -4383,7 +4434,7 @@ export async function startDaemon(opts: DaemonOptions) {
       if (confirm !== undefined && prepared.rejected.some(item => reloadConfirmation!.keys.includes(item.key))) return { ok: false, error: "configuration trust changed; run ahub settings reload again" };
       if (scope && prepared.rejected.some(item => item.key === scope)) return { ok: false, error: prepared.rejected.find(item => item.key === scope)!.reason };
       const { changes, candidate } = prepared;
-      const routingChanges = changedRawPaths({ ...runningRouting, sources: undefined }, { ...prepared.routing, sources: undefined }, "routing");
+      const routingChanges = changedRawPaths({ ...runningRouting, sources: undefined, retired: undefined }, { ...prepared.routing, sources: undefined, retired: undefined }, "routing");
       if (prepared.running.snapshots.enabled && repo && !turnLog) turnLog = new Turns(join(opts.stateDir, "hub.db"));
       const priorDesired = JSON.stringify([desiredConfig, desiredRouting, acceptedSources.trustLayers]);
       const rolesChanged = changes.some(change => change.key === "roles" || change.key.startsWith("roles.") || change.key === "planner");
@@ -4397,6 +4448,9 @@ export async function startDaemon(opts: DaemonOptions) {
       for (const change of changes.filter(change => change.key === "permission_modes" || change.key.startsWith("permission_modes."))) {
         for (const peer of change.key === "permission_modes" ? SUPPORTED_PEERS : [change.key.split(".")[1]!]) changedPermissionDefaults.add(peer);
       }
+      const priorRetired = new Set(config.retired ?? []);
+      config.retired = prepared.running.retired;
+      for (const line of config.retired ?? []) if (!priorRetired.has(line)) log(`config: ${line}`);
       config.permission_default_sources = candidate.permission_default_sources;
       for (const peer of changedPermissionDefaults) applyPendingPermissionDefault(peer);
       if (changes.some(change => change.key === "task_sweep" || change.key.startsWith("task_sweep."))) rescheduleSweep();
@@ -4572,7 +4626,7 @@ export async function startDaemon(opts: DaemonOptions) {
     const def = settingDef(key);
     if (typeof def === "string") return { error: def };
     const routing = activeRouting();
-    try { return { def, value: checkSettingValue(def, raw, def.type === "roles" ? compatibleRoles(def.path[1]!) : [...Object.keys(routing.routes), ...Object.keys(routing.hub_routes ?? {})]) }; }
+    try { return { def, value: checkSettingValue(def, raw, def.type === "roles" ? compatibleRoles(def.path[1]!) : Object.keys(routing.hub_routes ?? {})) }; }
     catch (error) { return { error: (error as Error).message }; }
   }
   const settingReason = (reason: unknown): string | undefined => {
@@ -5088,11 +5142,21 @@ export async function startDaemon(opts: DaemonOptions) {
         if (!PEER_ID.test(c.peer) || (RESERVED_IDS.has(c.peer) && !kimiPull)) return sock.close(4403, definitionOf(c.peer)?.attach?.admission?.reservedRefusal ?? "peer id is reserved or malformed");
         if (!membershipAllowed(c.peer)) return sock.close(4000, "peer is off roster; retry when a person adds it");
         if (!recoveryPeerAllowed(c.peer)) return sock.close(4403, "peer id is not part of the recovery roster");
+        if (definitionOf(c.peer)?.transport === "claude-channel" && msg.launchId !== undefined) {
+          let currentLaunch: unknown;
+          try {
+            const launch = JSON.parse(readFileSync(join(opts.stateDir, claudeStateFile("claude-launch", c.peer)), "utf8"));
+            if (launch.instanceId === instanceId && typeof launch.launchId === "string" && launch.launchId) currentLaunch = launch.launchId;
+          } catch { /* No current launch evidence: retain plain/pre-daemon attachment compatibility. */ }
+          if (currentLaunch !== undefined && msg.launchId !== currentLaunch) return sock.close(4430, "Claude launch ended; start a new session with ahub claude");
+          if (typeof msg.launchId === "string" && msg.launchId.length <= 128) c.launchId = msg.launchId;
+        }
         let peer = bus.peers.get(c.peer);
         if (kimiPull && peer instanceof AcpPeer && peer.state === "offline") peer = undefined;
         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;
+        if (msg.standby === true && ws.standbyHeld(msg.channel === false)) return sock.close(4000, "another session holds or is claiming this peer");
         // 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");
         preparedSessionRoles.delete(c.peer); // an external transport has no receipt for this daemon's native preamble
@@ -5542,6 +5606,13 @@ export async function startDaemon(opts: DaemonOptions) {
       }
       case "status":
         return void reply({ t: "status", status: status(c.role === "console") });
+      case "cli_audit_ack": {
+        if (c.role !== "console") return void reply({ ok: false, error: "cli_audit_ack is a console command" });
+        if (typeof msg.auditId !== "string" || !/^[a-f0-9-]{36}$/.test(msg.auditId)) return void reply({ ok: false, error: "invalid audit id" });
+        try { drainCliAuditsNow(); }
+        catch { return void reply({ ok: false, error: "CLI audit was not retained" }); }
+        return void reply({ ok: retainedCliAudits.has(msg.auditId), auditId: msg.auditId, instanceId });
+      }
       case "ui_snapshot":
         if (c.role !== "console") return void reply({ ok: false, error: "ui_snapshot is a console command" });
         if (!Number.isSafeInteger(msg.after ?? 0) || (msg.after ?? 0) < 0) return void reply({ ok: false, error: "invalid cursor" });
@@ -5579,6 +5650,14 @@ export async function startDaemon(opts: DaemonOptions) {
         if (typeof msg.admissionId === "string" && msg.admissionId === kimiAdmissionId) clearKimiAdmission();
         return void reply({ ok: true });
       }
+      case "terminal_launch": {
+        if (c.role !== "console") return void reply({ ok: false, error: "terminal launch registration is console only" });
+        if (stopping || recoveryActive() && !(recoveryPhase === "restored" && msg.operationId === recoveryOperationId)) return void reply({ ok: false, error: "recovery is holding terminal launches" });
+        const row = terminalLaunchCandidate(msg.launch, opts.cwd, opts.stateDir, instanceId);
+        if (!row || !membershipAllowed(row.peer) || !definitionOf(row.peer)?.session.launchRecord || recoveryActive() && !recoveryPeerAllowed(row.peer)) return void reply({ ok: false, error: "terminal launch identity unavailable" });
+        try { terminalLaunches.register(row); return void reply({ ok: true }); }
+        catch { return void reply({ ok: false, error: "terminal launch could not be registered; managed recovery is unavailable" }); }
+      }
       case "native_tui_launch": {
         if (c.role !== "console") return void reply({ ok: false, error: "native TUI launch is console only" });
         const peer = String(msg.peer), owner = bus.peers.get(peer);
@@ -5589,7 +5668,10 @@ export async function startDaemon(opts: DaemonOptions) {
           const options = msg.args ?? {};
           for (const key of ["model", "providerProfile", "sessionId"]) if (options[key] !== undefined && typeof options[key] !== "string") throw new Error("invalid option");
           return void reply({ ok: true, ...owner.tuiLaunch(msg.binding, options) });
-        } catch { return void reply({ ok: false, error: "owned Jcode launch or saved session could not be verified; details withheld" }); }
+        } catch (error) {
+          if (error instanceof JcodeOptionMismatch) return void reply({ ok: false, option: error.option, error: `owned Jcode launch differs from its running session in ${error.option}; start without it or stop jcode first` });
+          return void reply({ ok: false, error: "owned Jcode launch or saved session could not be verified; details withheld" });
+        }
       }
       case "peer_start":
         // #269: a start the hub makes in the peer's start mode, for a console child with no terminal of its own.
@@ -5719,6 +5801,9 @@ export async function startDaemon(opts: DaemonOptions) {
   }
   async function stopOnce(): Promise<void> {
     stopping = true;
+    terminalLaunches.clear();
+    // Start cancellation immediately; a failed read cleanup must not strand the other owned peers or finalization.
+    const terminalReadsStopped = terminalReads.stop().catch(() => { log("terminal owner query cleanup failed during shutdown"); });
     runnerRefreshAbort.abort();
     // A stop someone asked for is not a crash, even if it then runs past the shutdown deadline: forget the sessions now.
     try { removeSessions(opts.stateDir, instanceId); } catch { /* the state dir is gone */ }
@@ -5733,6 +5818,8 @@ export async function startDaemon(opts: DaemonOptions) {
     for (const pending of checkpointWaits.values()) pending.done(undefined);
     for (const p of permissions.values()) p.done(undefined);
     try {
+      await terminalReadsStopped;
+      await terminalLaunches.settled();
       // A peer can still be inside memory recall or its native handshake when kill arrives.
       // Drain those starts before taking the final owned-process snapshot.
       // Fence/abort the runner now, but slow container teardown must not consume the peer-stop deadline.
@@ -5741,7 +5828,7 @@ export async function startDaemon(opts: DaemonOptions) {
       // A fingerprint still being detected belongs in the research records written below; its peer must still be
       // attached when it settles, so this comes before the peers stop (each detection is bounded by its probe deadline).
       await Promise.allSettled([...detecting]);
-      const exits = await Promise.allSettled([...bus.peers.values()].map((p) => p.stop()).concat(sidecar ? [sidecar.stop()] : []));
+      const exits = await Promise.allSettled([...bus.peers.values()].map((p) => p.stop()));
       // A peer whose stop rejects must not strand the daemon (issue #56): its failure is
       // logged and shutdown finishes anyway, or the process ignores SIGTERM forever.
       for (const exit of exits) if (exit.status === "rejected") log(`peer stop failed during shutdown: ${(exit.reason as Error)?.message ?? exit.reason}`);

package/src/hub/delivery-superseded.ts

@@ -1,10 +1,25 @@
 import type { Envelope } from "./envelope.ts";
 import type { Task } from "./board.ts";
 
+type DeliveryTask = Pick<Task, "id" | "state" | "owner" | "reviewer" | "cancelled"> & Partial<Pick<Task, "history">>;
+
+/** No task text or timestamps: only this recipient's own acceptance in its current ownership span. */
+function recipientAccepted(task: DeliveryTask, recipient: string): boolean {
+  const history = task.history;
+  if (!history) return false;
+  // ponytail: inspect at most 4096 recent entries. Older/unknown acceptance keeps the brief held; a persisted owner epoch can extend it.
+  for (let index = history.length - 1, first = Math.max(0, history.length - 4096); index >= first; index--) {
+    const entry = history[index]!;
+    if (entry.owner !== undefined || ["assigned", "reassigned", "escalated", "unassigned", "backlog returned untouched"].includes(entry.event)) return false;
+    if (entry.event === "accepted" && entry.by === recipient) return true;
+  }
+  return false;
+}
+
 /** Evidence only, never task text: a mixed/unknown/live row requires a person's decision. */
 export function supersededDeliveryReason(
   originals: readonly Envelope[],
-  board: { get(id: number): Pick<Task, "id" | "state" | "owner" | "reviewer" | "cancelled"> | undefined },
+  board: { get(id: number): DeliveryTask | undefined },
   recipient: string,
 ): string | undefined {
   if (!originals.length) return undefined;
@@ -22,6 +37,8 @@ export function supersededDeliveryReason(
       if (typeof env.refs.taskCancelled === "number" && env.refs.taskCancelled === task.cancelled?.flowRevision) return undefined;
       reasons.add(`task #${task.id} cancelled`);
     } else if (task.state === "approved") reasons.add(`task #${task.id} approved`);
+    else if (env.kind === "task" && env.refs.taskRecipient === "owner" && Number.isSafeInteger(env.refs.taskOffer) && env.refs.taskOffer! >= 1 &&
+      task.owner === recipient && ["in_progress", "in_review", "changes_requested"].includes(task.state) && recipientAccepted(task, recipient)) reasons.add(`task #${task.id} accepted`);
     else if ((env.kind === "review" || env.refs.taskRecipient === "reviewer") && (task.state !== "in_review" || task.reviewer !== recipient)) reasons.add(`task #${task.id} review moved`);
     else if (env.kind === "task" && env.refs.taskRecipient === "owner" && task.owner !== recipient) reasons.add(`task #${task.id} owner moved`);
     else return undefined; // Untagged legacy task notices and planner coordination carry no proof of supersession.
@@ -33,7 +50,7 @@ export function supersededDeliveryReason(
 /** Informational context for every referenced task, including peer/user and mixed rows. Never authorizes settlement. */
 export function deliveryTaskContext(
   originals: readonly Envelope[],
-  board: { get(id: number): Pick<Task, "id" | "state" | "owner" | "reviewer" | "cancelled"> | undefined },
+  board: { get(id: number): DeliveryTask | undefined },
   recipient: string,
 ): string | undefined {
   const context = new Set<string>();