@songsid/agend 2.1.0-beta.2 → 2.1.0-beta.21

package/dist/daemon.js

@@ -3,7 +3,6 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync,
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { createLogger } from "./logger.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { ContextGuardian } from "./context-guardian.js";
@@ -23,6 +22,40 @@ const DECISION_TOOLS = new Set(["post_decision", "list_decisions", "update_decis
 const TASK_TOOL = "task";
 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 class AutoPauseController {
+    thresholdMs;
+    idleSince = null;
+    pausedAt = null;
+    constructor(thresholdMs) {
+        this.thresholdMs = thresholdMs;
+    }
+    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;
+    }
+    markPaused(now = Date.now()) {
+        this.pausedAt = now;
+    }
+    markAwake() {
+        this.pausedAt = null;
+        this.idleSince = null;
+    }
+    async wakeOnDeliver(wake) {
+        if (this.pausedAt === null)
+            return;
+        await wake();
+        this.markAwake();
+    }
+    get isPaused() { return this.pausedAt !== null; }
+    get lastPausedAt() { return this.pausedAt; }
+}
 /**
  * Headless state machine for pane-based execution state detection.
  *
@@ -81,6 +114,55 @@ 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;
+    }
+}
+/** 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;
@@ -101,6 +183,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
@@ -130,8 +213,13 @@ export class Daemon extends EventEmitter {
     hangDetector = null;
     instanceState = "idle";
     instanceStateMachine = null;
+    pendingWork = new PendingWorkTracker();
     instanceStateMonitorTimer = null;
     statePollInFlight = false;
+    autoPauseController;
+    pauseRequested = false;
+    pauseWakeState = "active";
+    pauseWakeTransition = null;
     // Model failover: override model on next spawn when rate-limited
     modelOverride;
     // Context rotation v3: ring buffers for daemon-side snapshot
@@ -151,12 +239,17 @@ export class Daemon extends EventEmitter {
     pasteQueueDepth = 0;
     // 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 error state (rate-limited, paused, or crash loop). */
+    /** Whether this instance is in an abnormal error state (auto-pause is normal). */
     get isErrorState() {
-        return this.errorWaitingForRecovery || this.healthCheckPaused || Daemon.tmuxServerPaused;
+        return this.errorWaitingForRecovery || (this.healthCheckPaused && !this.isPaused) || Daemon.tmuxServerPaused;
     }
+    get isPaused() { return this.pauseWakeState !== "active"; }
+    get lastPausedAt() { return this.autoPauseController.lastPausedAt; }
+    getPauseWakeState() { return this.pauseWakeState; }
     /** Whether this instance is in a crash loop (3+ consecutive crashes). */
     get isCrashLoop() {
         return this.crashCount >= 3;
@@ -174,7 +267,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;
@@ -182,13 +275,23 @@ 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 : 0; // default: disabled
+        this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000);
     }
     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
@@ -214,6 +317,7 @@ export class Daemon extends EventEmitter {
                 if (saved.chatId) {
                     this.lastChatId = saved.chatId;
                     this.lastThreadId = saved.threadId || undefined;
+                    this.lastAdapterId = saved.adapterId || undefined;
                 }
             }
         }
@@ -293,13 +397,18 @@ export class Daemon extends EventEmitter {
                 // Fleet manager routed a message to us (topic mode)
                 const meta = msg.meta;
                 const targetSession = msg.targetSession;
-                this.pushChannelMessage(msg.content, meta, targetSession);
+                void this.wake().then(() => {
+                    this.pushChannelMessage(msg.content, meta, targetSession);
+                }).catch(err => {
+                    this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
+                });
             }
             else if (msg.type === "raw_paste") {
                 // Paste raw text directly to CLI without [user:] wrapping.
                 if (this.tmux) {
                     const rawText = msg.content;
                     this.pasteLock = this.pasteLock.then(async () => {
+                        await this.wake();
                         await this.deliverMessage(rawText);
                         this.logger.debug({ text: rawText.slice(0, 100) }, "Raw paste delivered");
                     }).catch(err => {
@@ -310,7 +419,9 @@ export class Daemon extends EventEmitter {
             else if (msg.type === "fleet_schedule_trigger") {
                 const payload = msg.payload;
                 const meta = msg.meta;
-                this.pushChannelMessage(payload.message, meta);
+                void this.wake().then(() => this.pushChannelMessage(payload.message, meta)).catch(err => {
+                    this.logger.error({ err: err.message }, "Wake failed for scheduled delivery");
+                });
             }
             else if (msg.type === "fleet_tool_status_ack") {
                 // Fleet manager sent us the messageId for our tool status message
@@ -323,6 +434,8 @@ export class Daemon extends EventEmitter {
                     requestId: msg.requestId,
                     instanceName: this.name,
                     ...snapshot,
+                    state: this.isPaused ? "paused" : snapshot.state,
+                    pausedAt: this.lastPausedAt,
                 });
             }
         });
@@ -463,11 +576,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",
@@ -485,6 +605,12 @@ export class Daemon extends EventEmitter {
                 // Human-readable backend label for logs (e.g. "claude", "kiro-cli")
                 const cliLabel = this.backend?.binaryName ?? "CLI";
                 let paneStatus = await this.tmux.getPaneStatus();
+                // Auto-pause intentionally exits the pane process. A health tick that
+                // began just before pause must not classify that exit as a crash.
+                if (this.isPaused || this.pauseWakeState === "waking") {
+                    scheduleNext();
+                    return;
+                }
                 if (paneStatus?.alive) {
                     scheduleNext();
                     return;
@@ -712,6 +838,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)
@@ -831,26 +959,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)
@@ -862,12 +977,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++) {
@@ -909,12 +1031,16 @@ 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;
     }
     getInstanceState() {
-        return this.instanceState;
+        return this.isPaused ? "paused" : this.instanceState;
     }
     getInstanceStateSnapshot() {
         return this.instanceStateMachine?.snapshot() ?? {
@@ -924,8 +1050,149 @@ export class Daemon extends EventEmitter {
             stateChangedAt: Date.now(),
         };
     }
+    /** Gracefully stop the CLI while keeping its remain-on-exit tmux window. */
+    async pause() {
+        if (this.pauseWakeState === "paused")
+            return;
+        if (this.pauseWakeState === "pausing" || this.pauseWakeState === "waking") {
+            await this.pauseWakeTransition;
+            if (this.getPauseWakeState() !== "active")
+                return;
+        }
+        if (this.instanceState !== "idle" || this.pasteQueueDepth > 0) {
+            this.pauseRequested = false;
+            return;
+        }
+        this.pauseWakeState = "pausing";
+        this.healthCheckPaused = true;
+        this.freezeRuntimeMonitors();
+        const transition = (async () => {
+            try {
+                this.saveSessionId();
+                const quitCmd = this.backend?.getQuitCommand();
+                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++) {
+                    await new Promise(r => setTimeout(r, 200));
+                    const status = await this.tmux?.getPaneStatus();
+                    if (status && !status.alive) {
+                        exited = true;
+                        break;
+                    }
+                }
+                if (!exited) {
+                    await this.killProcessTree("SIGTERM");
+                    await new Promise(r => setTimeout(r, 1_000));
+                    const status = await this.tmux?.getPaneStatus();
+                    if (status?.alive) {
+                        await this.killProcessTree("SIGKILL");
+                        await new Promise(r => setTimeout(r, 200));
+                    }
+                }
+                const finalStatus = await this.tmux?.getPaneStatus();
+                if (!finalStatus || finalStatus.alive) {
+                    throw new Error("Auto-pause could not stop the CLI while preserving its tmux window");
+                }
+                this.pauseWakeState = "paused";
+                this.autoPauseController.markPaused();
+                writeFileSync(join(this.instanceDir, "paused-state.json"), JSON.stringify({
+                    paused_at: this.lastPausedAt,
+                }));
+                this.logger.info({ pausedAt: this.lastPausedAt }, "Instance auto-paused");
+                this.ipcServer?.broadcast({
+                    type: "instance_state", instanceName: this.name, state: "paused", pausedAt: this.lastPausedAt,
+                });
+                this.emit("auto_paused", { name: this.name, pausedAt: this.lastPausedAt });
+            }
+            catch (err) {
+                this.pauseWakeState = "active";
+                this.healthCheckPaused = false;
+                this.pauseRequested = false;
+                this.resumeRuntimeMonitors();
+                throw err;
+            }
+        })();
+        this.pauseWakeTransition = transition;
+        try {
+            await transition;
+        }
+        finally {
+            if (this.pauseWakeTransition === transition)
+                this.pauseWakeTransition = null;
+        }
+    }
+    /** Respawn the CLI in the preserved window and block until its prompt is ready. */
+    async wake(timeoutMs = 30_000) {
+        if (this.pauseWakeState === "active")
+            return;
+        if (this.pauseWakeState === "pausing")
+            await this.pauseWakeTransition;
+        if (this.getPauseWakeState() === "active")
+            return;
+        if (this.pauseWakeState === "waking") {
+            await this.pauseWakeTransition;
+            return;
+        }
+        this.pauseWakeState = "waking";
+        this.spawning = true;
+        const transition = this.autoPauseController.wakeOnDeliver(async () => {
+            let timeout;
+            try {
+                const ready = await Promise.race([
+                    this.trySpawn(true, timeoutMs),
+                    new Promise(resolve => { timeout = setTimeout(() => resolve(false), timeoutMs); }),
+                ]);
+                if (!ready)
+                    throw new Error(`Wake timed out before CLI became ready (${timeoutMs}ms)`);
+            }
+            finally {
+                if (timeout)
+                    clearTimeout(timeout);
+            }
+        });
+        this.pauseWakeTransition = transition;
+        try {
+            await transition;
+            this.pauseWakeState = "active";
+            this.healthCheckPaused = false;
+            this.pauseRequested = false;
+            try {
+                unlinkSync(join(this.instanceDir, "paused-state.json"));
+            }
+            catch { }
+            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,
+            });
+            this.emit("auto_woke", { name: this.name });
+        }
+        catch (err) {
+            this.pauseWakeState = "paused";
+            this.healthCheckPaused = true;
+            this.logger.error({ err: err.message }, "Instance wake failed");
+            throw err;
+        }
+        finally {
+            this.spawning = false;
+            if (this.pauseWakeTransition === transition)
+                this.pauseWakeTransition = null;
+        }
+    }
     startInstanceStateMonitor() {
-        if (!this.tmux || !this.backend || this.instanceStateMonitorTimer)
+        if (this.runtimeMonitorsFrozen || !this.tmux || !this.backend || this.instanceStateMonitorTimer)
             return;
         const rawConfig = this.config.hang_detector;
         const timeoutMinutes = rawConfig?.timeout_minutes;
@@ -935,7 +1202,8 @@ export class Daemon extends EventEmitter {
         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 readyPattern = this.backend.getReadyPattern();
+        this.instanceStateMachine = new PaneStateMachine(readyPattern, stuckTimeoutMs);
         const poll = async () => {
             if (!this.tmux || this.spawning || this.statePollInFlight)
                 return;
@@ -948,6 +1216,11 @@ export class Daemon extends EventEmitter {
                 const previous = this.instanceState;
                 const snapshot = this.instanceStateMachine.observe(pane);
                 this.instanceState = snapshot.state;
+                // Only a transition back to idle completes pending work. Repeated idle
+                // polls between enqueue and paste must not clear a newly-recorded inbound.
+                if (snapshot.state === "idle" && previous !== "idle") {
+                    this.pendingWork.recordIdle(snapshot.observedAt);
+                }
                 if (snapshot.state !== previous) {
                     this.logger.info({
                         previousState: previous,
@@ -959,9 +1232,15 @@ export class Daemon extends EventEmitter {
                     // 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");
+                        this.handleStuckTransition(pane, snapshot, readyPattern);
                     }
                 }
+                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
@@ -975,6 +1254,54 @@ export class Daemon extends EventEmitter {
         void poll();
         this.instanceStateMonitorTimer = setInterval(() => { void poll(); }, pollIntervalMs);
     }
+    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(),
+        };
+        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;
+        }
+        if (this.instanceStateMonitorTimer) {
+            clearInterval(this.instanceStateMonitorTimer);
+            this.instanceStateMonitorTimer = null;
+        }
+        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;
     }
@@ -1053,12 +1380,13 @@ 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 (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
@@ -1632,14 +1960,14 @@ export class Daemon extends EventEmitter {
         return resumedSuccessfully;
     }
     /** Kill the entire process tree of the current tmux pane (CLI + MCP server). */
-    async killProcessTree() {
+    async killProcessTree(signal = "SIGTERM") {
         if (!this.tmux)
             return;
         try {
             const pid = await TmuxManager.getPanePid(this.tmuxSessionName, this.tmux.getWindowId());
             if (pid) {
-                process.kill(-pid, "SIGTERM");
-                this.logger.debug({ pid }, "Killed process group");
+                process.kill(-pid, signal);
+                this.logger.debug({ pid, signal }, "Killed process group");
             }
         }
         catch { /* process group may not exist or already dead */ }
@@ -1650,7 +1978,7 @@ export class Daemon extends EventEmitter {
      * Handles confirmation dialogs (trust folder, bypass permissions).
      * Returns true if CLI is ready, false if it failed or got stuck.
      */
-    async trySpawn() {
+    async trySpawn(reuseWindow = false, startupTimeoutMs) {
         const backendConfig = this.buildBackendConfig();
         // Compare freshly-built instructions against the last value the agent was
         // told about. Computed for ALL backends (not gated by
@@ -1713,16 +2041,29 @@ export class Daemon extends EventEmitter {
         const cmd = `${envPrefix} ` + this.backend.buildCommand(backendConfig);
         // Ensure tmux session exists (may have been destroyed if all windows died)
         await TmuxManager.ensureSession(this.tmuxSessionName);
-        const windowId = await this.tmux.createWindow(cmd, resolvedCwd, this.name);
+        let windowId;
+        if (reuseWindow) {
+            this.controlClient?.unregisterWindow(this.tmux.getWindowId());
+            await this.tmux.respawnWindow(cmd, resolvedCwd);
+            windowId = this.tmux.getWindowId();
+        }
+        else {
+            windowId = await this.tmux.createWindow(cmd, resolvedCwd, this.name);
+        }
         writeFileSync(join(this.instanceDir, "window-id"), windowId);
         // Enable remain-on-exit to capture exit codes on crash
         await this.tmux.setRemainOnExit().catch(err => {
             this.logger.warn({ err }, "Failed to set remain-on-exit — exit codes will not be captured");
         });
+        if (reuseWindow && !this.config.lightweight) {
+            await this.tmux.pipeOutput(join(this.instanceDir, "output.log")).catch(err => {
+                this.logger.warn({ err }, "Failed to restore pipe-pane after wake");
+            });
+        }
         // Register with control client and wait for output + idle
         await this.controlClient?.registerWindow(windowId);
         if (this.controlClient) {
-            const total = this.config.startup_timeout_ms ?? 25_000;
+            const total = startupTimeoutMs ?? this.config.startup_timeout_ms ?? 25_000;
             const outputTimeout = Math.round(total * 0.6);
             const idleTimeout = total - outputTimeout;
             const hasOutput = await this.controlClient.waitForOutput(windowId, outputTimeout);
@@ -1812,14 +2153,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 */ }
     }