@songsid/agend 2.1.0-beta.8 → 2.1.0

package/dist/daemon.js

@@ -1,8 +1,9 @@
 import { join, dirname, basename, resolve } from "node:path";
-import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, chmodSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, chmodSync, renameSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
+import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { ContextGuardian } from "./context-guardian.js";
@@ -20,32 +21,71 @@ const CROSS_INSTANCE_TOOLS = new Set(["send_to_instance", "list_instances", "sta
 const SCHEDULE_TOOLS = new Set(["create_schedule", "list_schedules", "update_schedule", "delete_schedule"]);
 const DECISION_TOOLS = new Set(["post_decision", "list_decisions", "update_decision"]);
 const TASK_TOOL = "task";
+/** Point a resumed CLI at its one backend-native instruction source. */
+export function buildInstructionReloadNotice(binaryName, instanceName, instanceDir) {
+    const source = binaryName === "codex" || binaryName === "grok"
+        ? "AGENTS.md"
+        : binaryName === "kiro-cli"
+            ? `.kiro/steering/agend-${instanceName}.md`
+            : binaryName === "agy"
+                ? ".agents/agents.md"
+                : binaryName === "gemini"
+                    ? "GEMINI.md"
+                    : join(instanceDir, "fleet-instructions.md");
+    return `[system] Your AgEnD instructions have been updated. Reload only ${source}; do not scan other instruction directories. Do not reply to this message.`;
+}
 export const DEFAULT_STUCK_TIMEOUT_MS = 10 * 60_000;
-export const DEFAULT_STATE_POLL_INTERVAL_MS = 5_000;
-/** Headless idle timer used by the daemon and unit tests. */
+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";
+/** Read the last real channel inbound timestamp persisted across daemon restarts. */
+export function readLastInboundAt(instanceDir, now = Date.now()) {
+    try {
+        const value = Number(readFileSync(join(instanceDir, LAST_INBOUND_FILE), "utf-8").trim());
+        return Number.isFinite(value) && value >= 0 && value <= now ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Atomically persist the last real channel inbound timestamp. */
+export function writeLastInboundAt(instanceDir, timestamp) {
+    mkdirSync(instanceDir, { recursive: true });
+    const target = join(instanceDir, LAST_INBOUND_FILE);
+    const temp = `${target}.${process.pid}.tmp`;
+    writeFileSync(temp, String(timestamp));
+    renameSync(temp, target);
+}
+/** Headless inactivity timer used by the daemon and unit tests. */
 export class AutoPauseController {
     thresholdMs;
-    idleSince = null;
+    lastActivityAt;
     pausedAt = null;
-    constructor(thresholdMs) {
+    constructor(thresholdMs, lastActivityAt = Date.now()) {
         this.thresholdMs = thresholdMs;
+        this.lastActivityAt = lastActivityAt;
+    }
+    recordActivity(now = Date.now()) {
+        this.lastActivityAt = now;
     }
     observe(state, now = Date.now()) {
         if (this.pausedAt !== null || this.thresholdMs <= 0)
             return false;
-        if (state !== "idle") {
-            this.idleSince = null;
-            return false;
-        }
-        this.idleSince ??= now;
-        return now - this.idleSince >= this.thresholdMs;
+        // Inactivity is based on the last user inbound, not on how long this daemon
+        // has observed the idle pane. This preserves pause eligibility across fleet
+        // restarts while still ensuring an actively working instance is never paused.
+        return state === "idle" && now - this.lastActivityAt >= this.thresholdMs;
     }
     markPaused(now = Date.now()) {
         this.pausedAt = now;
     }
-    markAwake() {
+    markAwake(now = Date.now()) {
         this.pausedAt = null;
-        this.idleSince = null;
+        // A deliberate wake is activity in its own right and must provide a fresh
+        // window for the wake-before-deliver facade to enqueue its inbound message.
+        this.lastActivityAt = now;
     }
     async wakeOnDeliver(wake) {
         if (this.pausedAt === null)
@@ -105,6 +145,16 @@ export class PaneStateMachine {
         }
         return this.snapshot(now);
     }
+    /** Record pane motion from tmux control mode without capturing pane content. */
+    recordOutput(now = Date.now()) {
+        this.lastPaneChangeAt = now;
+        this.lastObservedAt = now;
+        if (this.currentState !== "working") {
+            this.currentState = "working";
+            this.stateChangedAt = now;
+        }
+        return this.snapshot(now);
+    }
     snapshot(now = Date.now()) {
         return {
             state: this.currentState,
@@ -114,6 +164,79 @@ export class PaneStateMachine {
         };
     }
 }
+/** Tracks whether an inbound arrived after the most recent confirmed idle prompt. */
+export class PendingWorkTracker {
+    lastInboundAt = 0;
+    lastIdleAt;
+    sequence = 0;
+    lastInboundOrder = 0;
+    lastIdleOrder = 0;
+    constructor(now = Date.now()) {
+        this.lastIdleAt = now;
+    }
+    recordInbound(now = Date.now()) {
+        this.lastInboundAt = now;
+        this.lastInboundOrder = ++this.sequence;
+    }
+    recordIdle(now = Date.now()) {
+        // An async pane poll can finish after a newer inbound. Do not let its stale
+        // observation clear work which had not arrived when the pane was captured.
+        if (now < this.lastInboundAt)
+            return;
+        this.lastIdleAt = now;
+        this.lastIdleOrder = ++this.sequence;
+    }
+    hasPendingWork() {
+        return this.lastInboundOrder > this.lastIdleOrder;
+    }
+}
+const NORMAL_ENTER_SETTLE_MS = 500;
+const FIRST_ENTER_SETTLE_MS = 1_750;
+const FIRST_DELIVERY_WINDOW_MS = 5_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
+ * visible but the TUI can still swallow Enter while completing its redraw.
+ */
+export class FirstDeliveryDelay {
+    readyAt = 0;
+    pending = false;
+    recordReady(now = Date.now()) {
+        this.readyAt = now;
+        this.pending = true;
+    }
+    consume(now = Date.now()) {
+        if (!this.pending)
+            return NORMAL_ENTER_SETTLE_MS;
+        this.pending = false;
+        return this.readyAt > 0 && now - this.readyAt < FIRST_DELIVERY_WINDOW_MS
+            ? FIRST_ENTER_SETTLE_MS
+            : NORMAL_ENTER_SETTLE_MS;
+    }
+}
+/** Redact likely credentials and control sequences before pane text reaches logs. */
+export function sanitizePaneTail(pane, lineCount = 5) {
+    const secretAssignment = /\b(token|secret|password|passwd|api[_-]?key|authorization)\b\s*[:=]\s*\S+/gi;
+    const bearer = /\bBearer\s+\S+/gi;
+    const knownToken = /\b(?:sk-[A-Za-z0-9_-]+|ghp_[A-Za-z0-9]+|github_pat_[A-Za-z0-9_]+|AKIA[A-Z0-9]{16})\b/g;
+    const jwt = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+    const opaqueSecret = /\b[A-Za-z0-9_+/=-]{32,}\b/g;
+    const lines = pane
+        .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "")
+        .split(/\r?\n/);
+    while (lines.length > 0 && /^\s*$/.test(lines[lines.length - 1]))
+        lines.pop();
+    return lines
+        .slice(-lineCount)
+        .map(line => line
+        .replace(bearer, "Bearer [REDACTED]")
+        .replace(secretAssignment, "$1=[REDACTED]")
+        .replace(knownToken, "[REDACTED]")
+        .replace(jwt, "[REDACTED]")
+        .replace(opaqueSecret, "[REDACTED]")
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
+        .slice(0, 200));
+}
 export class Daemon extends EventEmitter {
     name;
     config;
@@ -134,6 +257,7 @@ export class Daemon extends EventEmitter {
     // Track chatId/threadId from inbound messages for automatic outbound routing
     lastChatId;
     lastThreadId;
+    lastAdapterId;
     // Pending ack: react 🫡 on first transcript activity after receiving a message
     pendingAckMessage = null;
     // Tool status tracking for channel adapter
@@ -152,6 +276,8 @@ export class Daemon extends EventEmitter {
     lastSpawnAt = 0;
     crashTimestamps = [];
     healthCheckPaused = false;
+    /** CLI pane availability, independent from the daemon process and tri-state. */
+    processStatus = "running";
     spawning = false;
     skipResume = false;
     backgroundSessionRecoveryAttempted = false;
@@ -163,7 +289,19 @@ export class Daemon extends EventEmitter {
     hangDetector = null;
     instanceState = "idle";
     instanceStateMachine = null;
+    pendingWork = new PendingWorkTracker();
+    /** Fallback safety sweep used only when no shared tmux control client exists. */
     instanceStateMonitorTimer = null;
+    instanceStateIdleTimer = null;
+    instanceStateStuckTimer = null;
+    instanceStateOutputListener = null;
+    instanceStateOutputEventName = null;
+    instanceStateSafetyListener = null;
+    instanceStateLastOutputAt = 0;
+    instanceStateIdleDebounceMs = DEFAULT_STATE_IDLE_DEBOUNCE_MS;
+    instanceStateStuckTimeoutMs = DEFAULT_STUCK_TIMEOUT_MS;
+    instanceStateReadyPattern = null;
+    instanceStateMonitorActive = false;
     statePollInFlight = false;
     autoPauseController;
     pauseRequested = false;
@@ -186,12 +324,15 @@ export class Daemon extends EventEmitter {
     warmupNeeded = false;
     lastBuiltInstructions = "";
     pasteQueueDepth = 0;
+    firstDeliveryDelay = new FirstDeliveryDelay();
     // PTY error pattern monitoring
     errorMonitorTimer = null;
     /** Prevent in-flight monitor callbacks from re-arming after a pause. */
     runtimeMonitorsFrozen = false;
     errorWaitingForRecovery = false; // true = error detected, waiting for ready pattern
     errorDetectedAt = 0;
+    errorRecoveryDeadlineAt = 0;
+    activeErrorPatternKey = null;
     /** Whether this instance is in an abnormal error state (auto-pause is normal). */
     get isErrorState() {
         return this.errorWaitingForRecovery || (this.healthCheckPaused && !this.isPaused) || Daemon.tmuxServerPaused;
@@ -203,11 +344,16 @@ export class Daemon extends EventEmitter {
     get isCrashLoop() {
         return this.crashCount >= 3;
     }
+    /** The most recent error type detected by the error monitor (e.g. "rate_limit", "auth_error"). */
+    get lastErrorType() {
+        return this.lastDetectedErrorType;
+    }
     lastFailoverAt = 0; // cooldown: prevent repeated failover triggers
     static FAILOVER_COOLDOWN_MS = 5 * 60_000; // 5 minutes
-    lastErrorNotifiedAt = new Map(); // per-type cooldown for all actions
+    lastErrorNotifiedAt = new Map(); // per-pattern cooldown for all actions
     static ERROR_COOLDOWN_MS = 5 * 60_000;
-    // Count-based dedup: per error type, the number of pattern occurrences already
+    static ERROR_RECOVERY_TIMEOUT_MS = 5 * 60_000;
+    // Count-based dedup: per error pattern, the number of occurrences already
     // accounted for. A scan counts occurrences across the WHOLE pane; count > this
     // baseline means a NEW error appeared. On recovery we absorb the current count
     // (not reset to 0) so the just-handled error doesn't re-trigger, while a later
@@ -216,6 +362,15 @@ export class Daemon extends EventEmitter {
     // still registers as new (prevents the old hash-dedup's permanent suppression).
     lastErrorCount = new Map();
     lastDetectedErrorType = null;
+    static errorPatternKey(ep) {
+        return `${ep.type}:${ep.pattern.source}`;
+    }
+    clearErrorRecoveryGate() {
+        this.errorWaitingForRecovery = false;
+        this.errorDetectedAt = 0;
+        this.errorRecoveryDeadlineAt = 0;
+        this.activeErrorPatternKey = null;
+    }
     constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger) {
         super();
         this.name = name;
@@ -230,17 +385,14 @@ export class Daemon extends EventEmitter {
         this.tmuxSessionName = getTmuxSession();
         this.messageBus = new MessageBus();
         this.messageBus.setLogger(this.logger);
-        const autoPauseMinutes = typeof config.auto_pause_after === "number" ? config.auto_pause_after : 0; // default: disabled
-        this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000);
+        // General is the dispatcher — it must stay warm to route messages, so it is
+        // never auto-paused regardless of auto_pause_after.
+        const isGeneral = config.general_topic === true || name === "general";
+        const autoPauseMinutes = isGeneral ? 0 : (typeof config.auto_pause_after === "number" ? config.auto_pause_after : 0); // default: disabled
+        this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000, readLastInboundAt(instanceDir) ?? Date.now());
     }
     async start() {
         mkdirSync(this.instanceDir, { recursive: true });
-        // A daemon restart performs a normal CLI start, so any persisted auto-pause
-        // marker from the previous daemon is stale.
-        try {
-            unlinkSync(join(this.instanceDir, "paused-state.json"));
-        }
-        catch { }
         writeFileSync(join(this.instanceDir, "daemon.pid"), String(process.pid));
         this.logger.info(`Starting ${this.name}`);
         // P1: Read crash state from previous run — skip resume if last run was a crash loop
@@ -266,6 +418,7 @@ export class Daemon extends EventEmitter {
                 if (saved.chatId) {
                     this.lastChatId = saved.chatId;
                     this.lastThreadId = saved.threadId || undefined;
+                    this.lastAdapterId = saved.adapterId || undefined;
                 }
             }
         }
@@ -383,6 +536,7 @@ export class Daemon extends EventEmitter {
                     instanceName: this.name,
                     ...snapshot,
                     state: this.isPaused ? "paused" : snapshot.state,
+                    processStatus: this.processStatus,
                     pausedAt: this.lastPausedAt,
                 });
             }
@@ -446,7 +600,7 @@ export class Daemon extends EventEmitter {
                 else {
                     await new Promise(r => setTimeout(r, 5000));
                 }
-                await this.tmux?.pasteText("[system] Your instructions/steering files have been updated. Re-read your steering files. Do not reply to this message.");
+                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 {
@@ -527,8 +681,10 @@ export class Daemon extends EventEmitter {
         if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
             return;
         const { max_retries, backoff, reset_after } = this.config.restart_policy;
-        if (max_retries <= 0)
-            return; // restart disabled
+        // Liveness monitoring remains active when automatic restart is disabled;
+        // otherwise a dead pane leaves its last idle snapshot cached forever.
+        const configuredInterval = this.config.restart_policy.health_check_interval_ms ?? 30_000;
+        const healthCheckIntervalMs = Math.min(60_000, configuredInterval > 0 ? configuredInterval : 30_000);
         const scheduleNext = () => {
             if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
                 return;
@@ -583,11 +739,13 @@ export class Daemon extends EventEmitter {
                 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).
@@ -665,6 +823,7 @@ export class Daemon extends EventEmitter {
                         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);
                         }
@@ -690,6 +849,11 @@ export class Daemon extends EventEmitter {
                 }
                 // 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;
@@ -765,6 +929,7 @@ export class Daemon extends EventEmitter {
                         }
                         catch { /* may not exist */ }
                     }
+                    this.setProcessStatus("running");
                     this.logger.info({ resumed }, `Respawned ${cliLabel} window after crash`);
                     this.emit("crash_respawn", this.name);
                 }
@@ -772,10 +937,39 @@ export class Daemon extends EventEmitter {
                     this.logger.error({ err }, `Failed to respawn ${cliLabel} window`);
                 }
                 scheduleNext();
-            }, this.config.restart_policy.health_check_interval_ms ?? 30_000);
+            }, healthCheckIntervalMs);
         };
         scheduleNext();
     }
+    /**
+     * Publish pane-process availability separately from idle/working/stuck.
+     * 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.
+     */
+    setProcessStatus(status) {
+        if (this.processStatus === status)
+            return;
+        this.processStatus = status;
+        if (status === "running") {
+            // A successful crash respawn is a new pane generation. It is ready by
+            // this point, so an error gate inherited from the dead pane must not keep
+            // the new process from being monitored.
+            this.clearErrorRecoveryGate();
+            this.startInstanceStateMonitor();
+        }
+        else {
+            this.stopInstanceStateMonitor();
+            // Force the next ready capture to emit a fresh transition after respawn.
+            this.instanceState = "working";
+        }
+        this.ipcServer?.broadcast({
+            type: "instance_process_state",
+            instanceName: this.name,
+            status,
+            observedAt: Date.now(),
+        });
+        this.emit("instance_process_state", { name: this.name, status });
+    }
     /**
      * Periodically scan PTY output for backend-defined error patterns.
      *
@@ -805,13 +999,6 @@ export class Daemon extends EventEmitter {
                 if (!alive)
                     return;
                 const pane = await this.tmux.capturePane();
-                // Count occurrences of a pattern across the WHOLE pane (not just the text
-                // after the last ready prompt — a fast recovery can put "ready" AFTER the
-                // error line, which the old scanText approach missed).
-                const countMatches = (pattern) => {
-                    const g = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
-                    return (pane.match(g) || []).length;
-                };
                 // Auto-dismiss runtime dialogs (e.g. Codex rate limit model switch)
                 for (const dialog of dialogs) {
                     if (!dialog.pattern.test(pane))
@@ -829,73 +1016,96 @@ export class Daemon extends EventEmitter {
                     }
                     return; // Dialog dismissed, skip error checks this cycle
                 }
-                // State: waiting for recovery — check if agent is back to ready
-                if (this.errorWaitingForRecovery) {
-                    if (readyPattern.test(pane)) {
-                        const downtime = Math.round((Date.now() - this.errorDetectedAt) / 1000);
-                        // Absorb the current count of the just-handled error type so it isn't
-                        // re-triggered; a later NEW occurrence pushes the count higher again.
-                        if (this.lastDetectedErrorType) {
-                            const ep = patterns.find(p => p.type === this.lastDetectedErrorType);
-                            if (ep)
-                                this.lastErrorCount.set(ep.type, countMatches(ep.pattern));
-                        }
-                        this.errorWaitingForRecovery = false;
-                        this.errorDetectedAt = 0;
-                        this.logger.info({ downtime_s: downtime }, "PTY error recovered — agent is ready again");
-                        this.emit("pty_recovered", { name: this.name, downtime_s: downtime });
-                    }
-                    return; // Don't check for errors while waiting for recovery
-                }
-                // State: monitoring — count-based new-error detection over the full pane
-                for (const ep of patterns) {
-                    const count = countMatches(ep.pattern);
-                    const seen = this.lastErrorCount.get(ep.type) ?? 0;
-                    if (count <= seen) {
-                        // Occurrences scrolled out of the capture buffer → lower the baseline
-                        // so a future re-occurrence still counts as new (no permanent suppress).
-                        if (count < seen)
-                            this.lastErrorCount.set(ep.type, count);
-                        continue;
-                    }
-                    // count > seen → a NEW occurrence of this error appeared.
-                    // Cooldown: 2nd-layer guard so the same type isn't re-notified within
-                    // the window. Leave the count unconsumed so it fires once cooldown ends.
-                    if (!ep.skipCooldown) {
-                        const lastNotified = this.lastErrorNotifiedAt.get(ep.type) ?? 0;
-                        if (Date.now() - lastNotified < Daemon.ERROR_COOLDOWN_MS) {
-                            this.logger.debug({ errorType: ep.type }, "PTY error suppressed (cooldown active)");
-                            break;
-                        }
-                    }
-                    if (ep.action === "failover" && Date.now() - this.lastFailoverAt < Daemon.FAILOVER_COOLDOWN_MS) {
-                        this.logger.debug({ errorType: ep.type }, "PTY error suppressed (failover cooldown active)");
-                        break;
-                    }
-                    this.lastErrorCount.set(ep.type, count);
-                    // skipRecoveryWait: this error self-recovers (e.g. a timeout — Kiro is
-                    // back at its prompt immediately). Its ready-pattern only matches the
-                    // startup banner, so entering "waiting for recovery" would never clear
-                    // and would block ALL future error detection. Just absorb the baseline
-                    // (done above) and keep monitoring so the next occurrence still fires.
-                    if (!ep.skipRecoveryWait) {
-                        this.errorWaitingForRecovery = true;
-                        this.errorDetectedAt = Date.now();
-                        this.lastDetectedErrorType = ep.type;
-                    }
-                    this.lastErrorNotifiedAt.set(ep.type, Date.now());
-                    if (ep.action === "failover")
-                        this.lastFailoverAt = Date.now();
-                    this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${ep.message}`);
-                    this.emit("pty_error", { name: this.name, ...ep });
-                    break; // Only handle first new error per scan
-                }
+                this.evaluateErrorPatterns(pane, patterns, readyPattern);
             }
             catch {
                 // capturePane can fail if window is transitioning — ignore
             }
         }, 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()) {
+        // 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.
+        const countMatches = (pattern) => {
+            const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+            return (pane.match(new RegExp(pattern.source, flags)) || []).length;
+        };
+        // 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)) {
+                const downtime = Math.round((now - this.errorDetectedAt) / 1000);
+                const active = patterns.find(ep => Daemon.errorPatternKey(ep) === this.activeErrorPatternKey);
+                if (active) {
+                    this.lastErrorCount.set(Daemon.errorPatternKey(active), countMatches(active.pattern));
+                }
+                this.clearErrorRecoveryGate();
+                this.logger.info({ downtime_s: downtime }, "PTY error recovered — agent is ready again");
+                this.emit("pty_recovered", { name: this.name, downtime_s: downtime });
+                return;
+            }
+            if (now <= this.errorRecoveryDeadlineAt)
+                return;
+            // Re-arm the active occurrence as a reminder. Without lowering its
+            // baseline, clearing the gate alone would still leave count === seen and
+            // could never satisfy the promised post-timeout re-notification.
+            const active = patterns.find(ep => Daemon.errorPatternKey(ep) === this.activeErrorPatternKey);
+            if (active) {
+                const key = Daemon.errorPatternKey(active);
+                const count = countMatches(active.pattern);
+                if (count > 0)
+                    this.lastErrorCount.set(key, count - 1);
+            }
+            this.logger.warn({ errorType: this.lastDetectedErrorType }, "PTY error recovery deadline expired — resuming error scan");
+            this.clearErrorRecoveryGate();
+        }
+        // State: monitoring — count-based new-error detection over the full pane.
+        for (const ep of patterns) {
+            const key = Daemon.errorPatternKey(ep);
+            const count = countMatches(ep.pattern);
+            const seen = this.lastErrorCount.get(key) ?? 0;
+            if (count <= seen) {
+                // Occurrences scrolled out of the capture buffer → lower the baseline
+                // so a future re-occurrence still counts as new (no permanent suppress).
+                if (count < seen)
+                    this.lastErrorCount.set(key, count);
+                continue;
+            }
+            // count > seen → a NEW occurrence of this exact pattern appeared.
+            // Leave a cooldown-suppressed count unconsumed so it can fire once the
+            // cooldown expires, but continue scanning unrelated patterns this cycle.
+            if (!ep.skipCooldown) {
+                const lastNotified = this.lastErrorNotifiedAt.get(key) ?? 0;
+                if (now - lastNotified < Daemon.ERROR_COOLDOWN_MS) {
+                    this.logger.debug({ errorType: ep.type }, "PTY error suppressed (cooldown active)");
+                    continue;
+                }
+            }
+            if (ep.action === "failover" && now - this.lastFailoverAt < Daemon.FAILOVER_COOLDOWN_MS) {
+                this.logger.debug({ errorType: ep.type }, "PTY error suppressed (failover cooldown active)");
+                continue;
+            }
+            this.lastErrorCount.set(key, count);
+            // skipRecoveryWait: this error self-recovers (e.g. a timeout — Kiro is
+            // back at its prompt immediately). Keep monitoring so the next occurrence
+            // can fire without waiting for a possibly startup-only ready pattern.
+            if (!ep.skipRecoveryWait) {
+                this.errorWaitingForRecovery = true;
+                this.errorDetectedAt = now;
+                this.errorRecoveryDeadlineAt = now + Daemon.ERROR_RECOVERY_TIMEOUT_MS;
+                this.activeErrorPatternKey = key;
+                this.lastDetectedErrorType = ep.type;
+            }
+            this.lastErrorNotifiedAt.set(key, now);
+            if (ep.action === "failover")
+                this.lastFailoverAt = now;
+            this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${ep.message}`);
+            this.emit("pty_error", { name: this.name, ...ep });
+            break; // Only handle first unsuppressed new error per scan
+        }
+    }
     /**
      * Interrupt the CLI's current generation (cancel button / `/cancel`).
      * Direct tmux key event (not a paste) so it registers as the interrupt key.
@@ -925,12 +1135,19 @@ export class Daemon extends EventEmitter {
             this.healthCheckPaused = true;
             let killed = false;
             const quitCmd = this.backend?.getQuitCommand();
+            const quitKey = this.backend?.getQuitKey?.();
             if (quitCmd) {
                 await this.tmux.sendKeys(quitCmd);
                 // Delay before Enter to prevent tmux server race when multiple
                 // instances stop in parallel (same pattern as pasteText).
                 await new Promise(r => setTimeout(r, 150));
                 await this.tmux.sendSpecialKey("Enter");
+            }
+            else if (quitKey) {
+                // Some CLIs quit via a key chord (e.g. grok Ctrl+Q), not a typed command.
+                await this.tmux.sendSpecialKey(quitKey);
+            }
+            if (quitCmd || quitKey) {
                 // Wait up to 3s for graceful exit, polling every 200ms. A healthy CLI
                 // exits within ~1s; a longer wait just delays the force-kill fallback.
                 for (let i = 0; i < 15; i++) {
@@ -972,10 +1189,6 @@ export class Daemon extends EventEmitter {
         catch (e) {
             this.logger.debug({ err: e }, "Failed to remove PID file");
         }
-        try {
-            unlinkSync(join(this.instanceDir, "paused-state.json"));
-        }
-        catch { }
     }
     getHangDetector() {
         return this.hangDetector;
@@ -1011,10 +1224,17 @@ export class Daemon extends EventEmitter {
             try {
                 this.saveSessionId();
                 const quitCmd = this.backend?.getQuitCommand();
-                if (quitCmd && this.tmux) {
-                    await this.tmux.sendKeys(quitCmd);
-                    await new Promise(r => setTimeout(r, 150));
-                    await this.tmux.sendSpecialKey("Enter");
+                const quitKey = this.backend?.getQuitKey?.();
+                if (this.tmux) {
+                    if (quitCmd) {
+                        await this.tmux.sendKeys(quitCmd);
+                        await new Promise(r => setTimeout(r, 150));
+                        await this.tmux.sendSpecialKey("Enter");
+                    }
+                    else if (quitKey) {
+                        // Key-chord quit (e.g. grok Ctrl+Q) — no typed command to send.
+                        await this.tmux.sendSpecialKey(quitKey);
+                    }
                 }
                 let exited = false;
                 for (let i = 0; i < 15; i++) {
@@ -1040,9 +1260,7 @@ export class Daemon extends EventEmitter {
                 }
                 this.pauseWakeState = "paused";
                 this.autoPauseController.markPaused();
-                writeFileSync(join(this.instanceDir, "paused-state.json"), JSON.stringify({
-                    paused_at: this.lastPausedAt,
-                }));
+                writePausedMarker(this.instanceDir, this.lastPausedAt ?? Date.now());
                 this.logger.info({ pausedAt: this.lastPausedAt }, "Instance auto-paused");
                 this.ipcServer?.broadcast({
                     type: "instance_state", instanceName: this.name, state: "paused", pausedAt: this.lastPausedAt,
@@ -1101,10 +1319,10 @@ export class Daemon extends EventEmitter {
             this.pauseWakeState = "active";
             this.healthCheckPaused = false;
             this.pauseRequested = false;
-            try {
-                unlinkSync(join(this.instanceDir, "paused-state.json"));
-            }
-            catch { }
+            // trySpawn resolved only after the new CLI reached its ready prompt.
+            // Discard any recovery gate retained while monitors were frozen.
+            this.clearErrorRecoveryGate();
+            clearPausedMarker(this.instanceDir);
             this.transcriptMonitor?.resetOffset();
             this.resumeRuntimeMonitors();
             this.logger.info("Instance auto-woke");
@@ -1125,62 +1343,201 @@ export class Daemon extends EventEmitter {
                 this.pauseWakeTransition = null;
         }
     }
+    applyInstanceStateSnapshot(snapshot, pane) {
+        const previous = this.instanceState;
+        this.instanceState = snapshot.state;
+        // Only a transition back to idle completes pending work. Repeated idle
+        // observations between enqueue and paste must not clear a newer inbound.
+        if (snapshot.state === "idle" && previous !== "idle") {
+            this.pendingWork.recordIdle(snapshot.observedAt);
+        }
+        if (snapshot.state !== previous) {
+            this.logger.info({
+                previousState: previous,
+                state: snapshot.state,
+                unchangedForMs: snapshot.unchangedForMs,
+            }, "Instance execution state changed");
+            this.emit("instance_state", { name: this.name, ...snapshot });
+            this.ipcServer?.broadcast({ type: "instance_state", instanceName: this.name, ...snapshot });
+            if (snapshot.state === "stuck" && pane && this.instanceStateReadyPattern) {
+                this.handleStuckTransition(pane, snapshot, this.instanceStateReadyPattern);
+            }
+        }
+        if (snapshot.state !== "idle")
+            this.pauseRequested = false;
+        if (!this.pauseRequested && this.pasteQueueDepth === 0 && this.autoPauseController.observe(snapshot.state)) {
+            this.pauseRequested = true;
+            this.emit("auto_pause_requested", { name: this.name, idleSince: snapshot.stateChangedAt });
+        }
+    }
+    clearInstanceStateIdleTimer() {
+        if (this.instanceStateIdleTimer)
+            clearTimeout(this.instanceStateIdleTimer);
+        this.instanceStateIdleTimer = null;
+    }
+    clearInstanceStateStuckTimer() {
+        if (this.instanceStateStuckTimer)
+            clearTimeout(this.instanceStateStuckTimer);
+        this.instanceStateStuckTimer = null;
+    }
+    scheduleInstanceStateStuckDeadline(changeAt) {
+        // Keep one deadline timer per instance. High-volume TUIs can emit hundreds
+        // of %output records per second; replacing a long timeout for every chunk
+        // would trade tmux subprocess CPU for timer churn.
+        if (this.instanceStateStuckTimer)
+            return;
+        const delay = Math.max(0, changeAt + this.instanceStateStuckTimeoutMs - Date.now());
+        this.instanceStateStuckTimer = setTimeout(() => {
+            this.instanceStateStuckTimer = null;
+            const latestChangeAt = this.instanceStateLastOutputAt || changeAt;
+            if (latestChangeAt + this.instanceStateStuckTimeoutMs > Date.now()) {
+                this.scheduleInstanceStateStuckDeadline(latestChangeAt);
+                return;
+            }
+            void this.captureAndEvaluateInstanceState("stuck_deadline", this.instanceStateLastOutputAt);
+        }, delay);
+    }
+    scheduleInstanceStateIdleCapture() {
+        if (this.instanceStateIdleTimer)
+            return;
+        const expectedOutputAt = this.instanceStateLastOutputAt;
+        const delay = Math.max(0, expectedOutputAt + this.instanceStateIdleDebounceMs - Date.now());
+        this.instanceStateIdleTimer = setTimeout(() => {
+            this.instanceStateIdleTimer = null;
+            const latestOutputAt = this.instanceStateLastOutputAt;
+            if (latestOutputAt > expectedOutputAt
+                && latestOutputAt + this.instanceStateIdleDebounceMs > Date.now()) {
+                this.scheduleInstanceStateIdleCapture();
+                return;
+            }
+            void this.captureAndEvaluateInstanceState("idle_debounce", latestOutputAt);
+        }, delay);
+    }
+    async captureAndEvaluateInstanceState(reason, expectedOutputAt = 0) {
+        if (!this.instanceStateMonitorActive || this.runtimeMonitorsFrozen || !this.tmux || !this.instanceStateMachine || this.spawning)
+            return;
+        if (this.statePollInFlight) {
+            if (reason === "idle_debounce")
+                this.scheduleInstanceStateIdleCapture();
+            return;
+        }
+        this.statePollInFlight = true;
+        const captureStartedAt = Date.now();
+        try {
+            const pane = await this.tmux.capturePane();
+            // Output received while capture-pane was in flight makes this snapshot
+            // stale. Its output handler has already armed a new debounce.
+            if ((expectedOutputAt > 0 && this.instanceStateLastOutputAt > expectedOutputAt)
+                || (this.instanceStateLastOutputAt > 0 && this.instanceStateLastOutputAt >= captureStartedAt))
+                return;
+            const observedChangeAt = expectedOutputAt || captureStartedAt;
+            this.instanceStateMachine.observe(pane, observedChangeAt);
+            const snapshot = this.instanceStateMachine.observe(pane, Date.now());
+            this.applyInstanceStateSnapshot(snapshot, pane);
+            if (snapshot.state === "idle") {
+                this.clearInstanceStateStuckTimer();
+            }
+            else if (snapshot.state === "working") {
+                // If control mode missed the pane change, the safety capture becomes
+                // the new progress timestamp and re-arms both deadlines.
+                if (!expectedOutputAt)
+                    this.instanceStateLastOutputAt = captureStartedAt;
+                this.scheduleInstanceStateStuckDeadline(this.instanceStateLastOutputAt || captureStartedAt);
+            }
+        }
+        catch (err) {
+            this.logger.debug({ err: err.message, reason }, "Instance state capture failed");
+        }
+        finally {
+            this.statePollInFlight = false;
+        }
+    }
+    handleInstancePaneOutput(event) {
+        if (!this.instanceStateMonitorActive || this.runtimeMonitorsFrozen)
+            return;
+        const windowId = this.tmux?.getWindowId();
+        if (!windowId || event.windowId !== windowId || !this.instanceStateMachine)
+            return;
+        this.instanceStateLastOutputAt = event.at;
+        const snapshot = this.instanceStateMachine.recordOutput(event.at);
+        this.applyInstanceStateSnapshot(snapshot);
+        this.scheduleInstanceStateIdleCapture();
+        this.scheduleInstanceStateStuckDeadline(event.at);
+    }
+    bindInstanceStateOutputListener(windowId) {
+        if (!this.controlClient || !this.instanceStateMonitorActive)
+            return;
+        if (!this.instanceStateOutputListener) {
+            this.instanceStateOutputListener = event => this.handleInstancePaneOutput(event);
+        }
+        if (this.instanceStateOutputEventName) {
+            this.controlClient.removeListener(this.instanceStateOutputEventName, this.instanceStateOutputListener);
+        }
+        this.instanceStateOutputEventName = `output:${windowId}`;
+        this.controlClient.on(this.instanceStateOutputEventName, this.instanceStateOutputListener);
+    }
     startInstanceStateMonitor() {
-        if (this.runtimeMonitorsFrozen || !this.tmux || !this.backend || this.instanceStateMonitorTimer)
+        if (this.runtimeMonitorsFrozen || !this.tmux || !this.backend || this.instanceStateMonitorActive)
             return;
         const rawConfig = this.config.hang_detector;
         const timeoutMinutes = rawConfig?.timeout_minutes;
-        const stuckTimeoutMs = typeof timeoutMinutes === "number" && timeoutMinutes > 0
+        this.instanceStateStuckTimeoutMs = typeof timeoutMinutes === "number" && timeoutMinutes > 0
             ? timeoutMinutes * 60_000
             : DEFAULT_STUCK_TIMEOUT_MS;
-        const pollIntervalMs = typeof rawConfig?.poll_interval_ms === "number" && rawConfig.poll_interval_ms > 0
-            ? rawConfig.poll_interval_ms
-            : DEFAULT_STATE_POLL_INTERVAL_MS;
-        this.instanceStateMachine = new PaneStateMachine(this.backend.getReadyPattern(), stuckTimeoutMs);
-        const poll = async () => {
-            if (!this.tmux || this.spawning || this.statePollInFlight)
-                return;
-            this.statePollInFlight = true;
-            try {
-                const paneStatus = await this.tmux.getPaneStatus();
-                if (!paneStatus?.alive)
-                    return;
-                const pane = await this.tmux.capturePane();
-                const previous = this.instanceState;
-                const snapshot = this.instanceStateMachine.observe(pane);
-                this.instanceState = snapshot.state;
-                if (snapshot.state !== previous) {
-                    this.logger.info({
-                        previousState: previous,
-                        state: snapshot.state,
-                        unchangedForMs: snapshot.unchangedForMs,
-                    }, "Instance execution state changed");
-                    this.emit("instance_state", { name: this.name, ...snapshot });
-                    this.ipcServer?.broadcast({ type: "instance_state", instanceName: this.name, ...snapshot });
-                    // Emit exactly once per transition into stuck. Further notifications
-                    // require observable progress (working) or a ready prompt (idle) first.
-                    if (snapshot.state === "stuck") {
-                        this.hangDetector?.emit("hang");
-                    }
-                }
-                if (snapshot.state !== "idle")
-                    this.pauseRequested = false;
-                if (!this.pauseRequested && this.pasteQueueDepth === 0 && this.autoPauseController.observe(snapshot.state)) {
-                    this.pauseRequested = true;
-                    this.emit("auto_pause_requested", { name: this.name, idleSince: snapshot.stateChangedAt });
-                }
-            }
-            catch (err) {
-                // A pane can disappear between status and capture during restart. Keep
-                // the last known state and retry on the next poll.
-                this.logger.debug({ err: err.message }, "Instance state poll failed");
-            }
-            finally {
-                this.statePollInFlight = false;
-            }
+        this.instanceStateIdleDebounceMs = typeof rawConfig?.idle_debounce_ms === "number" && rawConfig.idle_debounce_ms >= 0
+            ? rawConfig.idle_debounce_ms
+            : DEFAULT_STATE_IDLE_DEBOUNCE_MS;
+        this.instanceStateReadyPattern = this.backend.getReadyPattern();
+        this.instanceStateMachine = new PaneStateMachine(this.instanceStateReadyPattern, this.instanceStateStuckTimeoutMs);
+        this.instanceStateLastOutputAt = 0;
+        this.instanceStateMonitorActive = true;
+        if (this.controlClient) {
+            this.instanceStateSafetyListener = () => { void this.captureAndEvaluateInstanceState("safety_sweep"); };
+            this.bindInstanceStateOutputListener(this.tmux.getWindowId());
+            this.controlClient.on("safety_sweep", this.instanceStateSafetyListener);
+        }
+        else {
+            // Standalone/test fallback. Fleet production uses the one shared control
+            // client and therefore one fleet-level safety sweep instead of N timers.
+            this.instanceStateMonitorTimer = setInterval(() => {
+                void this.captureAndEvaluateInstanceState("safety_sweep");
+            }, DEFAULT_STATE_SAFETY_SWEEP_MS);
+        }
+        void this.captureAndEvaluateInstanceState("initial");
+    }
+    stopInstanceStateMonitor() {
+        this.instanceStateMonitorActive = false;
+        this.clearInstanceStateIdleTimer();
+        this.clearInstanceStateStuckTimer();
+        if (this.instanceStateMonitorTimer)
+            clearInterval(this.instanceStateMonitorTimer);
+        this.instanceStateMonitorTimer = null;
+        if (this.controlClient && this.instanceStateOutputListener && this.instanceStateOutputEventName) {
+            this.controlClient.removeListener(this.instanceStateOutputEventName, this.instanceStateOutputListener);
+        }
+        if (this.controlClient && this.instanceStateSafetyListener) {
+            this.controlClient.removeListener("safety_sweep", this.instanceStateSafetyListener);
+        }
+        this.instanceStateOutputListener = null;
+        this.instanceStateOutputEventName = null;
+        this.instanceStateSafetyListener = null;
+    }
+    handleStuckTransition(pane, snapshot, readyPattern) {
+        const deterministicReadyPattern = new RegExp(readyPattern.source, readyPattern.flags.replace(/[gy]/g, ""));
+        const diagnostic = {
+            backend: this.backend?.binaryName ?? this.config.backend ?? "unknown",
+            paneTail: sanitizePaneTail(pane),
+            readyPattern: readyPattern.toString(),
+            readyMatched: deterministicReadyPattern.test(pane),
+            unchangedForMs: snapshot.unchangedForMs,
+            pendingWork: this.pendingWork.hasPendingWork(),
         };
-        void poll();
-        this.instanceStateMonitorTimer = setInterval(() => { void poll(); }, pollIntervalMs);
+        if (!diagnostic.pendingWork) {
+            this.logger.debug(diagnostic, "Suppressing stuck notification without pending work");
+            return;
+        }
+        this.logger.warn(diagnostic, "Instance pane stuck with pending work");
+        this.hangDetector?.emit("hang", { unchangedForMs: snapshot.unchangedForMs });
     }
     /** Stop every runtime poller/watcher while preserving IPC and daemon state. */
     freezeRuntimeMonitors() {
@@ -1193,10 +1550,7 @@ export class Daemon extends EventEmitter {
             clearInterval(this.errorMonitorTimer);
             this.errorMonitorTimer = null;
         }
-        if (this.instanceStateMonitorTimer) {
-            clearInterval(this.instanceStateMonitorTimer);
-            this.instanceStateMonitorTimer = null;
-        }
+        this.stopInstanceStateMonitor();
         this.transcriptMonitor?.stop();
         this.guardian?.stop();
     }
@@ -1291,12 +1645,23 @@ export class Daemon extends EventEmitter {
         // Remember (and persist) the reply target. Only real channel messages have a
         // non-empty chat_id; cross-instance messages have chat_id="" and must NOT
         // overwrite it (their reply would otherwise go nowhere).
-        this.updateLastChat(meta.chat_id, meta.thread_id);
+        this.updateLastChat(meta.chat_id, meta.thread_id, meta.adapter_id);
+        if (meta.chat_id) {
+            const inboundAt = Date.now();
+            this.autoPauseController.recordActivity(inboundAt);
+            try {
+                writeLastInboundAt(this.instanceDir, inboundAt);
+            }
+            catch (err) {
+                this.logger.warn({ err: err.message }, "Failed to persist last inbound timestamp");
+            }
+        }
         if (this.pendingInstructionsUpdate) {
             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);
         // Format message with metadata prefix for the agent
@@ -1315,7 +1680,10 @@ export class Daemon extends EventEmitter {
         }
         let formatted;
         if (fromInstance) {
-            formatted = `[from:${fromInstance}] ${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.)`;
+            // #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.)`;
         }
         else {
             const via = meta.source ? ` via ${meta.source}` : "";
@@ -1346,7 +1714,7 @@ export class Daemon extends EventEmitter {
                 }
                 if (this.pendingInstructionsNotice) {
                     this.pendingInstructionsNotice = false;
-                    await this.deliverMessage("[system] Your instructions/steering files have been updated. Re-read your steering files. Do not reply to this message.");
+                    await this.deliverMessage(buildInstructionReloadNotice(this.backend?.binaryName ?? "unknown", this.name, this.instanceDir));
                 }
                 const status = (chatId && messageId)
                     ? { chatId: meta.thread_id || chatId, messageId }
@@ -1403,8 +1771,14 @@ export class Daemon extends EventEmitter {
                     await new Promise(r => setTimeout(r, 2000));
                 continue;
             }
-            // Settle the bracketed paste, then submit.
-            await new Promise(r => setTimeout(r, 500));
+            // Settle the bracketed paste, then submit. The first delivery immediately
+            // after ready gets a longer one-shot delay because the TUI may still be
+            // completing its final redraw even though the prompt already matched.
+            const enterSettleMs = this.firstDeliveryDelay.consume();
+            if (enterSettleMs > NORMAL_ENTER_SETTLE_MS) {
+                this.logger.debug({ enterSettleMs }, "First delivery after ready — extending Enter settle delay");
+            }
+            await new Promise(r => setTimeout(r, enterSettleMs));
             const enterAt = Date.now();
             await this.tmux.sendSpecialKey("Enter");
             if (status)
@@ -1447,6 +1821,7 @@ export class Daemon extends EventEmitter {
             this.tmux = new TmuxManager(this.tmuxSessionName, match.id);
             writeFileSync(join(this.instanceDir, "window-id"), match.id);
             await this.controlClient?.registerWindow(match.id);
+            this.bindInstanceStateOutputListener(match.id);
             this.logger.info({ windowId: match.id }, "Recovered window ID for message delivery");
             return match.id;
         }
@@ -1793,6 +2168,7 @@ export class Daemon extends EventEmitter {
             },
             skipPermissions: this.config.skipPermissions,
             model: this.modelOverride ?? this.config.model,
+            kiroUi: this.config.kiro_ui,
             skipResume: this.skipResume,
             instructions,
             agentMode: isCliMode ? "cli" : "mcp",
@@ -1972,6 +2348,7 @@ export class Daemon extends EventEmitter {
         }
         // Register with control client and wait for output + idle
         await this.controlClient?.registerWindow(windowId);
+        this.bindInstanceStateOutputListener(windowId);
         if (this.controlClient) {
             const total = startupTimeoutMs ?? this.config.startup_timeout_ms ?? 25_000;
             const outputTimeout = Math.round(total * 0.6);
@@ -1996,7 +2373,10 @@ export class Daemon extends EventEmitter {
         // but a startup crash would already be caught by waitForOutput/waitForIdle above.
         if (!await this.tmux.isWindowAlive())
             return false;
-        return this.dismissDialogsUntilReady(3);
+        const ready = await this.dismissDialogsUntilReady(3);
+        if (ready)
+            this.firstDeliveryDelay.recordReady();
+        return ready;
     }
     /**
      * Repeatedly check pane content, dismiss any confirmation dialogs,
@@ -2063,14 +2443,17 @@ export class Daemon extends EventEmitter {
      * messages) so it never overwrites a real channel target. Persisted to
      * last-chat.json so the reply target survives a restart (see start()).
      */
-    updateLastChat(chatId, threadId) {
+    updateLastChat(chatId, threadId, adapterId) {
         if (!chatId)
             return;
         this.lastChatId = chatId;
-        if (threadId)
-            this.lastThreadId = threadId;
+        // An unthreaded inbound must clear a previous topic rather than leaking it
+        // into the next reply target.
+        this.lastThreadId = threadId || undefined;
+        if (adapterId)
+            this.lastAdapterId = adapterId;
         try {
-            writeFileSync(join(this.instanceDir, "last-chat.json"), JSON.stringify({ chatId: this.lastChatId, threadId: this.lastThreadId }));
+            writeFileSync(join(this.instanceDir, "last-chat.json"), JSON.stringify({ chatId: this.lastChatId, threadId: this.lastThreadId, adapterId: this.lastAdapterId }));
         }
         catch { /* best effort */ }
     }