codedeck 0.1.2 → 0.1.4

package/dist/core/errors.js

@@ -58,4 +58,60 @@ export class ProtocolError extends RunAgentError {
         super(message, "PROTOCOL_ERROR", { cause });
     }
 }
+// Order matters: the most specific signatures first. "EPIPE" alone is LAST —
+// it is a substring task output can legitimately contain (e.g. a test grepping
+// for EPIPE), while process-level "unhandled rejection" text virtually never
+// comes from the task's work.
+const HARNESS_CRASH_PATTERNS = [
+    [/unhandled\s+(rejection|promise)/i, "unhandled_rejection"],
+    [/unhandled\s+exception/i, "unhandled_exception"],
+    [/segmentation fault/i, "segfault"],
+    [/heap\s+out\s+of\s+memory|fatal error:/i, "v8_fatal"],
+    [/epipe/i, "EPIPE"],
+    [/err_stream_/i, "stream_error"],
+];
+const FATAL_SIGNALS = { SIGSEGV: true, SIGBUS: true, SIGABRT: true, SIGILL: true, SIGKILL: true };
+// Exit code 128+N is the shell convention for "died by signal N".
+const SIGNAL_EXIT_CODES = {
+    134: "SIGABRT",
+    137: "SIGKILL",
+    139: "SIGSEGV",
+};
+export function classifyFailure(text, exitCode, signal) {
+    const clean = (text || "").trim();
+    const detail = clean.slice(0, 300) || undefined;
+    for (const [pattern, reason] of HARNESS_CRASH_PATTERNS) {
+        if (pattern.test(clean)) {
+            return { code: "HARNESS_CRASH", blame: "harness", retryable: true, reason, detail };
+        }
+    }
+    if (signal && FATAL_SIGNALS[signal]) {
+        return { code: "HARNESS_CRASH", blame: "harness", retryable: true, signal };
+    }
+    if (exitCode != null && SIGNAL_EXIT_CODES[exitCode]) {
+        return { code: "HARNESS_CRASH", blame: "harness", retryable: true, signal: SIGNAL_EXIT_CODES[exitCode] };
+    }
+    if (exitCode != null && exitCode !== 0) {
+        // Non-zero without a harness-crash signature: the honest default is
+        // "the work failed" — a blind retry of the same prompt rarely differs.
+        return { code: "TASK_ERROR", blame: "task", retryable: false, detail: detail || `exit code ${exitCode}` };
+    }
+    // No signature at all. Callers reaching this lost the stream mid-flight
+    // (driver exception, socket death), which is a harness-side failure.
+    return { code: "UNKNOWN", blame: "harness", retryable: true, detail };
+}
+// CLI exit codes for `codedeck run` (non-detach), documented in README:
+// 0 completed/stopped · 1 task failed · 2 harness crashed (retryable) · 3 infra
+export function exitCodeForOutcome(outcome) {
+    const status = outcome.status || "";
+    if (status === "failed" || status === "orphaned") {
+        const blame = outcome.failure?.blame;
+        if (blame === "harness")
+            return 2;
+        if (blame === "infra")
+            return 3;
+        return 1;
+    }
+    return 0;
+}
 //# sourceMappingURL=errors.js.map

package/dist/core/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,aAAc,SAAQ,KAAK;IAGpB;IACA;IAHlB,YACE,OAAe,EACC,IAAY,EACZ,OAAiB;QAEjC,KAAK,CAAC,OAAO,CAAC,CAAC;QAHC,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAU;QAGjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;CACF;AAED,MAAM,OAAO,sBAAuB,SAAQ,aAAa;IACvD,YAAY,KAAa;QACvB,KAAK,CAAC,UAAU,KAAK,oBAAoB,EAAE,qBAAqB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC/E,CAAC;CACF;AAED,MAAM,OAAO,gCAAiC,SAAQ,aAAa;IACjE,YAAY,KAAa;QACvB,KAAK,CAAC,UAAU,KAAK,2BAA2B,EAAE,qBAAqB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,CAAC;CACF;AAED,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IACtD,YAAY,KAAa,EAAE,KAAe;QACxC,KAAK,CAAC,0BAA0B,KAAK,GAAG,EAAE,oBAAoB,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;IACpF,CAAC;CACF;AAED,MAAM,OAAO,oBAAqB,SAAQ,aAAa;IACrD,YAAY,EAAU;QACpB,KAAK,CAAC,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC;CACF;AAED,MAAM,OAAO,sBAAuB,SAAQ,aAAa;IACvD,YAAY,EAAU;QACpB,KAAK,CAAC,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACzE,CAAC;CACF;AAED,MAAM,OAAO,2BAA4B,SAAQ,aAAa;IAC5D,YAAY,KAAa,EAAE,UAAkB;QAC3C,KAAK,CAAC,UAAU,KAAK,uBAAuB,UAAU,GAAG,EAAE,0BAA0B,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;IAChH,CAAC;CACF;AAED,MAAM,OAAO,uBAAwB,SAAQ,aAAa;IACxD,YAAY,GAAW;QACrB,KAAK,CAAC,+BAA+B,GAAG,GAAG,EAAE,sBAAsB,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAChF,CAAC;CACF;AAED,MAAM,OAAO,2BAA4B,SAAQ,aAAa;IAC5D,YAAY,KAAe;QACzB,KAAK,CAAC,+BAA+B,EAAE,0BAA0B,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAChF,CAAC;CACF;AAED,MAAM,OAAO,sBAAuB,SAAQ,aAAa;IACvD,YAAY,KAAe;QACzB,KAAK,CAAC,gCAAgC,EAAE,oBAAoB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3E,CAAC;CACF;AAED,MAAM,OAAO,aAAc,SAAQ,aAAa;IAC9C,YAAY,OAAe,EAAE,KAAe;QAC1C,KAAK,CAAC,OAAO,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9C,CAAC;CACF"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"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"}

package/dist/core/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/core/events.ts"],"names":[],"mappings":"AA8IA,MAAM,UAAU,WAAW,CACzB,IAAmD;IAEnD,OAAO;QACL,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,GAAG,IAAI;KACH,CAAC;AACT,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAiB;IAC/C,OAAO,KAAK,CAAC,IAAI,KAAK,mBAAmB,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB,CAAC;AAC/E,CAAC"}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/core/events.ts"],"names":[],"mappings":"AAsJA,MAAM,UAAU,WAAW,CACzB,IAAmD;IAEnD,OAAO;QACL,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,GAAG,IAAI;KACH,CAAC;AACT,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAiB;IAC/C,OAAO,KAAK,CAAC,IAAI,KAAK,mBAAmB,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB,CAAC;AAC/E,CAAC"}

package/dist/core/session.js.map

@@ -1 +1 @@
-{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/core/session.ts"],"names":[],"mappings":"AAkDA,MAAM,UAAU,gBAAgB,CAAC,MAAqB;IACpD,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,UAAU,CAAC;AACxG,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,MAAqB;IAClD,OAAO,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,aAAa,IAAI,MAAM,KAAK,MAAM,CAAC;AACxG,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,2EAA2E;IAC3E,kDAAkD;IAClD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAChC,cAAc;IACd,uDAAuD;IACvD,IAAI,CAAC;QACH,aAAa;QACb,UAAU,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;IACpG,CAAC;IAAC,MAAM,CAAC;QACP,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5F,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAY,EAAE,SAAiB;IAChE,MAAM,KAAK,GAAG,IAAI;SACf,WAAW,EAAE;SACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;SAC3B,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;SACrB,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC;IAC1B,OAAO,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;AACpC,CAAC"}
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/core/session.ts"],"names":[],"mappings":"AAgEA,MAAM,UAAU,gBAAgB,CAAC,MAAqB;IACpD,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,UAAU,CAAC;AACxG,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,MAAqB;IAClD,OAAO,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,aAAa,IAAI,MAAM,KAAK,MAAM,CAAC;AACxG,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,2EAA2E;IAC3E,kDAAkD;IAClD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAChC,cAAc;IACd,uDAAuD;IACvD,IAAI,CAAC;QACH,aAAa;QACb,UAAU,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;IACpG,CAAC;IAAC,MAAM,CAAC;QACP,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5F,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAY,EAAE,SAAiB;IAChE,MAAM,KAAK,GAAG,IAAI;SACf,WAAW,EAAE;SACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;SAC3B,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;SACrB,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC;IAC1B,OAAO,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;AACpC,CAAC"}

package/dist/daemon/daemon.js

@@ -7,21 +7,24 @@ import { EventStore } from "../store/events.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 { generateSessionId } from "../core/session.js";
 import { getGitInfo } from "../git/repository.js";
 import { createWorktree } from "../git/worktree.js";
 import { getDiff } from "../git/diff.js";
-import { ProcessManager } from "./process-manager.js";
+import { processAlive, processStartTime } from "../utils/process.js";
+import { readSessionProcessMetadata } from "../drivers/session-runtime.js";
 import { loadConfig } from "../config/config.js";
+import { classifyFailure } from "../core/errors.js";
 class Daemon {
     db;
     sessions;
     events;
     registry = getRegistry();
-    pm = new ProcessManager();
     server;
     subscribers = new Map(); // sessionId -> sockets
     startTime = Date.now();
+    sessionLocks = new Set();
     constructor() {
         ensureDirs();
         this.db = new Database();
@@ -66,20 +69,94 @@ class Daemon {
         }
         catch { }
     }
+    // Sessions whose detached process outlived the daemon are RE-ATTACHED, not
+    // orphaned: the process is independent (own process group, output in log
+    // files), so a daemon restart is invisible to it. A live process keeps
+    // streaming; a dead one is drained and classified from its log tail.
     async recover() {
-        // Mark active sessions as orphaned if process not alive
+        const paths = getPaths();
         const actives = this.sessions.listActive();
         for (const s of actives) {
-            if (s.pid) {
+            const driver = this.registry.get(s.agent);
+            const metadata = readSessionProcessMetadata(s.id);
+            const pid = metadata?.pid ?? s.pid;
+            const recordedStart = metadata?.pidStartTime ?? s.pidStartTime;
+            const processPresent = pid != null && processAlive(pid);
+            const currentStart = pid != null ? processStartTime(pid) : undefined;
+            const pidReused = processPresent &&
+                recordedStart !== undefined &&
+                currentStart !== undefined &&
+                currentStart !== recordedStart;
+            // 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) {
+                const failure = {
+                    code: "HARNESS_CRASH",
+                    blame: "harness",
+                    retryable: true,
+                    reason: "pid_reused",
+                    detail: `PID ${pid} no longer identifies the launched harness`,
+                };
+                const detail = failure.detail ?? `PID ${pid} no longer identifies the launched harness`;
+                const event = {
+                    type: "session.failed",
+                    sessionId: s.id,
+                    timestamp: new Date().toISOString(),
+                    error: detail,
+                    failure,
+                    raw: { pid, expectedStartTime: recordedStart, currentStart },
+                };
+                this.events.append(s.id, event);
+                this.sessions.setStatus(s.id, "failed", { lastEvent: detail, failure });
+                continue;
+            }
+            const alive = processPresent;
+            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);
+            if (typeof driver.attach === "function" && pid != null && hasDetachedLogs && identityVerified) {
                 try {
-                    process.kill(s.pid, 0);
-                    // still alive externally but not managed by us; treat as orphaned
-                    this.sessions.setStatus(s.id, "orphaned");
+                    await driver.attach({
+                        sessionId: s.id,
+                        pid,
+                        pidStartTime: recordedStart,
+                        nativeSessionId: s.nativeSessionId,
+                        logOffset: s.logOffset,
+                        stderrOffset: s.stderrOffset,
+                    });
                 }
-                catch {
-                    // not alive
-                    this.sessions.setStatus(s.id, "failed");
+                catch (e) {
+                    // Corrupt log / fs failure: fall back to the legacy marking.
+                    this.sessions.setStatus(s.id, alive ? "orphaned" : "failed", {
+                        lastEvent: e instanceof Error ? e.message.slice(0, 200) : "reattach failed",
+                    });
+                    continue;
+                }
+                if (!s.pid || !s.pidStartTime) {
+                    this.sessions.update(s.id, { pid, pidStartTime: recordedStart ?? currentStart });
+                }
+                const drvSession = {
+                    id: s.id,
+                    nativeSessionId: s.nativeSessionId,
+                    pid,
+                    pidStartTime: recordedStart,
+                    cwd: s.worktree || s.cwd,
+                    model: s.model,
+                };
+                if (alive) {
+                    this.sessions.setStatus(s.id, "working", { lastEvent: "reattached after daemon restart" });
                 }
+                void this.attachDriverEvents(s.id, driver, drvSession);
+                continue;
+            }
+            // Sessions created before file transport have no reattachable log, and
+            // live sessions without a PID identity are not safe to trust.
+            if (pid) {
+                this.sessions.setStatus(s.id, alive ? "orphaned" : "failed");
             }
             else {
                 this.sessions.setStatus(s.id, "failed");
@@ -142,6 +219,8 @@ class Daemon {
                     name: p.name,
                     agent,
                     model: p.model,
+                    effort: p.effort,
+                    fast: !!p.fast,
                     status: "starting",
                     repository,
                     cwd,
@@ -158,11 +237,21 @@ class Daemon {
                 send({ result: { session } });
                 // Now start driver in background
                 this.startDriverForSession(sessionId, prompt, p.model).catch((e) => {
+                    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: e instanceof Error ? e.message : String(e) });
+                        this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
                     }
                     catch { }
-                    this.broadcast(sessionId, { type: "session.failed", sessionId, timestamp: new Date().toISOString(), error: e instanceof Error ? e.message : String(e), raw: e });
+                    this.broadcast(sessionId, failEv);
                 });
                 break;
             }
@@ -194,40 +283,78 @@ class Daemon {
                     return;
                 }
                 const driver = this.registry.get(s.agent);
-                // Check capabilities resume
+                // 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 (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 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;
+                }
                 if (!driver.capabilities().resume) {
                     send({ error: { code: "CAPABILITY_NOT_SUPPORTED", message: `Agent ${s.agent} does not support resume` } });
                     return;
                 }
-                // Update status to working
-                this.sessions.setStatus(s.id, "working", { lastEvent: `send: ${p.message.slice(0, 80)}` });
-                // Emit turn.started
-                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);
+                this.sessionLocks.add(s.id);
                 try {
-                    // driver.send will spawn new process
-                    // Need to get current handle session object
-                    const nativeId = s.nativeSessionId;
-                    // Create a ephemeral DriverSession for send
-                    const drvSession = { id: s.id, nativeSessionId: nativeId, cwd: s.worktree || s.cwd, model: s.model, pid: s.pid };
+                    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);
+                    const drvSession = {
+                        id: s.id,
+                        nativeSessionId: s.nativeSessionId,
+                        cwd: s.worktree || s.cwd,
+                        model: s.model,
+                        pid: s.pid,
+                        pidStartTime: s.pidStartTime,
+                    };
                     await driver.send(drvSession, p.message);
-                    // Update nativeSessionId if driver discovered new one
                     const handle = driver.getHandle?.(s.id);
-                    const newNative = handle?.nativeSessionId || drvSession.nativeSessionId;
+                    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 });
+                    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(() => { });
                     send({ result: { ok: true } });
                 }
                 catch (e) {
-                    this.sessions.setStatus(s.id, "failed");
-                    send({ error: { code: "SEND_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                    const message = e instanceof Error ? e.message : String(e);
+                    try {
+                        this.sessions.setStatus(s.id, "failed");
+                    }
+                    catch { }
+                    send({ error: { code: "SEND_FAILED", message } });
+                }
+                finally {
+                    this.sessionLocks.delete(s.id);
                 }
                 break;
             }
@@ -239,20 +366,74 @@ class Daemon {
                     return;
                 }
                 const driver = this.registry.get(s.agent);
-                try {
-                    await driver.stop({ id: s.id, nativeSessionId: s.nativeSessionId, cwd: s.worktree || s.cwd, pid: s.pid });
+                if (this.sessionLocks.has(s.id)) {
+                    send({ error: { code: "SESSION_BUSY", message: `Session ${s.id} has another lifecycle operation in progress` } });
+                    return;
                 }
-                catch { }
-                // Also try process manager
+                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 (s.status === "stopped" || ((s.status === "completed" || s.status === "failed") && !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 = s.status === "completed" || s.status === "failed";
+                const eventsBeforeStop = this.events.count(s.id);
                 try {
-                    await this.pm.stop(s.id);
+                    // 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,
+                    });
+                    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);
+                    }
+                    send({ result: { ok: true } });
+                }
+                catch (e) {
+                    try {
+                        this.sessions.setStatus(s.id, previousStatus);
+                    }
+                    catch { }
+                    send({ error: { code: "STOP_FAILED", message: e instanceof Error ? e.message : String(e) } });
+                }
+                finally {
+                    this.sessionLocks.delete(s.id);
                 }
-                catch { }
-                this.sessions.setStatus(s.id, "stopped");
-                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);
-                send({ result: { ok: true } });
                 break;
             }
             case "session.logs": {
@@ -286,6 +467,23 @@ class Daemon {
                     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);
@@ -404,10 +602,14 @@ class Daemon {
             prompt,
             cwd: session.worktree || session.cwd,
             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.
+            effort: session.effort,
+            fast: session.fast,
         });
         // Update pid and native id when available
         if (drvSession.pid)
-            this.sessions.update(sessionId, { pid: drvSession.pid });
+            this.sessions.update(sessionId, { pid: drvSession.pid, pidStartTime: processStartTime(drvSession.pid) });
         // Poll native id shortly
         for (let i = 0; i < 10; i++) {
             await new Promise((r) => setTimeout(r, 200));
@@ -422,30 +624,61 @@ class Daemon {
                 break;
             }
         }
-        // Store proc for manager if handle has proc
-        const handle = drvSession.handle;
-        if (handle?.proc) {
-            this.pm.register(sessionId, handle.proc);
-        }
         // Attach events
         await this.attachDriverEvents(sessionId, driver, drvSession);
     }
     async attachDriverEvents(sessionId, driver, drvSession) {
         try {
             for await (const ev of driver.events(drvSession)) {
-                // Persist
-                this.events.append(sessionId, ev, ev.raw);
-                // Update session status based on event
-                this.updateSessionFromEvent(sessionId, ev);
-                // Broadcast
-                this.broadcast(sessionId, ev);
+                // 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;
+                try {
+                    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);
+                    }
+                    db.exec("COMMIT");
+                }
+                catch (error) {
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch { }
+                    throw error;
+                }
+                // Broadcast only after the durable event+cursor commit, and never
+                // broadcast a replay that was already in the event store.
+                if (inserted !== 0)
+                    this.broadcast(sessionId, ev);
             }
         }
         catch (e) {
-            const errEv = { type: "session.failed", sessionId, timestamp: new Date().toISOString(), error: e instanceof Error ? e.message : String(e), raw: e };
+            // A driver exception mid-stream is a harness/pipe failure, not task
+            // output — classify so agents can retry instead of blaming the work.
+            const msg = e instanceof Error ? e.message : String(e);
+            const failure = classifyFailure(msg);
+            const errEv = {
+                type: "session.failed",
+                sessionId,
+                timestamp: new Date().toISOString(),
+                error: msg,
+                failure,
+                raw: e,
+            };
             this.events.append(sessionId, errEv);
             this.broadcast(sessionId, errEv);
-            this.sessions.setStatus(sessionId, "failed", { lastEvent: errEv.error });
+            this.sessions.setStatus(sessionId, "failed", { lastEvent: msg.slice(0, 200), failure });
             return;
         }
         // When events done, ensure terminal status if not already
@@ -457,43 +690,55 @@ class Daemon {
                 this.sessions.setStatus(sessionId, "completed", { lastEvent: last.reason || "completed" });
             }
             else if (last?.type === "session.failed") {
-                this.sessions.setStatus(sessionId, "failed", { lastEvent: last.error });
+                this.sessions.setStatus(sessionId, "failed", { lastEvent: last.error?.slice(0, 200), failure: last.failure });
             }
             else {
-                // If no terminal, assume completed
-                this.sessions.setStatus(sessionId, "completed");
+                // Stream ended with NO terminal event: the harness died without
+                // reporting (the EPIPE class of crash). A false "completed" makes a
+                // polling agent proceed on missing work; "failed" is the honest
+                // default and matches what the dead process implies.
+                const failure = {
+                    code: "HARNESS_CRASH",
+                    blame: "harness",
+                    retryable: true,
+                    detail: "event stream ended without a terminal event",
+                };
+                const error = sess.lastEvent || "event stream ended without a terminal event";
+                const errEv = { type: "session.failed", sessionId, timestamp: new Date().toISOString(), error, failure };
+                this.events.append(sessionId, errEv);
+                this.broadcast(sessionId, errEv);
+                this.sessions.setStatus(sessionId, "failed", { lastEvent: error.slice(0, 200), failure });
             }
         }
-        // Unregister process
-        this.pm.unregister(sessionId);
     }
     updateSessionFromEvent(sessionId, ev) {
         try {
-            if (ev.type === "session.completed") {
+            const current = this.sessions.get(sessionId);
+            if (current?.status === "stopped" && (ev.type === "session.completed" || ev.type === "session.failed")) {
+                return;
+            }
+            if (ev.type === "session.started") {
+                if (ev.nativeSessionId)
+                    this.sessions.update(sessionId, { nativeSessionId: ev.nativeSessionId });
+            }
+            else if (ev.type === "session.completed") {
                 this.sessions.setStatus(sessionId, "completed", { lastEvent: ev.reason || "completed" });
             }
             else if (ev.type === "session.failed") {
-                this.sessions.setStatus(sessionId, "failed", { lastEvent: ev.error?.slice(0, 200) });
+                this.sessions.setStatus(sessionId, "failed", { lastEvent: ev.error.slice(0, 200), failure: ev.failure });
             }
             else if (ev.type === "tool.started") {
                 this.sessions.update(sessionId, { lastEvent: `tool: ${ev.tool.name}` });
             }
             else if (ev.type === "message") {
-                const content = ev.content || "";
-                this.sessions.update(sessionId, { lastEvent: content.slice(0, 80) });
-            }
-            else if (ev.type === "text.delta") {
-                // Don't spam updatedAt too much? Just lastEvent
+                this.sessions.update(sessionId, { lastEvent: ev.content.slice(0, 80) });
             }
             else if (ev.type === "usage.updated") {
-                const u = ev.usage;
                 const sess = this.sessions.get(sessionId);
                 if (sess) {
-                    const usage = { ...(sess.usage || {}), ...u };
-                    this.sessions.update(sessionId, { usage });
+                    this.sessions.update(sessionId, { usage: { ...(sess.usage || {}), ...ev.usage } });
                 }
             }
-            // Also update updatedAt
             this.sessions.update(sessionId, { updatedAt: new Date() });
         }
         catch { }