codedeck 0.7.0 → 0.7.2

package/dist/daemon/daemon.js

@@ -1,30 +1,34 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawn } from "node:child_process";
 import { Database } from "../store/database.js";
-import { SessionStore } from "../store/sessions.js";
+import { AmbiguousSessionIdError, SessionStore } from "../store/sessions.js";
 import { EventStore } from "../store/events.js";
 import { ClaimsStore } from "../store/claims.js";
 import { getPaths, ensureDirs } from "../config/paths.js";
 import { createIpcServer } from "./ipc.js";
+import { acquireInstanceLock } from "./instance-lock.js";
+import { WebEnsureError, WebSupervisor } from "./web-supervisor.js";
 import { getRegistry } from "../drivers/registry.js";
-import { isTerminalStatus, liveStatus, normalizeAgentId } from "../core/session.js";
+import { isActiveStatus, isTerminalStatus, liveStatus, normalizeAgentId } from "../core/session.js";
 import { parseSandbox } from "../core/driver.js";
 import { generateSessionId } from "../core/session.js";
 import { getGitInfo } from "../git/repository.js";
 import { createWorktree } from "../git/worktree.js";
 import { getDiff } from "../git/diff.js";
-import { killTree, processAlive, processStartTime, resolveInhibitBin, sleep } from "../utils/process.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 { classifyFailure, RunAgentError } from "../core/errors.js";
+import { invalidWebHostMessage, resolveWebHost } from "../config/web-host.js";
+import { invalidWebPortMessage, resolveWebPort } from "../config/web-port.js";
+import { classifyFailure, errorMessage, isStoreBusy, RunAgentError } from "../core/errors.js";
+import { parseRole } from "../core/roles.js";
 import { getCachedOrDiscoverModels } from "../core/models.js";
 import { aggregateRunUsage } from "../core/run-usage.js";
 import { UsageLedger } from "../store/usage-ledger.js";
 import { openSourceKey, workerSourceKey } from "../core/usage-source.js";
 import { NativeLinkStore } from "../store/native-links.js";
-import { findTranscript, readTranscriptUsage } from "../core/claude-transcript.js";
+import { consumeTranscriptChunk, findTranscript, readTranscriptUsage, TRANSCRIPT_CHUNK_LIMIT_BYTES, } from "../core/claude-transcript.js";
 // Daemon's view of power readiness for the doctor IPC result (field names
 // fixed by cross-worker contract; the CLI falls back to local detection
 // when the daemon is unreachable).
@@ -74,6 +78,16 @@ function livePidIdentity(s) {
         processAlive(s.pid) &&
         processStartTime(s.pid) === s.pidStartTime);
 }
+// Backoff for a busy store in the event loop; capped, never given up while
+// the daemon runs (see persistDriverEvent).
+const STORE_BUSY_RETRY_BASE_MS = 25;
+const STORE_BUSY_RETRY_MAX_MS = 2000;
+function appendDaemonLog(line) {
+    try {
+        fs.appendFileSync(getPaths().daemonLog, `[${new Date().toISOString()}] ${line}\n`);
+    }
+    catch { }
+}
 class Daemon {
     db;
     sessions;
@@ -83,20 +97,179 @@ class Daemon {
     nativeLinks;
     registry = getRegistry();
     server;
+    boundPaths;
     subscribers = new Map(); // sessionId -> sockets
     startTime = Date.now();
     startupReconcilePromise = Promise.resolve();
     sessionLocks = new Set();
+    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.
+    healing = new Map();
     // Power-shutdown state. `shuttingDown` is set synchronously by the signal
     // handler so concurrent handleRequest calls are refused during the drain.
     shuttingDown = false;
     // Exactly-once drain: concurrent handleShutdown callers share one promise.
     shutdownPromise = null;
-    // Best-effort delay-lock child (systemd-inhibit), alive for the daemon's
-    // whole life when the binary exists; killed after TRUNCATE in the drain.
-    inhibitChild = null;
-    inhibitExitHookInstalled = false;
+    // Supervisor of the web console child, created on the first web.ensure.
+    web;
+    spawnWebChild;
     inFlightModels = new Map();
+    inFlightOpenUsageReconciliations = new Map();
+    liveTranscriptCursors = new Map();
+    liveTranscriptQueues = new Map();
+    async withLiveTranscriptLock(nativeId, operation) {
+        const previous = this.liveTranscriptQueues.get(nativeId) ?? Promise.resolve();
+        let unlock;
+        const current = new Promise((resolve) => { unlock = resolve; });
+        this.liveTranscriptQueues.set(nativeId, current);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            unlock();
+            if (this.liveTranscriptQueues.get(nativeId) === current) {
+                this.liveTranscriptQueues.delete(nativeId);
+            }
+        }
+    }
+    async ingestLiveTranscript(sessionId, nativeId, suppliedPath) {
+        return this.withLiveTranscriptLock(nativeId, async () => {
+            const isActiveClaudeOpenRow = () => {
+                const session = this.sessions.get(sessionId);
+                return session?.origin === "open" && session.agent === "claude" && isActiveStatus(session.status);
+            };
+            if (!isActiveClaudeOpenRow())
+                return [];
+            let resolvedPath;
+            let stat;
+            try {
+                const projectsRoot = await fs.promises.realpath(path.join(os.homedir(), ".claude", "projects"));
+                resolvedPath = await fs.promises.realpath(suppliedPath);
+                const relativePath = path.relative(projectsRoot, resolvedPath);
+                if (relativePath === "" ||
+                    relativePath === ".." ||
+                    relativePath.startsWith(`..${path.sep}`) ||
+                    path.isAbsolute(relativePath) ||
+                    path.basename(resolvedPath) !== `${nativeId}.jsonl`)
+                    return [];
+                stat = await fs.promises.stat(resolvedPath);
+                if (!stat.isFile())
+                    return [];
+            }
+            catch {
+                return [];
+            }
+            let file;
+            try {
+                file = await fs.promises.open(resolvedPath, "r");
+            }
+            catch {
+                return [];
+            }
+            try {
+                if (!isActiveClaudeOpenRow())
+                    return [];
+                let previous = [];
+                try {
+                    previous = this.nativeLinks.link(sessionId, nativeId).previous;
+                    const saved = this.liveTranscriptCursors.get(nativeId);
+                    const reset = saved !== undefined &&
+                        (saved.device !== stat.dev || saved.inode !== stat.ino || stat.size < saved.byteOffset);
+                    const state = {
+                        pendingLine: reset ? new Uint8Array() : saved?.pendingLine ?? new Uint8Array(),
+                        discardUntilNewline: reset ? false : saved?.discardUntilNewline ?? false,
+                        inputTokens: saved?.inputTokens ?? 0,
+                        outputTokens: saved?.outputTokens ?? 0,
+                        cachedTokens: saved?.cachedTokens ?? 0,
+                        seenMessageKeys: saved?.seenMessageKeys ?? new Set(),
+                    };
+                    const byteOffset = reset ? 0 : saved?.byteOffset ?? 0;
+                    const bytesToRead = Math.min(TRANSCRIPT_CHUNK_LIMIT_BYTES, Math.max(0, stat.size - byteOffset));
+                    const buffer = Buffer.alloc(bytesToRead);
+                    const { bytesRead } = bytesToRead === 0
+                        ? { bytesRead: 0 }
+                        : await file.read(buffer, 0, bytesToRead, byteOffset);
+                    const nextState = consumeTranscriptChunk(state, buffer.subarray(0, bytesRead));
+                    if (!isActiveClaudeOpenRow())
+                        return previous;
+                    const db = this.db.getHandle();
+                    db.exec("BEGIN");
+                    try {
+                        this.usageLedger.observe(sessionId, openSourceKey(nativeId), {
+                            inputTokens: nextState.inputTokens,
+                            outputTokens: nextState.outputTokens,
+                            cachedTokens: nextState.cachedTokens,
+                        });
+                        db.exec("COMMIT");
+                    }
+                    catch {
+                        try {
+                            db.exec("ROLLBACK");
+                        }
+                        catch { }
+                        return previous;
+                    }
+                    this.liveTranscriptCursors.set(nativeId, {
+                        ...nextState,
+                        byteOffset: byteOffset + bytesRead,
+                        device: stat.dev,
+                        inode: stat.ino,
+                    });
+                    return previous;
+                }
+                catch {
+                    return previous;
+                }
+            }
+            finally {
+                await file.close().catch(() => { });
+            }
+        });
+    }
+    queueOpenUsageReconciliation(sessionId, nativeIds) {
+        const uniqueIds = [...new Set(nativeIds)];
+        const keyFor = (nativeId) => JSON.stringify([sessionId, nativeId]);
+        const pendingIds = uniqueIds.filter((nativeId) => !this.inFlightOpenUsageReconciliations.has(keyFor(nativeId)));
+        if (pendingIds.length === 0)
+            return;
+        const keys = pendingIds.map(keyFor);
+        const reconciliation = Promise.resolve().then(() => this.reconcileOpenUsageSafely(sessionId, pendingIds));
+        for (const key of keys)
+            this.inFlightOpenUsageReconciliations.set(key, reconciliation);
+        const clearInFlight = () => {
+            for (const key of keys) {
+                if (this.inFlightOpenUsageReconciliations.get(key) === reconciliation) {
+                    this.inFlightOpenUsageReconciliations.delete(key);
+                }
+            }
+        };
+        void reconciliation.then(clearInFlight, clearInFlight);
+    }
+    async cleanupReleasedTranscriptCursors(sessionId) {
+        const nativeIds = new Set(this.nativeLinks.linksFor([sessionId]).map((link) => link.nativeId));
+        await Promise.all([...nativeIds].map((nativeId) => this.withLiveTranscriptLock(nativeId, async () => {
+            const activeClaudeOpenIds = this.sessions.listActive()
+                .filter((session) => session.origin === "open" && session.agent === "claude")
+                .map((session) => session.id);
+            const stillActive = this.nativeLinks.linksFor(activeClaudeOpenIds)
+                .some((link) => link.nativeId === nativeId);
+            if (!stillActive)
+                this.liveTranscriptCursors.delete(nativeId);
+        })));
+    }
+    queueReleasedTranscriptCursorCleanup(sessionId) {
+        queueMicrotask(() => {
+            void this.cleanupReleasedTranscriptCursors(sessionId).catch((error) => {
+                const detail = errorMessage(error);
+                try {
+                    fs.appendFileSync(getPaths().daemonLog, `[${new Date().toISOString()}] usage cursor cleanup failed session=${sessionId}: ${detail}\n`);
+                }
+                catch { }
+            });
+        });
+    }
     async fetchModels(agent, refresh) {
         const key = `${agent || "all"}:${Boolean(refresh)}`;
         const existing = this.inFlightModels.get(key);
@@ -108,7 +281,9 @@ class Daemon {
         this.inFlightModels.set(key, promise);
         return promise;
     }
-    constructor() {
+    constructor(options = {}) {
+        this.web = options.webSupervisor;
+        this.spawnWebChild = options.spawnWebChild;
         ensureDirs();
         this.db = new Database();
         const handle = this.db.getHandle();
@@ -141,7 +316,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");
                 }
@@ -152,20 +327,26 @@ 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");
         }
         catch { }
         // Graceful power shutdown: exactly-once drain on power signals. SIGHUP
-        // covers lid-close/logout via logind. Keep listeners installed so a
+        // covers logout/session teardown. Keep listeners installed so a
         // repeated signal reaches the synchronous shuttingDown guard.
+        //
+        // No systemd-inhibit delay lock: one only helps a holder that reacts to
+        // logind's PrepareForShutdown and then releases it. The drain starts on
+        // SIGTERM, which arrives after the delay expires, so the lock stalled
+        // every poweroff and suspend for the full InhibitDelayMaxSec for nothing.
         process.on("SIGTERM", () => this.onSignal("SIGTERM"));
         process.on("SIGINT", () => this.onSignal("SIGINT"));
         process.on("SIGHUP", () => this.onSignal("SIGHUP"));
-        // Best-effort delay lock so the system waits for the drain. Silent
-        // no-op when systemd-inhibit is absent (containers, macOS, CI).
-        this.maybeSpawnInhibit();
         console.log(`[daemon] listening on ${paths.daemonSock} pid=${process.pid}`);
         // Keep alive
         // Write log
@@ -180,6 +361,7 @@ class Daemon {
     // streaming; a dead one is drained and classified from its log tail.
     async recover() {
         const paths = getPaths();
+        this.reviveStoreBusyFailures(paths.logsDir);
         const actives = this.sessions.listActive();
         for (const s of actives) {
             // Power-shutdown rows are terminal: never reattach, never flip. A
@@ -248,7 +430,10 @@ class Daemon {
             // Never attach to or signal a PID whose identity changed while the
             // daemon was away. The original harness is gone; the replacement is
             // somebody else's process.
-            if (pidReused) {
+            // A revived row died long ago: its PID may be anyone's by now, but its
+            // log is still its own, so drain it as dead instead of failing it.
+            const healing = this.healing.has(s.id);
+            if (pidReused && !healing) {
                 const failure = {
                     code: "HARNESS_CRASH",
                     blame: "harness",
@@ -269,13 +454,14 @@ class Daemon {
                 this.sessions.setStatus(s.id, "failed", { lastEvent: detail, failure });
                 continue;
             }
-            const alive = processPresent;
+            // Only a healing row reaches here with a reused PID; it counts as dead.
+            const alive = processPresent && !pidReused;
             const stdoutPath = path.join(paths.logsDir, `${s.id}.ndjson`);
             const stderrPath = path.join(paths.logsDir, `${s.id}.stderr.log`);
             const hasDetachedLogs = fs.existsSync(stdoutPath) || fs.existsSync(stderrPath);
             // A live PID without a recorded identity is unsafe to attach: it may be
             // a recycled process. A dead PID is safe to drain from its own log.
-            const identityVerified = !processPresent || (recordedStart !== undefined && currentStart === recordedStart);
+            const identityVerified = !alive || (recordedStart !== undefined && currentStart === recordedStart);
             if (typeof driver.attach === "function" && pid != null && hasDetachedLogs && identityVerified) {
                 try {
                     await driver.attach({
@@ -321,6 +507,61 @@ class Daemon {
             }
         }
     }
+    // A session the old event loop failed on "database is locked" was never
+    // over: the harness kept writing its log past the persisted offset. Flip
+    // such rows back to working so the reattach loop below drains the log
+    // (dead harness) or keeps tailing it (live one), exactly as after a restart.
+    reviveStoreBusyFailures(logsDir) {
+        for (const s of this.sessions.listStoreBusyFailures()) {
+            if (s.origin === "open")
+                continue;
+            const logs = [path.join(logsDir, `${s.id}.ndjson`), path.join(logsDir, `${s.id}.stderr.log`)]
+                .filter((file) => fs.existsSync(file));
+            const metadata = readSessionProcessMetadata(s.id);
+            const pid = metadata?.pid ?? s.pid;
+            if (logs.length === 0 || pid == null)
+                continue;
+            const recordedStart = metadata?.pidStartTime ?? s.pidStartTime;
+            const alive = processAlive(pid) && (recordedStart === undefined || processStartTime(pid) === recordedStart);
+            // Parsers stamp events with read time. For a dead harness the last log
+            // write is the best bound on when the backlog really happened.
+            const endedAt = alive
+                ? undefined
+                : new Date(Math.max(...logs.map((file) => fs.statSync(file).mtimeMs)));
+            const last = this.db.getHandle().prepare(`SELECT COALESCE(MAX(sequence), 0) AS seq FROM events WHERE session_id = ?`).get(s.id);
+            this.healing.set(s.id, { fromSequence: last.seq, endedAt });
+            this.sessions.setStatus(s.id, "working", {
+                failure: null,
+                completedAt: null,
+                lastEvent: "healing after a store-busy failure",
+            });
+            appendDaemonLog(`healing ${s.id} from store-busy failure (${alive ? "live" : "dead"} harness)`);
+        }
+    }
+    // Once a revived session's stream ends, pin the drained backlog and the
+    // terminal time to the log mtime instead of the replay time.
+    finishHeal(sessionId) {
+        const heal = this.healing.get(sessionId);
+        if (!heal)
+            return;
+        this.healing.delete(sessionId);
+        if (!heal.endedAt)
+            return;
+        const endedAt = heal.endedAt.toISOString();
+        try {
+            this.db.getHandle().prepare(`
+        UPDATE events
+        SET timestamp = ?, normalized_payload = json_set(normalized_payload, '$.timestamp', ?)
+        WHERE session_id = ? AND sequence > ? AND timestamp > ?
+      `).run(endedAt, endedAt, sessionId, heal.fromSequence, endedAt);
+            const s = this.sessions.get(sessionId);
+            if (s && isTerminalStatus(s.status))
+                this.sessions.update(sessionId, { completedAt: heal.endedAt });
+        }
+        catch (error) {
+            appendDaemonLog(`heal timestamps for ${sessionId} failed: ${errorMessage(error)}`);
+        }
+    }
     async reconcileOpenUsage(sessionId, nativeIds) {
         const session = this.sessions.get(sessionId);
         if (!session || session.origin !== "open" || session.agent !== "claude")
@@ -366,13 +607,45 @@ class Daemon {
     async reconcileOpenUsageSafely(sessionId, nativeIds) {
         try {
             await this.reconcileOpenUsage(sessionId, nativeIds);
+            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`);
             }
             catch { }
+            return false;
+        }
+    }
+    nextSessionId() {
+        for (let attempt = 0; attempt < 100; attempt++) {
+            const sessionId = generateSessionId();
+            if (!this.sessions.getExact(sessionId) && !this.reservedSessionIds.has(sessionId)) {
+                this.reservedSessionIds.add(sessionId);
+                return sessionId;
+            }
+        }
+        throw new Error("Unable to generate a unique session ID after 100 attempts");
+    }
+    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 RunAgentError) {
+                send({ error: { code: error.code, message: error.message, details: error.details } });
+                return;
+            }
+            throw error;
         }
     }
     async handleRequest(req, socket) {
@@ -383,746 +656,736 @@ 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;
         }
-        switch (method) {
-            case "session.create": {
-                const p = params;
-                const prompt = p.prompt;
-                if (!prompt) {
-                    send({ error: { code: "INVALID", message: "prompt required" } });
-                    return;
-                }
-                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)) {
-                    send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
-                    return;
-                }
-                const requestSandbox = resolveRequestSandbox(p.sandbox);
-                const configuredSandbox = resolveDefaultSandbox(cfg);
-                const sandbox = agent === "codex" ? requestSandbox ?? configuredSandbox : undefined;
-                const sessionId = generateSessionId();
-                let cwd = path.resolve(cwdIn);
-                let worktree;
-                let branch;
-                let repository;
-                let baseCommit;
-                const gitInfo = await getGitInfo(cwd);
-                if (this.shuttingDown) {
-                    send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
-                    return;
-                }
-                if (gitInfo)
-                    repository = gitInfo.root;
-                const wantsWorktree = p.worktree === true || (p.worktree === undefined && cfg.worktree === true);
-                const wantsNoWorktree = p.noWorktree === true || p.worktree === false;
-                if (wantsWorktree && gitInfo) {
+        try {
+            switch (method) {
+                case "session.create": {
+                    const p = params;
+                    const prompt = p.prompt;
+                    if (!prompt) {
+                        send({ error: { code: "INVALID", message: "prompt required" } });
+                        return;
+                    }
+                    const cwdIn = p.cwd || process.cwd();
+                    const cfg = loadConfig();
+                    const rawAgent = p.agent || cfg.defaultAgent || "claude";
+                    const { agent, registered } = this.resolveRegisteredAgent(rawAgent);
+                    if (!registered) {
+                        send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
+                        return;
+                    }
+                    const requestSandbox = resolveRequestSandbox(p.sandbox);
+                    const configuredSandbox = resolveDefaultSandbox(cfg);
+                    const sandbox = agent === "codex" ? requestSandbox ?? configuredSandbox : undefined;
+                    let cwd = path.resolve(cwdIn);
+                    // Only record an edge to a session the store knows: a stale or foreign
+                    // CODEDECK_SESSION_ID must not invent a parent the tree cannot draw.
+                    const parent = typeof p.parentId === "string" && p.parentId.length > 0
+                        ? this.sessions.getExact(p.parentId)
+                        : null;
+                    const sessionId = this.nextSessionId();
+                    let worktree;
+                    let branch;
+                    let repository;
+                    let baseCommit;
+                    let gitInfo;
                     try {
-                        const wt = await createWorktree({ repoRoot: gitInfo.root, sessionId, prompt, name: p.name });
-                        if (this.shuttingDown) {
-                            send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                        gitInfo = await getGitInfo(cwd);
+                    }
+                    catch (error) {
+                        this.releaseSessionId(sessionId);
+                        throw error;
+                    }
+                    if (this.shuttingDown) {
+                        this.releaseSessionId(sessionId);
+                        sendShuttingDown();
+                        return;
+                    }
+                    if (gitInfo)
+                        repository = gitInfo.root;
+                    const wantsWorktree = p.worktree === true || (p.worktree === undefined && cfg.worktree === true);
+                    const wantsNoWorktree = p.noWorktree === true || p.worktree === false;
+                    if (wantsWorktree && gitInfo) {
+                        try {
+                            const wt = await createWorktree({ repoRoot: gitInfo.root, sessionId, prompt, name: p.name });
+                            if (this.shuttingDown) {
+                                this.releaseSessionId(sessionId);
+                                sendShuttingDown();
+                                return;
+                            }
+                            worktree = wt.path;
+                            branch = wt.branch;
+                            baseCommit = wt.baseCommit;
+                            cwd = worktree;
+                        }
+                        catch (e) {
+                            this.releaseSessionId(sessionId);
+                            send({ error: { code: "WORKTREE_FAILED", message: errorMessage(e) } });
                             return;
                         }
-                        worktree = wt.path;
-                        branch = wt.branch;
-                        baseCommit = wt.baseCommit;
-                        cwd = worktree;
                     }
-                    catch (e) {
-                        send({ error: { code: "WORKTREE_FAILED", message: e instanceof Error ? e.message : String(e) } });
-                        return;
+                    else if (gitInfo) {
+                        baseCommit = gitInfo.head;
                     }
-                }
-                else if (gitInfo) {
-                    baseCommit = gitInfo.head;
-                }
-                const now = new Date();
-                const session = {
-                    id: sessionId,
-                    runId: typeof p.runId === "string" ? p.runId : undefined,
-                    name: p.name,
-                    agent,
-                    model: p.model,
-                    effort: p.effort,
-                    fast: !!p.fast,
-                    sandbox,
-                    dangerouslyBypassApprovalsAndSandbox: !!p.dangerouslyBypassApprovalsAndSandbox,
-                    status: "starting",
-                    repository,
-                    cwd,
-                    worktree,
-                    branch,
-                    baseCommit: baseCommit || undefined,
-                    pid: undefined,
-                    createdAt: now,
-                    updatedAt: now,
-                };
-                this.sessions.create(session);
-                // 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 failure = classifyFailure(msg);
-                    const failEv = {
-                        type: "session.failed",
-                        sessionId,
-                        timestamp: new Date().toISOString(),
-                        error: msg,
-                        failure,
-                        raw: e,
+                    const now = new Date();
+                    const session = {
+                        id: sessionId,
+                        runId: typeof p.runId === "string" ? p.runId : parent?.runId ?? undefined,
+                        parentId: parent?.id,
+                        role: typeof p.role === "string" ? parseRole(p.role) : undefined,
+                        name: p.name,
+                        agent,
+                        model: p.model,
+                        effort: p.effort,
+                        fast: !!p.fast,
+                        sandbox,
+                        dangerouslyBypassApprovalsAndSandbox: !!p.dangerouslyBypassApprovalsAndSandbox,
+                        status: "starting",
+                        repository,
+                        cwd,
+                        worktree,
+                        branch,
+                        baseCommit: baseCommit || undefined,
+                        pid: undefined,
+                        createdAt: now,
+                        updatedAt: now,
                     };
                     try {
-                        this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
+                        this.sessions.create(session);
                     }
-                    catch { }
-                    this.broadcast(sessionId, failEv);
-                });
-                break;
-            }
-            case "session.adopt": {
-                const p = params;
-                const cwdIn = p.cwd || process.cwd();
-                const rawAgent = p.agent || "claude";
-                const agent = (normalizeAgentId(rawAgent) ?? rawAgent);
-                if (!this.registry.has(agent)) {
-                    send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
-                    return;
-                }
-                const cwd = path.resolve(cwdIn);
-                let repository;
-                let baseCommit = p.baseCommit;
-                const gitInfo = await getGitInfo(cwd);
-                if (this.shuttingDown) {
-                    send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
-                    return;
-                }
-                const matchingSession = typeof p.resume === "string" && p.resume.length > 0
-                    ? this.sessions.listOpenByNativeId(p.resume).find((session) => session.agent === agent)
-                    : undefined;
-                if (matchingSession &&
-                    (isTerminalStatus(matchingSession.status) || !livePidIdentity(matchingSession))) {
-                    const now = new Date();
-                    this.sessions.setStatus(matchingSession.id, "working", {
-                        ...(p.model !== undefined ? { model: p.model } : {}),
-                        ...(p.effort !== undefined ? { effort: p.effort } : {}),
-                        ...(p.name !== undefined ? { name: p.name } : {}),
-                        ...(p.cwd !== undefined ? { cwd } : {}),
-                        pid: null,
-                        pidStartTime: null,
-                        completedAt: null,
-                        lastEvent: null,
-                        failure: null,
-                        updatedAt: now,
+                    finally {
+                        this.releaseSessionId(sessionId);
+                    }
+                    // Start driver async (don't block response too long)
+                    send({ result: { session } });
+                    // Now start driver in background
+                    this.startDriverForSession(sessionId, prompt, p.model).catch((e) => {
+                        if (this.shuttingDown)
+                            return;
+                        const msg = errorMessage(e);
+                        const failure = classifyFailure(msg);
+                        const failEv = {
+                            type: "session.failed",
+                            sessionId,
+                            timestamp: new Date().toISOString(),
+                            error: msg,
+                            failure,
+                            raw: e,
+                        };
+                        try {
+                            this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
+                        }
+                        catch { }
+                        this.broadcast(sessionId, failEv);
                     });
-                    const revived = this.sessions.get(matchingSession.id);
-                    const event = {
-                        type: "session.started",
-                        sessionId: revived.id,
-                        timestamp: now.toISOString(),
-                        agent,
-                        nativeSessionId: p.resume,
-                    };
-                    this.events.append(revived.id, event);
-                    this.broadcast(revived.id, event);
-                    send({ result: { session: revived } });
                     break;
                 }
-                let sessionId = generateSessionId();
-                while (this.sessions.get(sessionId)) {
-                    sessionId = generateSessionId();
-                }
-                if (gitInfo) {
-                    repository = gitInfo.root;
-                    if (!baseCommit)
-                        baseCommit = gitInfo.head;
-                }
-                const now = new Date();
-                const session = {
-                    id: sessionId,
-                    runId: sessionId,
-                    origin: "open",
-                    name: p.name,
-                    agent,
-                    model: p.model,
-                    effort: p.effort,
-                    status: "working",
-                    repository,
-                    cwd,
-                    worktree: p.worktree,
-                    branch: p.branch,
-                    baseCommit: baseCommit || undefined,
-                    createdAt: now,
-                    updatedAt: now,
-                };
-                this.sessions.create(session);
-                send({ result: { session } });
-                break;
-            }
-            case "session.patch": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                let pidStartTime = p.pidStartTime;
-                if (p.pid !== undefined && pidStartTime === undefined) {
-                    pidStartTime = processStartTime(p.pid);
-                }
-                const updates = {};
-                if (p.pid !== undefined)
-                    updates.pid = p.pid;
-                if (pidStartTime !== undefined)
-                    updates.pidStartTime = pidStartTime;
-                if (p.worktree !== undefined)
-                    updates.worktree = p.worktree;
-                if (p.branch !== undefined)
-                    updates.branch = p.branch;
-                if (p.baseCommit !== undefined)
-                    updates.baseCommit = p.baseCommit;
-                if (p.cwd !== undefined)
-                    updates.cwd = p.cwd;
-                this.sessions.update(s.id, updates);
-                const updated = this.sessions.get(s.id);
-                send({ result: { session: updated } });
-                break;
-            }
-            case "session.linkNative": {
-                const p = (params || {});
-                if (typeof p.id !== "string" || typeof p.nativeId !== "string" || p.nativeId.length === 0) {
-                    send({ error: { code: "INVALID", message: "id and nativeId required" } });
-                    return;
-                }
-                const session = this.sessions.get(p.id);
-                if (!session) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                if (session.origin !== "open") {
-                    send({ result: { created: false } });
-                    return;
-                }
-                const { created, previous } = this.nativeLinks.link(session.id, p.nativeId);
-                if (previous.length > 0)
-                    await this.reconcileOpenUsageSafely(session.id, previous);
-                send({ result: { created } });
-                break;
-            }
-            case "session.release": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                // Release owns the terminal outcome: a queued message must not
-                // survive as a phantom "na fila" on every exit, including the
-                // terminal early return below.
-                this.clearPending(s.id);
-                // Interrupted is an archival terminal: a power-shutdown row stays
-                // actionable and release may finalize it to completed/failed — unless
-                // its process is still alive under the same identity, which keeps
-                // the send path's stop-first guard instead of orphaning it.
-                if (s.status === "interrupted" && livePidIdentity(s)) {
-                    send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running (stop it first)` } });
-                    return;
-                }
-                if (isTerminalStatus(s.status) && s.status !== "interrupted") {
-                    send({ result: { session: this.sessions.get(s.id) } });
-                    return;
-                }
-                const targetStatus = p.status === "failed" ? "failed" : "completed";
-                const extra = {};
-                if (p.nativeSessionId !== undefined) {
-                    extra.nativeSessionId = p.nativeSessionId;
-                }
-                if (targetStatus === "failed") {
-                    extra.lastEvent = (p.error || "failed").slice(0, 200);
-                }
-                else {
-                    extra.lastEvent = "released";
-                }
-                this.sessions.setStatus(s.id, targetStatus, extra);
-                if (s.origin === "open" && s.agent === "claude") {
-                    if (typeof p.nativeSessionId === "string" && p.nativeSessionId.length > 0) {
-                        this.nativeLinks.link(s.id, p.nativeSessionId);
+                case "session.adopt": {
+                    const p = params;
+                    const cwdIn = p.cwd || process.cwd();
+                    const rawAgent = p.agent || "claude";
+                    const { agent, registered } = this.resolveRegisteredAgent(rawAgent);
+                    if (!registered) {
+                        send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${agent}` } });
+                        return;
                     }
-                    await this.reconcileOpenUsageSafely(s.id);
-                }
-                const ev = targetStatus === "failed"
-                    ? {
-                        type: "session.failed",
-                        sessionId: s.id,
-                        timestamp: new Date().toISOString(),
-                        error: p.error || "session failed",
+                    const cwd = path.resolve(cwdIn);
+                    let repository;
+                    let baseCommit = p.baseCommit;
+                    const gitInfo = await getGitInfo(cwd);
+                    if (this.shuttingDown) {
+                        sendShuttingDown();
+                        return;
                     }
-                    : {
-                        type: "session.completed",
-                        sessionId: s.id,
-                        timestamp: new Date().toISOString(),
-                        reason: "released",
-                    };
-                this.events.append(s.id, ev);
-                this.broadcast(s.id, ev);
-                const updated = this.sessions.get(s.id);
-                send({ result: { session: updated } });
-                break;
-            }
-            case "session.list": {
-                const p = params;
-                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;
-            }
-            case "session.get": {
-                const p = params;
-                const stored = this.sessions.get(p.id);
-                if (!stored) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                const s = withLiveStatus(stored);
-                const evCount = this.events.count(s.id);
-                const recent = this.events.list(s.id, 10);
-                send({ result: { session: s, events: recent, eventCount: evCount } });
-                break;
-            }
-            case "session.rename": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                if (!p.name || !p.name.trim()) {
-                    send({ error: { code: "INVALID", message: "name required" } });
-                    return;
-                }
-                this.sessions.update(s.id, { name: p.name });
-                send({ result: { ok: true } });
-                break;
-            }
-            case "session.send": {
-                const p = params;
-                const validated = validateSendMessage(p.message);
-                if ("code" in validated) {
-                    send({ error: { code: validated.code, message: validated.error } });
-                    return;
-                }
-                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` } });
-                    return;
-                }
-                if (s.origin === "open") {
-                    send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Session ${s.id} is an interactive head session and does not support headless prompt turns` } });
-                    return;
-                }
-                const driver = this.registry.get(s.agent);
-                if (!driver.capabilities().resume) {
-                    send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Agent ${s.agent} does not support resume` } });
-                    return;
-                }
-                if (s.status === "interrupted" && !s.nativeSessionId) {
-                    send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Session ${s.id} cannot resume (no native session id or agent ${s.agent} does not support resume)` } });
-                    return;
-                }
-                // Power-interrupted sessions with a live process keep the old rule:
-                // stop first, never queue behind a running harness.
-                if (s.status === "interrupted" && livePidIdentity(s)) {
-                    send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running (stop it first)` } });
-                    return;
-                }
-                // A lifecycle operation owns the session: retry instead of queueing,
-                // so a send racing stop cannot strand a phantom slot with no stream
-                // tail left to consume it (stop cancels the queue on exit).
-                if (this.sessionLocks.has(s.id)) {
-                    send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} has another lifecycle operation in progress` } });
-                    return;
-                }
-                // Do not start a second harness while the current one is still live:
-                // both runtimes would tail the same per-session file and duplicate
-                // every event from the follow-up turn. Queue behind a live turn only.
-                const busyHandle = driver.getHandle?.(s.id);
-                const busyState = busyHandle && typeof busyHandle === "object"
-                    ? busyHandle
-                    : undefined;
-                const runtimeBusy = busyHandle !== undefined && (busyState?.done !== true || busyState?.drained !== true);
-                const busy = s.status === "starting" || runtimeBusy || livePidIdentity(s);
-                if (busy) {
-                    // One-slot queue, last-wins: persist without holding the lifecycle
-                    // lock, then converge — the turn may have ended between the busy
-                    // read and this persist, in which case tryDispatch starts now.
-                    const pendingAt = new Date().toISOString();
-                    try {
-                        this.sessions.update(s.id, { pendingMessage: message, pendingAt });
+                    const matchingSession = typeof p.resume === "string" && p.resume.length > 0
+                        ? this.sessions.listOpenByNativeId(p.resume).find((session) => session.agent === agent)
+                        : undefined;
+                    if (matchingSession &&
+                        (isTerminalStatus(matchingSession.status) || !livePidIdentity(matchingSession))) {
+                        const now = new Date();
+                        this.sessions.setStatus(matchingSession.id, "working", {
+                            ...(p.model !== undefined ? { model: p.model } : {}),
+                            ...(p.effort !== undefined ? { effort: p.effort } : {}),
+                            ...(p.name !== undefined ? { name: p.name } : {}),
+                            ...(p.cwd !== undefined ? { cwd } : {}),
+                            pid: null,
+                            pidStartTime: null,
+                            completedAt: null,
+                            lastEvent: null,
+                            failure: null,
+                            updatedAt: now,
+                        });
+                        const revived = this.sessions.get(matchingSession.id);
+                        const event = {
+                            type: "session.started",
+                            sessionId: revived.id,
+                            timestamp: now.toISOString(),
+                            agent,
+                            nativeSessionId: p.resume,
+                        };
+                        this.emit(revived.id, event);
+                        send({ result: { session: revived } });
+                        break;
                     }
-                    catch (e) {
-                        send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(e) } });
-                        return;
+                    const sessionId = this.nextSessionId();
+                    if (gitInfo) {
+                        repository = gitInfo.root;
+                        if (!baseCommit)
+                            baseCommit = gitInfo.head;
                     }
-                    const queuedEvent = {
-                        type: "message.queued",
-                        sessionId: s.id,
-                        timestamp: pendingAt,
-                        prompt: message,
-                        pendingAt,
+                    const now = new Date();
+                    const session = {
+                        id: sessionId,
+                        runId: sessionId,
+                        origin: "open",
+                        role: typeof p.role === "string" ? parseRole(p.role) : undefined,
+                        name: p.name,
+                        agent,
+                        model: p.model,
+                        effort: p.effort,
+                        status: "working",
+                        repository,
+                        cwd,
+                        worktree: p.worktree,
+                        branch: p.branch,
+                        baseCommit: baseCommit || undefined,
+                        createdAt: now,
+                        updatedAt: now,
                     };
                     try {
-                        this.events.append(s.id, queuedEvent);
+                        this.sessions.create(session);
                     }
-                    catch { }
-                    this.broadcast(s.id, queuedEvent);
-                    try {
-                        this.sessions.update(s.id, { lastEvent: `queued: ${message.slice(0, 80)}` });
+                    finally {
+                        this.releaseSessionId(sessionId);
                     }
-                    catch { }
-                    void this.tryDispatch(s.id);
-                    send({ result: { ok: true, queued: true } });
-                    return;
+                    send({ result: { session } });
+                    break;
                 }
-                // Resumable now (terminal completed/failed/stopped/orphaned, or
-                // interrupted without a live process): a stale queued slot loses to
-                // the new message, which starts immediately.
-                this.sessionLocks.add(s.id);
-                try {
-                    try {
-                        this.sessions.update(s.id, { pendingMessage: null, pendingAt: null });
+                case "session.patch": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
+                        return;
                     }
-                    catch { }
-                    await this.runResumeTurn(s, message);
-                    send({ result: { ok: true, queued: false } });
+                    let pidStartTime = p.pidStartTime;
+                    if (p.pid !== undefined && pidStartTime === undefined) {
+                        pidStartTime = processStartTime(p.pid);
+                    }
+                    const updates = {};
+                    if (p.pid !== undefined)
+                        updates.pid = p.pid;
+                    if (pidStartTime !== undefined)
+                        updates.pidStartTime = pidStartTime;
+                    if (p.worktree !== undefined)
+                        updates.worktree = p.worktree;
+                    if (p.branch !== undefined)
+                        updates.branch = p.branch;
+                    if (p.baseCommit !== undefined)
+                        updates.baseCommit = p.baseCommit;
+                    if (p.cwd !== undefined)
+                        updates.cwd = p.cwd;
+                    this.sessions.update(s.id, updates);
+                    const updated = this.sessions.get(s.id);
+                    send({ result: { session: updated } });
+                    break;
                 }
-                catch (e) {
-                    const errText = e instanceof Error ? e.message : String(e);
-                    const code = e instanceof Error && e.code === "SERVICE_UNAVAILABLE"
-                        ? "SERVICE_UNAVAILABLE"
-                        : this.shuttingDown ? "SERVICE_UNAVAILABLE" : "SEND_FAILED";
-                    if (code === "SERVICE_UNAVAILABLE") {
-                        send({ error: { code, message: errText } });
+                case "session.linkNative": {
+                    const p = (params || {});
+                    if (typeof p.id !== "string" || typeof p.nativeId !== "string" || p.nativeId.length === 0) {
+                        send({ error: { code: "INVALID", message: "id and nativeId required" } });
                         return;
                     }
-                    try {
-                        this.sessions.setStatus(s.id, "failed");
+                    const session = this.sessions.get(p.id);
+                    if (!session) {
+                        sendSessionNotFound(p.id);
+                        return;
                     }
-                    catch { }
-                    send({ error: { code: "SEND_FAILED", message: errText } });
-                }
-                finally {
-                    if (!this.shuttingDown)
-                        this.sessionLocks.delete(s.id);
-                }
-                break;
-            }
-            case "session.stop": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                // Stop cancels a queued message on every exit (explicit cancel),
-                // including the BUSY/NOT_RUNNING/UNSAFE early returns below.
-                this.clearPending(s.id);
-                const driver = this.registry.get(s.agent);
-                if (this.sessionLocks.has(s.id)) {
-                    send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} has another lifecycle operation in progress` } });
-                    return;
-                }
-                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;
-                if (isTerminalStatus(s.status) && !hasRuntime && !liveIdentity) {
-                    send({ error: { code: "SESSION_NOT_RUNNING", message: `Session ${s.id} is ${s.status}` } });
-                    return;
-                }
-                if (s.pid != null && !hasRuntime && !s.pidStartTime) {
-                    send({ error: { code: "STOP_UNSAFE", message: `Cannot safely stop session ${s.id}: PID identity is unavailable` } });
-                    return;
+                    if (session.origin !== "open") {
+                        send({ result: { created: false } });
+                        return;
+                    }
+                    const { created, previous } = this.nativeLinks.link(session.id, p.nativeId);
+                    if (previous.length > 0)
+                        await this.reconcileOpenUsageSafely(session.id, previous);
+                    send({ result: { created } });
+                    break;
                 }
-                this.sessionLocks.add(s.id);
-                const previousStatus = s.status;
-                const hadTerminalStatus = isTerminalStatus(s.status);
-                const eventsBeforeStop = this.events.count(s.id);
-                try {
-                    // Mark active sessions first so an attached event loop that ends
-                    // during stop cannot synthesize a failure or overwrite the outcome.
-                    if (!hadTerminalStatus)
-                        this.sessions.setStatus(s.id, "stopped");
-                    await driver.stop({
-                        id: s.id,
-                        nativeSessionId: s.nativeSessionId,
-                        cwd: s.worktree || s.cwd,
-                        pid: s.pid,
-                        pidStartTime: s.pidStartTime,
-                    });
-                    if (this.shuttingDown) {
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                case "session.release": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
                         return;
                     }
-                    const last = this.events.last(s.id);
-                    const terminalArrivedDuringStop = this.events.count(s.id) > eventsBeforeStop &&
-                        (last?.type === "session.completed" || last?.type === "session.failed");
-                    if (terminalArrivedDuringStop) {
-                        if (last.type === "session.completed") {
-                            this.sessions.setStatus(s.id, "completed", { lastEvent: last.reason || "completed" });
-                        }
-                        else {
-                            this.sessions.setStatus(s.id, "failed", { lastEvent: last.error.slice(0, 200), failure: last.failure });
+                    // Release owns the terminal outcome: a queued message must not
+                    // survive as a phantom "na fila" on every exit, including the
+                    // terminal early return below.
+                    this.clearPending(s.id);
+                    // Interrupted is an archival terminal: a power-shutdown row stays
+                    // actionable and release may finalize it to completed/failed — unless
+                    // its process is still alive under the same identity, which keeps
+                    // the send path's stop-first guard instead of orphaning it.
+                    if (s.status === "interrupted" && livePidIdentity(s)) {
+                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running (stop it first)` } });
+                        return;
+                    }
+                    if (isTerminalStatus(s.status) && s.status !== "interrupted") {
+                        send({ result: { session: this.sessions.get(s.id) } });
+                        return;
+                    }
+                    const targetStatus = p.status === "failed" ? "failed" : "completed";
+                    const extra = {};
+                    if (p.nativeSessionId !== undefined) {
+                        extra.nativeSessionId = p.nativeSessionId;
+                    }
+                    if (targetStatus === "failed") {
+                        extra.lastEvent = (p.error || "failed").slice(0, 200);
+                    }
+                    else {
+                        extra.lastEvent = "released";
+                    }
+                    this.sessions.setStatus(s.id, targetStatus, extra);
+                    if (s.origin === "open" && s.agent === "claude") {
+                        if (typeof p.nativeSessionId === "string" && p.nativeSessionId.length > 0) {
+                            this.nativeLinks.link(s.id, p.nativeSessionId);
                         }
+                        const reconciled = await this.reconcileOpenUsageSafely(s.id);
+                        if (reconciled)
+                            this.queueReleasedTranscriptCursorCleanup(s.id);
                     }
-                    else if (!hadTerminalStatus) {
-                        const ev = {
+                    const ev = targetStatus === "failed"
+                        ? {
+                            type: "session.failed",
+                            sessionId: s.id,
+                            timestamp: new Date().toISOString(),
+                            error: p.error || "session failed",
+                        }
+                        : {
                             type: "session.completed",
                             sessionId: s.id,
                             timestamp: new Date().toISOString(),
-                            reason: "stopped",
-                            exitCode: 130,
+                            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;
+                }
+                case "session.list": {
+                    const p = params;
+                    const all = p?.all;
+                    const list = this.sessions.list(100, all).map(withLiveStatus);
+                    const hidden = all ? 0 : this.sessions.countHiddenByWindow();
+                    send({ result: { sessions: list, hidden } });
+                    break;
+                }
+                case "session.get": {
+                    const p = params;
+                    const stored = this.sessions.get(p.id);
+                    if (!stored) {
+                        sendSessionNotFound(p.id);
+                        return;
                     }
-                    // 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.
-                    this.clearPending(s.id);
-                    send({ result: { ok: true } });
+                    const s = withLiveStatus(stored);
+                    const evCount = this.events.count(s.id);
+                    const recent = this.events.list(s.id, 10);
+                    send({ result: { session: s, events: recent, eventCount: evCount } });
+                    break;
                 }
-                catch (e) {
-                    if (this.shuttingDown) {
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                case "session.rename": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
                         return;
                     }
-                    try {
-                        this.sessions.setStatus(s.id, previousStatus);
+                    if (!p.name || !p.name.trim()) {
+                        send({ error: { code: "INVALID", message: "name required" } });
+                        return;
                     }
-                    catch { }
-                    send({ error: { code: "STOP_FAILED", message: e instanceof Error ? e.message : String(e) } });
-                }
-                finally {
-                    if (!this.shuttingDown)
-                        this.sessionLocks.delete(s.id);
-                }
-                break;
-            }
-            case "session.logs": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
-                }
-                if (p.follow) {
-                    // For follow, we upgrade to subscribe behavior? But spec says logs --follow streams
-                    // We'll handle by keeping socket open and streaming
-                    // Send existing events as result then keep streaming live
-                    const all = this.events.list(s.id, 1000);
-                    send({ result: { session: s, events: all } });
-                    // Then subscribe
-                    this.addSubscriber(s.id, socket);
-                    // Don't close socket
-                    return;
-                }
-                else {
-                    const all = this.events.list(s.id, 1000);
-                    send({ result: { session: s, events: all } });
-                }
-                break;
-            }
-            case "session.subscribe": {
-                const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
-                    send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
-                    return;
+                    this.sessions.update(s.id, { name: p.name });
+                    send({ result: { ok: true } });
+                    break;
                 }
-                // A late subscriber must not wait forever for a broadcast that already
-                // happened. Replay the terminal event when available, then close the
-                // stream just like a live terminal broadcast.
-                if (isTerminalStatus(s.status)) {
-                    const last = this.events.last(s.id);
-                    if (last?.type === "session.completed" || last?.type === "session.failed") {
+                case "session.send": {
+                    const p = params;
+                    const validated = validateSendMessage(p.message);
+                    if ("code" in validated) {
+                        send({ error: { code: validated.code, message: validated.error } });
+                        return;
+                    }
+                    const message = validated.message;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
+                        return;
+                    }
+                    if (s.origin === "open") {
+                        send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Session ${s.id} is an interactive head session and does not support headless prompt turns` } });
+                        return;
+                    }
+                    const driver = this.registry.get(s.agent);
+                    if (!driver.capabilities().resume) {
+                        send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Agent ${s.agent} does not support resume` } });
+                        return;
+                    }
+                    if (s.status === "interrupted" && !s.nativeSessionId) {
+                        send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Session ${s.id} cannot resume (no native session id or agent ${s.agent} does not support resume)` } });
+                        return;
+                    }
+                    // Power-interrupted sessions with a live process keep the old rule:
+                    // stop first, never queue behind a running harness.
+                    if (s.status === "interrupted" && livePidIdentity(s)) {
+                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running (stop it first)` } });
+                        return;
+                    }
+                    // A lifecycle operation owns the session: retry instead of queueing,
+                    // so a send racing stop cannot strand a phantom slot with no stream
+                    // tail left to consume it (stop cancels the queue on exit).
+                    if (this.sessionLocks.has(s.id)) {
+                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} has another lifecycle operation in progress` } });
+                        return;
+                    }
+                    // Do not start a second harness while the current one is still live:
+                    // both runtimes would tail the same per-session file and duplicate
+                    // every event from the follow-up turn. Queue behind a live turn only.
+                    const busyHandle = driver.getHandle?.(s.id);
+                    const busyState = busyHandle && typeof busyHandle === "object"
+                        ? busyHandle
+                        : undefined;
+                    const runtimeBusy = busyHandle !== undefined && (busyState?.done !== true || busyState?.drained !== true);
+                    const busy = s.status === "starting" || runtimeBusy || livePidIdentity(s);
+                    if (busy) {
+                        // One-slot queue, last-wins: persist without holding the lifecycle
+                        // lock, then converge — the turn may have ended between the busy
+                        // read and this persist, in which case tryDispatch starts now.
+                        const pendingAt = new Date().toISOString();
+                        try {
+                            this.sessions.update(s.id, { pendingMessage: message, pendingAt });
+                        }
+                        catch (e) {
+                            send({ error: { code: "SEND_FAILED", message: errorMessage(e) } });
+                            return;
+                        }
+                        const queuedEvent = {
+                            type: "message.queued",
+                            sessionId: s.id,
+                            timestamp: pendingAt,
+                            prompt: message,
+                            pendingAt,
+                        };
+                        try {
+                            this.events.append(s.id, queuedEvent);
+                        }
+                        catch { }
+                        this.broadcast(s.id, queuedEvent);
                         try {
-                            socket.write(JSON.stringify({ type: "event", event: last, id: s.id }) + "\n");
+                            this.sessions.update(s.id, { lastEvent: `queued: ${message.slice(0, 80)}` });
                         }
                         catch { }
+                        void this.tryDispatch(s.id);
+                        send({ result: { ok: true, queued: true } });
+                        return;
                     }
+                    // Resumable now (terminal completed/failed/stopped/orphaned, or
+                    // interrupted without a live process): a stale queued slot loses to
+                    // the new message, which starts immediately.
+                    this.sessionLocks.add(s.id);
                     try {
-                        socket.write(JSON.stringify({ type: "done", id: s.id }) + "\n");
+                        try {
+                            this.sessions.update(s.id, { pendingMessage: null, pendingAt: null });
+                        }
+                        catch { }
+                        await this.runResumeTurn(s, message);
+                        send({ result: { ok: true, queued: false } });
                     }
-                    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` } });
-                    return;
-                }
-                const diff = await getDiff({ cwd: s.cwd, worktree: s.worktree, baseCommit: s.baseCommit, repository: s.repository });
-                send({ result: diff });
-                break;
-            }
-            case "claims.add": {
-                const p = params;
-                try {
-                    const claim = this.claims.add(p.sessionId, p.pathGlob, p.reason);
-                    send({ result: { claim } });
+                    catch (e) {
+                        const errText = errorMessage(e);
+                        const code = e instanceof Error && e.code === "SERVICE_UNAVAILABLE"
+                            ? "SERVICE_UNAVAILABLE"
+                            : this.shuttingDown ? "SERVICE_UNAVAILABLE" : "SEND_FAILED";
+                        if (code === "SERVICE_UNAVAILABLE") {
+                            send({ error: { code, message: errText } });
+                            return;
+                        }
+                        try {
+                            this.sessions.setStatus(s.id, "failed");
+                        }
+                        catch { }
+                        send({ error: { code: "SEND_FAILED", message: errText } });
+                    }
+                    finally {
+                        if (!this.shuttingDown)
+                            this.sessionLocks.delete(s.id);
+                    }
+                    break;
                 }
-                catch (error) {
-                    if (error instanceof RunAgentError) {
-                        send({ error: { code: error.code, message: error.message, details: error.details } });
+                case "session.stop": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
                         return;
                     }
-                    throw error;
-                }
-                break;
-            }
-            case "claims.query": {
-                const p = params;
-                try {
-                    const claims = this.claims.query(p.sessionId, p.path);
-                    send({ result: { claims } });
-                }
-                catch (error) {
-                    if (error instanceof RunAgentError) {
-                        send({ error: { code: error.code, message: error.message, details: error.details } });
+                    // Stop cancels a queued message on every exit (explicit cancel),
+                    // including the BUSY/NOT_RUNNING/UNSAFE early returns below.
+                    this.clearPending(s.id);
+                    const driver = this.registry.get(s.agent);
+                    if (this.sessionLocks.has(s.id)) {
+                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} has another lifecycle operation in progress` } });
                         return;
                     }
-                    throw error;
+                    const handle = driver.getHandle?.(s.id);
+                    const hasRuntime = handle !== undefined;
+                    const liveIdentity = livePidIdentity(s);
+                    if (isTerminalStatus(s.status) && !hasRuntime && !liveIdentity) {
+                        send({ error: { code: "SESSION_NOT_RUNNING", message: `Session ${s.id} is ${s.status}` } });
+                        return;
+                    }
+                    if (s.pid != null && !hasRuntime && !s.pidStartTime) {
+                        send({ error: { code: "STOP_UNSAFE", message: `Cannot safely stop session ${s.id}: PID identity is unavailable` } });
+                        return;
+                    }
+                    this.sessionLocks.add(s.id);
+                    const previousStatus = s.status;
+                    const hadTerminalStatus = isTerminalStatus(s.status);
+                    const eventsBeforeStop = this.events.count(s.id);
+                    try {
+                        // Mark active sessions first so an attached event loop that ends
+                        // during stop cannot synthesize a failure or overwrite the outcome.
+                        if (!hadTerminalStatus)
+                            this.sessions.setStatus(s.id, "stopped");
+                        await driver.stop({
+                            id: s.id,
+                            nativeSessionId: s.nativeSessionId,
+                            cwd: s.worktree || s.cwd,
+                            pid: s.pid,
+                            pidStartTime: s.pidStartTime,
+                        });
+                        if (this.shuttingDown) {
+                            sendShuttingDown();
+                            return;
+                        }
+                        const last = this.events.last(s.id);
+                        const terminalArrivedDuringStop = this.events.count(s.id) > eventsBeforeStop &&
+                            (last?.type === "session.completed" || last?.type === "session.failed");
+                        if (terminalArrivedDuringStop) {
+                            if (last.type === "session.completed") {
+                                this.sessions.setStatus(s.id, "completed", { lastEvent: last.reason || "completed" });
+                            }
+                            else {
+                                this.sessions.setStatus(s.id, "failed", { lastEvent: last.error.slice(0, 200), failure: last.failure });
+                            }
+                        }
+                        else if (!hadTerminalStatus) {
+                            const ev = {
+                                type: "session.completed",
+                                sessionId: s.id,
+                                timestamp: new Date().toISOString(),
+                                reason: "stopped",
+                                exitCode: 130,
+                            };
+                            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.
+                        this.clearPending(s.id);
+                        send({ result: { ok: true } });
+                    }
+                    catch (e) {
+                        if (this.shuttingDown) {
+                            sendShuttingDown();
+                            return;
+                        }
+                        try {
+                            this.sessions.setStatus(s.id, previousStatus);
+                        }
+                        catch { }
+                        send({ error: { code: "STOP_FAILED", message: errorMessage(e) } });
+                    }
+                    finally {
+                        if (!this.shuttingDown)
+                            this.sessionLocks.delete(s.id);
+                    }
+                    break;
                 }
-                break;
-            }
-            case "claims.release": {
-                const p = params;
-                try {
-                    const claim = this.claims.release(p.sessionId, p.claimId);
-                    send({ result: { claim } });
+                case "session.logs": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
+                        return;
+                    }
+                    if (p.follow) {
+                        // For follow, we upgrade to subscribe behavior? But spec says logs --follow streams
+                        // We'll handle by keeping socket open and streaming
+                        // Send existing events as result then keep streaming live
+                        const all = this.events.list(s.id, 1000);
+                        send({ result: { session: s, events: all } });
+                        // Then subscribe
+                        this.addSubscriber(s.id, socket);
+                        // Don't close socket
+                        return;
+                    }
+                    else {
+                        const all = this.events.list(s.id, 1000);
+                        send({ result: { session: s, events: all } });
+                    }
+                    break;
                 }
-                catch (error) {
-                    if (error instanceof RunAgentError) {
-                        send({ error: { code: error.code, message: error.message, details: error.details } });
+                case "session.subscribe": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
                         return;
                     }
-                    throw error;
+                    // A late subscriber must not wait forever for a broadcast that already
+                    // happened. Replay the terminal event when available, then close the
+                    // stream just like a live terminal broadcast.
+                    if (isTerminalStatus(s.status)) {
+                        const last = this.events.last(s.id);
+                        if (last?.type === "session.completed" || last?.type === "session.failed") {
+                            try {
+                                socket.write(JSON.stringify({ type: "event", event: last, id: s.id }) + "\n");
+                            }
+                            catch { }
+                        }
+                        try {
+                            socket.write(JSON.stringify({ type: "done", id: s.id }) + "\n");
+                        }
+                        catch { }
+                        return;
+                    }
+                    this.addSubscriber(s.id, socket);
+                    return;
                 }
-                break;
-            }
-            case "daemon.status": {
-                const paths = getPaths();
-                let uptime = Date.now() - this.startTime;
-                send({ result: { running: true, pid: process.pid, uptime, db: paths.db } });
-                break;
-            }
-            case "doctor": {
-                const nodeVersion = process.version;
-                let gitInstalled = false;
-                let gitVersion;
-                try {
-                    const { execFile } = await import("node:child_process");
-                    const { promisify } = await import("node:util");
-                    const execFileAsync = promisify(execFile);
-                    const { stdout } = await execFileAsync("git", ["--version"], { timeout: 3000 });
-                    gitInstalled = true;
-                    gitVersion = stdout.trim();
+                case "session.diff": {
+                    const p = params;
+                    const s = this.sessions.get(p.id);
+                    if (!s) {
+                        sendSessionNotFound(p.id);
+                        return;
+                    }
+                    const diff = await getDiff({ cwd: s.cwd, worktree: s.worktree, baseCommit: s.baseCommit, repository: s.repository });
+                    send({ result: diff });
+                    break;
                 }
-                catch {
-                    gitInstalled = false;
+                case "claims.add": {
+                    const p = params;
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.add(sessionId, p.pathGlob, p.reason), (claim) => ({ result: { claim } }), send);
+                    break;
                 }
-                const agents = await this.registry.detectAll();
-                const caps = {};
-                for (const [k, drv] of this.registry.drivers.entries()) {
-                    caps[k] = drv.capabilities();
+                case "claims.query": {
+                    const p = params;
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.query(sessionId, p.path), (claims) => ({ result: { claims } }), send);
+                    break;
                 }
-                const agentsWithCaps = {};
-                for (const [k, v] of Object.entries(agents)) {
-                    agentsWithCaps[k] = { ...v, capabilities: caps[k] };
+                case "claims.release": {
+                    const p = params;
+                    this.handleClaimRequest(p.sessionId, (sessionId) => this.claims.release(sessionId, p.claimId), (claim) => ({ result: { claim } }), send);
+                    break;
                 }
-                const paths = getPaths();
-                const dbExists = fs.existsSync(paths.db);
-                send({
-                    result: {
-                        node: { version: nodeVersion },
-                        git: { installed: gitInstalled, version: gitVersion },
-                        agents: agentsWithCaps,
-                        daemon: { running: true, pid: process.pid, uptime: Date.now() - this.startTime },
-                        database: { path: paths.db, exists: dbExists },
-                        // Power readiness from the daemon's view (field names fixed by
-                        // cross-worker contract; CLI falls back to local detection).
-                        power: {
-                            serviceInstalled: powerServiceInstalled(),
-                            inhibitAvailable: resolveInhibitBin() !== null,
+                case "doctor": {
+                    const nodeVersion = process.version;
+                    let gitInstalled = false;
+                    let gitVersion;
+                    try {
+                        const { execFile } = await import("node:child_process");
+                        const { promisify } = await import("node:util");
+                        const execFileAsync = promisify(execFile);
+                        const { stdout } = await execFileAsync("git", ["--version"], { timeout: 3000 });
+                        gitInstalled = true;
+                        gitVersion = stdout.trim();
+                    }
+                    catch {
+                        gitInstalled = false;
+                    }
+                    const agents = await this.registry.detectAll();
+                    const caps = {};
+                    for (const [k, drv] of this.registry.drivers.entries()) {
+                        caps[k] = drv.capabilities();
+                    }
+                    const agentsWithCaps = {};
+                    for (const [k, v] of Object.entries(agents)) {
+                        agentsWithCaps[k] = { ...v, capabilities: caps[k] };
+                    }
+                    const paths = getPaths();
+                    const dbExists = fs.existsSync(paths.db);
+                    send({
+                        result: {
+                            node: { version: nodeVersion },
+                            git: { installed: gitInstalled, version: gitVersion },
+                            agents: agentsWithCaps,
+                            daemon: { running: true, pid: process.pid, uptime: Date.now() - this.startTime },
+                            database: { path: paths.db, exists: dbExists },
+                            // Power readiness from the daemon's view (field names fixed by
+                            // cross-worker contract; CLI falls back to local detection).
+                            power: {
+                                serviceInstalled: powerServiceInstalled(),
+                            },
                         },
-                    },
-                });
-                break;
-            }
-            case "models.list": {
-                const p = (params || {});
-                if (p.agent && !this.registry.has(p.agent)) {
-                    send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${p.agent}` } });
-                    return;
+                    });
+                    break;
                 }
-                const agents = await this.fetchModels(p.agent, p.refresh);
-                send({ result: { agents } });
-                break;
-            }
-            case "usage.get": {
-                const p = (params || {});
-                if (typeof p.runId !== "string" || p.runId.length === 0) {
-                    send({ error: { code: "INVALID", message: "runId required" } });
-                    return;
+                case "models.list": {
+                    const p = (params || {});
+                    if (p.agent && !this.registry.has(p.agent)) {
+                        send({ error: { code: "AGENT_NOT_FOUND", message: `Unknown agent ${p.agent}` } });
+                        return;
+                    }
+                    const agents = await this.fetchModels(p.agent, p.refresh);
+                    send({ result: { agents } });
+                    break;
                 }
-                if (p.observe !== undefined) {
-                    const { nativeId, costUsd } = p.observe;
-                    if (typeof nativeId !== "string" ||
-                        nativeId.length === 0 ||
-                        typeof costUsd !== "number" ||
-                        !Number.isFinite(costUsd) ||
-                        costUsd < 0) {
-                        send({ error: { code: "INVALID", message: "observe requires nativeId and a finite non-negative costUsd" } });
+                case "usage.get": {
+                    const p = (params || {});
+                    if (typeof p.runId !== "string" || p.runId.length === 0) {
+                        send({ error: { code: "INVALID", message: "runId required" } });
                         return;
                     }
-                    const session = this.sessions.getByRunId(p.runId)
-                        .find((candidate) => candidate.id === p.runId && candidate.origin === "open");
-                    if (session) {
+                    const runId = p.runId;
+                    const resolvedRunId = this.sessions.getByRunId(runId).length > 0
+                        ? runId
+                        : this.sessions.get(runId)?.id ?? runId;
+                    let observation;
+                    if (p.observe !== undefined) {
+                        const raw = p.observe;
+                        const nativeId = typeof raw === "object" && raw !== null && !Array.isArray(raw)
+                            ? raw.nativeId
+                            : undefined;
+                        const costUsd = typeof raw === "object" && raw !== null && !Array.isArray(raw)
+                            ? raw.costUsd
+                            : undefined;
+                        if (typeof nativeId !== "string" ||
+                            nativeId.length === 0 ||
+                            typeof costUsd !== "number" ||
+                            !Number.isFinite(costUsd) ||
+                            costUsd < 0) {
+                            send({ error: { code: "INVALID", message: "observe requires nativeId and a finite non-negative costUsd" } });
+                            return;
+                        }
+                        observation = { nativeId, costUsd };
+                    }
+                    const session = this.sessions.getByRunId(resolvedRunId)
+                        .find((candidate) => candidate.id === resolvedRunId && candidate.origin === "open");
+                    const earlierNativeIds = new Set();
+                    if (session && observation) {
                         const db = this.db.getHandle();
                         db.exec("BEGIN");
-                        let previous = [];
                         try {
-                            previous = this.nativeLinks.link(session.id, nativeId).previous;
-                            this.usageLedger.observe(session.id, openSourceKey(nativeId), { cost: costUsd });
+                            const { previous } = this.nativeLinks.link(session.id, observation.nativeId);
+                            previous.forEach((nativeId) => earlierNativeIds.add(nativeId));
+                            this.usageLedger.observe(session.id, openSourceKey(observation.nativeId), { cost: observation.costUsd });
                             db.exec("COMMIT");
                         }
                         catch (error) {
@@ -1132,35 +1395,74 @@ class Daemon {
                             catch { }
                             throw error;
                         }
-                        if (previous.length > 0)
-                            await this.reconcileOpenUsageSafely(session.id, previous);
                     }
+                    const rawTranscript = p.transcript;
+                    const transcript = typeof rawTranscript === "object" && rawTranscript !== null && !Array.isArray(rawTranscript)
+                        ? rawTranscript
+                        : undefined;
+                    if (session &&
+                        session.agent === "claude" &&
+                        isActiveStatus(session.status) &&
+                        transcript &&
+                        typeof transcript.nativeId === "string" &&
+                        transcript.nativeId.length > 0 &&
+                        typeof transcript.path === "string" &&
+                        transcript.path.length > 0 &&
+                        (!observation || observation.nativeId === transcript.nativeId)) {
+                        const previous = await this.ingestLiveTranscript(session.id, transcript.nativeId, transcript.path);
+                        previous.forEach((nativeId) => earlierNativeIds.add(nativeId));
+                    }
+                    const sessions = this.sessions.getByRunId(resolvedRunId);
+                    const sessionIds = sessions.map((session) => session.id);
+                    const attributions = this.usageLedger.attributionsFor(sessionIds);
+                    const linkStates = this.nativeLinks.linksFor(sessionIds).map(({ sessionId, state }) => ({ sessionId, state }));
+                    send({ result: aggregateRunUsage(resolvedRunId, sessions, attributions, linkStates) });
+                    if (session && earlierNativeIds.size > 0) {
+                        this.queueOpenUsageReconciliation(session.id, [...earlierNativeIds]);
+                    }
+                    break;
                 }
-                const sessions = this.sessions.getByRunId(p.runId);
-                const sessionIds = sessions.map((session) => session.id);
-                const attributions = this.usageLedger.attributionsFor(sessionIds);
-                const linkStates = this.nativeLinks.linksFor(sessionIds).map(({ sessionId, state }) => ({ sessionId, state }));
-                send({ result: aggregateRunUsage(p.runId, sessions, attributions, linkStates) });
-                break;
-            }
-            case "usage.query": {
-                const p = (params || {});
-                try {
-                    const result = this.sessions.queryUsage(p);
-                    send({ result });
+                case "usage.query": {
+                    const p = (params || {});
+                    try {
+                        const result = this.sessions.queryUsage(p);
+                        send({ result });
+                    }
+                    catch (error) {
+                        send({ error: { code: "USAGE_QUERY_ERROR", message: errorMessage(error) } });
+                    }
+                    break;
                 }
-                catch (error) {
-                    send({ error: { code: "USAGE_QUERY_ERROR", message: error instanceof Error ? error.message : String(error) } });
+                case "web.ensure": {
+                    const p = (params || {});
+                    try {
+                        send({ result: await this.webHost().ensure(p) });
+                    }
+                    catch (error) {
+                        if (error instanceof WebEnsureError) {
+                            send({ error: { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) } });
+                        }
+                        else {
+                            send({ error: { code: "WEB_START_FAILED", message: errorMessage(error) } });
+                        }
+                    }
+                    break;
                 }
-                break;
+                case "daemon.stop": {
+                    send({ result: { ok: true } });
+                    void this.handleShutdown("daemon.stop").finally(() => process.exit(0));
+                    break;
+                }
+                default:
+                    send({ error: { code: "UNKNOWN_METHOD", message: `Unknown method ${method}` } });
             }
-            case "daemon.stop": {
-                send({ result: { ok: true } });
-                void this.handleShutdown("daemon.stop").finally(() => process.exit(0));
-                break;
+        }
+        catch (error) {
+            if (error instanceof AmbiguousSessionIdError) {
+                send({ error: { code: error.code, message: error.message } });
+                return;
             }
-            default:
-                send({ error: { code: "UNKNOWN_METHOD", message: `Unknown method ${method}` } });
+            throw error;
         }
     }
     addSubscriber(sessionId, socket) {
@@ -1197,6 +1499,30 @@ 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;
+    }
+    /**
+     * Start the web console with the daemon so its address answers without a
+     * prior web command. Not awaited: IPC never waits on the web stack.
+     */
+    autostartWeb() {
+        const config = loadConfig();
+        const { port, invalid } = resolveWebPort(config);
+        const { host, invalid: invalidHost } = resolveWebHost(config);
+        if (invalid !== undefined)
+            appendDaemonLog(invalidWebPortMessage(invalid));
+        if (invalidHost !== undefined)
+            appendDaemonLog(invalidWebHostMessage(invalidHost));
+        this.webHost()
+            .ensure({ preferredPort: port, preferredHost: host })
+            .catch((error) => appendDaemonLog(`web autostart failed: ${errorMessage(error)}`));
+    }
     async startDriverForSession(sessionId, prompt, model) {
         if (this.shuttingDown)
             return;
@@ -1210,8 +1536,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,
@@ -1278,10 +1603,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) {
@@ -1296,8 +1621,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,
@@ -1402,7 +1726,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);
@@ -1438,19 +1762,21 @@ class Daemon {
                 this.sessionLocks.delete(sessionId);
         }
     }
-    async attachDriverEvents(sessionId, driver, drvSession) {
-        try {
-            for await (const ev of driver.events(drvSession)) {
-                // A stop operation owns the terminal outcome. A terminal frame already
-                // buffered by the harness must not race it into the event log.
-                if (this.sessionLocks.has(sessionId) && (ev.type === "session.completed" || ev.type === "session.failed")) {
-                    continue;
-                }
-                const db = this.db.getHandle();
-                db.exec("BEGIN");
-                let inserted = 0;
+    // Commits one event with its cursor. A busy store is the daemon's problem,
+    // not the session's: the harness keeps running and its output stays in the
+    // log file, so retry the same event until the store frees up instead of
+    // failing a live session. Returns undefined when shutdown interrupts the
+    // wait (the drain owns the outcome); any other error propagates.
+    async persistDriverEvent(sessionId, driver, ev) {
+        const db = this.db.getHandle();
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                // IMMEDIATE takes the write lock up front, so busy_timeout applies.
+                // A deferred BEGIN read first and then got SQLITE_BUSY_SNAPSHOT on
+                // the upgrade, which no busy handler retries.
+                db.exec("BEGIN IMMEDIATE");
                 try {
-                    inserted = this.events.append(sessionId, ev, ev.raw);
+                    const inserted = this.events.append(sessionId, ev, ev.raw);
                     const offsets = driver.getOffsets?.(sessionId);
                     if (offsets) {
                         this.sessions.update(sessionId, { logOffset: offsets.log, stderrOffset: offsets.stderr });
@@ -1460,6 +1786,7 @@ class Daemon {
                         this.updateSessionFromEvent(sessionId, ev, inserted);
                     }
                     db.exec("COMMIT");
+                    return inserted;
                 }
                 catch (error) {
                     try {
@@ -1468,6 +1795,29 @@ class Daemon {
                     catch { }
                     throw error;
                 }
+            }
+            catch (error) {
+                if (!isStoreBusy(error))
+                    throw error;
+                if (this.shuttingDown)
+                    return undefined;
+                if (attempt === 0)
+                    appendDaemonLog(`store busy persisting ${ev.type} for ${sessionId}; retrying`);
+                await sleep(Math.min(STORE_BUSY_RETRY_BASE_MS * 2 ** attempt, STORE_BUSY_RETRY_MAX_MS));
+            }
+        }
+    }
+    async attachDriverEvents(sessionId, driver, drvSession) {
+        try {
+            for await (const ev of driver.events(drvSession)) {
+                // A stop operation owns the terminal outcome. A terminal frame already
+                // buffered by the harness must not race it into the event log.
+                if (this.sessionLocks.has(sessionId) && (ev.type === "session.completed" || ev.type === "session.failed")) {
+                    continue;
+                }
+                const inserted = await this.persistDriverEvent(sessionId, driver, ev);
+                if (inserted === undefined)
+                    return;
                 // Broadcast only after the durable event+cursor commit, and never
                 // broadcast a replay that was already in the event store.
                 if (inserted !== 0)
@@ -1479,7 +1829,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",
@@ -1489,8 +1839,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;
         }
@@ -1522,11 +1871,11 @@ 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 });
             }
         }
+        this.finishHeal(sessionId);
         // A message queued while the turn ran starts now as the next turn.
         // tryDispatch rechecks resumability under the lifecycle lock; a stale
         // or unresumable slot stays put for a manual send.
@@ -1640,52 +1989,6 @@ class Daemon {
             return;
         void this.handleShutdown(reason).finally(() => process.exit(0));
     }
-    // Best-effort delay lock: while this child lives, systemd/logind delays
-    // shutdown up to InhibitDelayMaxSec so the drain can finish. Silent no-op
-    // when the binary is absent. The binary resolves through fixed absolute
-    // paths only, never PATH (typescript:S4036). Public so tests can drive it
-    // without start() (no socket binding); binOverride is the test seam for
-    // a fake binary.
-    maybeSpawnInhibit(binOverride) {
-        if (this.inhibitChild)
-            return;
-        const bin = binOverride ?? resolveInhibitBin();
-        if (!bin)
-            return;
-        // Absent binary (removed between resolve and spawn, or a bogus test
-        // seam path) is a silent no-op: spawn(2) failure would only surface
-        // as an async error event, leaving a dead child behind.
-        try {
-            if (!fs.existsSync(bin))
-                return;
-        }
-        catch {
-            return;
-        }
-        try {
-            const child = spawn(bin, ["--what=shutdown:sleep", "--who=CodeDeck", "--why=flush sessions", "--mode=delay", "sleep", "infinity"], { stdio: "ignore", detached: true });
-            child.on("error", () => { });
-            child.unref();
-            this.inhibitChild = child;
-            if (!this.inhibitExitHookInstalled) {
-                this.inhibitExitHookInstalled = true;
-                process.once("exit", () => this.killInhibitChild());
-            }
-        }
-        catch {
-            this.inhibitChild = null;
-        }
-    }
-    killInhibitChild() {
-        const child = this.inhibitChild;
-        this.inhibitChild = null;
-        if (!child)
-            return;
-        try {
-            child.kill();
-        }
-        catch { }
-    }
     // Graceful power shutdown. Exposed as a method so tests can drive the
     // drain without signals/systemd: exactly-once (concurrent callers share
     // one drain), never throws, never exits — callers decide on exit.
@@ -1697,6 +2000,11 @@ class Daemon {
         return this.shutdownPromise;
     }
     async runShutdown(reason) {
+        // SIGTERM only; the web child holds no state worth waiting for.
+        try {
+            this.web?.close();
+        }
+        catch { }
         const handle = this.db.getHandle();
         // Never close mid-transaction: roll back a stale BEGIN (best-effort)
         // BEFORE persisting, so the interrupted writes below stay durable.
@@ -1728,27 +2036,23 @@ class Daemon {
             handle.exec("PRAGMA wal_checkpoint(TRUNCATE)");
         }
         catch { }
-        // The delay lock has served its purpose; release it before closing.
-        this.killInhibitChild();
-        try {
-            const paths = getPaths();
-            try {
-                fs.unlinkSync(paths.daemonSock);
-            }
-            catch { }
+        if (this.boundPaths) {
             try {
-                fs.unlinkSync(paths.daemonPid);
+                fs.unlinkSync(this.boundPaths.sock);
             }
             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() {
@@ -1791,7 +2095,7 @@ class Daemon {
     async markInterrupted(s, reason) {
         try {
             // Serialize against an in-flight send/stop owner (bounded: the drain
-            // must fit in InhibitDelayMaxSec), then hold the lock so attached
+            // must fit before systemd's SIGKILL), then hold the lock so attached
             // event loops discard terminal frames instead of overwriting
             // `interrupted` (see attachDriverEvents).
             const deadline = Date.now() + 500;
@@ -1814,17 +2118,27 @@ 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 { }
     }
 }
+// Held for the process lifetime (instance-lock keeps the connection alive
+// against GC); the kernel drops it on exit, so shutdown does not release it.
+let instanceLock = null;
 // Entry
 if (process.argv.includes("--daemon")) {
+    // Take the lock before opening run-agent.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);
+    if (!instanceLock) {
+        appendDaemonLog(`pid ${process.pid}: another daemon holds ${getPaths().daemonLock}; exiting`);
+        process.exit(0);
+    }
     const d = new Daemon();
-    d.start().catch((e) => {
+    d.start().then(() => d.autostartWeb(), (e) => {
         console.error("[daemon] failed to start", e);
         process.exit(1);
     });