@songsid/agend 2.1.0-beta.3 → 2.1.0-beta.31

package/dist/daemon.js

@@ -1,9 +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 { createLogger } from "./logger.js";
+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";
@@ -21,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)
@@ -106,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,
@@ -115,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;
@@ -135,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
@@ -164,7 +287,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;
@@ -187,8 +322,11 @@ 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;
     /** Whether this instance is in an abnormal error state (auto-pause is normal). */
@@ -202,6 +340,10 @@ 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
@@ -215,7 +357,7 @@ export class Daemon extends EventEmitter {
     // still registers as new (prevents the old hash-dedup's permanent suppression).
     lastErrorCount = new Map();
     lastDetectedErrorType = null;
-    constructor(name, config, instanceDir, topicMode = false, backend, controlClient) {
+    constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger) {
         super();
         this.name = name;
         this.config = config;
@@ -223,21 +365,17 @@ export class Daemon extends EventEmitter {
         this.topicMode = topicMode;
         this.backend = backend;
         this.controlClient = controlClient;
-        this.logger = createLogger(config.log_level);
+        if (!rootLogger)
+            throw new Error("Daemon requires a shared root logger");
+        this.logger = rootLogger.child({ instance: name }, { level: config.log_level });
         this.tmuxSessionName = getTmuxSession();
         this.messageBus = new MessageBus();
         this.messageBus.setLogger(this.logger);
-        const autoPauseMinutes = typeof config.auto_pause_after === "number" ? config.auto_pause_after : 30;
-        this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000);
+        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, 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
@@ -263,6 +401,7 @@ export class Daemon extends EventEmitter {
                 if (saved.chatId) {
                     this.lastChatId = saved.chatId;
                     this.lastThreadId = saved.threadId || undefined;
+                    this.lastAdapterId = saved.adapterId || undefined;
                 }
             }
         }
@@ -443,7 +582,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 {
@@ -521,11 +660,18 @@ export class Daemon extends EventEmitter {
         this.logger.info(`${this.name} ready`);
     }
     startHealthCheck() {
+        if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
+            return;
         const { max_retries, backoff, reset_after } = this.config.restart_policy;
         if (max_retries <= 0)
             return; // restart disabled
         const scheduleNext = () => {
+            if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
+                return;
             this.healthCheckTimer = setTimeout(async () => {
+                this.healthCheckTimer = null;
+                if (this.runtimeMonitorsFrozen)
+                    return;
                 // Instance directory removed externally (e.g. `rm -rf ~/.agend/instances/<name>`).
                 // Stop the loop permanently — otherwise every tick triggers a respawn, whose
                 // writeRotationSnapshot fails with ENOENT and gets caught as "Failed to respawn",
@@ -776,6 +922,8 @@ export class Daemon extends EventEmitter {
      * (ready pattern visible), it goes back to monitoring for new errors.
      */
     startErrorMonitor() {
+        if (this.runtimeMonitorsFrozen || this.errorMonitorTimer)
+            return;
         const patterns = this.backend?.getErrorPatterns?.() ?? [];
         const dialogs = this.backend?.getRuntimeDialogs?.() ?? [];
         if (!patterns.length && !dialogs.length)
@@ -895,26 +1043,13 @@ export class Daemon extends EventEmitter {
     }
     async stop() {
         this.logger.info("Stopping daemon instance");
-        if (this.healthCheckTimer) {
-            clearTimeout(this.healthCheckTimer);
-            this.healthCheckTimer = null;
-        }
-        if (this.errorMonitorTimer) {
-            clearInterval(this.errorMonitorTimer);
-            this.errorMonitorTimer = null;
-        }
-        if (this.instanceStateMonitorTimer) {
-            clearInterval(this.instanceStateMonitorTimer);
-            this.instanceStateMonitorTimer = null;
-        }
+        this.freezeRuntimeMonitors();
         if (this.toolStatusDebounce) {
             clearTimeout(this.toolStatusDebounce);
             this.toolStatusDebounce = null;
         }
         this.pendingIpcRequests.clear();
         this.hangDetector?.stop();
-        this.transcriptMonitor?.stop();
-        this.guardian?.stop();
         if (this.adapter)
             await this.adapter.stop();
         // Notify MCP servers of graceful shutdown (prevents reconnect attempts)
@@ -926,12 +1061,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++) {
@@ -973,10 +1115,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;
@@ -1007,14 +1145,22 @@ export class Daemon extends EventEmitter {
         }
         this.pauseWakeState = "pausing";
         this.healthCheckPaused = true;
+        this.freezeRuntimeMonitors();
         const transition = (async () => {
             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 +1186,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,
@@ -1053,6 +1197,7 @@ export class Daemon extends EventEmitter {
                 this.pauseWakeState = "active";
                 this.healthCheckPaused = false;
                 this.pauseRequested = false;
+                this.resumeRuntimeMonitors();
                 throw err;
             }
         })();
@@ -1100,11 +1245,9 @@ export class Daemon extends EventEmitter {
             this.pauseWakeState = "active";
             this.healthCheckPaused = false;
             this.pauseRequested = false;
-            try {
-                unlinkSync(join(this.instanceDir, "paused-state.json"));
-            }
-            catch { }
+            clearPausedMarker(this.instanceDir);
             this.transcriptMonitor?.resetOffset();
+            this.resumeRuntimeMonitors();
             this.logger.info("Instance auto-woke");
             this.ipcServer?.broadcast({
                 type: "instance_state", instanceName: this.name, state: this.instanceState, pausedAt: null,
@@ -1123,62 +1266,229 @@ 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.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() {
+        this.runtimeMonitorsFrozen = true;
+        if (this.healthCheckTimer) {
+            clearTimeout(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+        if (this.errorMonitorTimer) {
+            clearInterval(this.errorMonitorTimer);
+            this.errorMonitorTimer = null;
+        }
+        this.stopInstanceStateMonitor();
+        this.transcriptMonitor?.stop();
+        this.guardian?.stop();
+    }
+    /** Restore the same monitor objects after wake without adding event listeners. */
+    resumeRuntimeMonitors() {
+        if (!this.runtimeMonitorsFrozen)
+            return;
+        this.runtimeMonitorsFrozen = false;
+        this.startHealthCheck();
+        if (!this.config.lightweight) {
+            this.transcriptMonitor?.startPolling();
+            this.guardian?.startWatching();
+            this.startErrorMonitor();
+        }
+        this.startInstanceStateMonitor();
     }
     getMessageBus() {
         return this.messageBus;
@@ -1258,12 +1568,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
@@ -1282,7 +1603,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}` : "";
@@ -1313,7 +1637,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 }
@@ -1370,8 +1694,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)
@@ -1414,6 +1744,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;
         }
@@ -1939,6 +2270,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);
@@ -1963,7 +2295,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,
@@ -2030,14 +2365,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 */ }
     }