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

package/dist/daemon.js

@@ -3,6 +3,7 @@ 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";
@@ -22,40 +23,6 @@ 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.
  *
@@ -114,55 +81,6 @@ 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;
@@ -183,7 +101,6 @@ 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
@@ -213,13 +130,8 @@ 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
@@ -239,17 +151,12 @@ 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 abnormal error state (auto-pause is normal). */
+    /** Whether this instance is in an error state (rate-limited, paused, or crash loop). */
     get isErrorState() {
-        return this.errorWaitingForRecovery || (this.healthCheckPaused && !this.isPaused) || Daemon.tmuxServerPaused;
+        return this.errorWaitingForRecovery || this.healthCheckPaused || 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;
@@ -267,7 +174,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, rootLogger) {
+    constructor(name, config, instanceDir, topicMode = false, backend, controlClient) {
         super();
         this.name = name;
         this.config = config;
@@ -275,23 +182,13 @@ export class Daemon extends EventEmitter {
         this.topicMode = topicMode;
         this.backend = backend;
         this.controlClient = controlClient;
-        if (!rootLogger)
-            throw new Error("Daemon requires a shared root logger");
-        this.logger = rootLogger.child({ instance: name }, { level: config.log_level });
+        this.logger = createLogger(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
@@ -317,7 +214,6 @@ export class Daemon extends EventEmitter {
                 if (saved.chatId) {
                     this.lastChatId = saved.chatId;
                     this.lastThreadId = saved.threadId || undefined;
-                    this.lastAdapterId = saved.adapterId || undefined;
                 }
             }
         }
@@ -397,18 +293,13 @@ export class Daemon extends EventEmitter {
                 // Fleet manager routed a message to us (topic mode)
                 const meta = msg.meta;
                 const targetSession = msg.targetSession;
-                void this.wake().then(() => {
-                    this.pushChannelMessage(msg.content, meta, targetSession);
-                }).catch(err => {
-                    this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
-                });
+                this.pushChannelMessage(msg.content, meta, targetSession);
             }
             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 => {
@@ -419,9 +310,7 @@ export class Daemon extends EventEmitter {
             else if (msg.type === "fleet_schedule_trigger") {
                 const payload = msg.payload;
                 const meta = msg.meta;
-                void this.wake().then(() => this.pushChannelMessage(payload.message, meta)).catch(err => {
-                    this.logger.error({ err: err.message }, "Wake failed for scheduled delivery");
-                });
+                this.pushChannelMessage(payload.message, meta);
             }
             else if (msg.type === "fleet_tool_status_ack") {
                 // Fleet manager sent us the messageId for our tool status message
@@ -434,8 +323,6 @@ export class Daemon extends EventEmitter {
                     requestId: msg.requestId,
                     instanceName: this.name,
                     ...snapshot,
-                    state: this.isPaused ? "paused" : snapshot.state,
-                    pausedAt: this.lastPausedAt,
                 });
             }
         });
@@ -576,18 +463,11 @@ 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",
@@ -605,12 +485,6 @@ 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;
@@ -838,8 +712,6 @@ 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)
@@ -959,13 +831,26 @@ export class Daemon extends EventEmitter {
     }
     async stop() {
         this.logger.info("Stopping daemon instance");
-        this.freezeRuntimeMonitors();
+        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;
+        }
         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)
@@ -977,19 +862,12 @@ 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++) {
@@ -1031,16 +909,12 @@ 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;
+        return this.instanceState;
     }
     getInstanceStateSnapshot() {
         return this.instanceStateMachine?.snapshot() ?? {
@@ -1050,149 +924,8 @@ 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.runtimeMonitorsFrozen || !this.tmux || !this.backend || this.instanceStateMonitorTimer)
+        if (!this.tmux || !this.backend || this.instanceStateMonitorTimer)
             return;
         const rawConfig = this.config.hang_detector;
         const timeoutMinutes = rawConfig?.timeout_minutes;
@@ -1202,8 +935,7 @@ 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;
-        const readyPattern = this.backend.getReadyPattern();
-        this.instanceStateMachine = new PaneStateMachine(readyPattern, stuckTimeoutMs);
+        this.instanceStateMachine = new PaneStateMachine(this.backend.getReadyPattern(), stuckTimeoutMs);
         const poll = async () => {
             if (!this.tmux || this.spawning || this.statePollInFlight)
                 return;
@@ -1216,11 +948,6 @@ 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,
@@ -1232,15 +959,9 @@ 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.handleStuckTransition(pane, snapshot, readyPattern);
+                        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
@@ -1254,54 +975,6 @@ 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;
     }
@@ -1380,13 +1053,12 @@ 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, meta.adapter_id);
+        this.updateLastChat(meta.chat_id, meta.thread_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
@@ -1960,14 +1632,14 @@ export class Daemon extends EventEmitter {
         return resumedSuccessfully;
     }
     /** Kill the entire process tree of the current tmux pane (CLI + MCP server). */
-    async killProcessTree(signal = "SIGTERM") {
+    async killProcessTree() {
         if (!this.tmux)
             return;
         try {
             const pid = await TmuxManager.getPanePid(this.tmuxSessionName, this.tmux.getWindowId());
             if (pid) {
-                process.kill(-pid, signal);
-                this.logger.debug({ pid, signal }, "Killed process group");
+                process.kill(-pid, "SIGTERM");
+                this.logger.debug({ pid }, "Killed process group");
             }
         }
         catch { /* process group may not exist or already dead */ }
@@ -1978,7 +1650,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(reuseWindow = false, startupTimeoutMs) {
+    async trySpawn() {
         const backendConfig = this.buildBackendConfig();
         // Compare freshly-built instructions against the last value the agent was
         // told about. Computed for ALL backends (not gated by
@@ -2041,29 +1713,16 @@ 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);
-        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);
-        }
+        const 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 = startupTimeoutMs ?? this.config.startup_timeout_ms ?? 25_000;
+            const total = 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);
@@ -2153,17 +1812,14 @@ 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, adapterId) {
+    updateLastChat(chatId, threadId) {
         if (!chatId)
             return;
         this.lastChatId = chatId;
-        // 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;
+        if (threadId)
+            this.lastThreadId = threadId;
         try {
-            writeFileSync(join(this.instanceDir, "last-chat.json"), JSON.stringify({ chatId: this.lastChatId, threadId: this.lastThreadId, adapterId: this.lastAdapterId }));
+            writeFileSync(join(this.instanceDir, "last-chat.json"), JSON.stringify({ chatId: this.lastChatId, threadId: this.lastThreadId }));
         }
         catch { /* best effort */ }
     }