codedeck 0.6.0 → 0.7.1

package/dist/daemon/daemon.js

@@ -1,26 +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, 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 { 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).
@@ -70,26 +78,197 @@ 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;
     events;
     claims;
+    usageLedger;
+    nativeLinks;
     registry = getRegistry();
     server;
     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 = error instanceof Error ? error.message : String(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);
@@ -101,18 +280,36 @@ 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();
         this.sessions = new SessionStore(handle);
         this.events = new EventStore(handle);
         this.claims = new ClaimsStore(handle);
+        this.usageLedger = new UsageLedger(handle);
+        this.nativeLinks = new NativeLinkStore(handle);
     }
     async start() {
         const paths = getPaths();
+        const isDead = (session) => !livePidIdentity(session);
         // Recover orphaned sessions
         await this.recover();
+        const staleSessionIds = new Set(this.nativeLinks.staleOpenRows(isDead).map((session) => session.id));
+        const retryableRows = this.db.getHandle().prepare(`
+      SELECT DISTINCT sessions.id
+      FROM sessions
+      INNER JOIN session_native_links ON session_native_links.session_id = sessions.id
+      WHERE sessions.origin = 'open'
+        AND sessions.agent = 'claude'
+        AND sessions.status IN ('completed', 'failed')
+        AND session_native_links.reconciled_at IS NULL
+    `).all();
+        for (const row of retryableRows)
+            staleSessionIds.add(row.id);
+        this.startupReconcilePromise = Promise.all([...staleSessionIds].map((sessionId) => this.reconcileOpenUsageSafely(sessionId))).then(() => { });
         this.server = createIpcServer(async (req, socket) => {
             try {
                 await this.handleRequest(req, socket);
@@ -135,14 +332,16 @@ class Daemon {
         }
         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
@@ -157,6 +356,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
@@ -225,7 +425,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",
@@ -246,13 +449,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({
@@ -298,6 +502,130 @@ 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: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async reconcileOpenUsage(sessionId, nativeIds) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.origin !== "open" || session.agent !== "claude")
+            return;
+        const selectedIds = nativeIds === undefined ? undefined : new Set(nativeIds);
+        const links = nativeIds === undefined
+            ? this.nativeLinks.linksFor([sessionId])
+            : this.nativeLinks.unreconciled(sessionId);
+        for (const link of links) {
+            if (selectedIds && !selectedIds.has(link.nativeId))
+                continue;
+            const transcript = findTranscript(link.nativeId);
+            if (!transcript) {
+                // A transcript that vanished after a successful read keeps its known state.
+                if (link.state === null || link.state === "missing") {
+                    this.nativeLinks.markReconciled(sessionId, link.nativeId, "missing");
+                }
+                continue;
+            }
+            const usage = await readTranscriptUsage(transcript);
+            const db = this.db.getHandle();
+            db.exec("BEGIN");
+            try {
+                this.usageLedger.observe(sessionId, openSourceKey(link.nativeId), {
+                    cost: usage.cost,
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cachedTokens: usage.cachedTokens,
+                    model: usage.model,
+                });
+                this.nativeLinks.markReconciled(sessionId, link.nativeId, usage.state);
+                db.exec("COMMIT");
+            }
+            catch (error) {
+                try {
+                    db.exec("ROLLBACK");
+                }
+                catch { }
+                throw error;
+            }
+        }
+    }
+    async reconcileOpenUsageSafely(sessionId, nativeIds) {
+        try {
+            await this.reconcileOpenUsage(sessionId, nativeIds);
+            return true;
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(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);
+    }
     async handleRequest(req, socket) {
         const { id, method, params } = req;
         const send = (res) => {
@@ -313,684 +641,860 @@ class Daemon {
             send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
             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 {
-                        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" } });
-                            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) } });
+        try {
+            switch (method) {
+                case "session.create": {
+                    const p = params;
+                    const prompt = p.prompt;
+                    if (!prompt) {
+                        send({ error: { code: "INVALID", message: "prompt required" } });
                         return;
                     }
-                }
-                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)
+                    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 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 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 {
-                        this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
+                        gitInfo = await getGitInfo(cwd);
                     }
-                    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;
-                }
-                let sessionId = generateSessionId();
-                while (this.sessions.get(sessionId)) {
-                    sessionId = generateSessionId();
-                }
-                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;
-                }
-                if (gitInfo) {
-                    repository = gitInfo.root;
-                    if (!baseCommit)
+                    catch (error) {
+                        this.releaseSessionId(sessionId);
+                        throw error;
+                    }
+                    if (this.shuttingDown) {
+                        this.releaseSessionId(sessionId);
+                        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 {
+                            const wt = await createWorktree({ repoRoot: gitInfo.root, sessionId, prompt, name: p.name });
+                            if (this.shuttingDown) {
+                                this.releaseSessionId(sessionId);
+                                send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                                return;
+                            }
+                            worktree = wt.path;
+                            branch = wt.branch;
+                            baseCommit = wt.baseCommit;
+                            cwd = worktree;
+                        }
+                        catch (e) {
+                            this.releaseSessionId(sessionId);
+                            send({ error: { code: "WORKTREE_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                            return;
+                        }
+                    }
+                    else if (gitInfo) {
                         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.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);
-                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: "released",
+                    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,
                     };
-                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 });
+                        this.sessions.create(session);
                     }
-                    catch (e) {
-                        send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                    finally {
+                        this.releaseSessionId(sessionId);
+                    }
+                    // Start driver async (don't block response too long)
+                    // But we need to start before returning? Return quickly then start
+                    send({ result: { session } });
+                    // Now start driver in background
+                    this.startDriverForSession(sessionId, prompt, p.model).catch((e) => {
+                        if (this.shuttingDown)
+                            return;
+                        const msg = e instanceof Error ? e.message : String(e);
+                        const 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);
+                    });
+                    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 queuedEvent = {
-                        type: "message.queued",
-                        sessionId: s.id,
-                        timestamp: pendingAt,
-                        prompt: message,
-                        pendingAt,
+                    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,
+                        });
+                        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;
+                    }
+                    const sessionId = this.nextSessionId();
+                    if (gitInfo) {
+                        repository = gitInfo.root;
+                        if (!baseCommit)
+                            baseCommit = gitInfo.head;
+                    }
+                    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;
-                }
-                // 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 });
+                    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;
                     }
-                    catch { }
-                    await this.runResumeTurn(s, message);
-                    send({ result: { ok: true, queued: false } });
-                }
-                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 } });
+                    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;
                     }
-                    try {
-                        this.sessions.setStatus(s.id, "failed");
+                    const session = this.sessions.get(p.id);
+                    if (!session) {
+                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
+                        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;
-                }
-                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" } });
+                    if (session.origin !== "open") {
+                        send({ result: { created: false } });
                         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 });
+                    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);
                         }
+                        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.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;
                     }
-                    // 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);
+                    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;
                 }
-                catch (e) {
-                    if (this.shuttingDown) {
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                case "session.send": {
+                    const p = params;
+                    const validated = validateSendMessage(p.message);
+                    if ("code" in validated) {
+                        send({ error: { code: validated.code, message: validated.error } });
                         return;
                     }
-                    try {
-                        this.sessions.setStatus(s.id, previousStatus);
+                    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;
                     }
-                    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;
-                }
-                // 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") {
+                    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 {
-                            socket.write(JSON.stringify({ type: "event", event: last, id: s.id }) + "\n");
+                            this.sessions.update(s.id, { pendingMessage: message, pendingAt });
+                        }
+                        catch (e) {
+                            send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(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 {
+                            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 = 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 } });
+                            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) {
+                        send({ error: { code: "SESSION_NOT_FOUND", message: `Session ${p.id} not found` } });
                         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;
-                }
-                break;
-            }
-            case "claims.release": {
-                const p = params;
-                try {
-                    const claim = this.claims.release(p.sessionId, p.claimId);
-                    send({ result: { claim } });
+                    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;
+                    }
+                    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" } });
+                            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.events.append(s.id, ev);
+                            this.broadcast(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) {
+                            send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                            return;
+                        }
+                        try {
+                            this.sessions.setStatus(s.id, previousStatus);
+                        }
+                        catch { }
+                        send({ error: { code: "STOP_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                    }
+                    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.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;
                     }
-                    throw error;
+                    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;
                 }
-                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.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;
+                    }
+                    // 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;
+                    }
+                    // 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;
                 }
-                catch {
-                    gitInstalled = false;
+                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;
                 }
-                const agents = await this.registry.detectAll();
-                const caps = {};
-                for (const [k, drv] of this.registry.drivers.entries()) {
-                    caps[k] = drv.capabilities();
+                case "claims.add": {
+                    const p = params;
+                    try {
+                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
+                        const claim = this.claims.add(sessionId, p.pathGlob, p.reason);
+                        send({ result: { claim } });
+                    }
+                    catch (error) {
+                        if (error instanceof RunAgentError) {
+                            send({ error: { code: error.code, message: error.message, details: error.details } });
+                            return;
+                        }
+                        throw error;
+                    }
+                    break;
                 }
-                const agentsWithCaps = {};
-                for (const [k, v] of Object.entries(agents)) {
-                    agentsWithCaps[k] = { ...v, capabilities: caps[k] };
+                case "claims.query": {
+                    const p = params;
+                    try {
+                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
+                        const claims = this.claims.query(sessionId, p.path);
+                        send({ result: { claims } });
+                    }
+                    catch (error) {
+                        if (error instanceof RunAgentError) {
+                            send({ error: { code: error.code, message: error.message, details: error.details } });
+                            return;
+                        }
+                        throw error;
+                    }
+                    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 "claims.release": {
+                    const p = params;
+                    try {
+                        const sessionId = this.sessions.get(p.sessionId)?.id ?? p.sessionId;
+                        const claim = this.claims.release(sessionId, p.claimId);
+                        send({ result: { claim } });
+                    }
+                    catch (error) {
+                        if (error instanceof RunAgentError) {
+                            send({ error: { code: error.code, message: error.message, details: error.details } });
+                            return;
+                        }
+                        throw error;
+                    }
+                    break;
+                }
+                case "daemon.status": {
+                    const paths = getPaths();
+                    let uptime = Date.now() - this.startTime;
+                    send({ result: { running: true, pid: process.pid, uptime, db: paths.db } });
+                    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();
+                    }
+                    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;
+                }
+                case "usage.get": {
+                    const p = (params || {});
+                    if (typeof p.runId !== "string" || p.runId.length === 0) {
+                        send({ error: { code: "INVALID", message: "runId required" } });
+                        return;
+                    }
+                    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");
+                        try {
+                            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) {
+                            try {
+                                db.exec("ROLLBACK");
+                            }
+                            catch { }
+                            throw error;
+                        }
+                    }
+                    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);
-                send({ result: aggregateRunUsage(p.runId, sessions) });
-                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: error instanceof Error ? error.message : String(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: error instanceof Error ? error.message : String(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) {
@@ -1027,6 +1531,26 @@ class Daemon {
             }
         }
     }
+    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: ${error instanceof Error ? error.message : String(error)}`));
+    }
     async startDriverForSession(sessionId, prompt, model) {
         if (this.shuttingDown)
             return;
@@ -1046,6 +1570,7 @@ class Daemon {
             sessionId,
             prompt,
             cwd: session.worktree || session.cwd,
+            runId: session.runId ?? undefined,
             model: model || session.model,
             // Read back from the session rather than the request so a follow-up turn
             // from send() runs with the same effort/tier the session was started with.
@@ -1129,6 +1654,7 @@ class Daemon {
         this.broadcast(s.id, turnEvent);
         const drvSession = {
             id: s.id,
+            runId: s.runId ?? undefined,
             nativeSessionId: s.nativeSessionId,
             cwd: s.worktree || s.cwd,
             model: s.model,
@@ -1266,28 +1792,31 @@ 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 });
                     }
                     if (inserted !== 0) {
                         // Update session status based on event.
-                        this.updateSessionFromEvent(sessionId, ev);
+                        this.updateSessionFromEvent(sessionId, ev, inserted);
                     }
                     db.exec("COMMIT");
+                    return inserted;
                 }
                 catch (error) {
                     try {
@@ -1296,6 +1825,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)
@@ -1355,13 +1907,35 @@ class Daemon {
                 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.
         if (!this.shuttingDown)
             void this.tryDispatch(sessionId);
     }
-    updateSessionFromEvent(sessionId, ev) {
+    previousUsageProcessOrdinal(sessionId, currentSequence, eventSequence) {
+        const previousUsageEvent = this.db.getHandle().prepare(`
+      SELECT sequence FROM events
+      WHERE session_id = ? AND type = 'usage.updated' AND sequence <= ?
+        AND (? IS NULL OR sequence <> ?)
+        AND (
+          json_extract(normalized_payload, '$.usage.cost') IS NOT NULL OR
+          json_extract(normalized_payload, '$.usage.inputTokens') IS NOT NULL OR
+          json_extract(normalized_payload, '$.usage.outputTokens') IS NOT NULL OR
+          json_extract(normalized_payload, '$.usage.cachedTokens') IS NOT NULL
+        )
+      ORDER BY sequence DESC
+      LIMIT 1
+    `).get(sessionId, currentSequence, eventSequence ?? null, eventSequence ?? null);
+        if (!previousUsageEvent)
+            return;
+        return this.db.getHandle().prepare(`
+      SELECT COUNT(*) AS count FROM events
+      WHERE session_id = ? AND type = 'session.started' AND sequence <= ?
+    `).get(sessionId, previousUsageEvent.sequence).count;
+    }
+    updateSessionFromEvent(sessionId, ev, sequence) {
         try {
             const current = this.sessions.get(sessionId);
             if (current?.status === "stopped" && (ev.type === "session.completed" || ev.type === "session.failed")) {
@@ -1390,7 +1964,22 @@ class Daemon {
                 const sess = this.sessions.get(sessionId);
                 if (sess) {
                     const next = ev.usage || {};
-                    if (ev.incremental) {
+                    const currentSequence = sequence ?? this.db.getHandle().prepare(`SELECT COALESCE(MAX(sequence), 0) AS sequence FROM events WHERE session_id = ?`).get(sessionId).sequence;
+                    const processOrdinal = this.db.getHandle().prepare(`
+            SELECT COUNT(*) AS count FROM events
+            WHERE session_id = ? AND type = 'session.started' AND sequence <= ?
+          `).get(sessionId, currentSequence);
+                    const sourceKey = workerSourceKey(sess, processOrdinal.count);
+                    if (sourceKey && !ev.incremental) {
+                        const previousOrdinal = sourceKey.startsWith("claude:")
+                            ? this.previousUsageProcessOrdinal(sessionId, currentSequence, sequence)
+                            : undefined;
+                        const seedIntoIncoming = previousOrdinal === undefined || previousOrdinal === processOrdinal.count;
+                        this.usageLedger.observe(sessionId, sourceKey, next, seedIntoIncoming);
+                        if (next.model)
+                            this.sessions.update(sessionId, { model: next.model });
+                    }
+                    else if (ev.incremental) {
                         const cur = sess.usage || {};
                         const inputTokens = (cur.inputTokens ?? 0) + (next.inputTokens ?? 0);
                         const outputTokens = (cur.outputTokens ?? 0) + (next.outputTokens ?? 0);
@@ -1432,52 +2021,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.
@@ -1489,6 +2032,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.
@@ -1520,8 +2068,6 @@ 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 {
@@ -1583,7 +2129,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;
@@ -1613,10 +2159,21 @@ class Daemon {
         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);
     });