@moxt-ai/mobius 0.0.299 → 0.0.301

package/dist/runtime.js

@@ -21633,6 +21633,10 @@ var SessionPromptDisposition = Object.freeze({
   Reject: "reject",
   Steer: "steer"
 });
+var SessionHistoryPolicy = Object.freeze({
+  Eager: "eager",
+  ExecutionOnly: "execution-only"
+});
 var MAX_PROMPT_LENGTH = 1e5;
 var MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
 var promptImageSchema = external_exports.object({
@@ -21694,6 +21698,9 @@ function decodeSessionPromptCommand(encoded) {
     directoryId: readDirectoryIdentifier(value, "directoryId"),
     disposition,
     images,
+    ...value["historyPolicy"] === void 0 ? {} : {
+      historyPolicy: readHistoryPolicy(value)
+    },
     kind: SESSION_PROMPT_KIND,
     prompt,
     resources,
@@ -21702,6 +21709,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);
@@ -22627,16 +22641,28 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.299",
+  version: "0.0.301",
   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"
@@ -22718,6 +22744,78 @@ var package_default = {
   homepage: "https://github.com/moxt-ai/mobius#readme"
 };
 
+// src/acp/harness/claude/parent-lifeline.ts
+import { spawn as spawn2 } from "node:child_process";
+import { Duplex } from "node:stream";
+var 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(); });
+`;
+function spawnClaudeWithParentLifeline(options) {
+  options.signal.throwIfAborted();
+  const child = spawn2(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)
+  };
+}
+
 // src/acp/harness/claude/upstream/dist/acp-agent.js
 import { execFile as execFile3 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -62438,6 +62536,7 @@ async function waitForMcpAuthentication(sessions, sessionId, query, serverName,
   return false;
 }
 var ClaudeAcpAgent = class {
+  spawnClaudeCodeProcess;
   sessions;
   client;
   clientCapabilities;
@@ -62454,7 +62553,8 @@ var ClaudeAcpAgent = class {
    *  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;
@@ -65031,6 +65131,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": ""
@@ -66449,7 +66550,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 };
@@ -66574,6 +66675,7 @@ var ClaudeAcpEndpoint = class {
     this.terminated = termination.promise;
     this.#resolveTermination = termination.resolve;
     const claude = createClaudeAcpApp({
+      spawnClaudeCodeProcess: spawnClaudeWithParentLifeline,
       environment: Object.freeze({
         ...process.env,
         ...options.environment,
@@ -66724,7 +66826,7 @@ var AcpConfigurationValueUnavailableError = class extends AcpExecutionError {
 };
 
 // src/acp/harness/codex/app-server-client.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 
 // src/acp/agent/in-process-endpoint.ts
 function acpEndpointTerminationError(termination) {
@@ -67057,7 +67159,7 @@ var CodexAppServerClient = class {
   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 },
@@ -67444,12 +67546,12 @@ function presentToolItem(item) {
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn8 = item.tool === "spawnAgent";
+    const spawn9 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn8 ? {
+      rawInput: spawn9 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -67457,10 +67559,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn8 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn9 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn8 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn9 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -68629,6 +68731,10 @@ var CodexSettings = class {
       approvalPolicy: mode.approvalPolicy,
       approvalsReviewer: mode.approvalsReviewer,
       sandboxPolicy: mode.sandboxPolicy,
+      // Codex only streams its provider-authored reasoning summary when the turn opts in.
+      // Keep the summary channel enabled so Thinking has visible content even when no raw
+      // reasoning text is available.
+      summary: "auto",
       // The collaboration mode rides on the turn: Codex applies it to the
       // thread, where it persists until changed. "Build" is Codex's `default`
       // mode, so it is only sent once a choice exists to apply.
@@ -69221,7 +69327,7 @@ import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute11,
 import { RequestError as RequestError7 } from "@agentclientprotocol/sdk";
 
 // 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";
 
 // src/acp/harness/pi/upstream/dist/pi-rpc/command.js
@@ -69338,7 +69444,7 @@ var PiRpcProcess = class _PiRpcProcess {
         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,
@@ -72338,6 +72444,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}`);
@@ -72921,6 +73098,9 @@ var PiAcpEndpoint = class {
     ).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)
@@ -73200,7 +73380,7 @@ var LocalAgentInventory = class {
 };
 
 // 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,
@@ -73391,7 +73571,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 },
@@ -75004,7 +75184,7 @@ var ClaudeAdapter = class {
 };
 
 // src/acp/native-history/codex/codex-history.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 
 // src/acp/protocol/native-session.ts
 var path6 = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
@@ -75701,7 +75881,7 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
   }
   signal.throwIfAborted();
   const launch = executableLaunch2(agent.agentIdentity.realPath, ["app-server"]);
-  const child = spawn6(launch.command, [...launch.arguments], {
+  const child = spawn7(launch.command, [...launch.arguments], {
     cwd,
     env: { ...process.env, ...agent.environment },
     ...platformSpawnOptions,
@@ -75936,6 +76116,16 @@ function toolStatus2(value) {
   }
 }
 function activityEvent(activity2) {
+  if (activity2.activityType === "reasoning") {
+    return {
+      payload: {
+        content: { text: activity2.output, type: "text" },
+        messageId: activity2.activityId,
+        sessionUpdate: "agent_thought_chunk"
+      },
+      type: "acp"
+    };
+  }
   return {
     payload: {
       content: activity2.content,
@@ -81032,6 +81222,18 @@ var acpSession = sqliteTable("acp_session", {
   updatedAt: text("updated_at").notNull()
 });
 
+// src/schema/acp-session-store/execution-receipt.ts
+var 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 = sqliteTable("session_live_event_position_allocation", {
   allocatedPosition: integer2("allocated_position").notNull().default(1e4),
@@ -81073,6 +81275,62 @@ var AcpSessionTable = class {
   };
 };
 
+// src/storage/session/execution-receipt-table.ts
+var receiptFields = external_exports.object({
+  commandId: external_exports.string(),
+  sessionId: external_exports.string(),
+  commandHash: external_exports.string(),
+  attemptId: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var 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();
+var 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 = external_exports.object({ allocatedPosition: external_exports.number().int().safe().nonnegative() });
 var LiveEventPositionTable = class {
@@ -81292,6 +81550,10 @@ var acpSessionStoreMigrations = [
   {
     "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"
   }
 ];
 
@@ -81946,12 +82208,12 @@ var SessionEvents = class {
     }
   };
 };
-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
   };
@@ -81989,7 +82251,7 @@ var MemorySessionEventStore = class {
     }
     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) {
@@ -82002,7 +82264,8 @@ var MemorySessionEventStore = class {
       session.sessionGenerationId,
       this.#eventIds.allocate(sessionId, session.sessionGenerationId),
       position,
-      event
+      event,
+      recordedAt
     );
     session.apply(recorded, this.#resolver(session));
     return recorded;
@@ -82043,12 +82306,14 @@ var MemorySessionEventStore = class {
   };
 };
 var 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;
@@ -82081,7 +82346,7 @@ var CachedSessionEventStore = class {
     }
     return resolved;
   };
-  append = (sessionId, event) => {
+  append = (sessionId, event, recordedAt) => {
     if (this.#flushSchedule.kind === "closed") {
       throw new Error("The V2 Session event store is closed");
     }
@@ -82092,7 +82357,8 @@ var CachedSessionEventStore = class {
       session.sessionGenerationId,
       this.#eventIds.allocate(sessionId, session.sessionGenerationId),
       position,
-      event
+      event,
+      recordedAt
     );
     session.apply(recorded, this.#resolver(sessionId, session));
     this.#sessions.set(sessionId, session);
@@ -82181,6 +82447,9 @@ var CachedSessionEventStore = class {
     this.#deletePersisted(sessionId, previous?.sessionGenerationId);
     const sessionGenerationId = randomUUID11();
     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 = () => {
@@ -82294,7 +82563,7 @@ function buildPromptContent(options, capabilities) {
 }
 
 // src/acp/connection/agent-connection.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { ndJsonStream as ndJsonStream3, RequestError as RequestError9 } from "@agentclientprotocol/sdk";
 function requestErrorMessage(error62) {
   const fallback = truncate(error62.message, 500);
@@ -82404,7 +82673,7 @@ var AgentConnection = class {
       return;
     }
     const launch = executableLaunch2(agent.adapterPath, agent.arguments);
-    const child = spawn7(launch.command, [...launch.arguments], {
+    const child = spawn8(launch.command, [...launch.arguments], {
       cwd,
       ...platformSpawnOptions,
       env: { ...process.env, ...agent.environment },
@@ -83678,6 +83947,19 @@ var RunningAgentTurn = class extends AgentTurnState {
 
 // 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);
@@ -83744,6 +84026,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);
@@ -83762,6 +84047,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",
@@ -83821,6 +84137,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);
@@ -84098,6 +84417,16 @@ var AgentSession = class _AgentSession {
     }
     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(
@@ -84348,7 +84677,7 @@ var AgentSession = class _AgentSession {
         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);
@@ -84547,14 +84876,14 @@ var AgentSession = class _AgentSession {
   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);
@@ -84575,7 +84904,7 @@ var AgentSession = class _AgentSession {
     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);
@@ -85493,13 +85822,14 @@ var SessionManager2 = class {
   }
   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,
@@ -85677,6 +86007,7 @@ var SessionManager2 = class {
     });
   });
   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) {
@@ -85685,7 +86016,7 @@ var SessionManager2 = class {
     }
     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(
@@ -85695,6 +86026,9 @@ var SessionManager2 = class {
       );
     }
     if (existing.usesEnvironment(options2.agent.environment)) {
+      if (recovery.kind === "execution-only") {
+        existing.startExecutionOnlyCapture();
+      }
       this.#executionProcesses.touch(options2.sessionId, existing);
       return existing.prepared();
     }
@@ -85989,10 +86323,13 @@ var SessionManager2 = class {
           "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");
@@ -86595,6 +86932,13 @@ var PromptLifecycle = class {
     }
     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",
@@ -86628,7 +86972,7 @@ var PromptLifecycle = class {
       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);
     }
   };
@@ -86665,18 +87009,149 @@ function isTerminal(state) {
 }
 var 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 = createHash6("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 = randomUUID13();
-    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) => {
@@ -86691,16 +87166,13 @@ var ExecutionReceipts = class {
     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;
@@ -86711,7 +87183,9 @@ var ExecutionReceipts = class {
   };
   close = () => {
     this.#executions.clear();
+    this.#recoveredCommands.clear();
     this.#terminalCountBySession.clear();
+    this.#activeCount = 0;
   };
   pruneTerminalReceipts = (sessionId) => {
     if ((this.#terminalCountBySession.get(sessionId) ?? 0) <= MAX_TERMINAL_RECEIPTS) {
@@ -86720,6 +87194,8 @@ var ExecutionReceipts = class {
     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);
@@ -87247,10 +87723,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();
@@ -87258,11 +87738,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",
@@ -87283,7 +87765,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(
@@ -87306,7 +87796,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,
@@ -89103,12 +89599,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) {
@@ -89177,7 +89675,8 @@ async function executePrompt({
         resources: attachments.resources,
         sessionId: command.sessionId,
         signal,
-        targetCommandId: command.targetCommandId
+        targetCommandId: command.targetCommandId,
+        recovery
       });
       stopReason = result.stopReason;
     }
@@ -89346,6 +89845,12 @@ var sessionPromptCommand = {
       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);
@@ -90471,7 +90976,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,
@@ -90541,6 +91047,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
             reportUpgradeAvailability,
             diagnostics,
             onConnected: () => {
+              layer.publishRecoveredOutcomes();
               if (catalogPublished) {
                 options.onConnectionStatus?.("online");
               }
@@ -90563,6 +91070,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
       }
     } finally {
       shutdown.abort();
+      operations.beginShutdown();
       await activeSessions.close();
       try {
         await catalogPublication;
@@ -90699,6 +91207,10 @@ async function createMobiusRuntimeEngine(connection, signal, environment = proce
 var MobiusRuntimeEngine = class {
   #config;
   #options;
+  #activeTurnCount = 0;
+  get activeTurnCount() {
+    return this.#activeTurnCount;
+  }
   #state = new IdleMobiusRuntimeState();
   constructor(config2, options = {}) {
     validateRuntimeConfiguration(config2);
@@ -90714,11 +91226,15 @@ var MobiusRuntimeEngine = class {
     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();
     }
   };