codedeck 0.3.0 → 0.4.1

package/dist/daemon/daemon.js

@@ -9,7 +9,7 @@ import { ClaimsStore } from "../store/claims.js";
 import { getPaths, ensureDirs } from "../config/paths.js";
 import { createIpcServer } from "./ipc.js";
 import { getRegistry } from "../drivers/registry.js";
-import { isTerminalStatus } from "../core/session.js";
+import { 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";
@@ -40,6 +40,36 @@ function resolveRequestSandbox(value) {
         return undefined;
     }
 }
+// Read-boundary liveness: serve a corpse as "dead" (same rule `ps` shows)
+// instead of the stale stored "working". Returns the same object when no
+// correction applies, so callers can skip copies; never mutates the store.
+function withLiveStatus(s) {
+    if (s.pid == null)
+        return s;
+    const status = liveStatus(s.status, s.pid, processAlive(s.pid));
+    return status === s.status ? s : { ...s, status: status };
+}
+// Send-queue cap: bytes, matching MAX_SEND_BODY_BYTES on the web route.
+const MAX_SEND_MESSAGE_BYTES = 64 * 1024;
+function validateSendMessage(raw) {
+    if (typeof raw !== "string")
+        return { code: "INVALID", error: "message required" };
+    const message = raw.trim();
+    if (!message)
+        return { code: "INVALID", error: "message required" };
+    if (Buffer.byteLength(message, "utf8") > MAX_SEND_MESSAGE_BYTES) {
+        return { code: "INVALID", error: "message too large" };
+    }
+    return { message };
+}
+// PID identity triple, same rule as the stop path: a recycled PID must
+// neither block a legitimate resume nor permit killing a stranger.
+function livePidIdentity(s) {
+    return (s.pid != null &&
+        s.pidStartTime != null &&
+        processAlive(s.pid) &&
+        processStartTime(s.pid) === s.pidStartTime);
+}
 class Daemon {
     db;
     sessions;
@@ -135,6 +165,53 @@ class Daemon {
             // starting|working|needs_input|idle.
             if (s.status === "interrupted")
                 continue;
+            if (s.origin === "open") {
+                if (s.pid == null) {
+                    this.sessions.setStatus(s.id, "failed", { lastEvent: "open session terminated before patch" });
+                    continue;
+                }
+                const currentStart = processStartTime(s.pid);
+                const processPresent = processAlive(s.pid);
+                const identityVerified = s.pidStartTime != null && currentStart === s.pidStartTime;
+                if (processPresent && identityVerified) {
+                    // Head process still running interactively; remain working, no driver to attach
+                    continue;
+                }
+                else if (!processPresent) {
+                    // Closed normally while daemon was away
+                    const ev = {
+                        type: "session.completed",
+                        sessionId: s.id,
+                        timestamp: new Date().toISOString(),
+                        reason: "closed while daemon was stopped",
+                    };
+                    this.events.append(s.id, ev);
+                    this.sessions.setStatus(s.id, "completed", { lastEvent: "closed while daemon was stopped" });
+                    continue;
+                }
+                else {
+                    // PID recycled (processPresent is true but !identityVerified)
+                    const failure = {
+                        code: "HARNESS_CRASH",
+                        blame: "harness",
+                        retryable: false,
+                        reason: "pid_reused",
+                        detail: `PID ${s.pid} no longer identifies the head session`,
+                    };
+                    const detail = failure.detail ?? `PID ${s.pid} no longer identifies the head session`;
+                    const event = {
+                        type: "session.failed",
+                        sessionId: s.id,
+                        timestamp: new Date().toISOString(),
+                        error: detail,
+                        failure,
+                        raw: { pid: s.pid, expectedStartTime: s.pidStartTime, currentStart },
+                    };
+                    this.events.append(s.id, event);
+                    this.sessions.setStatus(s.id, "failed", { lastEvent: detail, failure });
+                    continue;
+                }
+            }
             const driver = this.registry.get(s.agent);
             const metadata = readSessionProcessMetadata(s.id);
             const pid = metadata?.pid ?? s.pid;
@@ -246,7 +323,8 @@ class Daemon {
                 }
                 const cwdIn = p.cwd || process.cwd();
                 const cfg = loadConfig();
-                let agent = p.agent || cfg.defaultAgent || "claude";
+                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;
@@ -336,10 +414,140 @@ class Daemon {
                 });
                 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)
+                        baseCommit = gitInfo.head;
+                }
+                const now = new Date();
+                const session = {
+                    id: sessionId,
+                    runId: sessionId,
+                    origin: "open",
+                    name: p.name,
+                    agent,
+                    model: p.model,
+                    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",
+                    };
+                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);
+                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 } });
@@ -347,11 +555,12 @@ class Daemon {
             }
             case "session.get": {
                 const p = params;
-                const s = this.sessions.get(p.id);
-                if (!s) {
+                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 } });
@@ -374,124 +583,110 @@ class Daemon {
             }
             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);
-                // 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.
+                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;
                 }
-                if (s.status === "interrupted") {
-                    // Resume-turn admission for power-interrupted sessions: capability
-                    // BEFORE liveness, and liveness by process identity (same rule as
-                    // stop). A recycled PID must not block a legitimate resume.
-                    if (!s.nativeSessionId || !driver.capabilities().resume) {
-                        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;
+                // Do not start a second harness while the current one is still live:
+                // both runtimes would tail the same per-session file and duplicate
+                // every event from the follow-up turn. Queue behind a live turn only.
+                const busyHandle = driver.getHandle?.(s.id);
+                const busyState = busyHandle && typeof busyHandle === "object"
+                    ? busyHandle
+                    : undefined;
+                const runtimeBusy = busyHandle !== undefined && (busyState?.done !== true || busyState?.drained !== true);
+                const busy = s.status === "starting" || runtimeBusy || livePidIdentity(s);
+                if (busy) {
+                    // One-slot queue, last-wins: persist without holding the lifecycle
+                    // lock, then converge — the turn may have ended between the busy
+                    // read and this persist, in which case tryDispatch starts now.
+                    const pendingAt = new Date().toISOString();
+                    try {
+                        this.sessions.update(s.id, { pendingMessage: message, pendingAt });
                     }
-                    const liveIdentity = s.pid != null &&
-                        s.pidStartTime != null &&
-                        processAlive(s.pid) &&
-                        processStartTime(s.pid) === s.pidStartTime;
-                    if (liveIdentity) {
-                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running (stop it first)` } });
+                    catch (e) {
+                        send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(e) } });
                         return;
                     }
-                }
-                else {
-                    const handle = driver.getHandle?.(s.id);
-                    const runtimeState = handle && typeof handle === "object"
-                        ? handle
-                        : undefined;
-                    const runtimeDraining = handle !== undefined && (runtimeState?.done !== true || runtimeState?.drained !== true);
-                    if (s.status === "starting" || runtimeDraining || (s.status === "working" && s.pid != null && processAlive(s.pid))) {
-                        send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} is still running` } });
-                        return;
+                    const queuedEvent = {
+                        type: "message.queued",
+                        sessionId: s.id,
+                        timestamp: pendingAt,
+                        prompt: message,
+                        pendingAt,
+                    };
+                    try {
+                        this.events.append(s.id, queuedEvent);
                     }
-                    if (!driver.capabilities().resume) {
-                        send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Agent ${s.agent} does not support resume` } });
-                        return;
+                    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;
                 }
-                const drvSession = {
-                    id: s.id,
-                    nativeSessionId: s.nativeSessionId,
-                    cwd: s.worktree || s.cwd,
-                    model: s.model,
-                    effort: s.effort,
-                    fast: s.fast,
-                    sandbox: s.sandbox,
-                    dangerouslyBypassApprovalsAndSandbox: s.dangerouslyBypassApprovalsAndSandbox,
-                    pid: s.pid,
-                    pidStartTime: s.pidStartTime,
-                };
+                // 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 {
-                    if (this.shuttingDown) {
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
-                        return;
-                    }
-                    this.sessions.setStatus(s.id, "working", { lastEvent: `send: ${p.message.slice(0, 80)}` });
-                    const turnEvent = {
-                        type: "turn.started",
-                        sessionId: s.id,
-                        timestamp: new Date().toISOString(),
-                        prompt: p.message,
-                    };
-                    this.events.append(s.id, turnEvent);
-                    this.broadcast(s.id, turnEvent);
-                    await driver.send(drvSession, p.message);
-                    if (this.shuttingDown) {
-                        try {
-                            await driver.stop(drvSession);
-                        }
-                        catch { }
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
-                        return;
-                    }
-                    const handle = driver.getHandle?.(s.id);
-                    const handleNativeId = handle &&
-                        typeof handle === "object" &&
-                        "nativeSessionId" in handle &&
-                        typeof handle.nativeSessionId === "string"
-                        ? handle.nativeSessionId
-                        : undefined;
-                    const newNative = handleNativeId || drvSession.nativeSessionId;
-                    if (newNative && newNative !== s.nativeSessionId) {
-                        this.sessions.update(s.id, { nativeSessionId: newNative });
-                    }
-                    if (drvSession.pid) {
-                        this.sessions.update(s.id, {
-                            pid: drvSession.pid,
-                            pidStartTime: processStartTime(drvSession.pid),
-                        });
+                    try {
+                        this.sessions.update(s.id, { pendingMessage: null, pendingAt: null });
                     }
-                    this.sessions.update(s.id, { status: "working" });
-                    // Attach event loop for new turn
-                    this.attachDriverEvents(s.id, driver, drvSession).catch(() => { });
-                    send({ result: { ok: true } });
+                    catch { }
+                    await this.runResumeTurn(s, message);
+                    send({ result: { ok: true, queued: false } });
                 }
                 catch (e) {
-                    const message = e instanceof Error ? e.message : String(e);
-                    if (this.shuttingDown) {
-                        try {
-                            await driver.stop(drvSession);
-                        }
-                        catch { }
-                        send({ error: { code: "SERVICE_UNAVAILABLE", message: "daemon is shutting down" } });
+                    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 } });
+                    send({ error: { code: "SEND_FAILED", message: errText } });
                 }
                 finally {
                     if (!this.shuttingDown)
@@ -506,6 +701,9 @@ class Daemon {
                     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` } });
@@ -567,6 +765,9 @@ class Daemon {
                         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) {
@@ -771,6 +972,17 @@ class Daemon {
                 send({ result: aggregateRunUsage(p.runId, sessions) });
                 break;
             }
+            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;
+            }
             case "daemon.stop": {
                 send({ result: { ok: true } });
                 void this.handleShutdown("daemon.stop").finally(() => process.exit(0));
@@ -886,6 +1098,173 @@ class Daemon {
         // Attach events
         await this.attachDriverEvents(sessionId, driver, drvSession);
     }
+    /** Best-effort queue cancel; stop/release own the terminal outcome. */
+    clearPending(sessionId) {
+        try {
+            this.sessions.update(sessionId, { pendingMessage: null, pendingAt: null });
+        }
+        catch { }
+    }
+    /**
+    +   * Starts a resumed turn; caller MUST hold sessionLocks for the session.
+    +   * Shared by session.send (immediate) and tryDispatch (queued) so both
+    +   * paths emit the same frames in the same order.
+    +   */
+    async runResumeTurn(s, message) {
+        const driver = this.registry.get(s.agent);
+        if (this.shuttingDown) {
+            const early = new Error("daemon is shutting down");
+            early.code = "SERVICE_UNAVAILABLE";
+            throw early;
+        }
+        this.sessions.setStatus(s.id, "working", { lastEvent: `send: ${message.slice(0, 80)}` });
+        const turnEvent = {
+            type: "turn.started",
+            sessionId: s.id,
+            timestamp: new Date().toISOString(),
+            prompt: message,
+        };
+        this.events.append(s.id, turnEvent);
+        this.broadcast(s.id, turnEvent);
+        const drvSession = {
+            id: s.id,
+            nativeSessionId: s.nativeSessionId,
+            cwd: s.worktree || s.cwd,
+            model: s.model,
+            effort: s.effort,
+            fast: s.fast,
+            sandbox: s.sandbox,
+            dangerouslyBypassApprovalsAndSandbox: s.dangerouslyBypassApprovalsAndSandbox,
+            pid: s.pid,
+            pidStartTime: s.pidStartTime,
+        };
+        try {
+            await driver.send(drvSession, message);
+        }
+        catch (e) {
+            if (this.shuttingDown) {
+                try {
+                    await driver.stop(drvSession);
+                }
+                catch { }
+            }
+            throw e;
+        }
+        if (this.shuttingDown) {
+            try {
+                await driver.stop(drvSession);
+            }
+            catch { }
+            const late = new Error("daemon is shutting down");
+            late.code = "SERVICE_UNAVAILABLE";
+            throw late;
+        }
+        const handle = driver.getHandle?.(s.id);
+        const handleNativeId = handle &&
+            typeof handle === "object" &&
+            "nativeSessionId" in handle &&
+            typeof handle.nativeSessionId === "string"
+            ? handle.nativeSessionId
+            : undefined;
+        const newNative = handleNativeId || drvSession.nativeSessionId;
+        if (newNative && newNative !== s.nativeSessionId) {
+            this.sessions.update(s.id, { nativeSessionId: newNative });
+        }
+        if (drvSession.pid) {
+            this.sessions.update(s.id, {
+                pid: drvSession.pid,
+                pidStartTime: processStartTime(drvSession.pid),
+            });
+        }
+        this.sessions.update(s.id, { status: "working" });
+        // Attach event loop for new turn
+        this.attachDriverEvents(s.id, driver, drvSession).catch(() => { });
+    }
+    /**
+    +   * Starts the queued message as a new turn when the session is resumable.
+    +   * Never blocks: returns false leaving the slot intact when busy,
+    +   * unresumable, or shutting down. The stream tail calls this, and the
+    +   * busy send path calls it to converge on races (enqueue landing as the
+    +   * turn ends starts immediately instead of stranding).
+    +   */
+    async tryDispatch(sessionId) {
+        if (this.shuttingDown || this.sessionLocks.has(sessionId))
+            return false;
+        const queued = this.sessions.get(sessionId);
+        if (!queued || !queued.pendingMessage || queued.origin === "open")
+            return false;
+        this.sessionLocks.add(sessionId);
+        let message;
+        let pendingAt;
+        try {
+            const s = this.sessions.get(sessionId);
+            if (!s || !s.pendingMessage || s.origin === "open")
+                return false;
+            const driver = this.registry.get(s.agent);
+            if (!driver.capabilities().resume)
+                return false;
+            const handle = driver.getHandle?.(s.id);
+            const hs = handle && typeof handle === "object"
+                ? handle
+                : undefined;
+            // Same resolution as SessionDriver.send: without a native id the start
+            // would only throw after emitting turn.started and flipping status, so
+            // leave the slot quietly for a manual send instead.
+            const nativeId = s.nativeSessionId
+                || (typeof hs?.nativeSessionId === "string" ? hs.nativeSessionId : undefined);
+            if (!nativeId)
+                return false;
+            if (s.status === "starting")
+                return false;
+            if (handle !== undefined && (hs?.done !== true || hs?.drained !== true))
+                return false;
+            if (livePidIdentity(s))
+                return false;
+            message = s.pendingMessage;
+            pendingAt = s.pendingAt;
+            // Clear first so a crash mid-start cannot double-send; restored below
+            // when the start fails.
+            this.sessions.update(s.id, { pendingMessage: null, pendingAt: null });
+            await this.runResumeTurn(s, message);
+            return true;
+        }
+        catch (e) {
+            const errText = e instanceof Error ? e.message : String(e);
+            const unavailable = e?.code === "SERVICE_UNAVAILABLE" || this.shuttingDown;
+            if (!unavailable) {
+                const failure = classifyFailure(errText);
+                const errEv = {
+                    type: "session.failed",
+                    sessionId,
+                    timestamp: new Date().toISOString(),
+                    error: errText,
+                    failure,
+                };
+                try {
+                    this.events.append(sessionId, errEv);
+                }
+                catch { }
+                this.broadcast(sessionId, errEv);
+                try {
+                    this.sessions.setStatus(sessionId, "failed", { lastEvent: errText.slice(0, 200), failure });
+                }
+                catch { }
+            }
+            // Restore the slot so a failed dispatch never vanishes silently; the
+            // next manual send (or a future tail) retries it.
+            try {
+                if (message !== undefined) {
+                    this.sessions.update(sessionId, { pendingMessage: message, pendingAt: pendingAt ?? new Date().toISOString() });
+                }
+            }
+            catch { }
+            return false;
+        }
+        finally {
+            if (!this.shuttingDown)
+                this.sessionLocks.delete(sessionId);
+        }
+    }
     async attachDriverEvents(sessionId, driver, drvSession) {
         try {
             for await (const ev of driver.events(drvSession)) {
@@ -975,6 +1354,11 @@ class Daemon {
                 this.sessions.setStatus(sessionId, "failed", { lastEvent: error.slice(0, 200), failure });
             }
         }
+        // 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) {
         try {
@@ -995,6 +1379,9 @@ class Daemon {
             else if (ev.type === "tool.started") {
                 this.sessions.update(sessionId, { lastEvent: `tool: ${ev.tool.name}` });
             }
+            else if (ev.type === "message.queued") {
+                this.sessions.update(sessionId, { lastEvent: `queued: ${ev.prompt.slice(0, 80)}` });
+            }
             else if (ev.type === "message") {
                 this.sessions.update(sessionId, { lastEvent: ev.content.slice(0, 80) });
             }