@songsid/agend 0.0.1

package/dist/daemon.js

@@ -0,0 +1,1714 @@
+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 { 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";
+import { IpcServer } from "./channel/ipc-bridge.js";
+import { MessageBus } from "./channel/message-bus.js";
+import { shellQuote } from "./backend/types.js";
+import { getTmuxSession } from "./config.js";
+import { routeToolCall } from "./channel/tool-router.js";
+import { HangDetector } from "./hang-detector.js";
+import { buildFleetInstructions } from "./instructions.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Tool routing sets — module-level to avoid re-creation on every handleToolCall
+const CROSS_INSTANCE_TOOLS = new Set(["send_to_instance", "list_instances", "start_instance", "restart_instance", "create_instance", "delete_instance", "replace_instance", "request_information", "delegate_task", "report_result", "describe_instance"]);
+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 class Daemon extends EventEmitter {
+    name;
+    config;
+    instanceDir;
+    topicMode;
+    backend;
+    controlClient;
+    logger;
+    tmuxSessionName;
+    tmux = null;
+    ipcServer = null;
+    messageBus;
+    transcriptMonitor = null;
+    toolTracker = null;
+    guardian = null;
+    adapter = null;
+    pendingIpcRequests = new Map();
+    // Track chatId/threadId from inbound messages for automatic outbound routing
+    lastChatId;
+    lastThreadId;
+    // Pending ack: react 🫡 on first transcript activity after receiving a message
+    pendingAckMessage = null;
+    // Tool status tracking for channel adapter
+    toolStatusMessageId = null;
+    toolStatusLines = [];
+    toolStatusDebounce = null;
+    // Session identity: map IPC socket → sessionName (from mcp_ready)
+    socketSessionNames = new Map();
+    // Crash recovery
+    static tmuxServerCrashTimestamps = [];
+    static tmuxServerPaused = false;
+    static tmuxServerRecoveryTimer = null;
+    healthCheckTimer = null;
+    crashCount = 0;
+    lastCrashAt = 0;
+    lastSpawnAt = 0;
+    crashTimestamps = [];
+    healthCheckPaused = false;
+    spawning = false;
+    skipResume = false;
+    /** Whether the last spawn started a fresh session (not resumed). */
+    isNewSession = false;
+    // Context rotation quality tracking
+    rotationStartedAt = 0;
+    preRotationContextPct = 0;
+    hangDetector = null;
+    // Model failover: override model on next spawn when rate-limited
+    modelOverride;
+    // Context rotation v3: ring buffers for daemon-side snapshot
+    recentUserMessages = [];
+    recentEvents = [];
+    recentToolActivity = [];
+    snapshotConsumed = false;
+    pasteLock = Promise.resolve();
+    pendingInstructionsUpdate;
+    pendingInstructionsNotice = false;
+    pasteQueueDepth = 0;
+    // PTY error pattern monitoring
+    errorMonitorTimer = null;
+    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). */
+    get isErrorState() {
+        return this.errorWaitingForRecovery || this.healthCheckPaused || Daemon.tmuxServerPaused;
+    }
+    lastFailoverAt = 0; // cooldown: prevent repeated failover triggers
+    static FAILOVER_COOLDOWN_MS = 5 * 60_000; // 5 minutes
+    lastErrorNotifiedAt = new Map(); // per-type cooldown for all actions
+    static ERROR_COOLDOWN_MS = 5 * 60_000;
+    /** Cheap hash for pane content dedup — not cryptographic, just identity check */
+    static cheapPaneHash(pane) {
+        return `${pane.length}:${pane.slice(-200)}`;
+    }
+    // Hash dedup: suppress stale error re-detection after recovery
+    lastRecoveryPaneHash = null;
+    lastRecoveredErrorType = null;
+    lastDetectedErrorType = null;
+    constructor(name, config, instanceDir, topicMode = false, backend, controlClient) {
+        super();
+        this.name = name;
+        this.config = config;
+        this.instanceDir = instanceDir;
+        this.topicMode = topicMode;
+        this.backend = backend;
+        this.controlClient = controlClient;
+        this.logger = createLogger(config.log_level);
+        this.tmuxSessionName = getTmuxSession();
+        this.messageBus = new MessageBus();
+        this.messageBus.setLogger(this.logger);
+    }
+    async start() {
+        mkdirSync(this.instanceDir, { recursive: true });
+        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
+        const crashStatePath = join(this.instanceDir, "crash-state.json");
+        try {
+            if (existsSync(crashStatePath)) {
+                const state = JSON.parse(readFileSync(crashStatePath, "utf-8"));
+                if (state.resumeDisabled) {
+                    this.skipResume = true;
+                    this.logger.warn("Previous crash loop detected — starting without resume");
+                }
+                unlinkSync(crashStatePath);
+            }
+        }
+        catch { /* corrupt file — ignore */ }
+        // 1. IPC server — bridge between MCP server (Claude's child) and daemon
+        const sockPath = join(this.instanceDir, "channel.sock");
+        this.ipcServer = new IpcServer(sockPath, this.logger);
+        // Forward IPC server errors as daemon events (prevents unhandled 'error' crash).
+        // Guard: only forward post-listen errors — startup errors are handled by listen() rejection.
+        let ipcListening = false;
+        this.ipcServer.on("error", (err) => {
+            if (!ipcListening)
+                return; // startup errors handled by listen() rejection
+            this.logger.error({ err, name: this.name }, "IPC server error");
+            this.emit("error", err);
+        });
+        await this.ipcServer.listen();
+        ipcListening = true;
+        // Permanent IPC dispatcher: routes responses to pending requests by type+id key
+        this.ipcServer.on("message", (msg) => {
+            const type = msg.type;
+            if (!type)
+                return;
+            // Build lookup key matching the pattern used when registering
+            let key;
+            if ((type === "fleet_schedule_response" || type === "fleet_outbound_response" || type === "fleet_decision_response" || type === "fleet_task_response" || type === "fleet_display_name_response" || type === "fleet_description_response") && msg.fleetRequestId) {
+                key = String(msg.fleetRequestId);
+            }
+            else if (type === "fleet_outbound_response" && msg.requestId != null) {
+                key = `fleet_out_${msg.requestId}`;
+            }
+            if (key && this.pendingIpcRequests.has(key)) {
+                const handler = this.pendingIpcRequests.get(key);
+                this.pendingIpcRequests.delete(key);
+                handler(msg);
+            }
+        });
+        // IPC message relay: when daemon wants to push a channel message to Claude,
+        // it broadcasts to all IPC clients (the MCP server is one of them).
+        // When MCP server sends a tool_call, daemon handles it via the messageBus.
+        this.ipcServer.on("message", (msg, socket) => {
+            if (msg.type === "tool_call") {
+                // MCP server forwarding a Claude tool call (reply, react, edit, download)
+                this.handleToolCall(msg, socket);
+            }
+            else if (msg.type === "mcp_ready") {
+                const sessionName = msg.sessionName;
+                if (sessionName) {
+                    this.socketSessionNames.set(socket, sessionName);
+                    socket.on("close", () => {
+                        this.socketSessionNames.delete(socket);
+                        // Notify fleet manager so it can clean up sessionRegistry
+                        if (sessionName !== this.name) {
+                            this.ipcServer?.broadcast({ type: "session_disconnected", sessionName });
+                        }
+                    });
+                }
+                this.logger.debug({ sessionName }, "MCP channel server connected and ready");
+                // Notify FleetManager's IPC client that MCP is ready
+                this.ipcServer?.broadcast({ type: "mcp_ready", sessionName });
+            }
+            else if (msg.type === "query_sessions") {
+                // Fleet manager asks for all registered session names (catches sessions
+                // that sent mcp_ready before fleet manager connected).
+                const sessions = [];
+                for (const [s, sessionName] of this.socketSessionNames) {
+                    if (!s.destroyed && sessionName !== this.name) {
+                        // Individual mcp_ready for initial registration path
+                        this.ipcServer?.send(socket, { type: "mcp_ready", sessionName });
+                        sessions.push(sessionName);
+                    }
+                }
+                // Batch response for prune path
+                this.ipcServer?.send(socket, { type: "query_sessions_response", sessions });
+            }
+            else if (msg.type === "fleet_inbound") {
+                // Fleet manager routed a message to us (topic mode)
+                const meta = msg.meta;
+                const targetSession = msg.targetSession;
+                // Only update lastChatId/lastThreadId from real channel messages (non-empty chat_id).
+                // Cross-instance messages have empty chat_id and must not overwrite these.
+                if (meta.chat_id)
+                    this.lastChatId = meta.chat_id;
+                if (meta.chat_id && meta.thread_id)
+                    this.lastThreadId = meta.thread_id;
+                this.pushChannelMessage(msg.content, meta, targetSession);
+            }
+            else if (msg.type === "raw_paste") {
+                // Paste raw text directly to CLI without [user:] wrapping.
+                // Use pasteLock to serialize with other deliveries and wait for idle.
+                if (this.tmux) {
+                    const rawText = msg.content;
+                    this.pasteLock = this.pasteLock.then(async () => {
+                        await this.deliverMessage(rawText);
+                        this.logger.debug({ text: rawText.slice(0, 100) }, "Raw paste delivered");
+                    }).catch(err => {
+                        this.logger.warn({ err: err.message }, "raw_paste delivery error");
+                    });
+                }
+            }
+            else if (msg.type === "fleet_schedule_trigger") {
+                const payload = msg.payload;
+                const meta = msg.meta;
+                this.lastChatId = meta.chat_id;
+                this.lastThreadId = meta.thread_id;
+                this.pushChannelMessage(payload.message, meta);
+            }
+            else if (msg.type === "fleet_tool_status_ack") {
+                // Fleet manager sent us the messageId for our tool status message
+                this.toolStatusMessageId = msg.messageId;
+            }
+        });
+        // 2. Tmux — ensure session, create window if not alive
+        await TmuxManager.ensureSession(this.tmuxSessionName);
+        this.tmux = new TmuxManager(this.tmuxSessionName, "");
+        // Strategy A: always start fresh Claude window (MCP server has no reconnection)
+        // Kill any existing window from previous run
+        const windowIdFile = join(this.instanceDir, "window-id");
+        if (existsSync(windowIdFile)) {
+            const savedId = readFileSync(windowIdFile, "utf-8").trim();
+            if (savedId) {
+                const oldTmux = new TmuxManager(this.tmuxSessionName, savedId);
+                if (await oldTmux.isWindowAlive()) {
+                    this.saveSessionId();
+                    await oldTmux.killWindow();
+                    this.logger.info({ savedId }, "Killed old tmux window for fresh start");
+                }
+            }
+        }
+        const resumed = await this.spawnClaudeWindow();
+        this.isNewSession = !resumed;
+        if (!resumed) {
+            await this.injectSnapshotMessage();
+        }
+        else {
+            // Clean up stale snapshot file — resume restored full context, snapshot not needed
+            try {
+                unlinkSync(join(this.instanceDir, "rotation-state.json"));
+            }
+            catch { /* may not exist */ }
+        }
+        if (!this.config.lightweight) {
+            // 3. Pipe-pane for prompt detection
+            const outputLog = join(this.instanceDir, "output.log");
+            await this.tmux.pipeOutput(outputLog).catch(() => { });
+            // 4. Transcript monitor
+            this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger);
+            // 5. Wire transcript events
+            const ackIfPending = () => {
+                if (!this.pendingAckMessage || !this.adapter)
+                    return;
+                const { chatId, messageId } = this.pendingAckMessage;
+                this.pendingAckMessage = null;
+                this.adapter.react(chatId, messageId, "🫡")
+                    .catch(e => this.logger.debug({ err: e.message }, "Ack react failed"));
+            };
+            this.transcriptMonitor.on("tool_use", (name, input) => {
+                this.logger.debug({ tool: name }, "Tool use");
+                ackIfPending();
+                this.hangDetector?.recordActivity();
+                this.recordRecentEvent({ type: "tool_use", name, preview: this.summarizeTool(name, input) });
+                this.recordRecentToolActivity(this.summarizeTool(name, input));
+            });
+            this.transcriptMonitor.on("tool_result", (name, _output) => {
+                this.hangDetector?.recordActivity();
+                this.recordRecentEvent({ type: "tool_result", name });
+            });
+            this.transcriptMonitor.on("assistant_text", (text) => {
+                this.logger.debug({ text: text.slice(0, 200) }, "Claude response");
+                ackIfPending();
+                this.hangDetector?.recordActivity();
+                this.recordRecentEvent({ type: "assistant_text", preview: text.slice(0, 100) });
+            });
+            this.transcriptMonitor.startPolling();
+            // Hang detector
+            this.hangDetector = new HangDetector(15);
+            this.hangDetector.start();
+            // 8. Context guardian
+            const statusFile = join(this.instanceDir, "statusline.json");
+            this.guardian = new ContextGuardian(this.config.context_guardian, this.logger, statusFile);
+            this.guardian.startWatching();
+            this.guardian.on("status_update", () => {
+                this.saveSessionId();
+                this.hangDetector?.recordStatuslineUpdate();
+            });
+            // Context rotation removed: all CLI backends have built-in auto-compact.
+            // Crash recovery (health check + respawn with snapshot) is retained below.
+        }
+        // NOTE: Do NOT set process.env.AGEND_SOCKET_PATH here — it pollutes the
+        // shared fleet manager process env. Each daemon overwrites it, so the last
+        // one wins, causing MCP servers (especially kiro-cli which inherits process
+        // env) to connect to the wrong socket. The socket path is passed via
+        // per-instance MCP config files or wrapper scripts instead.
+        // 10. Health check — detect crashed tmux window and respawn
+        // Re-enabled: orphan window issue fixed by killing same-name windows before respawn.
+        // Without this, a dead CLI window goes undetected and messages are silently lost.
+        this.startHealthCheck();
+        if (!this.config.lightweight) {
+            this.startErrorMonitor();
+        }
+        this.logger.info(`${this.name} ready`);
+    }
+    startHealthCheck() {
+        const { max_retries, backoff, reset_after } = this.config.restart_policy;
+        if (max_retries <= 0)
+            return; // restart disabled
+        const scheduleNext = () => {
+            this.healthCheckTimer = setTimeout(async () => {
+                // 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",
+                // spamming errors every ~30s forever.
+                if (!existsSync(this.instanceDir)) {
+                    this.logger.warn({ instanceDir: this.instanceDir }, "Instance directory missing — stopping health check");
+                    this.healthCheckPaused = true;
+                    this.healthCheckTimer = null;
+                    return;
+                }
+                if (!this.tmux || this.spawning || this.healthCheckPaused || Daemon.tmuxServerPaused) {
+                    scheduleNext();
+                    return;
+                }
+                const paneStatus = await this.tmux.getPaneStatus();
+                if (paneStatus?.alive) {
+                    scheduleNext();
+                    return;
+                }
+                // paneStatus === null → window gone entirely (e.g. tmux server crash)
+                // paneStatus.alive === false → pane dead, exit code available
+                const exitCode = paneStatus?.exitCode;
+                this.logger.debug({ exitCode }, `[health] pane exited with code: ${exitCode}`);
+                // Normal exit (e.g. user Ctrl+C or /exit) — no crash, no respawn
+                if (paneStatus && exitCode === 0) {
+                    this.logger.info("CLI exited normally (code 0) — pausing health check");
+                    await this.tmux.killWindow();
+                    this.healthCheckPaused = true;
+                    return;
+                }
+                // Distinguish tmux server crash from single window crash
+                let crashType = "window";
+                if (!paneStatus) {
+                    const serverAlive = await TmuxManager.sessionExists(this.tmuxSessionName);
+                    if (!serverAlive) {
+                        crashType = "server";
+                        this.logger.error("tmux server died — all windows lost");
+                        // Fleet-level circuit breaker: pause all instances on repeated tmux server crashes
+                        Daemon.tmuxServerCrashTimestamps.push(Date.now());
+                        const cutoff = Date.now() - 5 * 60_000;
+                        Daemon.tmuxServerCrashTimestamps = Daemon.tmuxServerCrashTimestamps.filter(t => t > cutoff);
+                        if (Daemon.tmuxServerCrashTimestamps.length >= 2 && !Daemon.tmuxServerPaused) {
+                            Daemon.tmuxServerPaused = true;
+                            this.logger.error("Fleet-level tmux server circuit breaker triggered — pausing all respawns for 30s");
+                            this.emit("tmux_server_crash", this.name);
+                            if (!Daemon.tmuxServerRecoveryTimer) {
+                                Daemon.tmuxServerRecoveryTimer = setTimeout(() => {
+                                    Daemon.tmuxServerRecoveryTimer = null;
+                                    Daemon.tmuxServerPaused = false;
+                                }, 30_000);
+                            }
+                            scheduleNext();
+                            return;
+                        }
+                        await new Promise(r => setTimeout(r, 2_000)); // let session stabilize
+                    }
+                    else {
+                        this.logger.warn({ exitCode }, "Claude window died (tmux server alive)");
+                    }
+                }
+                else {
+                    this.logger.warn({ exitCode }, "Claude process exited");
+                }
+                // Capture last output from dead pane before killing
+                let lastOutput;
+                if (paneStatus) {
+                    try {
+                        const raw = await this.tmux.capturePaneWithHistory(50);
+                        // Strip ANSI escape codes for readability
+                        const cleaned = raw.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+                        lastOutput = cleaned.trimEnd() || undefined;
+                    }
+                    catch { /* best effort */ }
+                }
+                // Kill the dead window (remain-on-exit keeps it around) before respawn
+                if (paneStatus) {
+                    await this.tmux.killWindow();
+                }
+                // Append to crash history
+                this.appendCrashHistory({ exitCode, lastOutput, crashType });
+                // Detect rapid crash: sliding window — 3+ crashes in 5 minutes
+                this.crashTimestamps.push(Date.now());
+                const crashWindowMs = 5 * 60_000;
+                this.crashTimestamps = this.crashTimestamps.filter(t => t > Date.now() - crashWindowMs);
+                if (this.crashTimestamps.length >= 3) {
+                    this.healthCheckPaused = true;
+                    this.logger.error({ crashesInWindow: this.crashTimestamps.length }, "3+ crashes in 5 minutes — pausing respawn");
+                    // P1: Persist crash state so next process restart skips resume
+                    try {
+                        writeFileSync(join(this.instanceDir, "crash-state.json"), JSON.stringify({
+                            crashesInWindow: this.crashTimestamps.length,
+                            lastCrashAt: Date.now(),
+                            resumeDisabled: true,
+                        }));
+                    }
+                    catch { /* best effort */ }
+                    this.emit("crash_loop", this.name);
+                    return; // don't schedule next — paused
+                }
+                // Reset crash count if enough time has passed
+                if (reset_after > 0 && Date.now() - this.lastCrashAt > reset_after) {
+                    this.crashCount = 0;
+                }
+                this.crashCount++;
+                this.lastCrashAt = Date.now();
+                if (this.crashCount > max_retries) {
+                    this.logger.error({ crashCount: this.crashCount, maxRetries: max_retries }, "Max crash retries exceeded — not respawning");
+                    return; // don't schedule next — given up
+                }
+                // Calculate backoff delay
+                const delay = backoff === "exponential"
+                    ? Math.min(1000 * Math.pow(2, this.crashCount - 1), 60_000)
+                    : 1000 * this.crashCount;
+                this.logger.warn({ crashCount: this.crashCount, delay }, "Claude window died — respawning after backoff");
+                await new Promise(r => setTimeout(r, delay));
+                try {
+                    this.saveSessionId();
+                    this.transcriptMonitor?.resetOffset();
+                    // Kill orphan MCP server from the crashed CLI session.
+                    // MCP server writes its PID to channel.mcp.pid on startup.
+                    try {
+                        const pidFile = join(this.instanceDir, "channel.mcp.pid");
+                        const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+                        process.kill(pid, "SIGTERM");
+                        this.logger.info({ pid }, "Killed orphan MCP server");
+                    }
+                    catch { /* no pid file or process already dead */ }
+                    // Kill any same-name windows before respawn to prevent orphans.
+                    // Wrapped in try-catch: if tmux server is dead, listWindows throws —
+                    // must not block spawnClaudeWindow (which calls ensureSession).
+                    try {
+                        const windows = await TmuxManager.listWindows(this.tmuxSessionName);
+                        for (const w of windows) {
+                            if (w.name === this.name) {
+                                const tm = new TmuxManager(this.tmuxSessionName, w.id);
+                                await tm.killWindow();
+                            }
+                        }
+                    }
+                    catch { /* tmux server may be dead — ensureSession in trySpawn will recover */ }
+                    // Write snapshot before spawn — consumed only if resume fails
+                    this.writeRotationSnapshot("crash");
+                    // Try --resume first; spawnClaudeWindow falls back to fresh session if resume fails
+                    const resumed = await this.spawnClaudeWindow();
+                    if (!resumed) {
+                        // Resume failed → fresh session → inject snapshot for context
+                        await this.injectSnapshotMessage();
+                    }
+                    else {
+                        // Clean up stale snapshot — resume restored full context
+                        try {
+                            unlinkSync(join(this.instanceDir, "rotation-state.json"));
+                        }
+                        catch { /* may not exist */ }
+                    }
+                    this.logger.info({ resumed }, "Respawned Claude window after crash");
+                    this.emit("crash_respawn", this.name);
+                }
+                catch (err) {
+                    this.logger.error({ err }, "Failed to respawn Claude window");
+                }
+                scheduleNext();
+            }, this.config.restart_policy.health_check_interval_ms ?? 30_000);
+        };
+        scheduleNext();
+    }
+    /**
+     * Periodically scan PTY output for backend-defined error patterns.
+     *
+     * State machine to avoid false positives from stale buffer text:
+     *   MONITORING → (error pattern match) → WAITING_FOR_RECOVERY → (ready pattern match) → MONITORING
+     *
+     * Only emits pty_error once per error occurrence. After the agent recovers
+     * (ready pattern visible), it goes back to monitoring for new errors.
+     */
+    startErrorMonitor() {
+        const patterns = this.backend?.getErrorPatterns?.() ?? [];
+        const dialogs = this.backend?.getRuntimeDialogs?.() ?? [];
+        if (!patterns.length && !dialogs.length)
+            return;
+        if (!this.tmux)
+            return;
+        if (!this.backend)
+            return; // lightweight mode has no backend
+        const readyPattern = this.backend.getReadyPattern();
+        this.errorMonitorTimer = setInterval(async () => {
+            if (!this.tmux || this.spawning)
+                return;
+            try {
+                const alive = await this.tmux.isWindowAlive();
+                if (!alive)
+                    return;
+                const pane = await this.tmux.capturePane();
+                // Only scan text after the last prompt marker to avoid matching stale errors
+                // that remain in the capture-pane buffer after recovery.
+                let scanText = pane;
+                const rpg = new RegExp(readyPattern.source, readyPattern.flags.includes("g") ? readyPattern.flags : readyPattern.flags + "g");
+                let lastIdx = -1;
+                let m;
+                while ((m = rpg.exec(pane)) !== null)
+                    lastIdx = m.index;
+                if (lastIdx >= 0)
+                    scanText = pane.slice(lastIdx);
+                // Auto-dismiss runtime dialogs (e.g. Codex rate limit model switch)
+                for (const dialog of dialogs) {
+                    if (!dialog.pattern.test(pane))
+                        continue;
+                    this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
+                    const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
+                    for (const key of dialog.keys) {
+                        if (SPECIAL_KEYS.has(key)) {
+                            await this.tmux.sendSpecialKey(key);
+                        }
+                        else {
+                            await this.tmux.pasteText(key);
+                        }
+                        await new Promise(r => setTimeout(r, 200));
+                    }
+                    return; // Dialog dismissed, skip error checks this cycle
+                }
+                // State: waiting for recovery — check if agent is back to ready
+                if (this.errorWaitingForRecovery) {
+                    if (readyPattern.test(pane)) {
+                        const downtime = Math.round((Date.now() - this.errorDetectedAt) / 1000);
+                        // Record pane hash at recovery to suppress stale re-detection
+                        this.lastRecoveryPaneHash = Daemon.cheapPaneHash(pane);
+                        this.lastRecoveredErrorType = this.lastDetectedErrorType;
+                        this.errorWaitingForRecovery = false;
+                        this.errorDetectedAt = 0;
+                        this.logger.info({ downtime_s: downtime }, "PTY error recovered — agent is ready again");
+                        this.emit("pty_recovered", { name: this.name, downtime_s: downtime });
+                    }
+                    return; // Don't check for errors while waiting for recovery
+                }
+                // State: monitoring — check for new errors
+                const currentPaneHash = Daemon.cheapPaneHash(pane);
+                for (const ep of patterns) {
+                    if (!ep.pattern.test(scanText))
+                        continue;
+                    // Dedup: suppress if same error on same screen as last recovery
+                    if (this.lastRecoveryPaneHash && ep.type === this.lastRecoveredErrorType) {
+                        if (currentPaneHash === this.lastRecoveryPaneHash) {
+                            break; // same screen, same error → stale
+                        }
+                        // Screen changed — stop suppressing
+                        this.lastRecoveryPaneHash = null;
+                        this.lastRecoveredErrorType = null;
+                    }
+                    // Cooldown: skip if same error type was recently notified
+                    const lastNotified = this.lastErrorNotifiedAt.get(ep.type) ?? 0;
+                    if (Date.now() - lastNotified < Daemon.ERROR_COOLDOWN_MS) {
+                        this.logger.debug({ errorType: ep.type }, "PTY error suppressed (cooldown active)");
+                        break;
+                    }
+                    if (ep.action === "failover" && Date.now() - this.lastFailoverAt < Daemon.FAILOVER_COOLDOWN_MS) {
+                        this.logger.debug({ errorType: ep.type }, "PTY error suppressed (failover cooldown active)");
+                        break;
+                    }
+                    this.errorWaitingForRecovery = true;
+                    this.errorDetectedAt = Date.now();
+                    this.lastDetectedErrorType = ep.type;
+                    this.lastErrorNotifiedAt.set(ep.type, Date.now());
+                    if (ep.action === "failover")
+                        this.lastFailoverAt = Date.now();
+                    this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${ep.message}`);
+                    this.emit("pty_error", { name: this.name, ...ep });
+                    break; // Only handle first match per scan
+                }
+            }
+            catch {
+                // capturePane can fail if window is transitioning — ignore
+            }
+        }, 5_000); // Check every 5 seconds (runtime dialogs need fast response)
+    }
+    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.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)
+        this.ipcServer?.broadcast({ type: "shutdown" });
+        // Quit CLI FIRST — this kills MCP server child processes cleanly.
+        // IPC must stay open during quit so MCP servers receive the shutdown message.
+        if (this.tmux) {
+            this.saveSessionId();
+            this.healthCheckPaused = true;
+            let killed = false;
+            const quitCmd = this.backend?.getQuitCommand();
+            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");
+                // Wait up to 10s for graceful exit
+                for (let i = 0; i < 20; i++) {
+                    await new Promise(r => setTimeout(r, 500));
+                    const status = await this.tmux.getPaneStatus();
+                    if (!status || !status.alive) {
+                        killed = true;
+                        break;
+                    }
+                }
+            }
+            if (!killed)
+                this.logger.warn("CLI did not exit gracefully within 10s, force killing window");
+            // Always kill window — remain-on-exit keeps dead panes around after CLI exits
+            await this.tmux.killWindow();
+            const windowIdFile = join(this.instanceDir, "window-id");
+            try {
+                unlinkSync(windowIdFile);
+            }
+            catch (e) {
+                this.logger.debug({ err: e }, "Failed to remove window-id file");
+            }
+        }
+        // Close IPC AFTER CLI has exited — MCP servers are already dead at this point
+        await this.ipcServer?.close();
+        // Clean up backend config files
+        if (this.backend?.cleanup) {
+            this.backend.cleanup(this.buildBackendConfig());
+        }
+        // Clean up checked-out repos
+        try {
+            rmSync(join(this.instanceDir, "repos"), { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+        const pidPath = join(this.instanceDir, "daemon.pid");
+        try {
+            unlinkSync(pidPath);
+        }
+        catch (e) {
+            this.logger.debug({ err: e }, "Failed to remove PID file");
+        }
+    }
+    getHangDetector() {
+        return this.hangDetector;
+    }
+    getMessageBus() {
+        return this.messageBus;
+    }
+    // ── Tool status tracking ──────────────────────────────────────
+    summarizeTool(name, input) {
+        const inp = input;
+        if (!inp)
+            return name;
+        if (name === "Read")
+            return `Read ${inp.file_path ?? ""}`;
+        if (name === "Edit")
+            return `Edit ${inp.file_path ?? ""}`;
+        if (name === "Write")
+            return `Write ${inp.file_path ?? ""}`;
+        if (name === "Bash")
+            return `$ ${String(inp.command ?? "").slice(0, 50)}`;
+        if (name === "Glob")
+            return `Glob ${inp.pattern ?? ""}`;
+        if (name === "Grep")
+            return `Grep ${inp.pattern ?? ""}`;
+        if (name === "Agent")
+            return "Agent (subagent)";
+        if (name.startsWith("mcp__agend__"))
+            return ""; // skip channel tools
+        return name;
+    }
+    addToolStatus(name, input, state) {
+        const summary = this.summarizeTool(name, input);
+        if (!summary)
+            return; // skip empty (e.g., channel tools)
+        if (state === "running") {
+            this.toolStatusLines.push(`⏳ ${summary}`);
+        }
+        else {
+            // Mark the last matching tool as done
+            for (let i = this.toolStatusLines.length - 1; i >= 0; i--) {
+                if (this.toolStatusLines[i].includes(name) && this.toolStatusLines[i].startsWith("⏳")) {
+                    this.toolStatusLines[i] = this.toolStatusLines[i].replace("⏳", "✅");
+                    break;
+                }
+            }
+        }
+        this.debouncedSendToolStatus();
+    }
+    /** Debounce tool status updates to avoid channel rate limits */
+    debouncedSendToolStatus() {
+        if (this.toolStatusDebounce)
+            clearTimeout(this.toolStatusDebounce);
+        this.toolStatusDebounce = setTimeout(() => this.sendToolStatus(), 500);
+    }
+    sendToolStatus() {
+        const text = this.toolStatusLines.join("\n");
+        if (!text)
+            return;
+        this.ipcServer?.broadcast({
+            type: "fleet_tool_status",
+            instanceName: this.name,
+            text,
+            editMessageId: this.toolStatusMessageId,
+        });
+    }
+    /** Called by fleet manager when tool status message is sent (returns messageId) */
+    setToolStatusMessageId(messageId) {
+        this.toolStatusMessageId = messageId;
+    }
+    /**
+     * Push an inbound channel message to a specific MCP session.
+     * If targetSession is provided, only send to the matching socket.
+     * Otherwise send to the instance's own session (this.name).
+     */
+    pushChannelMessage(content, meta, _targetSession) {
+        if (!this.tmux) {
+            this.logger.warn("Cannot push channel message: tmux not running");
+            return;
+        }
+        if (this.pendingInstructionsUpdate) {
+            writeFileSync(join(this.instanceDir, "prev-instructions"), this.pendingInstructionsUpdate);
+            this.pendingInstructionsUpdate = undefined;
+        }
+        this.hangDetector?.recordInbound();
+        // v3: record user messages for rotation snapshot
+        this.recordRecentUserMessage(content, meta);
+        // Format message with metadata prefix for the agent
+        const user = meta.user || "unknown";
+        const fromInstance = meta.from_instance;
+        // /raw prefix: paste directly without [user:] wrapping (topic mode only, protected by allowed_users upstream)
+        if (!fromInstance && content.startsWith("/raw ")) {
+            const rawText = content.slice(5);
+            this.logger.info({ user }, "Raw paste from topic mode user");
+            this.pasteLock = this.pasteLock.then(async () => {
+                await this.deliverMessage(rawText);
+            }).catch(err => {
+                this.logger.warn({ err: err.message }, "pasteLock raw delivery error");
+            });
+            return;
+        }
+        let formatted;
+        if (fromInstance) {
+            formatted = `[from:${fromInstance}] ${content}\n(Reply using send_to_instance tool, NOT direct text)`;
+        }
+        else {
+            const via = meta.source ? ` via ${meta.source}` : "";
+            formatted = `[user:${user}${via}] ${content}\n(Reply using the reply tool — do NOT respond with direct text)`;
+        }
+        if (meta.reply_to_text) {
+            formatted += `\n(reply_to: "${meta.reply_to_text}")`;
+        }
+        // Serialize deliveries: each message waits for the previous to complete,
+        // and each waits for the CLI to be idle before pasting.
+        const enqueuedAt = Date.now();
+        const isFromInstance = !!meta.from_instance;
+        const chatId = meta.chat_id;
+        const messageId = meta.message_id;
+        const wasQueued = this.pasteQueueDepth > 0;
+        this.pasteQueueDepth++;
+        if (this.pasteQueueDepth > 3) {
+            this.logger.warn({ depth: this.pasteQueueDepth }, "Message delivery queue backing up");
+        }
+        if (wasQueued && chatId && messageId) {
+            this.emit("message_queued", { chatId, messageId });
+        }
+        this.pasteLock = this.pasteLock.then(async () => {
+            try {
+                // Drop stale user messages (>60s in queue), but never drop cross-instance messages
+                if (!isFromInstance && Date.now() - enqueuedAt > 60_000) {
+                    this.logger.warn({ age: Date.now() - enqueuedAt, user: meta.user }, "Dropping stale message");
+                    return;
+                }
+                if (this.config.pre_task_command) {
+                    await this.deliverMessage(this.config.pre_task_command);
+                }
+                if (this.pendingInstructionsNotice) {
+                    this.pendingInstructionsNotice = false;
+                    await this.deliverMessage("[system] Your instructions/steering files have been updated. Please re-read them for the latest guidelines.");
+                }
+                await this.deliverMessage(formatted);
+                if (chatId && messageId) {
+                    this.emit("message_delivered", { chatId, messageId });
+                }
+            }
+            finally {
+                this.pasteQueueDepth--;
+            }
+        }).catch(err => {
+            this.logger.warn({ err: err.message }, "pasteLock delivery error — chain continues");
+        });
+        this.logger.debug({ user: meta.user, text: content.slice(0, 100) }, "Queued channel message for delivery");
+    }
+    /** Deliver a single message: wait for idle, then paste */
+    async deliverMessage(formatted) {
+        const windowId = this.getWindowId();
+        if (windowId && this.controlClient) {
+            const idle = await this.controlClient.waitForIdle(windowId, this.config.lightweight ? 30_000 : 120_000);
+            if (!idle) {
+                this.logger.warn("Delivering message after idle timeout (CLI may be busy)");
+            }
+        }
+        const ok = await this.tmux.pasteText(formatted);
+        if (!ok) {
+            // Window ID may be stale after crash/respawn — try to find by name
+            this.logger.warn("pasteText failed, looking up window by name");
+            try {
+                const windows = await TmuxManager.listWindows(this.tmuxSessionName);
+                const match = windows.find(w => w.name === this.name);
+                if (match) {
+                    this.tmux = new TmuxManager(this.tmuxSessionName, match.id);
+                    writeFileSync(join(this.instanceDir, "window-id"), match.id);
+                    await this.controlClient?.registerWindow(match.id);
+                    await this.tmux.pasteText(formatted);
+                    this.logger.info({ windowId: match.id }, "Recovered window ID and delivered message");
+                }
+            }
+            catch (retryErr) {
+                this.logger.error({ err: retryErr }, "Failed to recover window for message delivery");
+            }
+        }
+    }
+    getWindowId() {
+        try {
+            return readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Find the IPC socket for a given sessionName */
+    findSocketBySession(sessionName) {
+        for (const [socket, name] of this.socketSessionNames) {
+            if (name === sessionName && !socket.destroyed)
+                return socket;
+        }
+        return undefined;
+    }
+    /**
+     * Handle a tool call from the MCP server (forwarded by Claude).
+     * Routes to the channel adapter via MessageBus.
+     */
+    handleToolCall(msg, socket) {
+        const tool = msg.tool;
+        const args = (msg.args ?? {});
+        const requestId = msg.requestId;
+        this.logger.debug({ tool, requestId }, "Tool call from MCP server");
+        // For now, log and respond. Full adapter routing will be wired in fleet manager.
+        const respond = (result, error) => {
+            this.ipcServer?.send(socket, { requestId, result, error });
+        };
+        // Repo checkout — handled locally in daemon (no fleet-manager)
+        if (tool === "checkout_repo") {
+            this.handleCheckoutRepo(args, respond);
+            return;
+        }
+        if (tool === "release_repo") {
+            this.handleReleaseRepo(args, respond);
+            return;
+        }
+        if (tool === "set_display_name" || tool === "set_description") {
+            const type = tool === "set_display_name" ? "fleet_set_display_name" : "fleet_set_description";
+            const fleetReqId = `${tool === "set_display_name" ? "dn" : "desc"}_${requestId}`;
+            this.ipcServer?.broadcast({
+                type,
+                payload: args,
+                meta: { instance_name: this.name },
+                fleetRequestId: fleetReqId,
+            });
+            const timeout = setTimeout(() => {
+                this.pendingIpcRequests.delete(fleetReqId);
+                respond(null, `${tool} timed out`);
+            }, 10_000);
+            this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
+                clearTimeout(timeout);
+                respond(respMsg.result, respMsg.error);
+            });
+            return;
+        }
+        if (tool === TASK_TOOL) {
+            const fleetReqId = `task_${requestId}`;
+            this.ipcServer?.broadcast({
+                type: "fleet_task",
+                payload: args,
+                meta: { instance_name: this.name },
+                fleetRequestId: fleetReqId,
+            });
+            const timeout = setTimeout(() => {
+                this.pendingIpcRequests.delete(fleetReqId);
+                respond(null, "Task operation timed out after 30s");
+            }, 30_000);
+            this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
+                clearTimeout(timeout);
+                respond(respMsg.result, respMsg.error);
+            });
+            return;
+        }
+        if (DECISION_TOOLS.has(tool)) {
+            const typeMap = {
+                post_decision: "fleet_decision_create",
+                list_decisions: "fleet_decision_list",
+                update_decision: "fleet_decision_update",
+            };
+            const fleetReqId = `dec_${requestId}`;
+            this.ipcServer?.broadcast({
+                type: typeMap[tool],
+                payload: args,
+                meta: { instance_name: this.name, working_directory: this.config.working_directory },
+                fleetRequestId: fleetReqId,
+            });
+            const timeout = setTimeout(() => {
+                this.pendingIpcRequests.delete(fleetReqId);
+                respond(null, "Decision operation timed out after 30s");
+            }, 30_000);
+            this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
+                clearTimeout(timeout);
+                respond(respMsg.result, respMsg.error);
+            });
+            return;
+        }
+        if (SCHEDULE_TOOLS.has(tool)) {
+            const typeMap = {
+                create_schedule: "fleet_schedule_create",
+                list_schedules: "fleet_schedule_list",
+                update_schedule: "fleet_schedule_update",
+                delete_schedule: "fleet_schedule_delete",
+            };
+            // Use fleetRequestId (not requestId) to avoid MCP server resolving the
+            // pending tool call prematurely when it receives the broadcast.
+            const fleetReqId = `sched_${requestId}`;
+            this.ipcServer?.broadcast({
+                type: typeMap[tool],
+                payload: args,
+                meta: { chat_id: this.lastChatId, thread_id: this.lastThreadId, instance_name: this.name },
+                fleetRequestId: fleetReqId,
+            });
+            // Wait for fleet_schedule_response via pending request map
+            const timeout = setTimeout(() => {
+                this.pendingIpcRequests.delete(fleetReqId);
+                respond(null, "Schedule operation timed out after 30s");
+            }, 30_000);
+            this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
+                clearTimeout(timeout);
+                respond(respMsg.result, respMsg.error);
+            });
+            return;
+        }
+        if (CROSS_INSTANCE_TOOLS.has(tool)) {
+            // Route to fleet manager via IPC (topic mode only)
+            if (this.topicMode && this.ipcServer) {
+                // Use fleetRequestId (not requestId) to avoid MCP server resolving the
+                // pending tool call prematurely when it receives the broadcast.
+                const fleetReqId = `xmsg_${requestId}`;
+                const senderSessionName = this.socketSessionNames.get(socket);
+                this.ipcServer.broadcast({
+                    type: "fleet_outbound",
+                    tool,
+                    args,
+                    fleetRequestId: fleetReqId,
+                    senderSessionName,
+                });
+                const crossTimeoutMs = (tool === "start_instance" || tool === "create_instance" || tool === "replace_instance") ? 60_000 : 30_000;
+                const timeout = setTimeout(() => {
+                    this.pendingIpcRequests.delete(fleetReqId);
+                    respond(null, `Cross-instance operation timed out after ${crossTimeoutMs / 1000}s`);
+                }, crossTimeoutMs);
+                this.pendingIpcRequests.set(fleetReqId, (respMsg) => {
+                    clearTimeout(timeout);
+                    respond(respMsg.result, respMsg.error);
+                });
+            }
+            else {
+                respond(null, "Cross-instance messaging requires topic mode");
+            }
+            return;
+        }
+        // Context-bound routing: reply/react/edit_message always use the daemon's last known context.
+        // chat_id and thread_id are not exposed in the tool schema — daemon is solely responsible for routing.
+        // Must run before IPC forwarding so topic-mode (fleet manager) also receives the correct chat_id.
+        if (["reply", "react", "edit_message"].includes(tool)) {
+            if (!this.lastChatId) {
+                respond(null, "No active chat context — awaiting inbound message");
+                return;
+            }
+            args.chat_id = this.lastChatId;
+            if (tool === "reply")
+                args.thread_id = this.lastThreadId;
+        }
+        // Route to adapter via MessageBus
+        const adapters = this.messageBus.getAllAdapters();
+        if (adapters.length === 0) {
+            // Topic mode: forward to fleet manager via IPC (fleet manager connected as IPC client)
+            // The fleet manager's IPC client receives this and routes to shared adapter.
+            // Use fleetRequestId (not requestId) to avoid other MCP sessions on this daemon
+            // from prematurely resolving their pending requests when they receive the broadcast.
+            const fleetReqId = `tool_${requestId}`;
+            const outboundKey = fleetReqId;
+            this.ipcServer?.broadcast({ type: "fleet_outbound", tool, args, fleetRequestId: fleetReqId });
+            const timeout = setTimeout(() => {
+                this.pendingIpcRequests.delete(outboundKey);
+                respond(null, "Fleet outbound timed out after 30s");
+            }, 30_000);
+            this.pendingIpcRequests.set(outboundKey, (respMsg) => {
+                clearTimeout(timeout);
+                respond(respMsg.result, respMsg.error);
+            });
+            return;
+        }
+        const adapter = adapters[0];
+        if (!routeToolCall(adapter, tool, args, this.lastThreadId, respond)) {
+            respond(null, `Unknown tool: ${tool}`);
+        }
+    }
+    /** Build config object for the CLI backend */
+    buildBackendConfig() {
+        const isCliMode = this.config.agent_mode === "cli";
+        const sockPath = join(this.instanceDir, "channel.sock");
+        let serverJs = join(__dirname, "channel", "mcp-server.js");
+        if (!existsSync(serverJs)) {
+            serverJs = join(__dirname, "..", "dist", "channel", "mcp-server.js");
+        }
+        // ── Resolve workflow and systemPrompt once, share between MCP env and instructions ──
+        let resolvedWorkflow;
+        if (this.config.workflow === false) {
+            resolvedWorkflow = false;
+        }
+        else {
+            const wf = this.config.workflow ?? "builtin";
+            if (wf !== "builtin") {
+                let content = wf;
+                if (content.startsWith("file:")) {
+                    try {
+                        content = readFileSync(content.slice(5), "utf-8");
+                    }
+                    catch {
+                        content = "";
+                    }
+                }
+                resolvedWorkflow = content || undefined;
+            }
+        }
+        let resolvedCustomPrompt;
+        if (this.config.systemPrompt) {
+            // Support comma-separated file: paths for prompt modularization:
+            //   systemPrompt: "file:prompts/role.md, file:prompts/rules.md, file:prompts/context.md"
+            const parts = this.config.systemPrompt.split(",").map((s) => s.trim());
+            const resolved = parts.map((part) => {
+                if (part.startsWith("file:")) {
+                    try {
+                        return readFileSync(part.slice(5), "utf-8");
+                    }
+                    catch {
+                        return "";
+                    }
+                }
+                return part;
+            }).filter(Boolean);
+            if (resolved.length > 0)
+                resolvedCustomPrompt = resolved.join("\n\n");
+        }
+        let decisions;
+        if (process.env.AGEND_DECISIONS) {
+            try {
+                decisions = JSON.parse(process.env.AGEND_DECISIONS);
+            }
+            catch (err) {
+                this.logger.warn({ err }, "AGEND_DECISIONS env var is not valid JSON — decisions will not be injected");
+            }
+        }
+        // ── MCP server env (dual-track: still passes env vars for MCP instructions fallback) ──
+        const mcpEnv = {
+            AGEND_SOCKET_PATH: sockPath,
+            AGEND_INSTANCE_NAME: this.name,
+            AGEND_WORKING_DIR: this.config.working_directory,
+        };
+        if (this.config.tool_set)
+            mcpEnv.AGEND_TOOL_SET = this.config.tool_set;
+        if (this.config.display_name)
+            mcpEnv.AGEND_DISPLAY_NAME = this.config.display_name;
+        if (this.config.description)
+            mcpEnv.AGEND_DESCRIPTION = this.config.description;
+        if (resolvedWorkflow === false)
+            mcpEnv.AGEND_WORKFLOW = "false";
+        else if (resolvedWorkflow)
+            mcpEnv.AGEND_WORKFLOW = resolvedWorkflow;
+        if (resolvedCustomPrompt)
+            mcpEnv.AGEND_CUSTOM_PROMPT = resolvedCustomPrompt;
+        if (process.env.AGEND_DECISIONS)
+            mcpEnv.AGEND_DECISIONS = process.env.AGEND_DECISIONS;
+        // ── Fleet instructions for additive system prompt injection ──
+        let instructions;
+        if (isCliMode) {
+            // CLI mode: inject CLI quick reference instead of MCP tool schema
+            let cliRef = "";
+            try {
+                const cliInstrPath = join(__dirname, "agent-cli-instructions.md");
+                if (!existsSync(cliInstrPath)) {
+                    const altPath = join(__dirname, "..", "dist", "agent-cli-instructions.md");
+                    if (existsSync(altPath))
+                        cliRef = readFileSync(altPath, "utf-8");
+                }
+                else {
+                    cliRef = readFileSync(cliInstrPath, "utf-8");
+                }
+            }
+            catch { /* fallback to empty */ }
+            instructions = buildFleetInstructions({
+                instanceName: this.name,
+                workingDirectory: this.config.working_directory,
+                displayName: this.config.display_name,
+                description: this.config.description,
+                customPrompt: resolvedCustomPrompt,
+                workflow: resolvedWorkflow,
+                decisions,
+                cliInstructions: cliRef || undefined,
+            });
+        }
+        else {
+            instructions = buildFleetInstructions({
+                instanceName: this.name,
+                workingDirectory: this.config.working_directory,
+                displayName: this.config.display_name,
+                description: this.config.description,
+                customPrompt: resolvedCustomPrompt,
+                workflow: resolvedWorkflow,
+                decisions,
+            });
+        }
+        const agentPort = parseInt(process.env.AGEND_PORT ?? "19280", 10);
+        return {
+            workingDirectory: this.config.working_directory,
+            instanceDir: this.instanceDir,
+            instanceName: this.name,
+            mcpServers: isCliMode ? {} : {
+                "agend": {
+                    command: "node",
+                    args: [serverJs],
+                    env: mcpEnv,
+                },
+            },
+            skipPermissions: this.config.skipPermissions,
+            model: this.modelOverride ?? this.config.model,
+            skipResume: this.skipResume,
+            instructions,
+            agentMode: isCliMode ? "cli" : "mcp",
+            agentPort: isCliMode ? agentPort : undefined,
+        };
+    }
+    /**
+     * After CLI is ready, paste any pending session snapshot as the first
+     * user input so the agent picks up where the previous session left off.
+     * This replaces the old system-prompt injection approach.
+     */
+    async injectSnapshotMessage() {
+        if (this.snapshotConsumed)
+            return;
+        const snapshot = this.buildSnapshotPrompt();
+        if (!snapshot || !this.tmux)
+            return;
+        if (this.pendingInstructionsUpdate) {
+            writeFileSync(join(this.instanceDir, "prev-instructions"), this.pendingInstructionsUpdate);
+            this.pendingInstructionsUpdate = undefined;
+        }
+        // Small delay to let the CLI fully render its ready prompt
+        await new Promise(r => setTimeout(r, 1_000));
+        try {
+            await this.tmux.pasteText(`[system:session-snapshot]\n${snapshot}\n\nThis is a background context restore — do NOT reply to or acknowledge this message. Simply resume normal operation when the next user or instance message arrives.`);
+            this.logger.info("Injected session snapshot as first message");
+            this.emit("snapshot_injected", this.name);
+        }
+        catch (err) {
+            this.logger.error({ err }, "Snapshot injection failed — session continues without context");
+            this.emit("snapshot_failed", this.name);
+        }
+    }
+    /** Spawn a CLI window. Returns true if --resume was used successfully. */
+    async spawnClaudeWindow() {
+        this.spawning = true;
+        let resumedSuccessfully = false;
+        try {
+            this.toolStatusLines = [];
+            this.toolStatusMessageId = null;
+            if (!this.backend) {
+                throw new Error("No backend configured — cannot spawn CLI window");
+            }
+            const attemptedResume = !this.skipResume;
+            const alive = await this.trySpawn();
+            if (!alive) {
+                // First attempt failed (stale --resume, crash, rate limit, etc.)
+                // Clean slate: clear session-id, skip resume, and retry once.
+                this.logger.warn("CLI startup failed — clearing session-id and retrying without resume");
+                const sidFile = join(this.instanceDir, "session-id");
+                try {
+                    unlinkSync(sidFile);
+                }
+                catch { /* may not exist */ }
+                this.skipResume = true;
+                await this.killProcessTree();
+                await this.tmux.killWindow();
+                const retryAlive = await this.trySpawn();
+                if (!retryAlive) {
+                    await this.killProcessTree();
+                    await this.tmux.killWindow();
+                    throw new Error("CLI failed to start after retry");
+                }
+            }
+            else if (attemptedResume) {
+                resumedSuccessfully = true;
+            }
+            this.lastSpawnAt = Date.now();
+            this.skipResume = false; // CLI started successfully — reset for next spawn
+        }
+        finally {
+            this.spawning = false;
+        }
+        return resumedSuccessfully;
+    }
+    /** Kill the entire process tree of the current tmux pane (CLI + MCP server). */
+    async killProcessTree() {
+        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");
+            }
+        }
+        catch { /* process group may not exist or already dead */ }
+    }
+    /**
+     * Spawn a CLI window and verify it reaches a ready state.
+     * Uses control mode to wait for output, then checks pane content.
+     * Handles confirmation dialogs (trust folder, bypass permissions).
+     * Returns true if CLI is ready, false if it failed or got stuck.
+     */
+    async trySpawn() {
+        const backendConfig = this.buildBackendConfig();
+        // Detect instructions change → notify agent on next message instead of
+        // forcing a new session. Resume is preserved so context isn't lost.
+        if (!backendConfig.skipResume && !this.backend.instructionsReloadedOnResume && backendConfig.instructions) {
+            const prevFile = join(this.instanceDir, "prev-instructions");
+            let prev = "";
+            try {
+                prev = readFileSync(prevFile, "utf-8");
+            }
+            catch { }
+            if (prev !== backendConfig.instructions) {
+                if (prev) {
+                    this.logger.info("Instructions changed — will notify agent on next message");
+                    this.pendingInstructionsNotice = true;
+                }
+                this.pendingInstructionsUpdate = backendConfig.instructions;
+            }
+        }
+        this.backend.writeConfig(backendConfig);
+        this.backend.preTrust?.(this.config.working_directory);
+        // Generate a fresh per-instance agent token each spawn. agent-cli reads
+        // this file from <instanceDir>/agent.token (mode 0o600) and sends its
+        // value in the X-Agend-Instance-Token header; the daemon-side /agent
+        // endpoint verifies it matches the on-disk value for the claimed
+        // instance. This prevents other local processes (even those holding
+        // the global web token) from impersonating instances.
+        const agentTokenPath = join(this.instanceDir, "agent.token");
+        const agentToken = randomBytes(32).toString("hex");
+        writeFileSync(agentTokenPath, agentToken, { mode: 0o600 });
+        try {
+            chmodSync(agentTokenPath, 0o600);
+        }
+        catch { }
+        // AGEND_HOME points the child's agent-cli at the same data dir the daemon
+        // is using, so it can locate <instanceDir>/agent.token.
+        const agendHome = join(this.instanceDir, "..", "..");
+        let envPrefix = `TERM=xterm-256color AGEND_INSTANCE_NAME=${shellQuote(this.name)} AGEND_HOME=${shellQuote(agendHome)}`;
+        if (backendConfig.agentMode === "cli" && backendConfig.agentPort) {
+            envPrefix += ` AGEND_PORT=${backendConfig.agentPort}`;
+        }
+        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, this.config.working_directory, 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");
+        });
+        // 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 outputTimeout = Math.round(total * 0.6);
+            const idleTimeout = total - outputTimeout;
+            const hasOutput = await this.controlClient.waitForOutput(windowId, outputTimeout);
+            if (!hasOutput) {
+                // Fallback: some TUI backends (e.g. opencode) don't trigger tmux %output events.
+                // Check pane content directly for ready pattern before giving up.
+                const pane = await this.tmux.capturePane();
+                if (!this.backend.getReadyPattern().test(pane))
+                    return false;
+            }
+            else {
+                await this.controlClient.waitForIdle(windowId, idleTimeout);
+            }
+        }
+        else {
+            await new Promise(r => setTimeout(r, 10_000));
+        }
+        // Dismiss confirmation dialogs and verify CLI reached prompt.
+        // With remain-on-exit, isWindowAlive() returns true even for dead panes,
+        // but a startup crash would already be caught by waitForOutput/waitForIdle above.
+        if (!await this.tmux.isWindowAlive())
+            return false;
+        return this.dismissDialogsUntilReady(3);
+    }
+    /**
+     * Repeatedly check pane content, dismiss any confirmation dialogs,
+     * and return true once CLI reaches a ready prompt.
+     */
+    async dismissDialogsUntilReady(maxAttempts) {
+        // Backend-specific startup dialogs, with hardcoded fallback for backward compat
+        const startupDialogs = this.backend?.getStartupDialogs?.() ?? [
+            { pattern: /[❯›]\s*\d+\.\s*No/m, keys: ["Down", "Enter"], description: "Confirmation dialog — navigate past No" },
+            { pattern: /[❯›]\s*Don't trust/m, keys: ["Up", "Up", "Enter"], description: "Trust dialog — navigate to trust option" },
+            { pattern: /No, exit|No, quit|Don't trust|I accept|I trust|Yes, continue|Trust folder/i, keys: ["Enter"], description: "Generic confirmation dialog" },
+            { pattern: /Resume Session/i, keys: ["Escape"], description: "Resume session picker — start fresh" },
+        ];
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const pane = await this.tmux.capturePane();
+                // Try each startup dialog pattern before checking ready state
+                let matched = false;
+                for (const dialog of startupDialogs) {
+                    if (dialog.pattern.test(pane)) {
+                        this.logger.debug(`Dismissing startup dialog: ${dialog.description}`);
+                        for (const key of dialog.keys) {
+                            if (key === "Up" || key === "Down" || key === "Enter" || key === "Escape") {
+                                await this.tmux.sendSpecialKey(key);
+                            }
+                            else {
+                                await this.tmux.sendKeys(key);
+                            }
+                            await new Promise(r => setTimeout(r, 200));
+                        }
+                        // Wait for next screen to render
+                        if (this.controlClient) {
+                            const wid = readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();
+                            await this.controlClient.waitForIdle(wid, 10_000);
+                        }
+                        else {
+                            await new Promise(r => setTimeout(r, 3_000));
+                        }
+                        if (!await this.tmux.isWindowAlive())
+                            return false;
+                        matched = true;
+                        break;
+                    }
+                }
+                if (matched)
+                    continue;
+                // CLI is ready (pattern defined by each backend)
+                if (this.backend.getReadyPattern().test(pane))
+                    return true;
+                // Fatal: command not found (must match full phrase to avoid false positives
+                // like Kiro's "agent X not found, using default")
+                if (/command not found|: not found$/m.test(pane))
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        // Exhausted attempts — assume ok for unknown CLI prompts
+        return true;
+    }
+    saveSessionId() {
+        const sid = this.backend?.getSessionId();
+        if (sid) {
+            writeFileSync(join(this.instanceDir, "session-id"), sid);
+        }
+    }
+    readContextPercentage() {
+        return this.backend?.getContextUsage() ?? 0;
+    }
+    /** Set a model override for next spawn (used by failover logic) */
+    setModelOverride(model) {
+        this.modelOverride = model;
+    }
+    /** Get the currently active model override */
+    getModelOverride() {
+        return this.modelOverride;
+    }
+    /** Public wrapper for graceful restart — wait for instance to be idle. */
+    waitForIdle(quietMs = 5000) {
+        return new Promise((resolve) => {
+            const monitor = this.transcriptMonitor;
+            // No transcript monitor (e.g. lightweight mode) — no events to wait for.
+            if (!monitor) {
+                setTimeout(resolve, quietMs);
+                return;
+            }
+            const events = ["tool_use", "tool_result", "assistant_text"];
+            let timer;
+            let settled = false;
+            const done = () => {
+                if (settled)
+                    return;
+                settled = true;
+                // Always remove from the same monitor we registered on — avoids
+                // imbalance if this.transcriptMonitor is later reassigned.
+                events.forEach(e => monitor.removeListener(e, reset));
+                resolve();
+            };
+            const reset = () => {
+                clearTimeout(timer);
+                timer = setTimeout(done, quietMs);
+            };
+            timer = setTimeout(done, quietMs);
+            events.forEach(e => monitor.on(e, reset));
+        });
+    }
+    // ── Context Rotation v3: Ring buffers ─────────────────────────
+    recordRecentUserMessage(content, meta) {
+        // Only record real user messages, not cross-instance messages
+        if (!meta.user || meta.user.startsWith("instance:"))
+            return;
+        this.recentUserMessages.push({
+            text: content.slice(0, 200),
+            ts: meta.ts ?? new Date().toISOString(),
+        });
+        if (this.recentUserMessages.length > 10)
+            this.recentUserMessages.shift();
+    }
+    recordRecentEvent(event) {
+        this.recentEvents.push(event);
+        if (this.recentEvents.length > 15)
+            this.recentEvents.shift();
+    }
+    recordRecentToolActivity(summary) {
+        if (!summary)
+            return;
+        this.recentToolActivity.push(summary);
+        if (this.recentToolActivity.length > 10)
+            this.recentToolActivity.shift();
+    }
+    // ── Context Rotation v3: Snapshot writer ──────────────────────
+    writeRotationSnapshot(reason) {
+        const statusline = this.readStatuslineData();
+        const snapshot = {
+            instance: this.name,
+            reason,
+            created_at: new Date().toISOString(),
+            working_directory: this.config.working_directory,
+            session_id: this.backend?.getSessionId() ?? null,
+            context_pct: this.readContextPercentage(),
+            recent_user_messages: [...this.recentUserMessages],
+            recent_events: [...this.recentEvents],
+            recent_tool_activity: [...this.recentToolActivity],
+            last_statusline: statusline ? {
+                model: statusline.model?.display_name,
+                cost_usd: statusline.cost?.total_cost_usd,
+                five_hour_pct: statusline.rate_limits?.five_hour?.used_percentage,
+                seven_day_pct: statusline.rate_limits?.seven_day?.used_percentage,
+            } : undefined,
+        };
+        const snapshotPath = join(this.instanceDir, "rotation-state.json");
+        writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+        this.snapshotConsumed = false;
+        this.logger.info({
+            reason,
+            context_pct: snapshot.context_pct,
+            user_msg_count: snapshot.recent_user_messages?.length ?? 0,
+            event_count: snapshot.recent_events?.length ?? 0,
+        }, "Snapshot written");
+        return snapshot;
+    }
+    /** Collect ring buffer data for handover to a replacement instance. */
+    collectHandoverContext() {
+        const lines = [];
+        if (this.recentUserMessages.length > 0) {
+            lines.push("Recent user messages:");
+            for (const msg of this.recentUserMessages)
+                lines.push(`- ${msg.text}`);
+            lines.push("");
+        }
+        if (this.recentEvents.length > 0) {
+            lines.push("Recent activity:");
+            for (const ev of this.recentEvents) {
+                if (ev.type === "assistant_text")
+                    lines.push(`- Assistant: ${ev.preview}`);
+                else
+                    lines.push(`- ${ev.name}${ev.preview ? `: ${ev.preview}` : ""}`);
+            }
+            lines.push("");
+        }
+        if (this.recentToolActivity.length > 0) {
+            lines.push("Recent tool activity:");
+            for (const t of this.recentToolActivity)
+                lines.push(`- ${t}`);
+            lines.push("");
+        }
+        const pct = this.readContextPercentage();
+        if (pct != null)
+            lines.push(`Context usage: ${pct}%`);
+        return lines.join("\n").slice(0, 4000);
+    }
+    appendCrashHistory(data) {
+        try {
+            const historyPath = join(this.instanceDir, "crash-history.jsonl");
+            const entry = {
+                timestamp: new Date().toISOString(),
+                instance: this.name,
+                crashType: data.crashType,
+                exitCode: data.exitCode,
+                lastOutput: data.lastOutput,
+                crashCount: this.crashCount + 1,
+                crashesInWindow: this.crashTimestamps.length,
+            };
+            appendFileSync(historyPath, JSON.stringify(entry) + "\n");
+            // Rotate based on file size (cheaper than parsing every time)
+            try {
+                const stat = statSync(historyPath);
+                if (stat.size > 512_000) {
+                    const content = readFileSync(historyPath, "utf-8");
+                    const lines = content.trim().split("\n").filter(Boolean);
+                    writeFileSync(historyPath, lines.slice(-50).join("\n") + "\n");
+                }
+            }
+            catch { /* best effort */ }
+        }
+        catch { /* best effort */ }
+    }
+    readStatuslineData() {
+        try {
+            const sf = join(this.instanceDir, "statusline.json");
+            return JSON.parse(readFileSync(sf, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Repo Checkout ─────────────────────────────────────────
+    async handleCheckoutRepo(args, respond) {
+        const { execFile: execFileCb } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execFileAsync = promisify(execFileCb);
+        const rawSource = args.source;
+        if (!rawSource) {
+            respond(null, "checkout_repo: missing required argument 'source'");
+            return;
+        }
+        const expanded = rawSource.replace(/^~/, process.env.HOME || "~");
+        // Resolve instance name to working_directory via IPC query
+        // If source doesn't look like a path, treat it as an instance name
+        if (!expanded.startsWith("/")) {
+            // Broadcast to get instance info — but we don't have fleet config in daemon.
+            // Instead, rely on fleet manager to resolve. For now, reject non-path sources.
+            respond(null, `Source must be an absolute path or ~-prefixed path. Use describe_instance to find a repo's working_directory.`);
+            return;
+        }
+        // Normalize to collapse any `..` segments.
+        const source = resolve(expanded);
+        const branch = args.branch || "HEAD";
+        // Validate branch ref: git refs allow [A-Za-z0-9._/-], reject `..` to prevent
+        // worktreePath escape via basename(source)-${branch.replace("/", "-")}.
+        // Reject leading `-` or `+` so git cannot interpret the value as an option
+        // flag (e.g. `--upload-pack=...`), which execFile cannot prevent on its own.
+        if (!/^[A-Za-z0-9._/-]+$/.test(branch) || branch.includes("..") || /^[-+]/.test(branch)) {
+            respond(null, `Invalid branch name: ${branch}`);
+            return;
+        }
+        // Verify it's a git repo
+        try {
+            await execFileAsync("git", ["rev-parse", "--git-dir"], { cwd: source });
+        }
+        catch {
+            respond(null, `Not a git repository: ${source}`);
+            return;
+        }
+        const repoDir = join(this.instanceDir, "repos");
+        mkdirSync(repoDir, { recursive: true });
+        const safeName = `${basename(source)}-${branch.replace(/\//g, "-")}`;
+        const worktreePath = join(repoDir, safeName);
+        try {
+            // Resolve branch/ref to verify it exists. Use `--` so git never treats
+            // branch as an option flag (defense in depth on top of the regex above).
+            await execFileAsync("git", ["rev-parse", "--verify", "--", branch], { cwd: source });
+            await execFileAsync("git", ["worktree", "add", "--detach", worktreePath, branch], { cwd: source });
+            const { stdout: commitHash } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd: worktreePath });
+            respond({ path: worktreePath, branch, source, commit: commitHash.trim() });
+        }
+        catch (err) {
+            respond(null, `Failed to checkout: ${err.message}`);
+        }
+    }
+    async handleReleaseRepo(args, respond) {
+        const repoPath = args.path;
+        const reposDir = join(this.instanceDir, "repos");
+        // Safety: only allow releasing paths under our repos/ directory
+        if (!repoPath.startsWith(reposDir)) {
+            respond(null, `Cannot release path outside instance repos directory`);
+            return;
+        }
+        try {
+            const { execFile: execFileCb } = await import("node:child_process");
+            const { promisify } = await import("node:util");
+            const execFileAsync = promisify(execFileCb);
+            await execFileAsync("git", ["worktree", "remove", "--force", repoPath]);
+        }
+        catch {
+            // Fallback: rm directly if git worktree remove fails
+            try {
+                rmSync(repoPath, { recursive: true, force: true });
+            }
+            catch { /* best effort */ }
+        }
+        respond({ released: true, path: repoPath });
+    }
+    buildSnapshotPrompt() {
+        const snapshotPath = join(this.instanceDir, "rotation-state.json");
+        try {
+            if (!existsSync(snapshotPath))
+                return null;
+            const snapshot = JSON.parse(readFileSync(snapshotPath, "utf-8"));
+            // Mark consumed in-memory to prevent re-injection on crash respawn.
+            // Delete file so subsequent daemon restarts don't re-inject stale snapshot.
+            this.snapshotConsumed = true;
+            try {
+                unlinkSync(snapshotPath);
+            }
+            catch { /* best effort */ }
+            const lines = ["## Previous Session Snapshot", ""];
+            lines.push(`Restart reason: ${snapshot.reason}`);
+            if (snapshot.context_pct != null)
+                lines.push(`Previous context usage: ${snapshot.context_pct}%`);
+            if (snapshot.session_id)
+                lines.push(`Previous session id: ${snapshot.session_id}`);
+            lines.push(`Working directory: ${snapshot.working_directory}`);
+            lines.push("");
+            if (snapshot.recent_user_messages && snapshot.recent_user_messages.length > 0) {
+                lines.push("Recent user messages:");
+                for (const msg of snapshot.recent_user_messages) {
+                    lines.push(`- ${msg.text}`);
+                }
+                lines.push("");
+            }
+            if (snapshot.recent_events && snapshot.recent_events.length > 0) {
+                lines.push("Recent activity:");
+                for (const ev of snapshot.recent_events) {
+                    if (ev.type === "assistant_text") {
+                        lines.push(`- Assistant: ${ev.preview}`);
+                    }
+                    else {
+                        lines.push(`- ${ev.name}${ev.preview ? `: ${ev.preview}` : ""}`);
+                    }
+                }
+                lines.push("");
+            }
+            lines.push("Instruction:");
+            lines.push("Resume work from this snapshot when relevant. Do not assume anything not stated here.");
+            // Enforce 2000-char budget
+            let result = lines.join("\n");
+            if (result.length > 2000) {
+                result = result.slice(0, 1997) + "...";
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=daemon.js.map