@songsid/agend 2.1.1-beta.16 → 2.1.1-beta.18

package/dist/daemon.js

@@ -10,11 +10,13 @@ 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 { PaneWriteLock } from "./pane-write-lock.js";
 import { buildFleetInstructions } from "./instructions.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -39,8 +41,6 @@ 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;
@@ -185,24 +185,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;
@@ -212,7 +235,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
@@ -278,6 +301,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
@@ -336,7 +374,6 @@ export class Daemon extends EventEmitter {
     ipcServer = null;
     messageBus;
     transcriptMonitor = null;
-    toolTracker = null;
     guardian = null;
     adapter = null;
     pendingIpcRequests = new Map();
@@ -347,6 +384,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;
@@ -366,6 +405,15 @@ export class Daemon extends EventEmitter {
     /** 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). */
@@ -388,6 +436,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;
@@ -408,7 +457,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.
@@ -551,9 +606,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);
@@ -602,6 +654,14 @@ export class Daemon extends EventEmitter {
                 // Fleet manager routed a message to us (topic mode)
                 const meta = msg.meta;
                 const targetSession = msg.targetSession;
+                // `no_wake` marks low-value signals (a non-approval reaction, #408): worth
+                // showing an instance that is already awake, never worth resuming a paused
+                // one and spending a turn on. Dropped rather than queued, so a paused
+                // instance does not surface a pile of stale emoji on its next wake.
+                if (meta?.no_wake === "true" && this.isPaused) {
+                    this.logger.debug({ preview: String(msg.content).slice(0, 60) }, "Dropping no_wake message for paused instance");
+                    return;
+                }
                 void this.wake().then(() => {
                     this.pushChannelMessage(msg.content, meta, targetSession);
                 }).catch(err => {
@@ -704,7 +764,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));
+                });
                 // Record the value the agent has now been told about so the next
                 // unchanged restart skips the reload.
                 try {
@@ -737,27 +802,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");
@@ -765,7 +834,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.
@@ -848,6 +916,7 @@ export class Daemon extends EventEmitter {
                         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) {
@@ -898,6 +967,7 @@ export class Daemon extends EventEmitter {
                         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");
@@ -1007,6 +1077,7 @@ export class Daemon extends EventEmitter {
                     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
@@ -1036,6 +1107,8 @@ export class Daemon extends EventEmitter {
                     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
                     }
                     // Calculate backoff delay
@@ -1119,6 +1192,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;
@@ -1164,6 +1252,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;
@@ -1176,20 +1265,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);
+                            }
+                            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
@@ -1197,7 +1296,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.
@@ -1205,10 +1304,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) {
@@ -1307,6 +1411,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";
@@ -1344,7 +1454,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)
@@ -1371,7 +1480,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);
@@ -1507,7 +1621,7 @@ export class Daemon extends EventEmitter {
             return;
         }
         this.pauseWakeState = "waking";
-        this.spawning = true;
+        this.beginSpawn();
         const transition = this.autoPauseController.wakeOnDeliver(async () => {
             let timeout;
             try {
@@ -1548,7 +1662,7 @@ export class Daemon extends EventEmitter {
             throw err;
         }
         finally {
-            this.spawning = false;
+            this.endSpawn();
             if (this.pauseWakeTransition === transition)
                 this.pauseWakeTransition = null;
         }
@@ -1560,6 +1674,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({
@@ -1650,6 +1768,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();
             }
@@ -1704,7 +1829,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) {
@@ -1745,6 +1871,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(),
         };
@@ -1787,6 +1919,28 @@ 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,
+        });
+    }
     summarizeTool(name, input) {
         const inp = input;
         if (!inp)
@@ -1876,7 +2030,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);
@@ -1976,6 +2129,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;
@@ -2003,6 +2158,21 @@ export class Daemon extends EventEmitter {
                 }
             }
         }
+        // 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;
@@ -2143,6 +2313,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);
@@ -2150,6 +2321,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");
@@ -2160,12 +2337,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;
     }
@@ -2236,8 +2439,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);
@@ -2259,8 +2462,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);
@@ -2286,8 +2489,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);
@@ -2308,7 +2511,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`);
@@ -2351,8 +2556,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);
@@ -2541,7 +2746,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.logger.info("Injected session snapshot as first message");
             this.emit("snapshot_injected", this.name);
         }
@@ -2550,9 +2757,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 = [];
@@ -2589,7 +2856,7 @@ export class Daemon extends EventEmitter {
             this.backgroundSessionRecoveryAttempted = false;
         }
         finally {
-            this.spawning = false;
+            this.endSpawn();
         }
         return resumedSuccessfully;
     }
@@ -2682,7 +2949,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
@@ -2748,15 +3020,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();