codedeck 0.7.1 → 0.7.3

package/dist/daemon/daemon.js

@@ -19,9 +19,10 @@ import { getDiff } from "../git/diff.js";
 import { killTree, processAlive, processStartTime, sleep } from "../utils/process.js";
 import { readSessionProcessMetadata } from "../drivers/session-runtime.js";
 import { loadConfig, resolveDefaultSandbox } from "../config/config.js";
+import { buildAutoResumePrompt, isAutoResumeEligible } from "./auto-resume.js";
 import { invalidWebHostMessage, resolveWebHost } from "../config/web-host.js";
 import { invalidWebPortMessage, resolveWebPort } from "../config/web-port.js";
-import { classifyFailure, isStoreBusy, RunAgentError } from "../core/errors.js";
+import { classifyFailure, errorMessage, isStoreBusy, CodedeckError } from "../core/errors.js";
 import { parseRole } from "../core/roles.js";
 import { getCachedOrDiscoverModels } from "../core/models.js";
 import { aggregateRunUsage } from "../core/run-usage.js";
@@ -97,10 +98,12 @@ class Daemon {
     nativeLinks;
     registry = getRegistry();
     server;
+    boundPaths;
     subscribers = new Map(); // sessionId -> sockets
     startTime = Date.now();
     startupReconcilePromise = Promise.resolve();
     sessionLocks = new Set();
+    autoResumeStarted = false;
     reservedSessionIds = new Set();
     // Sessions recover() revived from a store-busy failure: the sequence the
     // drain starts after, and the log mtime when the harness is already dead.
@@ -261,7 +264,7 @@ class Daemon {
     queueReleasedTranscriptCursorCleanup(sessionId) {
         queueMicrotask(() => {
             void this.cleanupReleasedTranscriptCursors(sessionId).catch((error) => {
-                const detail = error instanceof Error ? error.message : String(error);
+                const detail = errorMessage(error);
                 try {
                     fs.appendFileSync(getPaths().daemonLog, `[${new Date().toISOString()}] usage cursor cleanup failed session=${sessionId}: ${detail}\n`);
                 }
@@ -315,7 +318,7 @@ class Daemon {
                 await this.handleRequest(req, socket);
             }
             catch (e) {
-                const res = { id: req.id, error: { code: "INTERNAL", message: e instanceof Error ? e.message : String(e) } };
+                const res = { id: req.id, error: { code: "INTERNAL", message: errorMessage(e) } };
                 try {
                     socket.write(JSON.stringify(res) + "\n");
                 }
@@ -326,6 +329,10 @@ class Daemon {
             this.server.listen(paths.daemonSock, () => resolve());
             this.server.on("error", reject);
         });
+        this.boundPaths = {
+            sock: paths.daemonSock,
+            pid: paths.daemonPid,
+        };
         // Write pid file
         try {
             fs.writeFileSync(paths.daemonPid, String(process.pid), "utf-8");
@@ -349,6 +356,102 @@ class Daemon {
             fs.appendFileSync(paths.daemonLog, `[${new Date().toISOString()}] daemon started pid=${process.pid}\n`);
         }
         catch { }
+        this.startAutoResume();
+    }
+    startAutoResume() {
+        if (this.autoResumeStarted)
+            return;
+        this.autoResumeStarted = true;
+        const config = loadConfig().autoResume;
+        if (config?.enabled !== true)
+            return;
+        const maxAgeHours = typeof config.maxAgeHours === "number" && Number.isFinite(config.maxAgeHours)
+            ? config.maxAgeHours
+            : 24;
+        void this.autoResumeInterruptedSessions(maxAgeHours).catch((error) => {
+            appendDaemonLog(`auto-resume boot scan failed: ${errorMessage(error)}`);
+        });
+    }
+    async autoResumeInterruptedSessions(maxAgeHours) {
+        const ids = this.db.getHandle().prepare("SELECT id FROM sessions WHERE status = 'interrupted' ORDER BY updated_at ASC").all();
+        for (const { id } of ids) {
+            if (this.shuttingDown)
+                break;
+            const session = this.sessions.getExact(id);
+            if (!session)
+                continue;
+            let driver;
+            try {
+                driver = this.registry.get(session.agent);
+            }
+            catch (error) {
+                appendDaemonLog(`auto-resume failed for ${session.id}: ${errorMessage(error)}`);
+                continue;
+            }
+            if (!isAutoResumeEligible(session, {
+                now: new Date(),
+                maxAgeHours,
+                canResume: driver.capabilities().resume,
+                liveIdentity: livePidIdentity(session),
+            }))
+                continue;
+            if (this.sessionLocks.has(session.id))
+                continue;
+            const workingDirectory = session.worktree || session.cwd;
+            if (!fs.existsSync(workingDirectory)) {
+                appendDaemonLog(`auto-resume skipped ${session.id}: working directory missing (${workingDirectory})`);
+                continue;
+            }
+            this.sessionLocks.add(session.id);
+            const pendingMessage = session.pendingMessage;
+            const pendingAt = session.pendingAt;
+            try {
+                try {
+                    this.sessions.update(session.id, { pendingMessage: null, pendingAt: null });
+                }
+                catch { }
+                await this.runResumeTurn(session, buildAutoResumePrompt(session.pendingMessage));
+                appendDaemonLog(`auto-resume started session ${session.id}`);
+            }
+            catch (error) {
+                try {
+                    if (pendingMessage) {
+                        this.sessions.update(session.id, {
+                            pendingMessage,
+                            pendingAt: pendingAt ?? new Date().toISOString(),
+                        });
+                    }
+                }
+                catch { }
+                if (this.shuttingDown || error?.code === "SERVICE_UNAVAILABLE") {
+                    appendDaemonLog(`auto-resume paused for ${session.id}: daemon is shutting down`);
+                    break;
+                }
+                const message = errorMessage(error);
+                const failure = classifyFailure(message);
+                const failedEvent = {
+                    type: "session.failed",
+                    sessionId: session.id,
+                    timestamp: new Date().toISOString(),
+                    error: message,
+                    failure,
+                };
+                try {
+                    this.events.append(session.id, failedEvent);
+                }
+                catch { }
+                this.broadcast(session.id, failedEvent);
+                try {
+                    this.sessions.setStatus(session.id, "failed", { lastEvent: message.slice(0, 200), failure });
+                }
+                catch { }
+                appendDaemonLog(`auto-resume failed for ${session.id}: ${errorMessage(error)}`);
+            }
+            finally {
+                if (!this.shuttingDown)
+                    this.sessionLocks.delete(session.id);
+            }
+        }
     }
     // Sessions whose detached process outlived the daemon are RE-ATTACHED, not
     // orphaned: the process is independent (own process group, output in log
@@ -554,7 +657,7 @@ class Daemon {
                 this.sessions.update(sessionId, { completedAt: heal.endedAt });
         }
         catch (error) {
-            appendDaemonLog(`heal timestamps for ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
+            appendDaemonLog(`heal timestamps for ${sessionId} failed: ${errorMessage(error)}`);
         }
     }
     async reconcileOpenUsage(sessionId, nativeIds) {
@@ -605,7 +708,7 @@ class Daemon {
             return true;
         }
         catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
+            const detail = errorMessage(error);
             try {
                 fs.appendFileSync(getPaths().daemonLog, `[${new Date().toISOString()}] usage reconcile failed session=${sessionId}: ${detail}\n`);
             }
@@ -626,6 +729,23 @@ class Daemon {
     releaseSessionId(sessionId) {
         this.reservedSessionIds.delete(sessionId);
     }
+    resolveRegisteredAgent(rawAgent) {
+        const agent = (normalizeAgentId(rawAgent) ?? rawAgent);
+        return { agent, registered: this.registry.has(agent) };
+    }
+    handleClaimRequest(requestedSessionId, operation, result, send) {
+        try {
+            const sessionId = this.sessions.get(requestedSessionId)?.id ?? requestedSessionId;
+            send(result(operation(sessionId)));
+        }
+        catch (error) {
+            if (error instanceof CodedeckError) {
+                send({ error: { code: error.code, message: error.message, details: error.details } });
+                return;
+            }
+            throw error;
+        }
+    }
     async handleRequest(req, socket) {
         const { id, method, params } = req;
         const send = (res) => {
@@ -634,11 +754,13 @@ class Daemon {
             }
             catch { }
         };
+        const sendSessionNotFound = (sessionId) => send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${sessionId} not found` } });
+        const sendShuttingDown = () => send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
         // Power-shutdown guard: while draining, refuse new work so a send/stop
         // cannot race the interrupted persist. daemon.stop is the shutdown
         // trigger itself, so it stays admitted (idempotent via handleShutdown).
         if (this.shuttingDown && method !== "daemon.stop") {
-            send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+            sendShuttingDown();
             return;
         }
         try {
@@ -653,8 +775,8 @@ class Daemon {
                     const cwdIn = p.cwd || process.cwd();
                     const cfg = loadConfig();
                     const rawAgent = p.agent || cfg.defaultAgent || "claude";
-                    let agent = (normalizeAgentId(rawAgent) ?? rawAgent);
-                    if (!this.registry.has(agent)) {
+                    const { agent, registered } = this.resolveRegisteredAgent(rawAgent);
+                    if (!registered) {
                         send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
                         return;
                     }
@@ -682,7 +804,7 @@ class Daemon {
                     }
                     if (this.shuttingDown) {
                         this.releaseSessionId(sessionId);
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                        sendShuttingDown();
                         return;
                     }
                     if (gitInfo)
@@ -694,7 +816,7 @@ class Daemon {
                             const wt = await createWorktree({ repoRoot: gitInfo.root, sessionId, prompt, name: p.name });
                             if (this.shuttingDown) {
                                 this.releaseSessionId(sessionId);
-                                send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                                sendShuttingDown();
                                 return;
                             }
                             worktree = wt.path;
@@ -704,7 +826,7 @@ class Daemon {
                         }
                         catch (e) {
                             this.releaseSessionId(sessionId);
-                            send({ error: { code: "WORKTREE_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                            send({ error: { code: "WORKTREE_FAILED", message: errorMessage(e) } });
                             return;
                         }
                     }
@@ -741,13 +863,12 @@ class Daemon {
                         this.releaseSessionId(sessionId);
                     }
                     // Start driver async (don't block response too long)
-                    // But we need to start before returning? Return quickly then start
                     send({ result: { session } });
                     // Now start driver in background
                     this.startDriverForSession(sessionId, prompt, p.model).catch((e) => {
                         if (this.shuttingDown)
                             return;
-                        const msg = e instanceof Error ? e.message : String(e);
+                        const msg = errorMessage(e);
                         const failure = classifyFailure(msg);
                         const failEv = {
                             type: "session.failed",
@@ -769,8 +890,8 @@ class Daemon {
                     const p = params;
                     const cwdIn = p.cwd || process.cwd();
                     const rawAgent = p.agent || "claude";
-                    const agent = (normalizeAgentId(rawAgent) ?? rawAgent);
-                    if (!this.registry.has(agent)) {
+                    const { agent, registered } = this.resolveRegisteredAgent(rawAgent);
+                    if (!registered) {
                         send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
                         return;
                     }
@@ -779,7 +900,7 @@ class Daemon {
                     let baseCommit = p.baseCommit;
                     const gitInfo = await getGitInfo(cwd);
                     if (this.shuttingDown) {
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                        sendShuttingDown();
                         return;
                     }
                     const matchingSession = typeof p.resume === "string" && p.resume.length > 0
@@ -808,8 +929,7 @@ class Daemon {
                             agent,
                             nativeSessionId: p.resume,
                         };
-                        this.events.append(revived.id, event);
-                        this.broadcast(revived.id, event);
+                        this.emit(revived.id, event);
                         send({ result: { session: revived } });
                         break;
                     }
@@ -851,7 +971,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     let pidStartTime = p.pidStartTime;
@@ -884,7 +1004,7 @@ class Daemon {
                     }
                     const session = this.sessions.get(p.id);
                     if (!session) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     if (session.origin !== "open") {
@@ -901,7 +1021,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     // Release owns the terminal outcome: a queued message must not
@@ -953,8 +1073,7 @@ class Daemon {
                             timestamp: new Date().toISOString(),
                             reason: "released",
                         };
-                    this.events.append(s.id, ev);
-                    this.broadcast(s.id, ev);
+                    this.emit(s.id, ev);
                     const updated = this.sessions.get(s.id);
                     send({ result: { session: updated } });
                     break;
@@ -964,7 +1083,6 @@ class Daemon {
                     const all = p?.all;
                     const list = this.sessions.list(100, all).map(withLiveStatus);
                     const hidden = all ? 0 : this.sessions.countHiddenByWindow();
-                    // Enrich with last event?
                     send({ result: { sessions: list, hidden } });
                     break;
                 }
@@ -972,7 +1090,7 @@ class Daemon {
                     const p = params;
                     const stored = this.sessions.get(p.id);
                     if (!stored) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     const s = withLiveStatus(stored);
@@ -985,7 +1103,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     if (!p.name || !p.name.trim()) {
@@ -1006,7 +1124,7 @@ class Daemon {
                     const message = validated.message;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     if (s.origin === "open") {
@@ -1053,7 +1171,7 @@ class Daemon {
                             this.sessions.update(s.id, { pendingMessage: message, pendingAt });
                         }
                         catch (e) {
-                            send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                            send({ error: { code: "SEND_FAILED", message: errorMessage(e) } });
                             return;
                         }
                         const queuedEvent = {
@@ -1089,7 +1207,7 @@ class Daemon {
                         send({ result: { ok: true, queued: false } });
                     }
                     catch (e) {
-                        const errText = e instanceof Error ? e.message : String(e);
+                        const errText = errorMessage(e);
                         const code = e instanceof Error && e.code === "SERVICE_UNAVAILABLE"
                             ? "SERVICE_UNAVAILABLE"
                             : this.shuttingDown ? "SERVICE_UNAVAILABLE" : "SEND_FAILED";
@@ -1113,7 +1231,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     // Stop cancels a queued message on every exit (explicit cancel),
@@ -1126,10 +1244,7 @@ class Daemon {
                     }
                     const handle = driver.getHandle?.(s.id);
                     const hasRuntime = handle !== undefined;
-                    const liveIdentity = s.pid != null &&
-                        s.pidStartTime != null &&
-                        processAlive(s.pid) &&
-                        processStartTime(s.pid) === s.pidStartTime;
+                    const liveIdentity = livePidIdentity(s);
                     if (isTerminalStatus(s.status) && !hasRuntime && !liveIdentity) {
                         send({ error: { code: "SESSION_NOT_RUNNING", message: `Session ${s.id} is ${s.status}` } });
                         return;
@@ -1155,7 +1270,7 @@ class Daemon {
                             pidStartTime: s.pidStartTime,
                         });
                         if (this.shuttingDown) {
-                            send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                            sendShuttingDown();
                             return;
                         }
                         const last = this.events.last(s.id);
@@ -1177,8 +1292,7 @@ class Daemon {
                                 reason: "stopped",
                                 exitCode: 130,
                             };
-                            this.events.append(s.id, ev);
-                            this.broadcast(s.id, ev);
+                            this.emit(s.id, ev);
                         }
                         // A send may have persisted a slot after the entry clear (it saw a
                         // live turn before this stop took the lock): stop wins, clear again.
@@ -1187,14 +1301,14 @@ class Daemon {
                     }
                     catch (e) {
                         if (this.shuttingDown) {
-                            send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                            sendShuttingDown();
                             return;
                         }
                         try {
                             this.sessions.setStatus(s.id, previousStatus);
                         }
                         catch { }
-                        send({ error: { code: "STOP_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                        send({ error: { code: "STOP_FAILED", message: errorMessage(e) } });
                     }
                     finally {
                         if (!this.shuttingDown)
@@ -1206,7 +1320,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     if (p.follow) {
@@ -1230,7 +1344,7 @@ class Daemon {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     // A late subscriber must not wait forever for a broadcast that already
@@ -1250,23 +1364,14 @@ class Daemon {
                         catch { }
                         return;
                     }
-                    // Send buffered events first?
-                    // Then keep streaming
                     this.addSubscriber(s.id, socket);
-                    // Send ack? keep open
-                    // Optionally send done when session terminal? We'll handle via broadcast.
-                    // Don't send immediate response; just keep socket open for events
-                    // But we should send an initial ack to confirm subscription?
-                    // Use a separate message to indicate subscription started
-                    // Let's not send anything; client will just wait for events
-                    // Keep socket open
                     return;
                 }
                 case "session.diff": {
                     const p = params;
                     const s = this.sessions.get(p.id);
                     if (!s) {
-                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        sendSessionNotFound(p.id);
                         return;
                     }
                     const diff = await getDiff({ cwd: s.cwd, worktree: s.worktree, baseCommit: s.baseCommit, repository: s.repository });
@@ -1275,56 +1380,17 @@ class Daemon {
                 }
                 case "claims.add": {
                     const p = params;
-                    try {
-                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
-                        const claim = this.claims.add(sessionId, p.pathGlob, p.reason);
-                        send({ result: { claim } });
-                    }
-                    catch (error) {
-                        if (error instanceof RunAgentError) {
-                            send({ error: { code: error.code, message: error.message, details: error.details } });
-                            return;
-                        }
-                        throw error;
-                    }
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.add(sessionId, p.pathGlob, p.reason), (claim) => ({ result: { claim } }), send);
                     break;
                 }
                 case "claims.query": {
                     const p = params;
-                    try {
-                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
-                        const claims = this.claims.query(sessionId, p.path);
-                        send({ result: { claims } });
-                    }
-                    catch (error) {
-                        if (error instanceof RunAgentError) {
-                            send({ error: { code: error.code, message: error.message, details: error.details } });
-                            return;
-                        }
-                        throw error;
-                    }
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.query(sessionId, p.path), (claims) => ({ result: { claims } }), send);
                     break;
                 }
                 case "claims.release": {
                     const p = params;
-                    try {
-                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
-                        const claim = this.claims.release(sessionId, p.claimId);
-                        send({ result: { claim } });
-                    }
-                    catch (error) {
-                        if (error instanceof RunAgentError) {
-                            send({ error: { code: error.code, message: error.message, details: error.details } });
-                            return;
-                        }
-                        throw error;
-                    }
-                    break;
-                }
-                case "daemon.status": {
-                    const paths = getPaths();
-                    let uptime = Date.now() - this.startTime;
-                    send({ result: { running: true, pid: process.pid, uptime, db: paths.db } });
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.release(sessionId, p.claimId), (claim) => ({ result: { claim } }), send);
                     break;
                 }
                 case "doctor": {
@@ -1461,7 +1527,7 @@ class Daemon {
                         send({ result });
                     }
                     catch (error) {
-                        send({ error: { code: "USAGE_QUERY_ERROR", message: error instanceof Error ? error.message : String(error) } });
+                        send({ error: { code: "USAGE_QUERY_ERROR", message: errorMessage(error) } });
                     }
                     break;
                 }
@@ -1475,7 +1541,7 @@ class Daemon {
                             send({ error: { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) } });
                         }
                         else {
-                            send({ error: { code: "WEB_START_FAILED", message: error instanceof Error ? error.message : String(error) } });
+                            send({ error: { code: "WEB_START_FAILED", message: errorMessage(error) } });
                         }
                     }
                     break;
@@ -1531,6 +1597,10 @@ class Daemon {
             }
         }
     }
+    emit(sessionId, event) {
+        this.events.append(sessionId, event);
+        this.broadcast(sessionId, event);
+    }
     webHost() {
         this.web ??= new WebSupervisor({ log: appendDaemonLog, spawnChild: this.spawnWebChild });
         return this.web;
@@ -1549,7 +1619,7 @@ class Daemon {
             appendDaemonLog(invalidWebHostMessage(invalidHost));
         this.webHost()
             .ensure({ preferredPort: port, preferredHost: host })
-            .catch((error) => appendDaemonLog(`web autostart failed: ${error instanceof Error ? error.message : String(error)}`));
+            .catch((error) => appendDaemonLog(`web autostart failed: ${errorMessage(error)}`));
     }
     async startDriverForSession(sessionId, prompt, model) {
         if (this.shuttingDown)
@@ -1564,8 +1634,7 @@ class Daemon {
             return;
         this.sessions.update(sessionId, { status: "working" });
         const turnEvent = { type: "turn.started", sessionId, timestamp: new Date().toISOString(), prompt };
-        this.events.append(sessionId, turnEvent);
-        this.broadcast(sessionId, turnEvent);
+        this.emit(sessionId, turnEvent);
         const drvSession = await driver.start({
             sessionId,
             prompt,
@@ -1632,10 +1701,10 @@ class Daemon {
         catch { }
     }
     /**
-    +   * Starts a resumed turn; caller MUST hold sessionLocks for the session.
-    +   * Shared by session.send (immediate) and tryDispatch (queued) so both
-    +   * paths emit the same frames in the same order.
-    +   */
+     * Starts a resumed turn; caller MUST hold sessionLocks for the session.
+     * Shared by session.send (immediate) and tryDispatch (queued) so both
+     * paths emit the same frames in the same order.
+     */
     async runResumeTurn(s, message) {
         const driver = this.registry.get(s.agent);
         if (this.shuttingDown) {
@@ -1650,8 +1719,7 @@ class Daemon {
             timestamp: new Date().toISOString(),
             prompt: message,
         };
-        this.events.append(s.id, turnEvent);
-        this.broadcast(s.id, turnEvent);
+        this.emit(s.id, turnEvent);
         const drvSession = {
             id: s.id,
             runId: s.runId ?? undefined,
@@ -1756,7 +1824,7 @@ class Daemon {
             return true;
         }
         catch (e) {
-            const errText = e instanceof Error ? e.message : String(e);
+            const errText = errorMessage(e);
             const unavailable = e?.code === "SERVICE_UNAVAILABLE" || this.shuttingDown;
             if (!unavailable) {
                 const failure = classifyFailure(errText);
@@ -1859,7 +1927,7 @@ class Daemon {
                 return;
             // A driver exception mid-stream is a harness/pipe failure, not task
             // output — classify so agents can retry instead of blaming the work.
-            const msg = e instanceof Error ? e.message : String(e);
+            const msg = errorMessage(e);
             const failure = classifyFailure(msg);
             const errEv = {
                 type: "session.failed",
@@ -1869,8 +1937,7 @@ class Daemon {
                 failure,
                 raw: e,
             };
-            this.events.append(sessionId, errEv);
-            this.broadcast(sessionId, errEv);
+            this.emit(sessionId, errEv);
             this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
             return;
         }
@@ -1902,8 +1969,7 @@ class Daemon {
                 };
                 const error = sess.lastEvent || "event stream ended without a terminal event";
                 const errEv = { type: "session.failed", sessionId, timestamp: new Date().toISOString(), error, failure };
-                this.events.append(sessionId, errEv);
-                this.broadcast(sessionId, errEv);
+                this.emit(sessionId, errEv);
                 this.sessions.setStatus(sessionId, "failed", { lastEvent: error.slice(0, 200), failure });
             }
         }
@@ -2068,25 +2134,23 @@ class Daemon {
             handle.exec("PRAGMA wal_checkpoint(TRUNCATE)");
         }
         catch { }
-        try {
-            const paths = getPaths();
+        if (this.boundPaths) {
             try {
-                fs.unlinkSync(paths.daemonSock);
+                fs.unlinkSync(this.boundPaths.sock);
             }
             catch { }
             try {
-                fs.unlinkSync(paths.daemonPid);
-            }
-            catch { }
-            try {
-                this.server?.close();
-            }
-            catch { }
-            try {
-                this.db.close();
+                fs.unlinkSync(this.boundPaths.pid);
             }
             catch { }
         }
+        try {
+            this.server?.close();
+        }
+        catch { }
+        try {
+            this.db.close();
+        }
         catch { }
     }
     safeListActive() {
@@ -2152,8 +2216,7 @@ class Daemon {
                 failure,
                 raw: { reason },
             };
-            this.events.append(s.id, event);
-            this.broadcast(s.id, event);
+            this.emit(s.id, event);
             this.sessions.setStatus(s.id, "interrupted", { lastEvent: detail.slice(0, 200), failure });
         }
         catch { }
@@ -2164,7 +2227,7 @@ class Daemon {
 let instanceLock = null;
 // Entry
 if (process.argv.includes("--daemon")) {
-    // Take the lock before opening run-agent.db: a losing daemon must not
+    // Take the lock before opening codedeck.db: a losing daemon must not
     // migrate, recover or bind the socket. Exit 0 so the spawning CLI keeps
     // polling and connects to the daemon that already runs.
     instanceLock = acquireInstanceLock(getPaths().daemonLock);