@moxt-ai/mobius 0.0.300 → 0.0.302

package/dist/cli.js

@@ -2086,16 +2086,28 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.300",
+      version: "0.0.302",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
         mobius: "dist/cli.js"
       },
       exports: {
-        "./runtime": "./src/runtime.ts",
-        "./process": "./src/util/process/executable.ts",
-        "./filesystem": "./src/util/filesystem/private-path.ts"
+        "./runtime": {
+          "mobius-source": "./src/runtime.ts",
+          types: "./dist/runtime.d.ts",
+          default: "./dist/runtime.js"
+        },
+        "./process": {
+          "mobius-source": "./src/util/process/executable.ts",
+          types: "./dist/util/process/executable.d.ts",
+          default: "./dist/util/process/executable.js"
+        },
+        "./filesystem": {
+          "mobius-source": "./src/util/filesystem/private-path.ts",
+          types: "./dist/util/filesystem/private-path.d.ts",
+          default: "./dist/util/filesystem/private-path.js"
+        }
       },
       files: [
         "dist"
@@ -5593,6 +5605,84 @@ var init_commander = __esm({
   }
 });
 
+// src/acp/harness/claude/parent-lifeline.ts
+import { spawn } from "node:child_process";
+import { Duplex } from "node:stream";
+function spawnClaudeWithParentLifeline(options) {
+  options.signal.throwIfAborted();
+  const child = spawn(process.execPath, ["-e", supervisor, "--", options.command, ...options.args], {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["pipe", "pipe", "pipe", "pipe"],
+    windowsHide: true
+  });
+  const lifeline = child.stdio[3];
+  if (child.stdin === null || child.stdout === null || child.stderr === null || !(lifeline instanceof Duplex)) {
+    child.kill("SIGKILL");
+    throw new Error("The Claude process supervisor has no parent lifeline");
+  }
+  let termination = "running";
+  const stop = () => {
+    termination = "requested";
+    lifeline.end();
+    return true;
+  };
+  options.signal.addEventListener("abort", stop, { once: true });
+  if (options.signal.aborted) {
+    stop();
+  }
+  child.once("close", () => options.signal.removeEventListener("abort", stop));
+  child.stderr.pipe(process.stderr, { end: false });
+  return {
+    stdin: child.stdin,
+    stdout: child.stdout,
+    get killed() {
+      return termination === "requested";
+    },
+    get exitCode() {
+      return child.exitCode;
+    },
+    get signalCode() {
+      return child.signalCode;
+    },
+    kill: stop,
+    on: child.on.bind(child),
+    once: child.once.bind(child),
+    off: child.off.bind(child)
+  };
+}
+var supervisor;
+var init_parent_lifeline = __esm({
+  "src/acp/harness/claude/parent-lifeline.ts"() {
+    "use strict";
+    supervisor = `
+const { spawn, spawnSync } = require("node:child_process");
+const { Socket } = require("node:net");
+const [command, ...args] = process.argv.slice(1);
+const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32", windowsHide: true });
+const lifeline = new Socket({ fd: 3, readable: true, writable: false });
+let exited = false;
+function terminate() {
+    if (exited || child.pid === undefined) return;
+    if (process.platform === "win32") {
+        spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { timeout: 5000, windowsHide: true, stdio: "ignore" });
+    } else {
+        try { process.kill(-child.pid, "SIGKILL"); }
+        catch (error) { if (error.code !== "ESRCH") throw error; }
+    }
+}
+lifeline.on("end", terminate).on("error", terminate).resume();
+process.on("SIGTERM", terminate).on("SIGINT", terminate);
+process.stdin.pipe(child.stdin);
+child.stdin.on("error", () => {});
+child.stdout.pipe(process.stdout);
+child.stderr.pipe(process.stderr);
+child.once("error", (error) => { process.stderr.write(error.message); process.exitCode = 1; lifeline.destroy(); process.stdin.destroy(); });
+child.once("close", (code) => { exited = true; process.exitCode = code ?? 1; lifeline.destroy(); process.stdin.destroy(); });
+`;
+  }
+});
+
 // ../../node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.3.257_@anthropic-ai+sdk@0.122.0_zod@4.6.5__@modelconte_b0b90ed00d211c5955785f7de7f8dbf4/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as $ne } from "node:module";
 import * as xr from "node:fs/promises";
@@ -66545,7 +66635,7 @@ async function runPromptWithCancellation(agent, params, signal) {
 function createClaudeAcpApp(options = {}) {
   let agent = null;
   const app = acpAgent({ name: "claude-code-acp" }).onConnect((connection) => {
-    agent = new ClaudeAcpAgent(new ClientConnection(connection.client, options.onSessionUpdate), options.logger, options.environment);
+    agent = new ClaudeAcpAgent(new ClientConnection(connection.client, options.onSessionUpdate), options.logger, options.environment, options.spawnClaudeCodeProcess);
     options.onConnect?.(connection);
   }).onRequest(methods.agent.initialize, (ctx) => requiredAgent(agent).initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => requiredAgent(agent).newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => requiredAgent(agent).loadSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => requiredAgent(agent).unstable_forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => requiredAgent(agent).listSessions(ctx.params, ctx.signal)).onRequest(methods.agent.session.delete, (ctx) => requiredAgent(agent).deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => requiredAgent(agent).resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => requiredAgent(agent).closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => requiredAgent(agent).setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => requiredAgent(agent).setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => requiredAgent(agent).authenticate(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => requiredAgent(agent).unstable_listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => requiredAgent(agent).unstable_setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => requiredAgent(agent).unstable_disableProvider(ctx.params)).onRequest(methods.agent.logout, (ctx) => requiredAgent(agent).logout(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => runPromptWithCancellation(requiredAgent(agent), ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => requiredAgent(agent).cancel(ctx.params)).onRequest(STEER_METHOD, { parse: parseSteerRequest }, (ctx) => requiredAgent(agent).steer(ctx.params)).onRequest(RENAME_METHOD, { parse: parseRenameRequest }, (ctx) => requiredAgent(agent).renameSession(ctx.params)).onRequest(GOAL_CONTROL_METHOD, { parse: parseGoalRequest }, (ctx) => requiredAgent(agent).goal(ctx.params));
   return { agent: () => agent, app };
@@ -66741,6 +66831,7 @@ var init_acp_agent = __esm({
     };
     mcpAuthentications = /* @__PURE__ */ new WeakMap();
     ClaudeAcpAgent = class {
+      spawnClaudeCodeProcess;
       sessions;
       client;
       clientCapabilities;
@@ -66757,7 +66848,8 @@ var init_acp_agent = __esm({
        *  return "cancelled". See {@link DEFAULT_FORCE_CANCEL_GRACE_MS}. Mutable so
        *  tests can shrink it. */
       forceCancelGraceMs = DEFAULT_FORCE_CANCEL_GRACE_MS;
-      constructor(client2, logger, environment = process.env) {
+      constructor(client2, logger, environment = process.env, spawnClaudeCodeProcess) {
+        this.spawnClaudeCodeProcess = spawnClaudeCodeProcess;
         this.sessions = {};
         this.client = client2;
         this.logger = logger ?? console;
@@ -69334,6 +69426,7 @@ ${message.api_refusal_explanation}` : "";
             supportedDialogKinds: [REFUSAL_FALLBACK_DIALOG_KIND]
           } : {},
           pathToClaudeCodeExecutable: this.environment.CLAUDE_CODE_EXECUTABLE ?? await claudeCliPath(),
+          ...this.spawnClaudeCodeProcess === void 0 ? {} : { spawnClaudeCodeProcess: this.spawnClaudeCodeProcess },
           extraArgs: {
             ...userProvidedOptions?.extraArgs,
             "replay-user-messages": ""
@@ -69609,6 +69702,7 @@ var ClaudeAcpEndpoint;
 var init_endpoint = __esm({
   "src/acp/harness/claude/endpoint.ts"() {
     "use strict";
+    init_parent_lifeline();
     init_lib();
     ClaudeAcpEndpoint = class {
       #agent;
@@ -69622,6 +69716,7 @@ var init_endpoint = __esm({
         this.terminated = termination.promise;
         this.#resolveTermination = termination.resolve;
         const claude = createClaudeAcpApp({
+          spawnClaudeCodeProcess: spawnClaudeWithParentLifeline,
           environment: Object.freeze({
             ...process.env,
             ...options.environment,
@@ -70256,7 +70351,7 @@ var init_platform = __esm({
 });
 
 // src/util/process/executable.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { stat as stat4 } from "node:fs/promises";
 import { join as join12, resolve as resolve8 } from "node:path";
 async function resolveExecutablePath(requestedPath2, platform2 = process.platform) {
@@ -70422,7 +70517,7 @@ async function runBoundedProcess(options) {
   options.signal.throwIfAborted();
   const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
   const launch = executableLaunch2(options.command, options.arguments);
-  const child = spawn2(launch.command, [...launch.arguments], {
+  const child = spawn3(launch.command, [...launch.arguments], {
     cwd: options.cwd,
     ...hostPlatform.spawnOptions,
     env: { ...options.environment },
@@ -71053,7 +71148,7 @@ var init_app_server_protocol = __esm({
 });
 
 // src/acp/harness/codex/app-server-client.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 var INITIALIZE_TIMEOUT_MILLISECONDS, MESSAGE_OUTPUT_LIMIT_BYTES, CodexAppServerError, CodexAppServerClient;
 var init_app_server_client = __esm({
   "src/acp/harness/codex/app-server-client.ts"() {
@@ -71085,7 +71180,7 @@ var init_app_server_client = __esm({
       constructor(options) {
         this.#handlers = options.handlers;
         const launch = executableLaunch2(options.command, ["app-server"]);
-        this.#child = spawn3(launch.command, [...launch.arguments], {
+        this.#child = spawn4(launch.command, [...launch.arguments], {
           cwd: options.cwd,
           ...platformSpawnOptions,
           env: { ...process.env, ...options.environment },
@@ -71468,12 +71563,12 @@ function presentToolItem(item) {
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn10 = item.tool === "spawnAgent";
+    const spawn11 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn10 ? {
+      rawInput: spawn11 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -71481,10 +71576,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn10 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn11 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn10 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn11 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -73624,6 +73719,9 @@ function decodeSessionPromptCommand(encoded) {
     directoryId: readDirectoryIdentifier(value, "directoryId"),
     disposition,
     images,
+    ...value["historyPolicy"] === void 0 ? {} : {
+      historyPolicy: readHistoryPolicy(value)
+    },
     kind: SESSION_PROMPT_KIND,
     prompt,
     resources,
@@ -73632,6 +73730,13 @@ function decodeSessionPromptCommand(encoded) {
     targetCommandId
   };
 }
+function readHistoryPolicy(value) {
+  const field = value["historyPolicy"];
+  if (field === SessionHistoryPolicy.Eager || field === SessionHistoryPolicy.ExecutionOnly) {
+    return field;
+  }
+  throw new ProtocolMessageError("Invalid value field: historyPolicy");
+}
 function decodeSessionCancelCommand(encoded) {
   const value = parseJson(encoded);
   assertKind(value, SESSION_CANCEL_KIND);
@@ -73663,7 +73768,7 @@ function encodeSessionCancelCommand(message) {
 function encodeSessionPromptDispositionCommand(message) {
   return JSON.stringify(decodeSessionPromptDispositionCommand(JSON.stringify(message)));
 }
-var SESSION_PROMPT_KIND, SESSION_PROMPT_DISPOSITION_KIND, SESSION_CANCEL_KIND, SessionPromptDisposition, MAX_PROMPT_LENGTH, MAX_PROMPT_ATTACHMENT_LENGTH, promptImageSchema, promptResourceSchema, decodePromptImagesValue, decodePromptResourcesValue;
+var SESSION_PROMPT_KIND, SESSION_PROMPT_DISPOSITION_KIND, SESSION_CANCEL_KIND, SessionPromptDisposition, SessionHistoryPolicy, MAX_PROMPT_LENGTH, MAX_PROMPT_ATTACHMENT_LENGTH, promptImageSchema, promptResourceSchema, decodePromptImagesValue, decodePromptResourcesValue;
 var init_commands = __esm({
   "../mobius-sdk/src/protocol/session/prompt/commands.ts"() {
     "use strict";
@@ -73679,6 +73784,10 @@ var init_commands = __esm({
       Reject: "reject",
       Steer: "steer"
     });
+    SessionHistoryPolicy = Object.freeze({
+      Eager: "eager",
+      ExecutionOnly: "execution-only"
+    });
     MAX_PROMPT_LENGTH = 1e5;
     MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
     promptImageSchema = external_exports.object({
@@ -75612,7 +75721,11 @@ var init_agent = __esm({
           const decoded = threadListResponseSchema.parse(
             await this.#appServer.request(
               "thread/list",
-              { cursor: context.params.cursor ?? null },
+              {
+                cursor: context.params.cursor ?? null,
+                // Codex defaults to interactive sources and otherwise hides exec handoffs.
+                sourceKinds: ["cli", "vscode", "exec", "appServer"]
+              },
               AbortSignal.any([context.signal, AbortSignal.timeout(SESSION_LIST_TIMEOUT_MILLISECONDS2)])
             )
           );
@@ -75866,7 +75979,7 @@ var init_command2 = __esm({
 });
 
 // src/acp/harness/pi/upstream/dist/pi-rpc/process.js
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import * as readline from "node:readline";
 function stripAnsi(s) {
   return s.replace(ANSI_ESCAPE_REGEX, "");
@@ -75970,7 +76083,7 @@ var init_process = __esm({
             args.push("--fork", params.origin.sessionPath);
             break;
         }
-        const child = spawn4(cmd, args, {
+        const child = spawn5(cmd, args, {
           cwd: params.cwd,
           stdio: "pipe",
           env: params.environment,
@@ -79410,6 +79523,77 @@ ${JSON.stringify(stats, null, 2)}`;
         }, 0);
         return { sessionId: session.sessionId, configOptions, modes };
       }
+      async resumeSession(params) {
+        if (!isAbsolute11(params.cwd)) {
+          throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+        }
+        this.sessions.close(params.sessionId);
+        this.lastSessionCwd = params.cwd;
+        const stored = this.findStoredSession(params.sessionId);
+        if (!stored) {
+          throw RequestError7.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+        }
+        const session = await this.restoreSession(params.sessionId, {
+          cwd: params.cwd,
+          mcpServers: params.mcpServers
+        });
+        let configuration;
+        try {
+          configuration = await getSessionConfiguration(session.proc);
+        } catch (err) {
+          this.sessions.close(session.sessionId);
+          throw err;
+        }
+        const { configOptions, models, modes } = configuration;
+        const enableSkillCommands = getEnableSkillCommands(params.cwd, this.environment);
+        const fileCommands = loadSlashCommands(params.cwd, this.environment);
+        this.sessions.closeAllExcept?.(session.sessionId);
+        this.store.upsert({
+          sessionId: params.sessionId,
+          cwd: params.cwd,
+          sessionFile: stored.sessionFile
+        });
+        const response = {
+          configOptions,
+          models,
+          modes,
+          _meta: {
+            piAcp: {
+              startupInfo: null
+            }
+          }
+        };
+        setTimeout(() => {
+          void (async () => {
+            await session.publishContextUsage();
+            try {
+              const pi2 = await session.proc.getCommands();
+              const { commands } = toAvailableCommandsFromPiGetCommands(pi2, {
+                enableSkillCommands,
+                includeExtensionCommands: false
+              });
+              await this.conn.sessionUpdate({
+                sessionId: session.sessionId,
+                update: {
+                  sessionUpdate: "available_commands_update",
+                  availableCommands: mergeCommands(commands, builtinAvailableCommands())
+                }
+              });
+              return;
+            } catch {
+            }
+            await this.conn.sessionUpdate({
+              sessionId: session.sessionId,
+              update: {
+                sessionUpdate: "available_commands_update",
+                availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+              }
+            });
+          })().catch(() => {
+          });
+        }, 0);
+        return response;
+      }
       async loadSession(params) {
         if (!isAbsolute11(params.cwd)) {
           throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
@@ -79689,6 +79873,9 @@ var init_endpoint2 = __esm({
         ).onRequest(
           methods5.agent.session.load,
           async (context) => await piAgentOrThrow(piAgent).loadSession(context.params)
+        ).onRequest(
+          methods5.agent.session.resume,
+          async (context) => await piAgentOrThrow(piAgent).resumeSession(context.params)
         ).onRequest(
           methods5.agent.session.list,
           async (context) => await piAgentOrThrow(piAgent).listSessions(context.params)
@@ -80215,7 +80402,7 @@ var init_create_client = __esm({
 });
 
 // src/agent/discovery/acp-readiness-probe.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import {
   methods as methods8,
   ndJsonStream as ndJsonStream2,
@@ -80372,7 +80559,7 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
     }
   }
   const launch = executableLaunch2(agent.adapterPath, agent.arguments);
-  const child = spawn5(launch.command, [...launch.arguments], {
+  const child = spawn6(launch.command, [...launch.arguments], {
     cwd: defaultWorkspace,
     ...platformSpawnOptions,
     env: { ...environment, ...agent.environment },
@@ -83043,7 +83230,7 @@ var init_worker_lifecycle_log = __esm({
 });
 
 // src/daemon/lifecycle/worker-process.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { isAbsolute as isAbsolute13, resolve as resolve16 } from "node:path";
 function currentWorkerLaunch(version2) {
   const entry = process.argv[1];
@@ -83103,7 +83290,7 @@ var init_worker_process = __esm({
       constructor(launch, signal, environment) {
         signal.throwIfAborted();
         this.launch = launch;
-        this.#child = spawn6(launch.executable, [launch.entry, "__worker"], {
+        this.#child = spawn7(launch.executable, [launch.entry, "__worker"], {
           env: environment,
           windowsHide: true,
           stdio: ["ignore", "pipe", "pipe", "ipc"]
@@ -83436,9 +83623,9 @@ var init_manager2 = __esm({
 });
 
 // src/daemon/lifecycle/manager-client.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 async function spawnManager() {
-  const child = spawn7(process.execPath, [process.argv[1] ?? "", "__manager"], {
+  const child = spawn8(process.execPath, [process.argv[1] ?? "", "__manager"], {
     detached: true,
     windowsHide: true,
     env: process.env,
@@ -83844,7 +84031,7 @@ var init_history_images = __esm({
 });
 
 // src/acp/native-history/codex/codex-history.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 function bounded(value, maximum) {
   return value.slice(0, maximum);
 }
@@ -84220,7 +84407,7 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
   }
   signal.throwIfAborted();
   const launch = executableLaunch2(agent.agentIdentity.realPath, ["app-server"]);
-  const child = spawn8(launch.command, [...launch.arguments], {
+  const child = spawn9(launch.command, [...launch.arguments], {
     cwd,
     env: { ...process.env, ...agent.environment },
     ...platformSpawnOptions,
@@ -90233,6 +90420,25 @@ var init_acp_session = __esm({
   }
 });
 
+// src/schema/acp-session-store/execution-receipt.ts
+var executionReceipt;
+var init_execution_receipt = __esm({
+  "src/schema/acp-session-store/execution-receipt.ts"() {
+    "use strict";
+    init_sqlite_core();
+    executionReceipt = sqliteTable("execution_receipt", {
+      commandId: text("command_id").primaryKey(),
+      sessionId: text("session_id").notNull(),
+      commandHash: text("command_hash").notNull(),
+      attemptId: text("attempt_id").notNull(),
+      state: text("state").notNull(),
+      started: integer2("started", { mode: "boolean" }).notNull(),
+      outcome: text("outcome"),
+      updatedAt: text("updated_at").notNull()
+    });
+  }
+});
+
 // src/schema/acp-session-store/session-live-event-position-allocation.ts
 var sessionLiveEventPositionAllocation;
 var init_session_live_event_position_allocation = __esm({
@@ -90251,6 +90457,7 @@ var init_acp_session_store = __esm({
   "src/schema/acp-session-store/index.ts"() {
     "use strict";
     init_acp_session();
+    init_execution_receipt();
     init_session_live_event_position_allocation();
   }
 });
@@ -90299,6 +90506,71 @@ var init_acp_session_table = __esm({
   }
 });
 
+// src/storage/session/execution-receipt-table.ts
+var receiptFields, receiptSchema, ExecutionReceiptTable;
+var init_execution_receipt_table = __esm({
+  "src/storage/session/execution-receipt-table.ts"() {
+    "use strict";
+    init_drizzle_orm();
+    init_zod();
+    init_acp_session_store();
+    receiptFields = external_exports.object({
+      commandId: external_exports.string(),
+      sessionId: external_exports.string(),
+      commandHash: external_exports.string(),
+      attemptId: external_exports.string(),
+      updatedAt: external_exports.string()
+    });
+    receiptSchema = external_exports.discriminatedUnion("state", [
+      receiptFields.extend({ state: external_exports.literal("dispatching"), started: external_exports.literal(false), outcome: external_exports.null() }),
+      receiptFields.extend({ state: external_exports.literal("running"), started: external_exports.literal(true), outcome: external_exports.string().nullable() }),
+      receiptFields.extend({
+        state: external_exports.enum(["succeeded", "failed", "cancelled"]),
+        started: external_exports.boolean(),
+        outcome: external_exports.string().nullable()
+      })
+    ]).readonly();
+    ExecutionReceiptTable = class {
+      #database;
+      constructor(database) {
+        this.#database = database;
+      }
+      list = () => receiptSchema.array().parse(
+        this.#database.orm.select().from(executionReceipt).orderBy(asc(executionReceipt.updatedAt), asc(executionReceipt.commandId)).all()
+      );
+      save = (receipt) => {
+        this.#database.transaction(() => {
+          this.#database.orm.insert(executionReceipt).values(receipt).onConflictDoUpdate({ target: executionReceipt.commandId, set: receipt }).run();
+          if (receipt.state === "dispatching" || receipt.state === "running") {
+            return;
+          }
+          const retained = this.#database.orm.select({ commandId: executionReceipt.commandId }).from(executionReceipt).where(
+            and(
+              eq2(executionReceipt.sessionId, receipt.sessionId),
+              inArray(executionReceipt.state, ["succeeded", "failed", "cancelled"])
+            )
+          ).orderBy(desc(executionReceipt.updatedAt), desc(executionReceipt.commandId)).limit(1024).all();
+          if (retained.length === 1024) {
+            this.#database.orm.delete(executionReceipt).where(
+              and(
+                eq2(executionReceipt.sessionId, receipt.sessionId),
+                inArray(executionReceipt.state, ["succeeded", "failed", "cancelled"]),
+                notInArray(
+                  executionReceipt.commandId,
+                  retained.map((row) => row.commandId)
+                )
+              )
+            ).run();
+          }
+        });
+      };
+      remove = (commandId) => {
+        this.#database.orm.delete(executionReceipt).where(eq2(executionReceipt.commandId, commandId)).run();
+      };
+    };
+  }
+});
+
 // src/storage/session/live-event-position-table.ts
 var allocationRowSchema, LiveEventPositionTable;
 var init_live_event_position_table = __esm({
@@ -90552,6 +90824,10 @@ var init_acp_session_store_migrations = __esm({
       {
         "name": "0006_live_event_position_allocation.sql",
         "sql": "CREATE TABLE `session_live_event_position_allocation` (\n	`allocated_position` integer DEFAULT 10000 NOT NULL,\n	`session_id` text PRIMARY KEY NOT NULL\n);\n"
+      },
+      {
+        "name": "0007_busy_excalibur.sql",
+        "sql": "CREATE TABLE `execution_receipt` (\n	`command_id` text PRIMARY KEY NOT NULL,\n	`session_id` text NOT NULL,\n	`command_hash` text NOT NULL,\n	`attempt_id` text NOT NULL,\n	`state` text NOT NULL,\n	`started` integer NOT NULL,\n	`outcome` text,\n	`updated_at` text NOT NULL\n);\n"
       }
     ];
   }
@@ -91170,12 +91446,12 @@ var init_session_event_id_allocator = __esm({
 
 // src/session/history/session-event-store.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
-function liveEvent(sessionId, sessionGenerationId, eventId, position, event) {
+function liveEvent(sessionId, sessionGenerationId, eventId, position, event, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
     eventId,
     ...event,
     position: position.toString(),
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    recordedAt,
     sessionGenerationId,
     sessionId
   };
@@ -91336,7 +91612,7 @@ var init_session_event_store = __esm({
         }
         return resolved;
       };
-      append = (sessionId, event) => {
+      append = (sessionId, event, recordedAt) => {
         const session = this.#session(sessionId);
         const allocatedPosition = this.#allocatedPositionBySession.get(sessionId) ?? 9999;
         if (allocatedPosition === Number.MAX_SAFE_INTEGER) {
@@ -91349,7 +91625,8 @@ var init_session_event_store = __esm({
           session.sessionGenerationId,
           this.#eventIds.allocate(sessionId, session.sessionGenerationId),
           position,
-          event
+          event,
+          recordedAt
         );
         session.apply(recorded, this.#resolver(session));
         return recorded;
@@ -91390,12 +91667,14 @@ var init_session_event_store = __esm({
       };
     };
     CachedSessionEventStore = class {
+      #terminalOutcomes;
       #cacheTable;
       #eventIds;
       #liveEventPositions;
       #sessions = /* @__PURE__ */ new Map();
       #flushSchedule = { kind: "idle" };
-      constructor(cacheTable, liveEventPositions, eventIds = new InMemorySessionEventIdAllocator()) {
+      constructor(cacheTable, liveEventPositions, eventIds = new InMemorySessionEventIdAllocator(), terminalOutcomes = () => []) {
+        this.#terminalOutcomes = terminalOutcomes;
         this.#eventIds = eventIds;
         this.#liveEventPositions = liveEventPositions;
         this.#cacheTable = cacheTable;
@@ -91428,7 +91707,7 @@ var init_session_event_store = __esm({
         }
         return resolved;
       };
-      append = (sessionId, event) => {
+      append = (sessionId, event, recordedAt) => {
         if (this.#flushSchedule.kind === "closed") {
           throw new Error("The V2 Session event store is closed");
         }
@@ -91439,7 +91718,8 @@ var init_session_event_store = __esm({
           session.sessionGenerationId,
           this.#eventIds.allocate(sessionId, session.sessionGenerationId),
           position,
-          event
+          event,
+          recordedAt
         );
         session.apply(recorded, this.#resolver(sessionId, session));
         this.#sessions.set(sessionId, session);
@@ -91528,6 +91808,9 @@ var init_session_event_store = __esm({
         this.#deletePersisted(sessionId, previous?.sessionGenerationId);
         const sessionGenerationId = randomUUID12();
         this.#sessions.set(sessionId, new SessionEvents(sessionGenerationId));
+        for (const { event, recordedAt } of this.#terminalOutcomes(sessionId)) {
+          this.append(sessionId, event, recordedAt);
+        }
       };
       materializedEventCount = (sessionId) => this.#sessions.get(sessionId)?.materializedCount ?? 0;
       close = () => {
@@ -91648,7 +91931,7 @@ var init_prompt_content = __esm({
 });
 
 // src/acp/connection/agent-connection.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 import { ndJsonStream as ndJsonStream3, RequestError as RequestError9 } from "@agentclientprotocol/sdk";
 function requestErrorMessage(error62) {
   const fallback = truncate2(error62.message, 500);
@@ -91767,7 +92050,7 @@ var init_agent_connection = __esm({
           return;
         }
         const launch = executableLaunch2(agent.adapterPath, agent.arguments);
-        const child = spawn9(launch.command, [...launch.arguments], {
+        const child = spawn10(launch.command, [...launch.arguments], {
           cwd,
           ...platformSpawnOptions,
           env: { ...process.env, ...agent.environment },
@@ -93121,6 +93404,19 @@ var init_agent_turn = __esm({
 
 // src/session/live/session-restore.ts
 import { methods as methods10 } from "@agentclientprotocol/sdk";
+function hasMethodNotFoundCode(cause) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = cause;
+  while ((current instanceof Error || typeof current === "object" && current !== null) && !visited.has(current)) {
+    visited.add(current);
+    const code = Reflect.get(current, "code");
+    if (code === -32601 || code === "METHOD_NOT_FOUND" || code === "method_not_found") {
+      return true;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return false;
+}
 async function restoreSession(session, signal, recovery, origin) {
   if (origin !== void 0) {
     session.setSessionTitle(origin.title);
@@ -93187,6 +93483,9 @@ async function restoreSession(session, signal, recovery, origin) {
     }
     session.setPrompted(true);
     session.setRestored(true);
+    if (recovery.kind === "execution-only") {
+      session.startExecutionOnlyCapture();
+    }
     lifecycleResponse2 = forked;
   } else if (stored instanceof FoundStoredSession && stored.session.agentId === session.agentId && stored.session.cwd === session.cwd && arraysEqual(stored.session.additionalDirectories, session.additionalDirectories)) {
     session.selectNativeSession(stored.session.nativeSessionId);
@@ -93205,6 +93504,37 @@ async function restoreSession(session, signal, recovery, origin) {
         "session-load",
         async () => (await session.loadSession(signal, "ACP agent exited while loading a session")).response
       );
+    } else if (recovery.kind === "execution-only") {
+      try {
+        lifecycleResponse2 = await session.metrics.measure(
+          "session-resume",
+          async () => await session.race(
+            session.agentRequest(
+              methods10.agent.session.resume,
+              {
+                additionalDirectories: [...session.additionalDirectories],
+                cwd: session.cwd,
+                mcpServers: [],
+                sessionId: session.nativeSessionId()
+              },
+              { cancellationSignal: signal }
+            ),
+            "ACP agent exited while resuming a session",
+            signal
+          )
+        );
+      } catch (cause) {
+        signal.throwIfAborted();
+        if (cause instanceof AcpExecutionError && !hasMethodNotFoundCode(cause)) {
+          throw cause;
+        }
+        throw new AcpExecutionError(
+          "This Agent cannot continue a persisted session without replaying native history",
+          { cause },
+          "execution_only_unsupported"
+        );
+      }
+      session.startExecutionOnlyCapture();
     } else if (session.capabilities.resumeSession) {
       lifecycleResponse2 = await session.metrics.measure(
         "session-resume",
@@ -93264,6 +93594,9 @@ async function restoreSession(session, signal, recovery, origin) {
     );
     session.selectNativeSession(created.sessionId);
     session.setNativeHistoryOwnership({ kind: "fresh-session" });
+    if (recovery.kind === "execution-only") {
+      session.startExecutionOnlyCapture();
+    }
     lifecycleResponse2 = created;
   }
   session.restrictSessionCapabilities(lifecycleResponse2);
@@ -93579,6 +93912,16 @@ var init_agent_session = __esm({
         }
         await this.#completedHistory(signal, "ACP agent exited while loading history");
       };
+      /** Starts live event capture without asking the native Agent to replay its persisted history. */
+      startExecutionOnlyCapture = () => {
+        if (this.#sessionLoad.kind !== "not-requested") {
+          return;
+        }
+        this.#sessionLoad = {
+          history: new HistoryReplayCapture(this.#store.events, this.#mobiusSessionId),
+          kind: "execution-only"
+        };
+      };
       loadHistoryEvents = async (eventLimit, cursor, signal) => {
         if (!this.#capabilities.loadSession) {
           throw new AcpExecutionError(
@@ -93829,7 +94172,7 @@ var init_agent_session = __esm({
             response: {}
           };
         }
-        if (this.#capabilities.loadSession) {
+        if (this.#capabilities.loadSession && this.#sessionLoad.kind !== "execution-only") {
           await this.#completedHistory(options.signal, "ACP agent exited while loading history before a prompt");
         }
         const prompt = this.buildPrompt(options);
@@ -94028,14 +94371,14 @@ var init_agent_session = __esm({
       onElicitationComplete = (notification) => this.#interactions.onElicitationComplete(notification);
       onUpdate = (notification) => this.#updates.receive(notification);
       recordControlEvent = async (event) => {
-        if (this.#sessionLoad.kind !== "loaded") {
+        if (this.#sessionLoad.kind !== "loaded" && this.#sessionLoad.kind !== "execution-only") {
           return false;
         }
         await this.recordLifecycleEvent(event);
         return true;
       };
       recordLifecycleEvent = async (event) => {
-        if (event.type !== "lifecycle-metadata" || this.#sessionLoad.kind !== "loaded") {
+        if (event.type !== "lifecycle-metadata" || this.#sessionLoad.kind !== "loaded" && this.#sessionLoad.kind !== "execution-only") {
           return;
         }
         const liveEvent2 = this.#sessionLoad.history.recordLifecycle(event);
@@ -94056,7 +94399,7 @@ var init_agent_session = __esm({
         const rawUpdate = decodeAcpSessionUpdate(JSON.stringify(externalized.event));
         if (this.#sessionLoad.kind === "capturing") {
           await this.#sessionLoad.history.record(update, rawUpdate);
-        } else if (this.#sessionLoad.kind === "loaded") {
+        } else if (this.#sessionLoad.kind === "loaded" || this.#sessionLoad.kind === "execution-only") {
           const onSessionEvent = this.#getObserver().onSessionEvent;
           await this.#sessionLoad.history.record(update, rawUpdate, async (liveEvent2) => {
             await onSessionEvent?.(liveEvent2);
@@ -95043,13 +95386,14 @@ var init_session_manager = __esm({
       }
       async #replaceExecutionPreparation(existing, options) {
         const desiredConfigOptions = existing.prepared().configOptions;
+        const recovery = options.recovery ?? { kind: "interactive-only" };
         return await this.#executionProcesses.prepare(options.sessionId, async () => {
           await this.#retireSessionProcess(options.sessionId, existing, async () => await existing.close());
           const runtime = await this.#startRetainedSessionProcess(
             options,
             async () => await AgentSession.start(
               options,
-              { kind: "interactive-only" },
+              recovery,
               () => this.#observer,
               this.#store,
               unmeasuredOperationMetrics,
@@ -95227,6 +95571,7 @@ var init_session_manager = __esm({
         });
       });
       prepareExecutionSession = async (options) => this.#operations.run(options, async (options2) => {
+        const recovery = options2.recovery ?? { kind: "interactive-only" };
         this.#assertOpen(options2.sessionId);
         const pending = this.#executionProcesses.pending(options2.sessionId);
         if (pending !== void 0) {
@@ -95235,7 +95580,7 @@ var init_session_manager = __esm({
         }
         const existing = this.#executionProcesses.get(options2.sessionId);
         if (existing === void 0) {
-          return (await this.#startPreparation(options2, { kind: "interactive-only" })).prepared();
+          return (await this.#startPreparation(options2, recovery)).prepared();
         }
         if (!existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
           throw new AcpExecutionError(
@@ -95245,6 +95590,9 @@ var init_session_manager = __esm({
           );
         }
         if (existing.usesEnvironment(options2.agent.environment)) {
+          if (recovery.kind === "execution-only") {
+            existing.startExecutionOnlyCapture();
+          }
           this.#executionProcesses.touch(options2.sessionId, existing);
           return existing.prepared();
         }
@@ -95539,10 +95887,13 @@ var init_session_manager = __esm({
               "session_identity_mismatch"
             );
           }
+          if (options2.recovery?.kind === "execution-only") {
+            existing.startExecutionOnlyCapture();
+          }
           this.#executionProcesses.touch(options2.sessionId, existing);
           return existing;
         }
-        await this.prepareSession(options2);
+        await this.#prepareSession(options2, options2.recovery ?? { kind: "interactive-only" }, "reopen");
         const started = this.#executionProcesses.get(options2.sessionId);
         if (started === void 0) {
           throw new AcpExecutionError("ACP session did not start");
@@ -96100,6 +96451,7 @@ var PromptLifecycle;
 var init_prompt_lifecycle = __esm({
   "src/session/prompt/prompt-lifecycle.ts"() {
     "use strict";
+    init_protocol();
     PromptLifecycle = class {
       #sink;
       #terminal = /* @__PURE__ */ new Map();
@@ -96181,6 +96533,13 @@ var init_prompt_lifecycle = __esm({
         }
         this.#queued.delete(commandId);
       };
+      replayOutcome = async (sessionId, event) => {
+        if (event.type !== "lifecycle-metadata" || !("commandId" in event.payload)) {
+          return;
+        }
+        await this.#recordLifecycle(sessionId, event);
+        this.publishTerminal(sessionId, event.payload.commandId);
+      };
       queueChanged = async (sessionId) => {
         await this.#recordLifecycle(sessionId, {
           type: "lifecycle-metadata",
@@ -96214,7 +96573,7 @@ var init_prompt_lifecycle = __esm({
           type: "lifecycle-metadata",
           payload: { kind: "prompt.failed-before-start", commandId, code, message }
         });
-        if (!recorded) {
+        if (!recorded || code === SESSION_CLOSED_ERROR_CODE) {
           this.#sink.publishOperationFailure(sessionId, commandId, code, message);
         }
       };
@@ -96239,21 +96598,154 @@ var MAX_TERMINAL_RECEIPTS, ExecutionReceipts;
 var init_execution_receipts = __esm({
   "src/session/turn/execution-receipts.ts"() {
     "use strict";
+    init_protocol();
+    init_zod();
     MAX_TERMINAL_RECEIPTS = 1024;
     ExecutionReceipts = class {
       #executions = /* @__PURE__ */ new Map();
+      #recoveredCommands = /* @__PURE__ */ new Set();
       #terminalCountBySession = /* @__PURE__ */ new Map();
+      #table;
+      #closing = false;
+      #activeCount = 0;
+      #onCount;
+      constructor(table, onCount = () => void 0) {
+        this.#onCount = onCount;
+        this.#table = table;
+        for (const row of table?.list() ?? []) {
+          this.#executions.set(row.commandId, row);
+          this.#recoveredCommands.add(row.commandId);
+          if (!isTerminal(row.state)) {
+            this.#activeCount += 1;
+          }
+          if (isTerminal(row.state)) {
+            this.#terminalCountBySession.set(
+              row.sessionId,
+              (this.#terminalCountBySession.get(row.sessionId) ?? 0) + 1
+            );
+          }
+        }
+      }
+      #save = (commandId, receipt) => {
+        if (!this.#closing) {
+          this.#table?.save({ ...receipt, commandId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        }
+        const previous = this.#executions.get(commandId);
+        const wasActive = previous !== void 0 && !isTerminal(previous.state);
+        if (isTerminal(receipt.state)) {
+          this.#executions.delete(commandId);
+        }
+        this.#executions.set(commandId, receipt);
+        this.#activeCount += Number(!isTerminal(receipt.state)) - Number(wasActive);
+        this.#onCount(this.#activeCount);
+        if (isTerminal(receipt.state) && (previous === void 0 || !isTerminal(previous.state))) {
+          this.#terminalCountBySession.set(
+            receipt.sessionId,
+            (this.#terminalCountBySession.get(receipt.sessionId) ?? 0) + 1
+          );
+          this.pruneTerminalReceipts(receipt.sessionId);
+        }
+      };
+      beginShutdown = () => {
+        this.#closing = true;
+      };
+      outcome = (commandId) => {
+        const receipt = this.#executions.get(commandId);
+        return receipt?.outcome === null || receipt === void 0 ? void 0 : sessionEventPayloadSchema.parse(JSON.parse(receipt.outcome));
+      };
+      recordOutcome = (event) => {
+        if (event.type !== "lifecycle-metadata") {
+          return;
+        }
+        const payload = event.payload;
+        if (payload.kind !== "prompt.completed" && payload.kind !== "prompt.failed" && payload.kind !== "prompt.failed-before-start") {
+          return;
+        }
+        const receipt = this.#executions.get(payload.commandId);
+        if (receipt === void 0) {
+          return;
+        }
+        const sanitized = payload.kind === "prompt.completed" ? payload : { ...payload, message: "The local Agent could not complete the request" };
+        this.#save(payload.commandId, {
+          ...receipt,
+          state: payload.kind === "prompt.completed" ? payload.stopReason === "cancelled" ? "cancelled" : "succeeded" : "failed",
+          outcome: JSON.stringify({ type: "lifecycle-metadata", payload: sanitized, recordedAt: event.recordedAt })
+        });
+      };
+      recover = () => {
+        const recovered = [];
+        for (const [commandId, receipt] of [...this.#executions]) {
+          const event = receipt.outcome === null ? {
+            type: "lifecycle-metadata",
+            payload: receipt.started ? {
+              kind: "prompt.failed",
+              commandId,
+              attemptId: receipt.attemptId,
+              code: "runtime_restarted",
+              message: "The local runtime restarted while this request was running"
+            } : {
+              kind: "prompt.failed-before-start",
+              commandId,
+              code: "runtime_restarted",
+              message: "The local runtime restarted before this request started"
+            }
+          } : sessionEventPayloadSchema.parse(JSON.parse(receipt.outcome));
+          const recordedAt = receipt.outcome === null ? (/* @__PURE__ */ new Date()).toISOString() : external_exports.object({ recordedAt: external_exports.string() }).parse(JSON.parse(receipt.outcome)).recordedAt;
+          recovered.push({ sessionId: receipt.sessionId, event, recordedAt });
+          if (!isTerminal(receipt.state)) {
+            const state = event.type === "lifecycle-metadata" && event.payload.kind === "prompt.completed" ? event.payload.stopReason === "cancelled" ? "cancelled" : "succeeded" : "failed";
+            this.#save(commandId, { ...receipt, state, outcome: JSON.stringify({ ...event, recordedAt }) });
+          }
+        }
+        return recovered;
+      };
+      terminalOutcomes = (sessionId) => [...this.#executions.values()].flatMap((receipt) => {
+        if (receipt.sessionId !== sessionId || receipt.outcome === null) {
+          return [];
+        }
+        const decoded = JSON.parse(receipt.outcome);
+        return [
+          {
+            event: sessionEventPayloadSchema.parse(decoded),
+            recordedAt: external_exports.object({ recordedAt: external_exports.string() }).parse(decoded).recordedAt
+          }
+        ];
+      });
       claimExecution = (commandId, sessionId, commandJson) => {
         const commandHash = createHash7("sha256").update(commandJson).digest("hex");
-        const existing = this.#executions.get(commandId);
+        let existing = this.#executions.get(commandId);
+        const previous = this.outcome(commandId);
+        if (existing?.sessionId === sessionId && !existing.started && previous?.type === "lifecycle-metadata" && previous.payload.kind === "prompt.failed-before-start" && previous.payload.code === "runtime_restarted") {
+          this.#executions.delete(commandId);
+          this.#recoveredCommands.delete(commandId);
+          this.#table?.remove(commandId);
+          this.#terminalCountBySession.set(
+            sessionId,
+            Math.max(0, (this.#terminalCountBySession.get(sessionId) ?? 1) - 1)
+          );
+          existing = void 0;
+        }
         if (existing !== void 0) {
           if (existing.sessionId !== sessionId || existing.commandHash !== commandHash) {
             return { kind: "conflict" };
           }
-          return { attemptId: existing.attemptId, commandId, kind: "duplicate", state: existing.state };
+          return {
+            attemptId: existing.attemptId,
+            commandId,
+            kind: "duplicate",
+            state: existing.state,
+            outcome: this.#recoveredCommands.has(commandId) ? this.outcome(commandId) : void 0
+          };
         }
         const attemptId = randomUUID14();
-        this.#executions.set(commandId, { attemptId, commandHash, sessionId, state: "dispatching" });
+        this.#save(commandId, {
+          attemptId,
+          commandHash,
+          sessionId,
+          state: "dispatching",
+          started: false,
+          outcome: null
+        });
         return { attemptId, commandId, kind: "accepted", state: "dispatching" };
       };
       transitionExecution = (commandId, state) => {
@@ -96268,16 +96760,13 @@ var init_execution_receipts = __esm({
         if (!allowed) {
           throw new Error("The runtime execution transition is invalid");
         }
-        this.#executions.set(commandId, { ...current, state });
-        if (isTerminal(state)) {
-          this.#terminalCountBySession.set(
-            current.sessionId,
-            (this.#terminalCountBySession.get(current.sessionId) ?? 0) + 1
-          );
-          this.pruneTerminalReceipts(current.sessionId);
+        if (state === "running") {
+          this.#save(commandId, { ...current, state, started: true });
+        } else if (isTerminal(state)) {
+          this.#save(commandId, { ...current, state });
         }
       };
-      /** Receipts disappear when the runtime process exits. */
+      /** Only commands without a terminal result can still be cancelled. */
       findUnsettledAttemptId = (commandId, sessionId) => {
         const receipt = this.#executions.get(commandId);
         return receipt?.sessionId === sessionId && !isTerminal(receipt.state) ? receipt.attemptId : null;
@@ -96288,7 +96777,9 @@ var init_execution_receipts = __esm({
       };
       close = () => {
         this.#executions.clear();
+        this.#recoveredCommands.clear();
         this.#terminalCountBySession.clear();
+        this.#activeCount = 0;
       };
       pruneTerminalReceipts = (sessionId) => {
         if ((this.#terminalCountBySession.get(sessionId) ?? 0) <= MAX_TERMINAL_RECEIPTS) {
@@ -96297,6 +96788,8 @@ var init_execution_receipts = __esm({
         for (const [commandId, receipt] of this.#executions) {
           if (receipt.sessionId === sessionId && isTerminal(receipt.state)) {
             this.#executions.delete(commandId);
+            this.#recoveredCommands.delete(commandId);
+            this.#table?.remove(commandId);
             const remaining = (this.#terminalCountBySession.get(sessionId) ?? 1) - 1;
             if (remaining > 0) {
               this.#terminalCountBySession.set(sessionId, remaining);
@@ -96847,10 +97340,14 @@ function buildSessionLayer(options) {
   const databases = channelSessionDatabasePaths(stateDirectory, channelId);
   const sessionDatabase = openAcpSessionDatabase(databases.sessions);
   let events;
+  let operations;
   try {
+    operations = new ExecutionReceipts(new ExecutionReceiptTable(sessionDatabase), options.onExecutionCountChange);
     events = new CachedSessionEventStore(
       new SessionEventCacheTable(openSessionEventCacheDatabase(databases.events)),
-      new SqliteSessionLiveEventPosition(new LiveEventPositionTable(sessionDatabase))
+      new SqliteSessionLiveEventPosition(new LiveEventPositionTable(sessionDatabase)),
+      void 0,
+      (sessionId) => operations.terminalOutcomes(sessionId)
     );
   } catch (error62) {
     sessionDatabase.close();
@@ -96858,11 +97355,13 @@ function buildSessionLayer(options) {
   }
   const sessionStore = new SqliteSessionStore(new AcpSessionTable(sessionDatabase), events);
   const externalContent = new LocalExternalContentStore(stateDirectory);
-  const operations = new ExecutionReceipts();
   const activeSessions = new SessionTurns(operations, options.turnActivity);
   const directories = new WorkspaceDirectoryService(bindingId, defaultWorkspace);
   const manager = new SessionManager2({
-    observer: new SessionLayerObserver((event) => eventProjection.record(event), sink.publishInfo),
+    observer: new SessionLayerObserver((event) => {
+      operations.recordOutcome(event);
+      eventProjection.record(event);
+    }, sink.publishInfo),
     store: sessionStore,
     adapters: harnessAdapters,
     sessionIdentity: "native",
@@ -96883,7 +97382,15 @@ function buildSessionLayer(options) {
   });
   const eventProjection = new PromptLifecycle(
     sink,
-    (sessionId, event) => manager.recordLifecycleEvent(sessionId, event),
+    async (sessionId, event) => {
+      if (await manager.recordLifecycleEvent(sessionId, event)) {
+        return true;
+      }
+      const recorded = events.append(sessionId, event);
+      operations.recordOutcome(recorded);
+      eventProjection.record(recorded);
+      return true;
+    },
     activeSessions.recordSessionEvent
   );
   const nativeSessions = new NativeSessionService(
@@ -96906,7 +97413,13 @@ function buildSessionLayer(options) {
       );
     })
   );
+  const recoveredEvents = operations.recover().map(({ sessionId, event, recordedAt }) => events.append(sessionId, event, recordedAt));
   return {
+    publishRecoveredOutcomes: () => {
+      for (const event of recoveredEvents) {
+        sink.publish(event);
+      }
+    },
     activeSessions,
     directories,
     eventProjection,
@@ -96924,6 +97437,7 @@ var init_session_layer = __esm({
     init_registry();
     init_content_externalizer();
     init_acp_session_table();
+    init_execution_receipt_table();
     init_live_event_position_table();
     init_session_event_cache_table();
     init_local_databases();
@@ -98804,12 +99318,14 @@ async function executePrompt({
     const appliedSettings = command.sessionConfigurations === void 0 ? void 0 : agentForSessionConfiguration(agent, command.sessionConfigurations);
     const executionAgent = appliedSettings?.agent ?? agent;
     const sessionConfigurations = appliedSettings?.sessionConfigurations;
+    const recovery = command.historyPolicy === SessionHistoryPolicy.ExecutionOnly ? { kind: "execution-only" } : { kind: "interactive-only" };
     const preparation = {
       additionalDirectories: resolved.additionalDirectories,
       agent: executionAgent,
       cwd: resolved.cwd,
       sessionId: command.sessionId,
-      signal
+      signal,
+      recovery
     };
     let prepared = await sessions.prepareExecutionSession(preparation);
     if (command.sessionConfigurations !== void 0) {
@@ -98878,7 +99394,8 @@ async function executePrompt({
         resources: attachments.resources,
         sessionId: command.sessionId,
         signal,
-        targetCommandId: command.targetCommandId
+        targetCommandId: command.targetCommandId,
+        recovery
       });
       stopReason = result.stopReason;
     }
@@ -99076,6 +99593,12 @@ var init_prompt2 = __esm({
           return;
         }
         if (receipt.kind === "duplicate") {
+          const outcome = receipt.outcome;
+          if (outcome !== void 0) {
+            void context.eventProjection.replayOutcome(message.sessionId, outcome).catch((cause) => {
+              console.error("Could not replay the persisted execution outcome", cause);
+            });
+          }
           return;
         }
         const turn = context.sessionTurns.start(message, receipt.attemptId);
@@ -100282,7 +100805,8 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
       resolveAgent: (agentId, resolveSignal) => resolveCatalogAgent(config2, agentId, resolveSignal),
       sink: publisher,
       stateDirectory: config2.localContext.stateDirectory,
-      timer
+      timer,
+      onExecutionCountChange: options.onExecutionCountChange ?? (() => void 0)
     });
     const {
       activeSessions,
@@ -100352,6 +100876,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
             reportUpgradeAvailability,
             diagnostics,
             onConnected: () => {
+              layer.publishRecoveredOutcomes();
               if (catalogPublished) {
                 options.onConnectionStatus?.("online");
               }
@@ -100374,6 +100899,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
       }
     } finally {
       shutdown.abort();
+      operations.beginShutdown();
       await activeSessions.close();
       try {
         await catalogPublication;
@@ -100468,6 +100994,10 @@ var init_engine = __esm({
     MobiusRuntimeEngine = class {
       #config;
       #options;
+      #activeTurnCount = 0;
+      get activeTurnCount() {
+        return this.#activeTurnCount;
+      }
       #state = new IdleMobiusRuntimeState();
       constructor(config2, options = {}) {
         validateRuntimeConfiguration(config2);
@@ -100483,11 +101013,15 @@ var init_engine = __esm({
         try {
           await runRuntime(this.#config, signal, void 0, {
             ...this.#options.turnActivity === void 0 ? {} : { turnActivity: this.#options.turnActivity },
+            onExecutionCountChange: (count) => {
+              this.#activeTurnCount = count;
+            },
             ...this.#options.onConnectionStatus === void 0 ? {} : { onConnectionStatus: this.#options.onConnectionStatus },
             ...this.#options.reportUpgradeAvailability === void 0 ? {} : { reportUpgradeAvailability: this.#options.reportUpgradeAvailability },
             ...this.#options.processLogsDirectory === void 0 ? {} : { processLogsDirectory: this.#options.processLogsDirectory }
           });
         } finally {
+          this.#activeTurnCount = 0;
           this.#state = new FinishedMobiusRuntimeState();
         }
       };