@moxt-ai/mobius 0.0.150 → 0.0.153

package/dist/index.js

@@ -20990,6 +20990,11 @@ var assistantHistoryMessageSchema = external_exports.strictObject({
 }).readonly();
 var historyMessage = external_exports.discriminatedUnion("role", [userHistoryMessage, assistantHistoryMessageSchema]);
 var availableSessionHistoryObjectSchema = external_exports.strictObject({
+  streamPosition: external_exports.strictObject({
+    commandId: identifierStringSchema,
+    epoch: identifierStringSchema,
+    sequence: external_exports.number().int().nonnegative()
+  }).readonly().optional(),
   status: external_exports.literal("available"),
   messages: external_exports.array(historyMessage).max(SESSION_HISTORY_MESSAGE_LIMIT).readonly(),
   truncated: external_exports.boolean(),
@@ -21108,6 +21113,12 @@ var nativeSessionRequestSchema = external_exports.discriminatedUnion("action", [
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
   }).readonly(),
+  external_exports.strictObject({
+    ...identity,
+    action: external_exports.literal("fork-recorded"),
+    targetSessionId: identifierStringSchema,
+    throughCommandId: identifierStringSchema
+  }).readonly(),
   external_exports.strictObject({
     ...identity,
     action: external_exports.literal("delete"),
@@ -21131,6 +21142,12 @@ var nativeSessionCommandSchema = external_exports.discriminatedUnion("action", [
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
   }).readonly(),
+  external_exports.strictObject({
+    ...identity,
+    action: external_exports.literal("fork-recorded"),
+    targetSessionId: identifierStringSchema,
+    throughCommandId: identifierStringSchema
+  }).readonly(),
   external_exports.strictObject({
     ...identity,
     action: external_exports.literal("delete"),
@@ -21180,7 +21197,7 @@ var nativeSessionResultSchema = external_exports.discriminatedUnion("action", [
   }).readonly(),
   external_exports.strictObject({
     ...resultEnvelope,
-    action: external_exports.enum(["import", "fork"]),
+    action: external_exports.enum(["import", "fork", "fork-recorded"]),
     targetSessionId: identifierStringSchema,
     ready: sessionReadyEventSchema,
     title: external_exports.string().max(500)
@@ -21229,6 +21246,7 @@ var SESSION_EVENT_KIND = "session.event";
 var SESSION_EVENT_ACK_KIND = "session.event.ack";
 var SESSION_EVENT_DEFERRED_KIND = "session.event.deferred";
 var SESSION_EVENT_REJECTED_KIND = "session.event.rejected";
+var SESSION_FORKED_KIND = "session.forked";
 var SessionEventRejectionCode = {
   IdempotencyConflict: "idempotency_conflict",
   InvalidEvent: "invalid_event",
@@ -21246,13 +21264,13 @@ var reliableDeliverySchema = external_exports.strictObject({
   sourceSeq: external_exports.string().regex(/^(?:0|[1-9][0-9]*)$/u).max(40),
   streamId: identifierStringSchema
 }).readonly();
-var reliableEventEnvelopeSchema = external_exports.strictObject({
+var reliableSessionEventEnvelopeSchema = external_exports.strictObject({
   delivery: reliableDeliverySchema,
   kind: external_exports.literal(SESSION_EVENT_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   sessionId: identifierStringSchema
 }).readonly();
-var eventEnvelopeSchema = external_exports.union([ephemeralEventEnvelopeSchema, reliableEventEnvelopeSchema]).readonly();
+var eventEnvelopeSchema = external_exports.union([ephemeralEventEnvelopeSchema, reliableSessionEventEnvelopeSchema]).readonly();
 var acknowledgementOutcomeSchema = external_exports.discriminatedUnion("kind", [
   external_exports.strictObject({ kind: external_exports.literal("relayed") }).readonly(),
   external_exports.strictObject({
@@ -21281,6 +21299,12 @@ var eventRejectedSchema = external_exports.strictObject({
 }).readonly();
 var SESSION_QUEUE_CHANGED_KIND = "session.queue.changed";
 var sessionQueueChangedSchema = external_exports.strictObject({ kind: external_exports.literal(SESSION_QUEUE_CHANGED_KIND), sessionId: identifierStringSchema }).readonly();
+var sessionForkedSchema = external_exports.strictObject({
+  kind: external_exports.literal(SESSION_FORKED_KIND),
+  sessionId: identifierStringSchema,
+  sourceSessionId: identifierStringSchema,
+  throughCommandId: identifierStringSchema
+}).readonly();
 function decode5(encoded, schema) {
   let value;
   try {
@@ -21318,6 +21342,8 @@ function decodeRecordedSessionEvent(encoded) {
   switch (kind) {
     case SESSION_QUEUE_CHANGED_KIND:
       return decode5(encoded, sessionQueueChangedSchema);
+    case SESSION_FORKED_KIND:
+      return decode5(encoded, sessionForkedSchema);
     case AGENT_ACTIVITY_KIND:
       return decodeAgentActivityEvent(encoded);
     case AGENT_ACTIVITY_NARRATION_KIND:
@@ -24097,13 +24123,15 @@ var AcpPreparedSession = class {
   capabilities;
   commands;
   configOptions;
+  prompted;
   restored;
-  constructor(agentName, agentVersion, capabilities, commands, configOptions, restored) {
+  constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored) {
     this.agentName = agentName;
     this.agentVersion = agentVersion;
     this.capabilities = capabilities;
     this.commands = commands;
     this.configOptions = configOptions;
+    this.prompted = prompted;
     this.restored = restored;
   }
 };
@@ -30330,6 +30358,10 @@ var acpSessionStoreMigrations = [
   {
     "name": "0000_slimy_captain_midlands.sql",
     "sql": "CREATE TABLE `acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL,\n	`agent_id` text NOT NULL,\n	`native_session_id` text NOT NULL,\n	`cwd` text NOT NULL,\n	`additional_directories` text NOT NULL,\n	`prompted` integer NOT NULL,\n	`title` text NOT NULL,\n	`updated_at` text NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE `deleted_acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL\n);\n"
+  },
+  {
+    "name": "0001_regular_ultimates.sql",
+    "sql": "ALTER TABLE `acp_session` ADD `last_terminal_command_id` text;"
   }
 ];
 
@@ -30347,6 +30379,7 @@ var acpSession = sqliteTable("acp_session", {
   nativeSessionId: text("native_session_id").notNull(),
   cwd: text("cwd").notNull(),
   additionalDirectories: text("additional_directories").notNull(),
+  lastTerminalCommandId: text("last_terminal_command_id"),
   prompted: integer2("prompted", { mode: "boolean" }).notNull(),
   title: text("title").notNull(),
   updatedAt: text("updated_at").notNull()
@@ -30362,15 +30395,17 @@ var AcpStoredSession = class {
   additionalDirectories;
   agentId;
   cwd;
+  lastTerminalCommandId;
   nativeSessionId;
   prompted;
   sessionId;
   title;
   updatedAt;
-  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString(), lastTerminalCommandId = null) {
     this.additionalDirectories = [...additionalDirectories];
     this.agentId = agentId;
     this.cwd = cwd;
+    this.lastTerminalCommandId = lastTerminalCommandId;
     this.nativeSessionId = nativeSessionId;
     this.prompted = prompted;
     this.sessionId = sessionId;
@@ -30431,6 +30466,7 @@ var storedSessionRowSchema = external_exports.object({
   additionalDirectories: external_exports.string(),
   agentId: external_exports.string(),
   cwd: external_exports.string(),
+  lastTerminalCommandId: external_exports.string().nullable(),
   nativeSessionId: external_exports.string(),
   prompted: external_exports.boolean(),
   sessionId: external_exports.string(),
@@ -30450,7 +30486,8 @@ function decodeStoredSession(value) {
     additionalDirectories,
     row.prompted,
     row.title,
-    row.updatedAt
+    row.updatedAt,
+    row.lastTerminalCommandId
   );
 }
 var SqliteAcpSessionStore = class {
@@ -30517,6 +30554,7 @@ var SqliteAcpSessionStore = class {
       additionalDirectories: JSON.stringify(session.additionalDirectories),
       agentId: session.agentId,
       cwd: session.cwd,
+      lastTerminalCommandId: session.lastTerminalCommandId,
       nativeSessionId: session.nativeSessionId,
       prompted: session.prompted,
       sessionId: session.sessionId,
@@ -30569,6 +30607,7 @@ var AgentSession = class _AgentSession {
   #commands = [];
   #configRevision = 0;
   #configOptions = [];
+  #lastTerminalCommandId = null;
   #prompted = false;
   #nativePrompt = null;
   #sessionLoad = { kind: "not-requested" };
@@ -30672,6 +30711,7 @@ var AgentSession = class _AgentSession {
     this.#capabilities,
     this.#commands,
     this.#configOptions,
+    this.#prompted,
     this.#restored
   );
   loadHistory = async (signal) => {
@@ -30905,6 +30945,7 @@ var AgentSession = class _AgentSession {
     } else if (stored instanceof FoundAcpStoredSession && stored.session.agentId === this.#agentId && stored.session.cwd === this.#cwd && arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
       this.selectNativeSession(stored.session.nativeSessionId);
       this.#prompted = stored.session.prompted;
+      this.#lastTerminalCommandId = stored.session.lastTerminalCommandId;
       this.#sessionTitle = stored.session.title;
       this.#restored = true;
       if (this.#capabilities.resumeSession) {
@@ -30978,7 +31019,9 @@ var AgentSession = class _AgentSession {
         this.#cwd,
         this.#additionalDirectories,
         this.#prompted,
-        this.#sessionTitle ?? ""
+        this.#sessionTitle ?? "",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        this.#lastTerminalCommandId
       )
     );
   };
@@ -31178,7 +31221,9 @@ var AgentSession = class _AgentSession {
         this.#cwd,
         this.#additionalDirectories,
         true,
-        this.#sessionTitle
+        this.#sessionTitle,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        this.#lastTerminalCommandId
       )
     );
     this.#prompted = true;
@@ -31230,6 +31275,20 @@ var AgentSession = class _AgentSession {
           usage: result.usage ?? null
         });
       }
+      this.#lastTerminalCommandId = options.commandId;
+      this.#store.write(
+        new AcpStoredSession(
+          this.#mobiusSessionId,
+          this.#agentId,
+          this.#updates.sessionId(),
+          this.#cwd,
+          this.#additionalDirectories,
+          true,
+          this.#sessionTitle ?? "",
+          (/* @__PURE__ */ new Date()).toISOString(),
+          this.#lastTerminalCommandId
+        )
+      );
       return result;
     } catch (error62) {
       await running.activities.finish();
@@ -31422,7 +31481,9 @@ var AgentSession = class _AgentSession {
             this.#cwd,
             this.#additionalDirectories,
             this.#prompted,
-            this.#sessionTitle ?? ""
+            this.#sessionTitle ?? "",
+            (/* @__PURE__ */ new Date()).toISOString(),
+            this.#lastTerminalCommandId
           )
         );
       }
@@ -32468,9 +32529,17 @@ var AgentRuntimeManager = class {
         const openedKey = `${options2.agent.id}:${runtime.nativeSessionId()}`;
         this.#nativeOperations.add(openedKey);
         try {
+          const prepared = runtime.prepared();
+          if (origin.kind === "fork" && options2.agent.id === "claude") {
+            await this.#retireSessionProcess(
+              options2.sessionId,
+              runtime,
+              async () => await runtime.closeProcess()
+            );
+          }
           return {
             sessionId: options2.sessionId,
-            prepared: runtime.prepared()
+            prepared
           };
         } finally {
           this.#nativeOperations.delete(openedKey);
@@ -39047,6 +39116,7 @@ var ActiveDaemonTurn = class {
       commandId: decodeIdentifier(this.command.commandId),
       epoch: this.#epoch,
       messages: this.timelineMessages(),
+      sequence: this.#sequence,
       state: "running",
       truncated: false
     };
@@ -39074,7 +39144,7 @@ var ActiveDaemonTurn = class {
 };
 
 // src/daemon-turn-registry.ts
-var COMPLETED_TURN_RECOVERY_LIMIT = 32;
+var MAX_SESSIONS_WITH_COMPLETED_RECOVERY = 32;
 var waitForTurnCompletion = (turn, waitSignal) => {
   waitSignal.throwIfAborted();
   return new Promise((resolve9, reject) => {
@@ -39100,46 +39170,46 @@ var waitForTurnCompletion = (turn, waitSignal) => {
   });
 };
 var DaemonTurnRegistry = class {
-  #turns = /* @__PURE__ */ new Map();
-  #completed = /* @__PURE__ */ new Map();
+  #inFlightByCommandId = /* @__PURE__ */ new Map();
+  #latestCompletedBySessionId = /* @__PURE__ */ new Map();
   #operations;
   constructor(operations) {
     this.#operations = operations;
   }
   start = (command, attemptId) => {
     const turn = new ActiveDaemonTurn(command, attemptId);
-    this.#turns.set(command.commandId, turn);
+    this.#inFlightByCommandId.set(command.commandId, turn);
     return turn;
   };
-  get = (commandId) => this.#turns.get(commandId);
+  get = (commandId) => this.#inFlightByCommandId.get(commandId);
   finish = (turn) => {
     const recovery = turn.recovery();
-    this.#turns.delete(turn.command.commandId);
+    this.#inFlightByCommandId.delete(turn.command.commandId);
     if (recovery !== null) {
-      this.#completed.delete(turn.command.sessionId);
-      this.#completed.set(turn.command.sessionId, {
-        command: turn.command,
-        recovery: { ...recovery, state: "completed" }
-      });
-      while (this.#completed.size > COMPLETED_TURN_RECOVERY_LIMIT) {
-        const oldestSessionId = this.#completed.keys().next().value;
-        if (oldestSessionId === void 0) {
-          break;
-        }
-        this.#completed.delete(oldestSessionId);
-      }
+      this.retainLatestCompletedRecovery(turn.command, { ...recovery, state: "completed" });
     }
     turn.finish();
   };
+  retainLatestCompletedRecovery = (command, recovery) => {
+    this.#latestCompletedBySessionId.delete(command.sessionId);
+    this.#latestCompletedBySessionId.set(command.sessionId, { command, recovery });
+    while (this.#latestCompletedBySessionId.size > MAX_SESSIONS_WITH_COMPLETED_RECOVERY) {
+      const oldestSessionId = this.#latestCompletedBySessionId.keys().next().value;
+      if (oldestSessionId === void 0) {
+        break;
+      }
+      this.#latestCompletedBySessionId.delete(oldestSessionId);
+    }
+  };
   recordEvent = (event) => {
     if ("commandId" in event) {
-      const turn = this.#turns.get(event.commandId);
+      const turn = this.#inFlightByCommandId.get(event.commandId);
       if (turn !== void 0 && turn.command.sessionId === event.sessionId) {
         return turn.recordEvent(event);
       }
     }
     if (event.kind === SESSION_PERMISSION_RESOLVED_KIND || event.kind === SESSION_ELICITATION_RESOLVED_KIND) {
-      for (const turn of this.#turns.values()) {
+      for (const turn of this.#inFlightByCommandId.values()) {
         if (turn.matchesInteraction(event.interactionId, event.sessionId)) {
           return turn.recordEvent(event);
         }
@@ -39148,17 +39218,17 @@ var DaemonTurnRegistry = class {
     return event;
   };
   recordSteeringPrompt = (command) => {
-    const target = this.#turns.get(command.targetCommandId);
+    const target = this.#inFlightByCommandId.get(command.targetCommandId);
     return target?.recordSteeringPrompt(command) ?? false;
   };
   executionSnapshot = async (matches) => {
     const matching = [];
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (await matches(turn.command)) {
         matching.push(turn);
       }
     }
-    const current = matching.filter((turn) => this.#turns.get(turn.command.commandId) === turn);
+    const current = matching.filter((turn) => this.#inFlightByCommandId.get(turn.command.commandId) === turn);
     return {
       turn: current.map((turn) => turn.snapshot()).find((snapshot) => snapshot !== null) ?? null,
       queued: current.filter((turn) => turn.isQueued()).map(({ command }) => ({
@@ -39169,7 +39239,7 @@ var DaemonTurnRegistry = class {
     };
   };
   snapshot = (matches) => {
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (!matches(turn.command)) {
         continue;
       }
@@ -39181,7 +39251,7 @@ var DaemonTurnRegistry = class {
     return null;
   };
   recovery = (matches) => {
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (!matches(turn.command)) {
         continue;
       }
@@ -39190,7 +39260,7 @@ var DaemonTurnRegistry = class {
         return recovery;
       }
     }
-    for (const completed of this.#completed.values()) {
+    for (const completed of this.#latestCompletedBySessionId.values()) {
       if (matches(completed.command)) {
         return completed.recovery;
       }
@@ -39198,17 +39268,17 @@ var DaemonTurnRegistry = class {
     return null;
   };
   close = async () => {
-    const turns = [...this.#turns.values()];
+    const turns = [...this.#inFlightByCommandId.values()];
     for (const turn of turns) {
       turn.abortDaemon();
     }
     await Promise.all(turns.map((turn) => turn.completion));
-    this.#completed.clear();
+    this.#latestCompletedBySessionId.clear();
   };
   admitAndWait = async (turn, waitSignal, onQueued) => {
     const command = turn.command;
     waitSignal.throwIfAborted();
-    const head = () => [...this.#turns.values()].find(
+    const head = () => [...this.#inFlightByCommandId.values()].find(
       (turn2) => turn2.command.sessionId === command.sessionId && turn2.command.disposition !== SessionPromptDisposition.Steer
     );
     if (command.disposition === SessionPromptDisposition.Queue) {
@@ -39937,6 +40007,7 @@ var readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTur
 
 // src/native-sessions/service.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
+import { basename as basename5 } from "node:path";
 
 // src/native-sessions/acp-history.ts
 async function readAcpHistory(sessions, directories, bindingId, options, nativeSessionId) {
@@ -40077,6 +40148,64 @@ var NativeSessionService = class {
         sessionId: command.sessionId
       };
     }
+    if (command.action === "fork-recorded") {
+      const source = this.#sessions.findSessions([command.sessionId])[0];
+      if (source === void 0 || !source.prompted) {
+        throw new AcpExecutionError(
+          "The source conversation has no resumable native Agent session",
+          {},
+          "native_session_not_found"
+        );
+      }
+      if (source.agentId !== command.agentId || source.cwd !== cwd || source.additionalDirectories.length !== additionalDirectories.length || source.additionalDirectories.some((path2, index) => path2 !== additionalDirectories[index])) {
+        throw new AcpExecutionError(
+          "The source conversation execution target does not match the fork request",
+          {},
+          "native_session_target_changed"
+        );
+      }
+      if (source.lastTerminalCommandId !== command.throughCommandId) {
+        throw new AcpExecutionError(
+          "The selected Turn is no longer the source conversation head",
+          {},
+          "fork_point_stale"
+        );
+      }
+      const opened2 = await this.#sessions.openNativeSession(
+        { ...options, sessionId: command.targetSessionId },
+        { kind: "fork", nativeSessionId: source.nativeSessionId }
+      );
+      signal.throwIfAborted();
+      const directory = await this.#directories.list(this.#config.bindingId, command.directoryId, signal);
+      const ready2 = {
+        additionalDirectories: additionalDirectories.map((path2, index) => ({
+          directoryId: command.additionalDirectoryIds[index] ?? command.directoryId,
+          name: basename5(path2) || path2
+        })),
+        agentId: command.agentId,
+        agentName: opened2.prepared.agentName,
+        agentVersion: opened2.prepared.agentVersion,
+        capabilities: opened2.prepared.capabilities,
+        commands: opened2.prepared.commands,
+        configOptions: opened2.prepared.configOptions,
+        directoryId: command.directoryId,
+        directoryLabel: directory.directoryLabel,
+        kind: "session.ready",
+        requestId: command.requestId,
+        restored: true,
+        sessionId: opened2.sessionId
+      };
+      this.record(command, "native_recorded_session_forked");
+      return {
+        action: "fork-recorded",
+        kind: "native.session.result",
+        ready: ready2,
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        targetSessionId: command.targetSessionId,
+        title: source.title || "Untitled session"
+      };
+    }
     const prepared = await this.#sessions.prepareNativeSessionBrowser(options);
     if (!prepared.capabilities.listSessions) {
       throw new AcpExecutionError(
@@ -41398,7 +41527,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { realpath as realpath9, stat as stat8 } from "node:fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve7 } from "node:path";
+import { basename as basename6, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
@@ -41449,7 +41578,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
     kind: FILE_BEGIN_KIND,
     mediaType: raster?.mimeType ?? "application/octet-stream",
     modifiedAt: before.mtime.toISOString(),
-    name: basename5(target) || "file",
+    name: basename6(target) || "file",
     requestId: command.requestId,
     sessionId: command.sessionId
   });
@@ -41479,7 +41608,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
 }
 
 // src/authorization/resolve-session-directories.ts
-import { basename as basename6 } from "node:path";
+import { basename as basename7 } from "node:path";
 var ResolvedSessionDirectories = class {
   additionalDirectories;
   additionalDirectoryEntries;
@@ -41504,7 +41633,7 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
     additionalDirectories.push(directory);
     additionalDirectoryEntries.push({
       directoryId: additionalDirectoryId,
-      name: basename6(directory)
+      name: basename7(directory)
     });
   }
   return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
@@ -41719,6 +41848,7 @@ function paginateActiveTurn(history, activeTurn, sessionId, endIndex, limit) {
     historicalCharacterLimit
   ) : null;
   return {
+    streamPosition: { commandId: activeTurn.commandId, epoch: activeTurn.epoch, sequence: activeTurn.sequence },
     coveredCommandIds: historical?.coveredCommandIds ?? [],
     coveredMessageIds: [
       ...historical?.coveredMessageIds ?? [],
@@ -41751,6 +41881,7 @@ function mergeLiveSessionHistory(history, activeTurn, sessionId) {
   }
   return {
     coveredCommandIds: page.coveredCommandIds,
+    ...page.streamPosition === void 0 ? {} : { streamPosition: page.streamPosition },
     coveredMessageIds: page.coveredMessageIds,
     messages: page.messages,
     status: "available",
@@ -42241,14 +42372,15 @@ 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 preparation = {
+      additionalDirectories: resolved.additionalDirectories,
+      agent: executionAgent,
+      cwd: resolved.cwd,
+      sessionId: command.sessionId,
+      signal
+    };
+    let prepared = await sessions.prepareExecutionSession(preparation);
     if (command.sessionConfigurations !== void 0) {
-      const prepared = await sessions.prepareExecutionSession({
-        additionalDirectories: resolved.additionalDirectories,
-        agent: executionAgent,
-        cwd: resolved.cwd,
-        sessionId: command.sessionId,
-        signal
-      });
       if (availability.disposition === SessionPromptDisposition.Steer) {
         assertAppliedSessionConfiguration(prepared.configOptions, sessionConfigurations ?? []);
       } else {
@@ -42264,6 +42396,7 @@ async function executePrompt({
           command.sessionId,
           signal
         );
+        prepared = await sessions.prepareExecutionSession(preparation);
       }
     }
     audit.record({
@@ -42282,6 +42415,24 @@ async function executePrompt({
       }
     }
     const stream = activateAttempt();
+    if (!prepared.prompted) {
+      const listing = await directories.list(config2.bindingId, command.directoryId, signal);
+      publisher.publish(command.sessionId, {
+        additionalDirectories: resolved.additionalDirectoryEntries,
+        agentId: command.agentId,
+        agentName: prepared.agentName,
+        agentVersion: prepared.agentVersion,
+        capabilities: prepared.capabilities,
+        commands: prepared.commands,
+        configOptions: prepared.configOptions,
+        directoryId: command.directoryId,
+        directoryLabel: listing.directoryLabel,
+        kind: SESSION_READY_KIND,
+        requestId: command.commandId,
+        restored: prepared.restored,
+        sessionId: command.sessionId
+      });
+    }
     publisher.publish(command.sessionId, {
       commandId: command.commandId,
       epoch: stream.epoch,
@@ -42535,7 +42686,7 @@ async function executeSessionConfigure(publisher, socket, command, config2, dire
 // src/native-sessions/handle-native-requests.ts
 import { WebSocket as WebSocket5 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
-  const { audit, diagnostics, nativeSessions, signal, socket, timer } = dependencies;
+  const { audit, diagnostics, nativeSessions, publisher, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
   const cancel = (command) => {
     const request = pending.get(command.requestId);
@@ -42587,6 +42738,17 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command, operationSignal);
+        if (command.action === "fork-recorded" && result.action === "fork-recorded") {
+          publisher.publishBatch(result.ready.sessionId, [
+            result.ready,
+            {
+              kind: "session.forked",
+              sessionId: result.ready.sessionId,
+              sourceSessionId: command.sessionId,
+              throughCommandId: command.throughCommandId
+            }
+          ]);
+        }
         if (socket.readyState === WebSocket5.OPEN) {
           send(socket, result);
         }
@@ -42672,6 +42834,7 @@ function createDaemonCommandHandler({
     audit,
     diagnostics,
     nativeSessions,
+    publisher,
     signal,
     socket,
     timer
@@ -43424,6 +43587,16 @@ var SessionEventOutbox = class {
     this.#database.close();
   };
   enqueue = (sessionId, payload, critical) => {
+    const envelope2 = this.enqueueBatch(sessionId, [payload], critical)[0];
+    if (envelope2 === void 0) {
+      throw new Error("The Session event outbox did not enqueue the event");
+    }
+    return envelope2;
+  };
+  enqueueBatch = (sessionId, payloads, critical) => {
+    if (payloads.length < 1 || payloads.length > 32) {
+      throw new Error("A Session event batch must contain between 1 and 32 events");
+    }
     this.#database.exec("BEGIN IMMEDIATE");
     try {
       const state = this.#database.prepare(
@@ -43432,39 +43605,52 @@ var SessionEventOutbox = class {
                      WHERE singleton = 1`
       ).get();
       const sourceSeq = rowNumber(state, "next_source_seq");
-      if (sourceSeq < 1 || !Number.isSafeInteger(sourceSeq + 1)) {
+      if (sourceSeq < 1 || !Number.isSafeInteger(sourceSeq + payloads.length)) {
         throw new Error("The Session event source sequence is exhausted");
       }
-      const envelope2 = {
-        delivery: {
-          eventId: randomUUID7(),
-          kind: "reliable",
-          sourceSeq: sourceSeq.toString(),
-          streamId: rowString(state, "stream_id")
-        },
-        kind: SESSION_EVENT_KIND,
-        payload,
-        sessionId
-      };
-      const encoded = encodeSessionEventEnvelope(envelope2);
-      const byteLength = Buffer.byteLength(encoded, "utf8");
+      const streamId = rowString(state, "stream_id");
+      const stored = payloads.map((payload, index) => {
+        const envelope2 = {
+          delivery: {
+            eventId: randomUUID7(),
+            kind: "reliable",
+            sourceSeq: (sourceSeq + index).toString(),
+            streamId
+          },
+          kind: SESSION_EVENT_KIND,
+          payload,
+          sessionId
+        };
+        const encoded = encodeSessionEventEnvelope(envelope2);
+        return { byteLength: Buffer.byteLength(encoded, "utf8"), encoded, envelope: envelope2 };
+      });
+      const byteLength = stored.reduce((total, entry) => total + entry.byteLength, 0);
       const maximumBytes = critical ? this.#limits.criticalEventBytes : this.#limits.standardEventBytes;
       if (rowNumber(state, "total_bytes") + byteLength > maximumBytes) {
         throw new SessionEventOutboxCapacityError();
       }
-      this.#database.prepare(
+      const insert = this.#database.prepare(
         `INSERT INTO relay_session_event_outbox (
-                        event_id, session_id, source_seq, byte_length, envelope_json
-                    ) VALUES (?, ?, ?, ?, ?)`
-      ).run(envelope2.delivery.eventId, sessionId, sourceSeq, byteLength, encoded);
+                    event_id, session_id, source_seq, byte_length, envelope_json
+                ) VALUES (?, ?, ?, ?, ?)`
+      );
+      for (const entry of stored) {
+        insert.run(
+          entry.envelope.delivery.eventId,
+          sessionId,
+          Number(entry.envelope.delivery.sourceSeq),
+          entry.byteLength,
+          entry.encoded
+        );
+      }
       this.#database.prepare(
         `UPDATE relay_session_event_outbox_state
-                     SET next_source_seq = next_source_seq + 1,
+                     SET next_source_seq = next_source_seq + ?,
                          total_bytes = total_bytes + ?
                      WHERE singleton = 1`
-      ).run(byteLength);
+      ).run(stored.length, byteLength);
       this.#database.exec("COMMIT");
-      return envelope2;
+      return stored.map((entry) => entry.envelope);
     } catch (error62) {
       this.#database.exec("ROLLBACK");
       throw error62;
@@ -43565,7 +43751,7 @@ import { WebSocket as WebSocket9 } from "undici";
 var SESSION_EVENT_REPLAY_WINDOW = 16;
 var SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
 function reservesSessionEventCapacity(event) {
-  if (event.kind === SESSION_COMPLETED_KIND || event.kind === SESSION_FAILED_KIND) {
+  if (event.kind === SESSION_COMPLETED_KIND || event.kind === SESSION_FAILED_KIND || event.kind === SESSION_FORKED_KIND || event.kind === SESSION_READY_KIND) {
     return true;
   }
   return event.kind === AGENT_ACTIVITY_KIND && (event.activityType === "progress" || event.activityType === "reasoning") && (event.status === "completed" || event.status === "failed");
@@ -43638,6 +43824,11 @@ var DaemonSessionEventPublisher = class {
     }
     this.#publishNextBatch();
   };
+  publishBatch = (sessionId, events) => {
+    const critical = events.some(reservesSessionEventCapacity);
+    this.#outbox.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
+    this.#publishNextBatch();
+  };
   quarantine = (rejection) => {
     if (!this.#outbox.quarantine(rejection)) {
       return;