@songsid/agend 2.1.2-beta.15 → 2.1.2-beta.16

package/dist/daemon.js

@@ -1,19 +1,23 @@
 import { join, dirname, basename, resolve } from "node:path";
-import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, chmodSync, renameSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, renameSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { rotateLogIfNeeded } from "./logger.js";
+import { mcpServerState } from "./mcp-liveness.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { ContextGuardian } from "./context-guardian.js";
 import { IpcServer } from "./channel/ipc-bridge.js";
+import { daemonBudgetMs } from "./channel/ipc-timeouts.js";
 import { MessageBus } from "./channel/message-bus.js";
 import { shellQuote } from "./backend/types.js";
 import { getTmuxSession } from "./config.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { HangDetector } from "./hang-detector.js";
+import { writeSecretFile } from "./secret-file.js";
+import { PaneWriteLock } from "./pane-write-lock.js";
 import { buildFleetInstructions } from "./instructions.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -38,9 +42,9 @@ export function buildInstructionReloadNotice(binaryName, instanceName, instanceD
 export const DEFAULT_STUCK_TIMEOUT_MS = 10 * 60_000;
 export const DEFAULT_STATE_IDLE_DEBOUNCE_MS = 2_000;
 export const DEFAULT_STATE_SAFETY_SWEEP_MS = 60_000;
-/** @deprecated State detection is event-driven; this now aliases the safety sweep. */
-export const DEFAULT_STATE_POLL_INTERVAL_MS = DEFAULT_STATE_SAFETY_SWEEP_MS;
 const LAST_INBOUND_FILE = "last-inbound-at";
+/** Minimum gap between "health check is failing" notifications for one instance. */
+const HEALTH_ERROR_NOTIFY_INTERVAL_MS = 10 * 60_000;
 /**
  * Whether two working directories belong to the same project, so a fleet-scoped
  * decision recorded in one reaches the other. Covers the worktree/checkout
@@ -104,6 +108,40 @@ export function writeLastInboundAt(instanceDir, timestamp) {
     writeFileSync(temp, String(timestamp));
     renameSync(temp, target);
 }
+/**
+ * Render the handoff/routing metadata that rides along with an inbound message
+ * into the block actually pasted into the agent's pane.
+ *
+ * These fields were all populated by the sender (outbound-handlers builds them
+ * into `ipcMeta`) and delivered over IPC, but never rendered — so the receiving
+ * agent could not see them, and several documented flows could not work:
+ *
+ * - `report_result` requires a `correlation_id` the agent had no way to know, so
+ *   the "correlation_id not recognized" warning fired on essentially every call.
+ * - Delegation cancel buttons are retired by correlation id, so they never retired.
+ * - `react`, `edit_message` and `reply.reply_to` need `message_id`, which the tool
+ *   descriptions tell the agent to take "from the inbound block".
+ * - `download_attachment` needs `attachment_file_id`.
+ * - `requires_reply` was invisible, so a delegated task looked like an FYI.
+ *
+ * Only non-empty fields are emitted, so a plain user message gains at most a
+ * message_id line.
+ */
+export function renderHandoffMetadata(meta) {
+    const rows = [];
+    const add = (label, value) => {
+        if (value && value.trim())
+            rows.push(`${label}: ${value.trim()}`);
+    };
+    add("message_id", meta.message_id);
+    add("correlation_id", meta.correlation_id);
+    add("request_kind", meta.request_kind);
+    add("task_summary", meta.task_summary);
+    add("working_directory", meta.working_directory);
+    add("branch", meta.branch);
+    add("attachment_file_id", meta.attachment_file_id);
+    return rows.length ? `\n(${rows.join(" | ")})` : "";
+}
 /** Headless inactivity timer used by the daemon and unit tests. */
 export class AutoPauseController {
     thresholdMs;
@@ -148,24 +186,47 @@ export class AutoPauseController {
  * Pane motion wins over a ready match because several backends keep their ready
  * marker in a persistent header/footer while generating. A stable ready pane is
  * idle; changing content is working; stable non-ready content eventually sticks.
+ *
+ * ## Why an optional busy pattern exists
+ *
+ * "Motion wins" degrades badly when a backend's ready marker is *always* on
+ * screen. `stuck` requires `!ready`, so for such a backend the state can only ever
+ * be idle or working — the stuck edge, and with it `handleStuckTransition` and the
+ * hang notification, is unreachable. A frozen CLI is then reported as idle, which
+ * also clears pending work: the message the user sent is quietly booked as done.
+ *
+ * claude-code was exactly this case (see ClaudeCodeBackend.getReadyPattern). A
+ * backend that can point at a marker meaning "generating right now" supplies
+ * `getBusyPattern()`, and that match vetoes ready regardless of what the ready
+ * pattern says.
  */
 export class PaneStateMachine {
     stuckTimeoutMs;
     readyPattern;
+    busyPattern;
     lastPaneHash = null;
     lastPaneChangeAt;
     lastObservedAt;
     stateChangedAt;
     currentState = "idle";
-    constructor(readyPattern, stuckTimeoutMs = DEFAULT_STUCK_TIMEOUT_MS, now = Date.now()) {
+    constructor(readyPattern, stuckTimeoutMs = DEFAULT_STUCK_TIMEOUT_MS, now = Date.now(), busyPattern) {
         this.stuckTimeoutMs = stuckTimeoutMs;
         // Stateful g/y regexes mutate lastIndex and can alternate true/false across
         // polls. State detection must be deterministic for identical pane content.
         this.readyPattern = new RegExp(readyPattern.source, readyPattern.flags.replace(/[gy]/g, ""));
+        this.busyPattern = busyPattern
+            ? new RegExp(busyPattern.source, busyPattern.flags.replace(/[gy]/g, ""))
+            : null;
         this.lastPaneChangeAt = now;
         this.lastObservedAt = now;
         this.stateChangedAt = now;
     }
+    /** Ready, unless the backend can positively see that it is still generating. */
+    isReady(pane) {
+        if (this.busyPattern?.test(pane))
+            return false;
+        return this.readyPattern.test(pane);
+    }
     observe(pane, now = Date.now()) {
         const paneHash = createHash("sha256").update(pane).digest("hex");
         const firstObservation = this.lastPaneHash === null;
@@ -175,7 +236,7 @@ export class PaneStateMachine {
             this.lastPaneChangeAt = now;
         }
         this.lastObservedAt = now;
-        const ready = this.readyPattern.test(pane);
+        const ready = this.isReady(pane);
         const nextState = firstObservation
             ? ready ? "idle" : "working"
             : paneChanged
@@ -241,6 +302,21 @@ const FIRST_ENTER_SETTLE_MS = 1_750;
 const FIRST_DELIVERY_WINDOW_MS = 5_000;
 /** After busy native-queue paste+Enter, wait before checking the pane for silent loss. */
 const NATIVE_QUEUE_PASTE_VERIFY_MS = 2_000;
+/** Enter-confirmation poll: 10 × 200ms ≈ 2s of observed silence before giving up. */
+const CONFIRM_BUSY_POLLS = 10;
+const CONFIRM_BUSY_POLL_MS = 200;
+/**
+ * Ceiling on the whole confirmation, including time re-earned after a control-mode
+ * reconnect. Without it a reconnect loop could restart the poll indefinitely and
+ * hold the pane write lock along with it.
+ */
+const CONFIRM_BUSY_MAX_WAIT_MS = 10_000;
+/**
+ * How long a delivery waits for an in-flight spawn. Comfortably past the default
+ * 25s startup timeout plus dialog dismissal; past it we fall back to the old
+ * behaviour rather than holding a message indefinitely.
+ */
+const SPAWN_SETTLE_MAX_WAIT_MS = 60_000;
 /**
  * One-shot timing gate for the first paste after a CLI reaches its ready
  * prompt. Recent tmux versions expose a short interval where the prompt is
@@ -299,7 +375,6 @@ export class Daemon extends EventEmitter {
     ipcServer = null;
     messageBus;
     transcriptMonitor = null;
-    toolTracker = null;
     guardian = null;
     adapter = null;
     pendingIpcRequests = new Map();
@@ -310,6 +385,8 @@ export class Daemon extends EventEmitter {
     // Pending ack: react 🫡 on first transcript activity after receiving a message
     pendingAckMessage = null;
     // Tool status tracking for channel adapter
+    /** Last activity published to the fleet manager; null when nothing is running. */
+    currentActivity = null;
     toolStatusMessageId = null;
     toolStatusLines = [];
     toolStatusDebounce = null;
@@ -325,9 +402,19 @@ export class Daemon extends EventEmitter {
     lastSpawnAt = 0;
     crashTimestamps = [];
     healthCheckPaused = false;
+    lastHealthErrorNotifyAt = 0;
     /** CLI pane availability, independent from the daemon process and tri-state. */
     processStatus = "running";
     spawning = false;
+    /**
+     * Resolves when the in-flight spawn finishes; null when none is running.
+     *
+     * `spawning` alone can only be polled. Delivery needs to *wait*, and a boolean
+     * poll would either busy-loop or race the flag being cleared.
+     */
+    spawnSettled = null;
+    resolveSpawnSettled = null;
+    spawnDepth = 0;
     skipResume = false;
     backgroundSessionRecoveryAttempted = false;
     /** Whether the last spawn started a fresh session (not resumed). */
@@ -350,6 +437,7 @@ export class Daemon extends EventEmitter {
     instanceStateIdleDebounceMs = DEFAULT_STATE_IDLE_DEBOUNCE_MS;
     instanceStateStuckTimeoutMs = DEFAULT_STUCK_TIMEOUT_MS;
     instanceStateReadyPattern = null;
+    instanceStateBusyPattern = null;
     instanceStateMonitorActive = false;
     statePollInFlight = false;
     autoPauseController;
@@ -370,7 +458,13 @@ export class Daemon extends EventEmitter {
     recentEvents = [];
     recentToolActivity = [];
     snapshotConsumed = false;
+    /** Orders inbound channel messages against each other (queue-depth accounting
+     *  and ⏳/👀/✅ reactions live here). It does NOT cover the other writers that
+     *  reach the pane — {@link paneWriteLock} does. */
     pasteLock = Promise.resolve();
+    /** Mutual exclusion for *every* write into the pane, whichever subsystem it
+     *  comes from. See PaneWriteLock for why interleaving is destructive. */
+    paneWriteLock = new PaneWriteLock();
     pendingInstructionsUpdate;
     pendingInstructionsNotice = false;
     // Whether the warmup steering-reload notice should be injected after spawn.
@@ -383,6 +477,10 @@ export class Daemon extends EventEmitter {
     firstDeliveryDelay = new FirstDeliveryDelay();
     // PTY error pattern monitoring
     errorMonitorTimer = null;
+    /** Same 5-min gate the error monitor uses, so a dead MCP server alerts once. */
+    static MCP_DEATH_COOLDOWN_MS = 5 * 60_000;
+    lastMcpDeathNotifiedAt = 0;
+    mcpDeathNotifiedForPid = null;
     /** Prevent in-flight monitor callbacks from re-arming after a pause. */
     runtimeMonitorsFrozen = false;
     errorWaitingForRecovery = false; // true = error detected, waiting for ready pattern
@@ -509,9 +607,6 @@ export class Daemon extends EventEmitter {
             if ((type === "fleet_schedule_response" || type === "fleet_outbound_response" || type === "fleet_decision_response" || type === "fleet_task_response" || type === "fleet_display_name_response" || type === "fleet_description_response") && msg.fleetRequestId) {
                 key = String(msg.fleetRequestId);
             }
-            else if (type === "fleet_outbound_response" && msg.requestId != null) {
-                key = `fleet_out_${msg.requestId}`;
-            }
             if (key && this.pendingIpcRequests.has(key)) {
                 const handler = this.pendingIpcRequests.get(key);
                 this.pendingIpcRequests.delete(key);
@@ -662,7 +757,12 @@ export class Daemon extends EventEmitter {
                 else {
                     await new Promise(r => setTimeout(r, 5000));
                 }
-                await this.tmux?.pasteText(buildInstructionReloadNotice(this.backend?.binaryName ?? "unknown", this.name, this.instanceDir));
+                // This path only runs when pasteQueueDepth > 0 — i.e. exactly when a real
+                // delivery is already in flight or queued. Without the lock the notice and
+                // that delivery race into the same pane.
+                await this.paneWriteLock.run(async () => {
+                    await this.tmux?.pasteText(buildInstructionReloadNotice(this.backend?.binaryName ?? "unknown", this.name, this.instanceDir), this.systemPasteOptions());
+                });
                 // Record the value the agent has now been told about so the next
                 // unchanged restart skips the reload.
                 try {
@@ -695,27 +795,31 @@ export class Daemon extends EventEmitter {
             this.transcriptMonitor.on("tool_use", (name, input) => {
                 this.logger.debug({ tool: name }, "Tool use");
                 ackIfPending();
-                this.hangDetector?.recordActivity();
                 this.recordRecentEvent({ type: "tool_use", name, preview: this.summarizeTool(name, input) });
                 this.recordRecentToolActivity(this.summarizeTool(name, input));
+                this.publishActivity(this.summarizeTool(name, input));
             });
             this.transcriptMonitor.on("tool_result", (name, _output) => {
-                this.hangDetector?.recordActivity();
                 this.recordRecentEvent({ type: "tool_result", name });
+                // The tool finished; whatever comes next has not started yet. Better to
+                // show only elapsed time than to leave a stale "Bash: npm test" on screen.
+                this.publishActivity(null);
             });
             this.transcriptMonitor.on("assistant_text", (text) => {
                 this.logger.debug({ text: text.slice(0, 200) }, "Claude response");
                 ackIfPending();
-                this.hangDetector?.recordActivity();
                 this.recordRecentEvent({ type: "assistant_text", preview: text.slice(0, 100) });
             });
             this.transcriptMonitor.startPolling();
-            // HangDetector remains the fleet-manager notification event bridge. Its
-            // legacy silence timer is intentionally not started: pane state transitions
-            // below are now the sole source of hang events.
+            // HangDetector is the notification bridge to the fleet manager; pane state
+            // transitions below are the sole source of hang events (see hang-detector.ts).
+            // `hang_detector.enabled: false` opts out of the notification entirely.
+            // NOTE: `hang_detector.timeout_minutes` is NOT read here — the stuck timeout
+            // the pane monitor actually uses is resolved separately below. The two have
+            // long been separate; documented rather than silently ignored.
             const hangConfig = this.config.hang_detector;
             if (hangConfig?.enabled !== false) {
-                this.hangDetector = new HangDetector(hangConfig?.timeout_minutes ?? 10);
+                this.hangDetector = new HangDetector();
             }
             // 8. Context guardian
             const statusFile = join(this.instanceDir, "statusline.json");
@@ -723,7 +827,6 @@ export class Daemon extends EventEmitter {
             this.guardian.startWatching();
             this.guardian.on("status_update", () => {
                 this.saveSessionId();
-                this.hangDetector?.recordStatuslineUpdate();
             });
             // Context rotation removed: all CLI backends have built-in auto-compact.
             // Crash recovery (health check + respawn with snapshot) is retained below.
@@ -743,6 +846,40 @@ export class Daemon extends EventEmitter {
         this.startInstanceStateMonitor();
         this.logger.info(`${this.name} ready`);
     }
+    /**
+     * Detect a CRASHED MCP server and report it once.
+     *
+     * The MCP server writes its pid to channel.mcp.pid at startup and unlinks it on
+     * a clean exit, so "file present + pid dead" specifically means it died without
+     * cleaning up (crash / OOM / SIGKILL). A missing file is either "not started
+     * yet" or "exited cleanly" — neither is an incident, and an orphan exit implies
+     * the CLI itself died, which the crash detector already covers.
+     *
+     * The daemon deliberately does NOT try to respawn it: MCP is a stdio protocol
+     * where the CLI spawns the server and owns its pipes, so a daemon-spawned
+     * process would have no client reading it. Only the CLI can restore its own
+     * tools — hence notify, and let the operator decide about restarting.
+     */
+    checkMcpServerAlive() {
+        if (this.isPaused)
+            return;
+        const status = mcpServerState(this.instanceDir);
+        if (status.state === "unknown")
+            return;
+        if (status.state === "alive") {
+            this.mcpDeathNotifiedForPid = null; // the CLI respawned it — re-arm
+            return;
+        }
+        // Dead: report once per pid, and at most once per cooldown window.
+        if (this.mcpDeathNotifiedForPid === status.pid)
+            return;
+        if (Date.now() - this.lastMcpDeathNotifiedAt < Daemon.MCP_DEATH_COOLDOWN_MS)
+            return;
+        this.mcpDeathNotifiedForPid = status.pid;
+        this.lastMcpDeathNotifiedAt = Date.now();
+        this.logger.error({ pid: status.pid }, "MCP server process is gone — instance has no agend tools");
+        this.emit("mcp_died", { name: this.name, pid: status.pid });
+    }
     startHealthCheck() {
         if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
             return;
@@ -758,254 +895,285 @@ export class Daemon extends EventEmitter {
                 this.healthCheckTimer = null;
                 if (this.runtimeMonitorsFrozen)
                     return;
-                // Instance directory removed externally (e.g. `rm -rf ~/.agend/instances/<name>`).
-                // Stop the loop permanently — otherwise every tick triggers a respawn, whose
-                // writeRotationSnapshot fails with ENOENT and gets caught as "Failed to respawn",
-                // spamming errors every ~30s forever.
-                if (!existsSync(this.instanceDir)) {
-                    this.logger.warn({ instanceDir: this.instanceDir }, "Instance directory missing — stopping health check");
-                    this.healthCheckPaused = true;
-                    this.healthCheckTimer = null;
-                    return;
-                }
-                if (!this.tmux || this.spawning || this.healthCheckPaused || Daemon.tmuxServerPaused) {
-                    scheduleNext();
-                    return;
-                }
-                // Human-readable backend label for logs (e.g. "claude", "kiro-cli")
-                const cliLabel = this.backend?.binaryName ?? "CLI";
-                let paneStatus = await this.tmux.getPaneStatus();
-                // Auto-pause intentionally exits the pane process. A health tick that
-                // began just before pause must not classify that exit as a crash.
-                if (this.isPaused || this.pauseWakeState === "waking") {
-                    scheduleNext();
-                    return;
-                }
-                if (paneStatus?.alive) {
-                    // Instance output.log is fed by tmux pipe-pane and was previously never
-                    // rotated (only fleet.log / daemon.log were). Cap growth every tick.
-                    if (!this.config.lightweight) {
-                        rotateLogIfNeeded(join(this.instanceDir, "output.log"));
+                // The whole tick is guarded: an unguarded throw in here (a tmux hiccup,
+                // ENOSPC on the crash-history write) became an unhandled rejection, which
+                // the CLI turned into stopAll() + exit(1) for the ENTIRE fleet, and it also
+                // ended this instance's health loop because scheduleNext() sat after the
+                // throwing code. Catch, log, and keep checking.
+                try {
+                    // Instance directory removed externally (e.g. `rm -rf ~/.agend/instances/<name>`).
+                    // Stop the loop permanently — otherwise every tick triggers a respawn, whose
+                    // writeRotationSnapshot fails with ENOENT and gets caught as "Failed to respawn",
+                    // spamming errors every ~30s forever.
+                    if (!existsSync(this.instanceDir)) {
+                        this.logger.warn({ instanceDir: this.instanceDir }, "Instance directory missing — stopping health check");
+                        this.healthCheckPaused = true;
+                        this.healthCheckTimer = null;
+                        this.emitSupervisionEnded("instance directory was removed from disk", "Recreate the instance, or delete it from fleet.yaml.");
+                        return;
+                    }
+                    if (!this.tmux || this.spawning || this.healthCheckPaused || Daemon.tmuxServerPaused) {
+                        scheduleNext();
+                        return;
+                    }
+                    // The CLI owns the MCP server process, so the daemon can only observe it.
+                    this.checkMcpServerAlive();
+                    // Human-readable backend label for logs (e.g. "claude", "kiro-cli")
+                    const cliLabel = this.backend?.binaryName ?? "CLI";
+                    let paneStatus = await this.tmux.getPaneStatus();
+                    // Auto-pause intentionally exits the pane process. A health tick that
+                    // began just before pause must not classify that exit as a crash.
+                    if (this.isPaused || this.pauseWakeState === "waking") {
+                        scheduleNext();
+                        return;
                     }
-                    scheduleNext();
-                    return;
-                }
-                // A null status is ambiguous: it can be a transient `tmux list-panes`
-                // failure (e.g. tmux busy during a fleet-restart storm) rather than a
-                // real exit. Re-confirm once after a short delay before treating it as
-                // a crash. A non-null {alive:false} is a definite dead pane (real exit)
-                // and needs no recheck.
-                if (paneStatus === null) {
-                    await new Promise(r => setTimeout(r, 1500));
-                    paneStatus = await this.tmux.getPaneStatus();
                     if (paneStatus?.alive) {
-                        this.logger.debug(`[health] ${cliLabel} pane reported gone then alive on recheck — transient query failure, ignoring`);
+                        // Instance output.log is fed by tmux pipe-pane and was previously never
+                        // rotated (only fleet.log / daemon.log were). Cap growth every tick.
+                        if (!this.config.lightweight) {
+                            rotateLogIfNeeded(join(this.instanceDir, "output.log"));
+                        }
                         scheduleNext();
                         return;
                     }
-                }
-                // paneStatus === null → window gone entirely (e.g. tmux server crash)
-                // paneStatus.alive === false → pane dead, exit code available
-                const exitCode = paneStatus?.exitCode;
-                this.logger.debug({ exitCode }, `[health] pane exited with code: ${exitCode}`);
-                // Normal exit (e.g. user Ctrl+C or /exit) — no crash, no respawn
-                if (paneStatus && exitCode === 0) {
-                    this.setProcessStatus("stopped");
-                    this.logger.info("CLI exited normally (code 0) — pausing health check");
-                    await this.tmux.killWindow();
-                    this.healthCheckPaused = true;
-                    return;
-                }
-                this.setProcessStatus("crashed");
-                // Distinguish tmux server crash from single window crash.
-                // nullReason records *why* getPaneStatus returned null (for diagnosing
-                // whether this was a real window loss or a transient query failure).
-                let crashType = "window";
-                let nullReason;
-                if (!paneStatus) {
-                    const serverAlive = await TmuxManager.sessionExists(this.tmuxSessionName);
-                    if (!serverAlive) {
-                        crashType = "server";
-                        nullReason = "server_gone";
-                        this.logger.error(`tmux server died — all ${cliLabel} windows lost`);
-                        // Fleet-level circuit breaker: pause all instances on repeated tmux server crashes
-                        Daemon.tmuxServerCrashTimestamps.push(Date.now());
-                        const cutoff = Date.now() - 5 * 60_000;
-                        Daemon.tmuxServerCrashTimestamps = Daemon.tmuxServerCrashTimestamps.filter(t => t > cutoff);
-                        if (Daemon.tmuxServerCrashTimestamps.length >= 2 && !Daemon.tmuxServerPaused) {
-                            Daemon.tmuxServerPaused = true;
-                            this.logger.error("Fleet-level tmux server circuit breaker triggered — pausing all respawns for 30s");
-                            this.emit("tmux_server_crash", this.name);
-                            if (!Daemon.tmuxServerRecoveryTimer) {
-                                Daemon.tmuxServerRecoveryTimer = setTimeout(() => {
-                                    Daemon.tmuxServerRecoveryTimer = null;
-                                    Daemon.tmuxServerPaused = false;
-                                }, 30_000);
-                            }
+                    // A null status is ambiguous: it can be a transient `tmux list-panes`
+                    // failure (e.g. tmux busy during a fleet-restart storm) rather than a
+                    // real exit. Re-confirm once after a short delay before treating it as
+                    // a crash. A non-null {alive:false} is a definite dead pane (real exit)
+                    // and needs no recheck.
+                    if (paneStatus === null) {
+                        await new Promise(r => setTimeout(r, 1500));
+                        paneStatus = await this.tmux.getPaneStatus();
+                        if (paneStatus?.alive) {
+                            this.logger.debug(`[health] ${cliLabel} pane reported gone then alive on recheck — transient query failure, ignoring`);
                             scheduleNext();
                             return;
                         }
-                        await new Promise(r => setTimeout(r, 2_000)); // let session stabilize
                     }
-                    else {
-                        // null but server alive: window-level disappearance. Probe whether
-                        // the window truly no longer exists vs a transient query glitch.
-                        nullReason = "no_window";
-                        try {
-                            const windows = await TmuxManager.listWindows(this.tmuxSessionName);
-                            if (windows.some(w => w.name === this.name))
-                                nullReason = "window_present_query_glitch";
+                    // paneStatus === null → window gone entirely (e.g. tmux server crash)
+                    // paneStatus.alive === false → pane dead, exit code available
+                    const exitCode = paneStatus?.exitCode;
+                    this.logger.debug({ exitCode }, `[health] pane exited with code: ${exitCode}`);
+                    // Normal exit (e.g. user Ctrl+C or /exit) — no crash, no respawn
+                    if (paneStatus && exitCode === 0) {
+                        this.setProcessStatus("stopped");
+                        this.logger.info("CLI exited normally (code 0) — pausing health check");
+                        await this.tmux.killWindow();
+                        this.healthCheckPaused = true;
+                        this.emitSupervisionEnded("the CLI exited normally (code 0)", "Nothing crashed — start it again when you need it.");
+                        return;
+                    }
+                    this.setProcessStatus("crashed");
+                    // Distinguish tmux server crash from single window crash.
+                    // nullReason records *why* getPaneStatus returned null (for diagnosing
+                    // whether this was a real window loss or a transient query failure).
+                    let crashType = "window";
+                    let nullReason;
+                    if (!paneStatus) {
+                        const serverAlive = await TmuxManager.sessionExists(this.tmuxSessionName);
+                        if (!serverAlive) {
+                            crashType = "server";
+                            nullReason = "server_gone";
+                            this.logger.error(`tmux server died — all ${cliLabel} windows lost`);
+                            // Fleet-level circuit breaker: pause all instances on repeated tmux server crashes
+                            Daemon.tmuxServerCrashTimestamps.push(Date.now());
+                            const cutoff = Date.now() - 5 * 60_000;
+                            Daemon.tmuxServerCrashTimestamps = Daemon.tmuxServerCrashTimestamps.filter(t => t > cutoff);
+                            if (Daemon.tmuxServerCrashTimestamps.length >= 2 && !Daemon.tmuxServerPaused) {
+                                Daemon.tmuxServerPaused = true;
+                                this.logger.error("Fleet-level tmux server circuit breaker triggered — pausing all respawns for 30s");
+                                this.emit("tmux_server_crash", this.name);
+                                if (!Daemon.tmuxServerRecoveryTimer) {
+                                    Daemon.tmuxServerRecoveryTimer = setTimeout(() => {
+                                        Daemon.tmuxServerRecoveryTimer = null;
+                                        Daemon.tmuxServerPaused = false;
+                                    }, 30_000);
+                                }
+                                scheduleNext();
+                                return;
+                            }
+                            await new Promise(r => setTimeout(r, 2_000)); // let session stabilize
                         }
-                        catch {
-                            nullReason = "query_error";
+                        else {
+                            // null but server alive: window-level disappearance. Probe whether
+                            // the window truly no longer exists vs a transient query glitch.
+                            nullReason = "no_window";
+                            try {
+                                const windows = await TmuxManager.listWindows(this.tmuxSessionName);
+                                if (windows.some(w => w.name === this.name))
+                                    nullReason = "window_present_query_glitch";
+                            }
+                            catch {
+                                nullReason = "query_error";
+                            }
+                            this.logger.warn({ exitCode, nullReason }, `${cliLabel} window not found (tmux server alive)`);
                         }
-                        this.logger.warn({ exitCode, nullReason }, `${cliLabel} window not found (tmux server alive)`);
                     }
-                }
-                else {
-                    this.logger.warn({ exitCode }, `${cliLabel} process exited`);
-                }
-                // Capture last output before killing. Best-effort even when the pane is
-                // gone (paneStatus null) — gives the crash record something to diagnose
-                // from instead of an empty lastOutput.
-                let lastOutput;
-                try {
-                    const raw = await this.tmux.capturePaneWithHistory(50);
-                    // Strip ANSI escape codes for readability
-                    const cleaned = raw.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-                    lastOutput = cleaned.trimEnd() || undefined;
-                }
-                catch { /* best effort — pane may already be gone */ }
-                // Kill the dead window (remain-on-exit keeps it around) before respawn
-                if (paneStatus) {
-                    await this.tmux.killWindow();
-                }
-                // Detect claude-code background session conflict — recover without counting as crash
-                if (lastOutput && (lastOutput.includes("background agent") || lastOutput.includes("Session is currently running"))) {
-                    if (!this.backgroundSessionRecoveryAttempted) {
-                        this.backgroundSessionRecoveryAttempted = true;
-                        this.logger.warn("Detected lingering background agent session — starting fresh (no resume)");
-                        const sidFile = join(this.instanceDir, "session-id");
+                    else {
+                        this.logger.warn({ exitCode }, `${cliLabel} process exited`);
+                    }
+                    // Capture last output before killing. Best-effort even when the pane is
+                    // gone (paneStatus null) — gives the crash record something to diagnose
+                    // from instead of an empty lastOutput.
+                    let lastOutput;
+                    try {
+                        const raw = await this.tmux.capturePaneWithHistory(50);
+                        // Strip ANSI escape codes for readability
+                        const cleaned = raw.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+                        lastOutput = cleaned.trimEnd() || undefined;
+                    }
+                    catch { /* best effort — pane may already be gone */ }
+                    // Kill the dead window (remain-on-exit keeps it around) before respawn
+                    if (paneStatus) {
+                        await this.tmux.killWindow();
+                    }
+                    // Detect claude-code background session conflict — recover without counting as crash
+                    if (lastOutput && (lastOutput.includes("background agent") || lastOutput.includes("Session is currently running"))) {
+                        if (!this.backgroundSessionRecoveryAttempted) {
+                            this.backgroundSessionRecoveryAttempted = true;
+                            this.logger.warn("Detected lingering background agent session — starting fresh (no resume)");
+                            const sidFile = join(this.instanceDir, "session-id");
+                            try {
+                                unlinkSync(sidFile);
+                            }
+                            catch { }
+                            this.skipResume = true;
+                            await new Promise(r => setTimeout(r, 2_000));
+                            try {
+                                await this.spawnClaudeWindow();
+                                this.setProcessStatus("running");
+                                this.logger.info("Recovered from background session conflict");
+                                this.emit("crash_respawn", this.name);
+                            }
+                            catch (err) {
+                                this.logger.error({ err: err.message }, "Recovery from background session conflict failed");
+                            }
+                            return; // Don't count as crash
+                        }
+                        // Already attempted recovery — fall through to normal crash handling
+                    }
+                    // Detect a --continue/--resume failure (no conversation to resume). The
+                    // session-id file persists across the crash, so a blind respawn would add
+                    // --continue again and crash in the same way → loop. Clear the session id
+                    // and skip resume so the next spawn starts fresh. (skipResume also stops
+                    // saveSessionId below from resurrecting the id from statusline.json.)
+                    if (lastOutput && /no conversation found|no conversation to (continue|resume)|no previous (session|conversation)|--continue/i.test(lastOutput)) {
+                        this.logger.warn("Detected --continue/resume failure — clearing session-id; next spawn starts fresh");
                         try {
-                            unlinkSync(sidFile);
+                            unlinkSync(join(this.instanceDir, "session-id"));
                         }
-                        catch { }
+                        catch { /* may not exist */ }
                         this.skipResume = true;
-                        await new Promise(r => setTimeout(r, 2_000));
+                    }
+                    // Append to crash history
+                    this.appendCrashHistory({ exitCode, lastOutput, crashType, reason: nullReason });
+                    if (max_retries <= 0) {
+                        this.healthCheckPaused = true;
+                        this.logger.warn(`${cliLabel} window died — automatic restart is disabled`);
+                        this.emitSupervisionEnded("the CLI died and automatic restart is disabled (restart_policy.max_retries is 0)", "Start it manually, or raise max_retries in fleet.yaml.");
+                        return;
+                    }
+                    // Detect rapid crash: sliding window — 3+ crashes in 5 minutes
+                    this.crashTimestamps.push(Date.now());
+                    const crashWindowMs = 5 * 60_000;
+                    this.crashTimestamps = this.crashTimestamps.filter(t => t > Date.now() - crashWindowMs);
+                    if (this.crashTimestamps.length >= 3) {
+                        this.healthCheckPaused = true;
+                        this.logger.error({ crashesInWindow: this.crashTimestamps.length }, "3+ crashes in 5 minutes — pausing respawn");
+                        // P1: Persist crash state so next process restart skips resume
                         try {
-                            await this.spawnClaudeWindow();
-                            this.setProcessStatus("running");
-                            this.logger.info("Recovered from background session conflict");
-                            this.emit("crash_respawn", this.name);
-                        }
-                        catch (err) {
-                            this.logger.error({ err: err.message }, "Recovery from background session conflict failed");
+                            writeFileSync(join(this.instanceDir, "crash-state.json"), JSON.stringify({
+                                crashesInWindow: this.crashTimestamps.length,
+                                lastCrashAt: Date.now(),
+                                resumeDisabled: true,
+                            }));
                         }
-                        return; // Don't count as crash
+                        catch { /* best effort */ }
+                        this.emit("crash_loop", this.name);
+                        return; // don't schedule next — paused
                     }
-                    // Already attempted recovery — fall through to normal crash handling
-                }
-                // Detect a --continue/--resume failure (no conversation to resume). The
-                // session-id file persists across the crash, so a blind respawn would add
-                // --continue again and crash in the same way → loop. Clear the session id
-                // and skip resume so the next spawn starts fresh. (skipResume also stops
-                // saveSessionId below from resurrecting the id from statusline.json.)
-                if (lastOutput && /no conversation found|no conversation to (continue|resume)|no previous (session|conversation)|--continue/i.test(lastOutput)) {
-                    this.logger.warn("Detected --continue/resume failure — clearing session-id; next spawn starts fresh");
-                    try {
-                        unlinkSync(join(this.instanceDir, "session-id"));
+                    // Reset crash count if enough time has passed
+                    if (reset_after > 0 && Date.now() - this.lastCrashAt > reset_after) {
+                        this.crashCount = 0;
                     }
-                    catch { /* may not exist */ }
-                    this.skipResume = true;
-                }
-                // Append to crash history
-                this.appendCrashHistory({ exitCode, lastOutput, crashType, reason: nullReason });
-                if (max_retries <= 0) {
-                    this.healthCheckPaused = true;
-                    this.logger.warn(`${cliLabel} window died — automatic restart is disabled`);
-                    return;
-                }
-                // Detect rapid crash: sliding window — 3+ crashes in 5 minutes
-                this.crashTimestamps.push(Date.now());
-                const crashWindowMs = 5 * 60_000;
-                this.crashTimestamps = this.crashTimestamps.filter(t => t > Date.now() - crashWindowMs);
-                if (this.crashTimestamps.length >= 3) {
-                    this.healthCheckPaused = true;
-                    this.logger.error({ crashesInWindow: this.crashTimestamps.length }, "3+ crashes in 5 minutes — pausing respawn");
-                    // P1: Persist crash state so next process restart skips resume
-                    try {
-                        writeFileSync(join(this.instanceDir, "crash-state.json"), JSON.stringify({
-                            crashesInWindow: this.crashTimestamps.length,
-                            lastCrashAt: Date.now(),
-                            resumeDisabled: true,
-                        }));
+                    this.crashCount++;
+                    this.lastCrashAt = Date.now();
+                    if (this.crashCount > max_retries) {
+                        this.logger.error({ crashCount: this.crashCount, maxRetries: max_retries }, "Max crash retries exceeded — not respawning");
+                        this.healthCheckPaused = true;
+                        this.emitSupervisionEnded(`it crashed ${this.crashCount} times, exceeding restart_policy.max_retries (${max_retries})`, "Check the logs for the cause, then restart it.");
+                        return; // don't schedule next — given up
                     }
-                    catch { /* best effort */ }
-                    this.emit("crash_loop", this.name);
-                    return; // don't schedule next — paused
-                }
-                // Reset crash count if enough time has passed
-                if (reset_after > 0 && Date.now() - this.lastCrashAt > reset_after) {
-                    this.crashCount = 0;
-                }
-                this.crashCount++;
-                this.lastCrashAt = Date.now();
-                if (this.crashCount > max_retries) {
-                    this.logger.error({ crashCount: this.crashCount, maxRetries: max_retries }, "Max crash retries exceeded — not respawning");
-                    return; // don't schedule next — given up
-                }
-                // Calculate backoff delay
-                const delay = backoff === "exponential"
-                    ? Math.min(1000 * Math.pow(2, this.crashCount - 1), 60_000)
-                    : 1000 * this.crashCount;
-                this.logger.warn({ crashCount: this.crashCount, delay }, `${cliLabel} window died — respawning after backoff`);
-                await new Promise(r => setTimeout(r, delay));
-                try {
-                    this.saveSessionId();
-                    this.transcriptMonitor?.resetOffset();
-                    // Kill orphan MCP server from the crashed CLI session.
-                    // MCP server writes its PID to channel.mcp.pid on startup.
+                    // Calculate backoff delay
+                    const delay = backoff === "exponential"
+                        ? Math.min(1000 * Math.pow(2, this.crashCount - 1), 60_000)
+                        : 1000 * this.crashCount;
+                    this.logger.warn({ crashCount: this.crashCount, delay }, `${cliLabel} window died — respawning after backoff`);
+                    await new Promise(r => setTimeout(r, delay));
                     try {
-                        const pidFile = join(this.instanceDir, "channel.mcp.pid");
-                        const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
-                        process.kill(pid, "SIGTERM");
-                        this.logger.info({ pid }, "Killed orphan MCP server");
-                    }
-                    catch { /* no pid file or process already dead */ }
-                    // Kill any same-name windows before respawn to prevent orphans.
-                    // Wrapped in try-catch: if tmux server is dead, listWindows throws —
-                    // must not block spawnClaudeWindow (which calls ensureSession).
-                    try {
-                        const windows = await TmuxManager.listWindows(this.tmuxSessionName);
-                        for (const w of windows) {
-                            if (w.name === this.name) {
-                                const tm = new TmuxManager(this.tmuxSessionName, w.id);
-                                await tm.killWindow();
-                            }
+                        this.saveSessionId();
+                        this.transcriptMonitor?.resetOffset();
+                        // Kill orphan MCP server from the crashed CLI session.
+                        // MCP server writes its PID to channel.mcp.pid on startup.
+                        try {
+                            const pidFile = join(this.instanceDir, "channel.mcp.pid");
+                            const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+                            process.kill(pid, "SIGTERM");
+                            this.logger.info({ pid }, "Killed orphan MCP server");
                         }
-                    }
-                    catch { /* tmux server may be dead — ensureSession in trySpawn will recover */ }
-                    // Write snapshot before spawn — consumed only if resume fails
-                    this.writeRotationSnapshot("crash");
-                    // Try --resume first; spawnClaudeWindow falls back to fresh session if resume fails
-                    const resumed = await this.spawnClaudeWindow();
-                    if (!resumed) {
-                        // Resume failed → fresh session → inject snapshot for context
-                        await this.injectSnapshotMessage();
-                    }
-                    else {
-                        // Clean up stale snapshot — resume restored full context
+                        catch { /* no pid file or process already dead */ }
+                        // Kill any same-name windows before respawn to prevent orphans.
+                        // Wrapped in try-catch: if tmux server is dead, listWindows throws —
+                        // must not block spawnClaudeWindow (which calls ensureSession).
                         try {
-                            unlinkSync(join(this.instanceDir, "rotation-state.json"));
+                            const windows = await TmuxManager.listWindows(this.tmuxSessionName);
+                            for (const w of windows) {
+                                if (w.name === this.name) {
+                                    const tm = new TmuxManager(this.tmuxSessionName, w.id);
+                                    await tm.killWindow();
+                                }
+                            }
                         }
-                        catch { /* may not exist */ }
+                        catch { /* tmux server may be dead — ensureSession in trySpawn will recover */ }
+                        // Write snapshot before spawn — consumed only if resume fails
+                        this.writeRotationSnapshot("crash");
+                        // Try --resume first; spawnClaudeWindow falls back to fresh session if resume fails
+                        const resumed = await this.spawnClaudeWindow();
+                        if (!resumed) {
+                            // Resume failed → fresh session → inject snapshot for context
+                            await this.injectSnapshotMessage();
+                        }
+                        else {
+                            // Clean up stale snapshot — resume restored full context
+                            try {
+                                unlinkSync(join(this.instanceDir, "rotation-state.json"));
+                            }
+                            catch { /* may not exist */ }
+                        }
+                        this.setProcessStatus("running");
+                        this.logger.info({ resumed }, `Respawned ${cliLabel} window after crash`);
+                        this.emit("crash_respawn", this.name);
+                    }
+                    catch (err) {
+                        this.logger.error({ err }, `Failed to respawn ${cliLabel} window`);
                     }
-                    this.setProcessStatus("running");
-                    this.logger.info({ resumed }, `Respawned ${cliLabel} window after crash`);
-                    this.emit("crash_respawn", this.name);
                 }
                 catch (err) {
-                    this.logger.error({ err }, `Failed to respawn ${cliLabel} window`);
+                    this.logger.error({ err }, "Health check tick failed — continuing");
+                    // Surface it to the operator, not just the log — a health check that
+                    // keeps throwing means this instance is no longer being supervised.
+                    // Throttled: the tick repeats every ~30s, so an unnotified persistent
+                    // fault would otherwise post twice a minute forever.
+                    const now = Date.now();
+                    if (now - this.lastHealthErrorNotifyAt > HEALTH_ERROR_NOTIFY_INTERVAL_MS) {
+                        this.lastHealthErrorNotifyAt = now;
+                        this.emit("health_check_error", {
+                            name: this.name,
+                            message: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                    scheduleNext();
+                    return;
                 }
                 scheduleNext();
             }, healthCheckIntervalMs);
@@ -1017,6 +1185,21 @@ export class Daemon extends EventEmitter {
      * A dead remain-on-exit pane still contains the old ready prompt, so allowing
      * the pane monitor to capture it would re-create a false idle state.
      */
+    /**
+     * Announce that this instance is no longer being supervised.
+     *
+     * Four health-check exits set `healthCheckPaused = true` and returned without
+     * telling anyone: a clean CLI exit, `max_retries <= 0`, crash retries exhausted,
+     * and the instance directory being deleted. Only the crash-LOOP case emitted an
+     * event, so a fleet could quietly contain a dead instance that still looked fine
+     * on the dashboard — while messages routed to it queued or failed with a bare ❌.
+     *
+     * `crash_loop` already had this treatment; this is the same bridge for the other
+     * four, carrying a human-readable cause and the operator's next step.
+     */
+    emitSupervisionEnded(reason, remedy) {
+        this.emit("supervision_ended", { name: this.name, reason, remedy });
+    }
     setProcessStatus(status) {
         if (this.processStatus === status)
             return;
@@ -1062,6 +1245,7 @@ export class Daemon extends EventEmitter {
         if (!this.backend)
             return; // lightweight mode has no backend
         const readyPattern = this.backend.getReadyPattern();
+        const busyPattern = this.backend.getBusyPattern?.() ?? null;
         this.errorMonitorTimer = setInterval(async () => {
             if (!this.tmux || this.spawning)
                 return;
@@ -1074,20 +1258,30 @@ export class Daemon extends EventEmitter {
                 for (const dialog of dialogs) {
                     if (!dialog.pattern.test(pane))
                         continue;
-                    this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
-                    const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
-                    for (const key of dialog.keys) {
-                        if (SPECIAL_KEYS.has(key)) {
-                            await this.tmux.sendSpecialKey(key);
-                        }
-                        else {
-                            await this.tmux.pasteText(key);
+                    // These keys go straight into the pane. Sent while a message delivery is
+                    // mid-transaction, an `Escape` wipes the pasted text and an `Enter`
+                    // submits it half-composed — the user sees a message that vanished. Skip
+                    // (not queue) when the pane is busy: this poller runs every 5s, and the
+                    // dialog will still be on screen next tick.
+                    const dismissed = await this.paneWriteLock.tryRun(async () => {
+                        this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
+                        const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
+                        for (const key of dialog.keys) {
+                            if (SPECIAL_KEYS.has(key)) {
+                                await this.tmux.sendSpecialKey(key);
+                            }
+                            else {
+                                await this.tmux.pasteText(key, this.systemPasteOptions());
+                            }
+                            await new Promise(r => setTimeout(r, 200));
                         }
-                        await new Promise(r => setTimeout(r, 200));
+                    });
+                    if (!dismissed) {
+                        this.logger.debug({ dialog: dialog.description }, "Dialog dismissal deferred — pane write in flight");
                     }
-                    return; // Dialog dismissed, skip error checks this cycle
+                    return; // Dialog handled (or deliberately deferred): skip error checks this cycle
                 }
-                this.evaluateErrorPatterns(pane, patterns, readyPattern);
+                this.evaluateErrorPatterns(pane, patterns, readyPattern, Date.now(), busyPattern);
             }
             catch {
                 // capturePane can fail if window is transitioning — ignore
@@ -1095,7 +1289,7 @@ export class Daemon extends EventEmitter {
         }, 5_000); // Check every 5 seconds (runtime dialogs need fast response)
     }
     /** Evaluate one pane snapshot. Kept synchronous so state-machine edges are unit-testable. */
-    evaluateErrorPatterns(pane, patterns, readyPattern, now = Date.now()) {
+    evaluateErrorPatterns(pane, patterns, readyPattern, now = Date.now(), busyPattern = null) {
         // Count occurrences across the WHOLE pane (not just text after the last
         // ready prompt). Clone with `g` so stateful backend regexes cannot leak
         // lastIndex between monitor cycles.
@@ -1103,10 +1297,15 @@ export class Daemon extends EventEmitter {
             const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
             return (pane.match(new RegExp(pattern.source, flags)) || []).length;
         };
+        // Same veto as the state machine: a backend whose ready marker is permanently
+        // on screen would otherwise "recover" on the very first tick after the error,
+        // rebaselining the occurrence count while the error is still displayed — one
+        // notification, a false recovery log, then silence.
+        const looksReady = () => !busyPattern?.test(pane) && readyPattern.test(pane);
         // State: waiting for recovery. A missing/outdated ready pattern must not
         // suppress every future error forever, so the gate has a hard deadline.
         if (this.errorWaitingForRecovery) {
-            if (readyPattern.test(pane)) {
+            if (looksReady()) {
                 const downtime = Math.round((now - this.errorDetectedAt) / 1000);
                 const active = patterns.find(ep => Daemon.errorPatternKey(ep) === this.activeErrorPatternKey);
                 if (active) {
@@ -1205,6 +1404,12 @@ export class Daemon extends EventEmitter {
      * Interrupt the CLI's current generation (cancel button / `/cancel`).
      * Direct tmux key event (not a paste) so it registers as the interrupt key.
      * kiro-cli interrupts on Ctrl+C; the others (claude-code, codex, …) on Escape.
+     *
+     * Deliberately NOT taken through `paneWriteLock`. Cancel is the user's way out
+     * of a pane that is busy or wedged — queueing it behind the very delivery chain
+     * it exists to unblock would make the button useless exactly when it is needed.
+     * The cost is accepted: an Escape landing between a paste and its Enter discards
+     * that message, which is what the user asked for anyway.
      */
     async sendEscape() {
         const cancelKey = this.backend?.getCancelKey() ?? "Escape";
@@ -1242,7 +1447,6 @@ export class Daemon extends EventEmitter {
             this.toolStatusDebounce = null;
         }
         this.pendingIpcRequests.clear();
-        this.hangDetector?.stop();
         if (this.adapter)
             await this.adapter.stop();
         // Notify MCP servers of graceful shutdown (prevents reconnect attempts)
@@ -1269,7 +1473,12 @@ export class Daemon extends EventEmitter {
             if (!killed)
                 this.logger.warn("CLI did not exit gracefully within 3s, force killing window");
             // Always kill window — remain-on-exit keeps dead panes around after CLI exits
+            const stoppedWindowId = this.tmux.getWindowId();
             await this.tmux.killWindow();
+            // The control client is shared across the fleet and outlives this daemon, so
+            // a registration left behind here is re-resolved on every reconnect forever.
+            if (stoppedWindowId)
+                this.controlClient?.unregisterWindow(stoppedWindowId);
             const windowIdFile = join(this.instanceDir, "window-id");
             try {
                 unlinkSync(windowIdFile);
@@ -1405,7 +1614,7 @@ export class Daemon extends EventEmitter {
             return;
         }
         this.pauseWakeState = "waking";
-        this.spawning = true;
+        this.beginSpawn();
         const transition = this.autoPauseController.wakeOnDeliver(async () => {
             let timeout;
             try {
@@ -1446,7 +1655,7 @@ export class Daemon extends EventEmitter {
             throw err;
         }
         finally {
-            this.spawning = false;
+            this.endSpawn();
             if (this.pauseWakeTransition === transition)
                 this.pauseWakeTransition = null;
         }
@@ -1458,6 +1667,10 @@ export class Daemon extends EventEmitter {
         // observations between enqueue and paste must not clear a newer inbound.
         if (snapshot.state === "idle" && previous !== "idle") {
             this.pendingWork.recordIdle(snapshot.observedAt);
+            // The turn is over. A transcript can end on a tool_use with no matching
+            // tool_result (interrupted, crashed, cancelled), which would otherwise leave
+            // the last tool pinned to the progress line for the rest of the session.
+            this.publishActivity(null);
         }
         if (snapshot.state !== previous) {
             this.logger.info({
@@ -1548,6 +1761,13 @@ export class Daemon extends EventEmitter {
             this.instanceStateMachine.observe(pane, observedChangeAt);
             const snapshot = this.instanceStateMachine.observe(pane, Date.now());
             this.applyInstanceStateSnapshot(snapshot, pane);
+            // Backends without a transcript feed can still say what they are doing, if
+            // their TUI names it. Free-riding on a capture that already happened: no
+            // extra tmux call. Cadence is the capture cadence (idle debounce + the 60s
+            // safety sweep), which matches the progress ticker's own 60s interval.
+            if (this.backend?.getPaneActivity) {
+                this.publishActivity(snapshot.state === "idle" ? null : this.backend.getPaneActivity(pane));
+            }
             if (snapshot.state === "idle") {
                 this.clearInstanceStateStuckTimer();
             }
@@ -1602,7 +1822,8 @@ export class Daemon extends EventEmitter {
             ? rawConfig.idle_debounce_ms
             : DEFAULT_STATE_IDLE_DEBOUNCE_MS;
         this.instanceStateReadyPattern = this.backend.getReadyPattern();
-        this.instanceStateMachine = new PaneStateMachine(this.instanceStateReadyPattern, this.instanceStateStuckTimeoutMs);
+        this.instanceStateBusyPattern = this.backend.getBusyPattern?.() ?? null;
+        this.instanceStateMachine = new PaneStateMachine(this.instanceStateReadyPattern, this.instanceStateStuckTimeoutMs, Date.now(), this.instanceStateBusyPattern);
         this.instanceStateLastOutputAt = 0;
         this.instanceStateMonitorActive = true;
         if (this.controlClient) {
@@ -1643,6 +1864,12 @@ export class Daemon extends EventEmitter {
             paneTail: sanitizePaneTail(pane),
             readyPattern: readyPattern.toString(),
             readyMatched: deterministicReadyPattern.test(pane),
+            // A pane that is stuck *while* the ready marker matches means the busy
+            // pattern is what held it back — worth seeing when tuning either regex.
+            busyPattern: this.instanceStateBusyPattern?.toString(),
+            busyMatched: this.instanceStateBusyPattern
+                ? new RegExp(this.instanceStateBusyPattern.source, this.instanceStateBusyPattern.flags.replace(/[gy]/g, "")).test(pane)
+                : undefined,
             unchangedForMs: snapshot.unchangedForMs,
             pendingWork: this.pendingWork.hasPendingWork(),
         };
@@ -1685,6 +1912,40 @@ export class Daemon extends EventEmitter {
         return this.messageBus;
     }
     // ── Tool status tracking ──────────────────────────────────────
+    /**
+     * Tell the fleet manager what this instance is doing right now, for the live
+     * progress line on the cancel button.
+     *
+     * Purely cosmetic — nothing decides anything from it, so it is fine that only
+     * backends with a transcript feed report at all (claude-code today). For the
+     * rest the progress line keeps showing just elapsed time.
+     *
+     * Repeats are dropped: the ticker only edits the channel message when the text
+     * changes, and a stream of identical broadcasts would defeat that.
+     */
+    publishActivity(activity) {
+        const next = activity && activity.trim() ? activity.trim() : null;
+        if (next === this.currentActivity)
+            return;
+        this.currentActivity = next;
+        this.ipcServer?.broadcast({
+            type: "instance_activity",
+            instanceName: this.name,
+            activity: next,
+        });
+    }
+    /**
+     * Options for every system-initiated paste (startup notice, session snapshot,
+     * runtime-dialog keys).
+     *
+     * One place, so the three call sites cannot drift apart on it. Backends with a
+     * native input queue do not get the retry Enter: on those, a second bare Enter
+     * is not the no-op the retry assumed but a queue mutation — the same reason
+     * `deliverMessage` refuses to probe for busy with one.
+     */
+    systemPasteOptions() {
+        return { retryEnter: this.backend?.supportsQueuedInput?.() !== true };
+    }
     summarizeTool(name, input) {
         const inp = input;
         if (!inp)
@@ -1774,7 +2035,6 @@ export class Daemon extends EventEmitter {
             writeFileSync(join(this.instanceDir, "prev-instructions"), this.pendingInstructionsUpdate);
             this.pendingInstructionsUpdate = undefined;
         }
-        this.hangDetector?.recordInbound();
         this.pendingWork.recordInbound();
         // v3: record user messages for rotation snapshot
         this.recordRecentUserMessage(content, meta);
@@ -1797,12 +2057,26 @@ export class Daemon extends EventEmitter {
             // #77: show the sender's display name for readability, keeping the machine
             // instance name in parens so the recipient's send_to_instance target is valid.
             const fromLabel = meta.from_display ? `${meta.from_display} (${fromInstance})` : fromInstance;
-            formatted = `[from:${fromLabel}] ${content}\n(If you need to reply, use send_to_instance tool, NOT direct text. If there is nothing to add, you may stay silent.)`;
+            formatted = `[from:${fromLabel}] ${content}`;
+            formatted += renderHandoffMetadata(meta);
+            // A delegated task that requires a reply must not read like a chatty FYI —
+            // the "you may stay silent" line is for the latter only.
+            formatted += meta.requires_reply === "true"
+                ? "\n(A reply IS required: use report_result with the correlation_id above — or send_to_instance. Not direct text.)"
+                : "\n(If you need to reply, use send_to_instance tool, NOT direct text. If there is nothing to add, you may stay silent.)";
         }
         else {
             const via = meta.source ? ` via ${meta.source}` : "";
             const idTag = meta.user_id ? `, id:${meta.user_id}` : "";
-            formatted = `[user:${user}${via}${idTag}] ${content}\n(Reply using the reply tool — do NOT respond with direct text)`;
+            formatted = `[user:${user}${via}${idTag}] ${content}`;
+            // Reactions queued since the last real message (#432). One leading line of
+            // context, present only when something is pending — a reaction no longer
+            // costs a turn of its own.
+            if (meta.pending_reactions) {
+                formatted = `[Recent reactions: ${meta.pending_reactions}]\n${formatted}`;
+            }
+            formatted += renderHandoffMetadata(meta);
+            formatted += "\n(Reply using the reply tool — do NOT respond with direct text)";
         }
         if (meta.reply_to_text) {
             formatted += `\n(reply_to: "${meta.reply_to_text}")`;
@@ -1866,6 +2140,8 @@ export class Daemon extends EventEmitter {
             // Odd number of fences = unclosed. Remove all code fences from the message.
             formatted = formatted.replace(/```/g, "");
         }
+        // Before anything reads the window id: a spawn in progress is about to change it.
+        await this.waitForSpawnToSettle();
         let windowId = this.getWindowId();
         const supportsQueuedInput = this.backend?.supportsQueuedInput?.() === true;
         let handingOffToNativeQueue = false;
@@ -1881,9 +2157,33 @@ export class Daemon extends EventEmitter {
             }
             else {
                 this.logger.debug("CLI busy — queuing message until idle");
-                await this.controlClient.waitUntilIdle(windowId);
+                const becameIdle = await this.controlClient.waitUntilIdle(windowId);
+                if (!becameIdle) {
+                    // The pane never freed up. Report the failure instead of pasting into a
+                    // wedged CLI (where the text would sit unsubmitted and the next message
+                    // would land on top of it) — and instead of holding the queue silently.
+                    this.logger.error("Pane still busy after the idle wait — reporting delivery failure");
+                    if (status)
+                        this.emit("message_failed", status); // ❌
+                    return false;
+                }
             }
         }
+        // Everything above is *waiting*; everything below *writes*. Only the write is
+        // held under the pane lock — holding it across the idle wait (up to 30 min)
+        // would starve the runtime-dialog dismisser, which is often the very thing
+        // that would let the pane go idle again.
+        return this.paneWriteLock.run(() => this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status));
+    }
+    /**
+     * The write half of a delivery: paste → Enter → confirm, with retries.
+     *
+     * Always called under {@link paneWriteLock}. Split out from `deliverMessage`
+     * precisely so the lock's scope is visible at the call site rather than being
+     * an invariant maintained by comments.
+     */
+    async writeMessageToPane(formatted, initialWindowId, handingOffToNativeQueue, status) {
+        let windowId = initialWindowId;
         // Bug A: paste with backoff. Transient failures are usually a stale window id
         // after a crash/respawn — recover by name and retry (max 3 attempts, 2s apart).
         const maxAttempts = 3;
@@ -1966,8 +2266,20 @@ export class Daemon extends EventEmitter {
                     await this.tmux.sendSpecialKey("Enter");
                     becameBusy = await this.confirmBusyAfterEnter(windowId, retryAt);
                 }
-                if (becameBusy && status)
-                    this.emit("message_confirmed", status); // ✅
+                if (becameBusy) {
+                    if (status)
+                        this.emit("message_confirmed", status); // ✅
+                }
+                else {
+                    // Both Enters were swallowed: the text is sitting UNSUBMITTED in the
+                    // CLI's input box. This used to return true, so the reaction stayed at 👀
+                    // forever and the next delivery pasted on top — submitting two messages
+                    // as one. Say so instead.
+                    this.logger.error("Message pasted but never submitted (no idle→busy after two Enters)");
+                    if (status)
+                        this.emit("message_failed", status); // ❌
+                    return false;
+                }
             }
             else {
                 // No control client to observe output: fall back to the legacy double-Enter.
@@ -2012,6 +2324,7 @@ export class Daemon extends EventEmitter {
     }
     /** Re-resolve this instance's tmux window by name (stale id after crash/respawn). */
     async recoverWindow() {
+        const previousWindowId = this.tmux?.getWindowId();
         try {
             const windows = await TmuxManager.listWindows(this.tmuxSessionName);
             const match = windows.find(w => w.name === this.name);
@@ -2019,6 +2332,12 @@ export class Daemon extends EventEmitter {
                 return undefined;
             this.tmux = new TmuxManager(this.tmuxSessionName, match.id, resolveTmuxLogicalSize(this.config.terminal));
             writeFileSync(join(this.instanceDir, "window-id"), match.id);
+            // The window we were talking to is gone; leaving it registered means the
+            // control client re-resolves a dead id — one tmux subprocess — on every
+            // reconnect, for the life of the fleet process.
+            if (previousWindowId && previousWindowId !== match.id) {
+                this.controlClient?.unregisterWindow(previousWindowId);
+            }
             await this.controlClient?.registerWindow(match.id);
             this.bindInstanceStateOutputListener(match.id);
             this.logger.info({ windowId: match.id }, "Recovered window ID for message delivery");
@@ -2029,12 +2348,38 @@ export class Daemon extends EventEmitter {
             return undefined;
         }
     }
-    /** Poll up to ~2s (200ms × 10) for the pane to emit output after `since`. */
+    /**
+     * Poll up to ~2s (200ms × 10) for the pane to emit output after `since`.
+     *
+     * A `false` here is not "no output" — it is read as **"the message was pasted but
+     * never submitted"**, which re-sends Enter and then reports ❌ to the user. So a
+     * false negative costs a possible double submit and a failure notice for a
+     * message that actually arrived.
+     *
+     * That is exactly what a control-mode reconnect used to produce. `connect()`
+     * drops every output timestamp, so `hasOutputSince` answers `false` for a pane
+     * that did react — the evidence was thrown away, not absent. Blind time is
+     * therefore not counted against the budget: after a reset the poll restarts from
+     * the moment observation resumed. A hard wall-clock cap keeps a reconnect loop
+     * from extending this forever.
+     */
     async confirmBusyAfterEnter(windowId, since) {
-        for (let i = 0; i < 10; i++) {
-            await new Promise(r => setTimeout(r, 200));
-            if (this.controlClient.hasOutputSince(windowId, since))
+        const client = this.controlClient;
+        const hardDeadline = Date.now() + CONFIRM_BUSY_MAX_WAIT_MS;
+        let observedFrom = since;
+        let polls = 0;
+        while (polls < CONFIRM_BUSY_POLLS) {
+            await new Promise(r => setTimeout(r, CONFIRM_BUSY_POLL_MS));
+            if (client.hasOutputSince(windowId, observedFrom))
                 return true;
+            const resetAt = client.getObservationResetAt();
+            if (resetAt > observedFrom && Date.now() < hardDeadline) {
+                this.logger.debug({ windowId, resetAt }, "Control mode reconnected mid-confirmation — restarting the Enter check from when we could see again");
+                observedFrom = resetAt;
+                polls = 0;
+                continue;
+            }
+            polls++;
         }
         return false;
     }
@@ -2105,8 +2450,8 @@ export class Daemon extends EventEmitter {
             });
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(fleetReqId);
-                respond(null, "Task operation timed out after 30s");
-            }, 30_000);
+                respond(null, `Task operation timed out after ${daemonBudgetMs(tool) / 1000}s`);
+            }, daemonBudgetMs(tool));
             this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
@@ -2128,8 +2473,8 @@ export class Daemon extends EventEmitter {
             });
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(fleetReqId);
-                respond(null, "Decision operation timed out after 30s");
-            }, 30_000);
+                respond(null, `Decision operation timed out after ${daemonBudgetMs(tool) / 1000}s`);
+            }, daemonBudgetMs(tool));
             this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
@@ -2155,8 +2500,8 @@ export class Daemon extends EventEmitter {
             // Wait for fleet_schedule_response via pending request map
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(fleetReqId);
-                respond(null, "Schedule operation timed out after 30s");
-            }, 30_000);
+                respond(null, `Schedule operation timed out after ${daemonBudgetMs(tool) / 1000}s`);
+            }, daemonBudgetMs(tool));
             this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
@@ -2177,7 +2522,9 @@ export class Daemon extends EventEmitter {
                     fleetRequestId: fleetReqId,
                     senderSessionName,
                 });
-                const crossTimeoutMs = (tool === "start_instance" || tool === "create_instance" || tool === "replace_instance") ? 60_000 : 30_000;
+                // Shared table, so delete_instance and the deployment tools get the same
+                // budget here as the MCP client expects (the ad-hoc list omitted them).
+                const crossTimeoutMs = daemonBudgetMs(tool);
                 const timeout = setTimeout(() => {
                     this.pendingIpcRequests.delete(fleetReqId);
                     respond(null, `Cross-instance operation timed out after ${crossTimeoutMs / 1000}s`);
@@ -2220,8 +2567,8 @@ export class Daemon extends EventEmitter {
             this.ipcServer?.broadcast({ type: "fleet_outbound", tool, args, fleetRequestId: fleetReqId });
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(outboundKey);
-                respond(null, "Fleet outbound timed out after 30s");
-            }, 30_000);
+                respond(null, `Fleet outbound timed out after ${daemonBudgetMs(tool) / 1000}s`);
+            }, daemonBudgetMs(tool));
             this.pendingIpcRequests.set(outboundKey, (respMsg) => {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
@@ -2410,7 +2757,9 @@ export class Daemon extends EventEmitter {
         // Small delay to let the CLI fully render its ready prompt
         await new Promise(r => setTimeout(r, 1_000));
         try {
-            await this.tmux.pasteText(`[system:session-snapshot]\n${snapshot}\n\nThis is a background context restore — do NOT reply to or acknowledge this message. Simply resume normal operation when the next user or instance message arrives.`);
+            // Messages can arrive during a restart and be queued on pasteLock before the
+            // snapshot lands; both write to the pane, so both go through the same lock.
+            await this.paneWriteLock.run(() => this.tmux.pasteText(`[system:session-snapshot]\n${snapshot}\n\nThis is a background context restore — do NOT reply to or acknowledge this message. Simply resume normal operation when the next user or instance message arrives.`, this.systemPasteOptions()));
             this.logger.info("Injected session snapshot as first message");
             this.emit("snapshot_injected", this.name);
         }
@@ -2419,9 +2768,69 @@ export class Daemon extends EventEmitter {
             this.emit("snapshot_failed", this.name);
         }
     }
+    /**
+     * Depth, not a flag: the wake path marks a spawn and then calls trySpawn, which
+     * marks another. With a plain boolean the inner one's completion would clear the
+     * latch while the outer spawn was still dismissing dialogs, releasing delivery
+     * into exactly the window this exists to close.
+     */
+    beginSpawn() {
+        this.spawnDepth++;
+        this.spawning = true;
+        if (!this.spawnSettled) {
+            this.spawnSettled = new Promise(resolve => { this.resolveSpawnSettled = resolve; });
+        }
+    }
+    endSpawn() {
+        this.spawnDepth = Math.max(0, this.spawnDepth - 1);
+        if (this.spawnDepth > 0)
+            return; // an enclosing spawn is still running
+        this.spawning = false;
+        const resolve = this.resolveSpawnSettled;
+        this.spawnSettled = null;
+        this.resolveSpawnSettled = null;
+        resolve?.();
+    }
+    /**
+     * Hold until the CLI has finished starting up.
+     *
+     * Startup is not a quiet period: `dismissDialogsUntilReady` is clicking through
+     * trust prompts and session pickers. A pane showing a modal dialog produces no
+     * output, so `waitUntilIdle` reports it idle and a queued message gets pasted
+     * *into the dialog* — where the text is discarded and the Enter picks a menu
+     * item. The paste and the Enter both "succeed", so this loses the message
+     * without even a ❌.
+     *
+     * The pane write lock (#414) does not cover this: it serialises each key
+     * sequence, but it is released between one dialog and the next.
+     *
+     * Bounded, and called BEFORE the pane lock is taken — waiting on the spawn while
+     * holding the lock the spawn itself needs would deadlock.
+     */
+    async waitForSpawnToSettle() {
+        const settled = this.spawnSettled;
+        if (!settled)
+            return;
+        this.logger.debug("Holding delivery until the CLI has finished starting up");
+        let timer;
+        const cap = new Promise(resolve => {
+            timer = setTimeout(resolve, SPAWN_SETTLE_MAX_WAIT_MS);
+            timer.unref?.();
+        });
+        try {
+            await Promise.race([settled, cap]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        if (this.spawning) {
+            this.logger.warn("CLI still starting after the delivery hold — delivering anyway");
+        }
+    }
     /** Spawn a CLI window. Returns true if --resume was used successfully. */
     async spawnClaudeWindow() {
-        this.spawning = true;
+        this.beginSpawn();
         let resumedSuccessfully = false;
         try {
             this.toolStatusLines = [];
@@ -2458,7 +2867,7 @@ export class Daemon extends EventEmitter {
             this.backgroundSessionRecoveryAttempted = false;
         }
         finally {
-            this.spawning = false;
+            this.endSpawn();
         }
         return resumedSuccessfully;
     }
@@ -2529,11 +2938,13 @@ export class Daemon extends EventEmitter {
         // the global web token) from impersonating instances.
         const agentTokenPath = join(this.instanceDir, "agent.token");
         const agentToken = randomBytes(32).toString("hex");
-        writeFileSync(agentTokenPath, agentToken, { mode: 0o600 });
-        try {
-            chmodSync(agentTokenPath, 0o600);
+        const tokenWrite = writeSecretFile(agentTokenPath, agentToken);
+        if (!tokenWrite.ok) {
+            // Do not fail the spawn over it — an instance that cannot start is worse
+            // than one whose token is readable. But say so, loudly: the whole point of
+            // this token is that other local processes cannot use it.
+            this.logger.error({ path: agentTokenPath, mode: tokenWrite.mode?.toString(8), reason: tokenWrite.reason }, "Agent token file is not owner-only — other local users can impersonate this instance");
         }
-        catch { }
         // AGEND_HOME points the child's agent-cli at the same data dir the daemon
         // is using, so it can locate <instanceDir>/agent.token.
         const agendHome = join(this.instanceDir, "..", "..");
@@ -2551,7 +2962,12 @@ export class Daemon extends EventEmitter {
             windowId = this.tmux.getWindowId();
         }
         else {
+            // A crash respawn makes a brand new window. The dead one stays registered
+            // unless we say so — the respawn branch above already does.
+            const retired = this.tmux.getWindowId();
             windowId = await this.tmux.createWindow(cmd, resolvedCwd, this.name);
+            if (retired && retired !== windowId)
+                this.controlClient?.unregisterWindow(retired);
         }
         writeFileSync(join(this.instanceDir, "window-id"), windowId);
         // Enable remain-on-exit to capture exit codes on crash
@@ -2617,15 +3033,20 @@ export class Daemon extends EventEmitter {
                 for (const dialog of startupDialogs) {
                     if (dialog.pattern.test(pane)) {
                         this.logger.debug(`Dismissing startup dialog: ${dialog.description}`);
-                        for (const key of dialog.keys) {
-                            if (key === "Up" || key === "Down" || key === "Enter" || key === "Escape") {
-                                await this.tmux.sendSpecialKey(key);
-                            }
-                            else {
-                                await this.tmux.sendKeys(key);
+                        // Restart is exactly when inbound messages pile up, and nothing gates
+                        // delivery on `spawning`. Take the pane lock for the key sequence so a
+                        // queued message cannot be pasted into a half-dismissed trust dialog.
+                        await this.paneWriteLock.run(async () => {
+                            for (const key of dialog.keys) {
+                                if (key === "Up" || key === "Down" || key === "Enter" || key === "Escape") {
+                                    await this.tmux.sendSpecialKey(key);
+                                }
+                                else {
+                                    await this.tmux.sendKeys(key);
+                                }
+                                await new Promise(r => setTimeout(r, 200));
                             }
-                            await new Promise(r => setTimeout(r, 200));
-                        }
+                        });
                         // Wait for next screen to render
                         if (this.controlClient) {
                             const wid = readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();