@songsid/agend 2.0.12 → 2.1.0-beta.10

package/dist/daemon.js

@@ -1,9 +1,8 @@
 import { join, dirname, basename, resolve } from "node:path";
 import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, chmodSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { randomBytes } from "node:crypto";
+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";
@@ -21,6 +20,149 @@ 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";
+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.
+ *
+ * Pane motion wins over a ready match because several backends keep their ready
+ * marker in a persistent header/footer while generating. A stable ready pane is
+ * idle; changing content is working; stable non-ready content eventually sticks.
+ */
+export class PaneStateMachine {
+    stuckTimeoutMs;
+    readyPattern;
+    lastPaneHash = null;
+    lastPaneChangeAt;
+    lastObservedAt;
+    stateChangedAt;
+    currentState = "idle";
+    constructor(readyPattern, stuckTimeoutMs = DEFAULT_STUCK_TIMEOUT_MS, now = Date.now()) {
+        this.stuckTimeoutMs = stuckTimeoutMs;
+        // Stateful g/y regexes mutate lastIndex and can alternate true/false across
+        // polls. State detection must be deterministic for identical pane content.
+        this.readyPattern = new RegExp(readyPattern.source, readyPattern.flags.replace(/[gy]/g, ""));
+        this.lastPaneChangeAt = now;
+        this.lastObservedAt = now;
+        this.stateChangedAt = now;
+    }
+    observe(pane, now = Date.now()) {
+        const paneHash = createHash("sha256").update(pane).digest("hex");
+        const firstObservation = this.lastPaneHash === null;
+        const paneChanged = this.lastPaneHash !== paneHash;
+        if (paneChanged) {
+            this.lastPaneHash = paneHash;
+            this.lastPaneChangeAt = now;
+        }
+        this.lastObservedAt = now;
+        const ready = this.readyPattern.test(pane);
+        const nextState = firstObservation
+            ? ready ? "idle" : "working"
+            : paneChanged
+                ? "working"
+                : ready
+                    ? "idle"
+                    : now - this.lastPaneChangeAt >= this.stuckTimeoutMs
+                        ? "stuck"
+                        : "working";
+        if (nextState !== this.currentState) {
+            this.currentState = nextState;
+            this.stateChangedAt = now;
+        }
+        return this.snapshot(now);
+    }
+    snapshot(now = Date.now()) {
+        return {
+            state: this.currentState,
+            unchangedForMs: Math.max(0, now - this.lastPaneChangeAt),
+            observedAt: this.lastObservedAt,
+            stateChangedAt: this.stateChangedAt,
+        };
+    }
+}
+/** 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;
@@ -68,6 +210,15 @@ export class Daemon extends EventEmitter {
     rotationStartedAt = 0;
     preRotationContextPct = 0;
     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
@@ -87,12 +238,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;
@@ -110,7 +266,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;
@@ -118,13 +274,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
@@ -229,13 +395,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 => {
@@ -246,12 +417,25 @@ 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
                 this.toolStatusMessageId = msg.messageId;
             }
+            else if (msg.type === "query_instance_state") {
+                const snapshot = this.getInstanceStateSnapshot();
+                this.ipcServer?.send(socket, {
+                    type: "instance_state_response",
+                    requestId: msg.requestId,
+                    instanceName: this.name,
+                    ...snapshot,
+                    state: this.isPaused ? "paused" : snapshot.state,
+                    pausedAt: this.lastPausedAt,
+                });
+            }
         });
         // 2. Tmux — ensure session, create window if not alive
         await TmuxManager.ensureSession(this.tmuxSessionName);
@@ -356,9 +540,13 @@ export class Daemon extends EventEmitter {
                 this.recordRecentEvent({ type: "assistant_text", preview: text.slice(0, 100) });
             });
             this.transcriptMonitor.startPolling();
-            // Hang detector
-            this.hangDetector = new HangDetector(15);
-            this.hangDetector.start();
+            // HangDetector remains the fleet-manager notification event bridge. Its
+            // legacy silence timer is intentionally not started: pane state transitions
+            // below are now the sole source of hang events.
+            const hangConfig = this.config.hang_detector;
+            if (hangConfig?.enabled !== false) {
+                this.hangDetector = new HangDetector(hangConfig?.timeout_minutes ?? 10);
+            }
             // 8. Context guardian
             const statusFile = join(this.instanceDir, "statusline.json");
             this.guardian = new ContextGuardian(this.config.context_guardian, this.logger, statusFile);
@@ -382,14 +570,22 @@ export class Daemon extends EventEmitter {
         if (!this.config.lightweight) {
             this.startErrorMonitor();
         }
+        this.startInstanceStateMonitor();
         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",
@@ -407,6 +603,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;
@@ -634,6 +836,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)
@@ -753,22 +957,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;
-        }
+        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)
@@ -827,10 +1022,270 @@ 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.isPaused ? "paused" : this.instanceState;
+    }
+    getInstanceStateSnapshot() {
+        return this.instanceStateMachine?.snapshot() ?? {
+            state: this.instanceState,
+            unchangedForMs: 0,
+            observedAt: Date.now(),
+            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();
+                if (quitCmd && this.tmux) {
+                    await this.tmux.sendKeys(quitCmd);
+                    await new Promise(r => setTimeout(r, 150));
+                    await this.tmux.sendSpecialKey("Enter");
+                }
+                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.runtimeMonitorsFrozen || !this.tmux || !this.backend || this.instanceStateMonitorTimer)
+            return;
+        const rawConfig = this.config.hang_detector;
+        const timeoutMinutes = rawConfig?.timeout_minutes;
+        const stuckTimeoutMs = 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;
+        const readyPattern = this.backend.getReadyPattern();
+        this.instanceStateMachine = new PaneStateMachine(readyPattern, 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;
+                // 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,
+                        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.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
+                // the last known state and retry on the next poll.
+                this.logger.debug({ err: err.message }, "Instance state poll failed");
+            }
+            finally {
+                this.statePollInFlight = false;
+            }
+        };
+        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;
     }
@@ -915,6 +1370,7 @@ export class Daemon extends EventEmitter {
             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
@@ -1488,14 +1944,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 */ }
@@ -1506,7 +1962,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
@@ -1569,16 +2025,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);