@moxt-ai/mobius 0.0.146 → 0.0.149

package/dist/index.js

@@ -21060,18 +21060,21 @@ var activeTurnMessageSchema = external_exports.discriminatedUnion("role", [
   activeTurnAssistantMessageSchema
 ]);
 var activeTurnSnapshotSchema = external_exports.strictObject({
-  activities: external_exports.array(activeTurnActivitySchema).readonly(),
   commandId: identifierStringSchema,
-  content: external_exports.array(displayContentSchema).readonly(),
-  prompt: external_exports.string().max(1e5),
-  text: external_exports.string(),
-  truncated: external_exports.boolean(),
   epoch: identifierStringSchema,
+  hasOlder: external_exports.boolean(),
   interaction: external_exports.discriminatedUnion("kind", [sessionPermissionRequestedEventSchema, sessionElicitationRequestedEventSchema]).nullable(),
   messages: external_exports.array(activeTurnMessageSchema).max(SESSION_HISTORY_MESSAGE_LIMIT).readonly(),
   sequence: external_exports.number().int().nonnegative(),
-  state: external_exports.literal("running")
-}).readonly();
+  state: external_exports.literal("running"),
+  truncated: external_exports.boolean()
+}).readonly().refine(
+  (snapshot) => snapshot.messages.reduce(
+    (total, message) => total + message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0),
+    0
+  ) <= SESSION_HISTORY_CHARACTER_LIMIT,
+  "Active Turn snapshot content is too large"
+);
 var identity = {
   ...envelope,
   kind: external_exports.literal(NATIVE_SESSION_REQUEST_KIND),
@@ -21215,27 +21218,14 @@ var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSch
 
 // ../protocol/src/session-events.ts
 var SESSION_EVENT_KIND = "session.event";
-var SESSION_EVENT_COMMITTED_KIND = "session.event.committed";
 var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
 var eventEnvelopeSchema = external_exports.strictObject({
   kind: external_exports.literal(SESSION_EVENT_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   sessionId: identifierStringSchema
 }).readonly();
-var committedEventSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_EVENT_COMMITTED_KIND),
-  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
-  sessionId: identifierStringSchema
-}).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 SESSION_TURN_UPDATED_KIND = "session.turn.updated";
-var sessionTurnUpdatedSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_TURN_UPDATED_KIND),
-  sessionId: identifierStringSchema,
-  turn: activeTurnSnapshotSchema
-}).readonly();
-var decodeSessionTurnUpdatedEvent = (encoded) => decode5(encoded, sessionTurnUpdatedSchema);
 function decode5(encoded, schema) {
   let value;
   try {
@@ -21265,8 +21255,6 @@ var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSche
 function decodeRecordedSessionEvent(encoded) {
   const kind = decodeMessageKind(encoded);
   switch (kind) {
-    case SESSION_TURN_UPDATED_KIND:
-      return decodeSessionTurnUpdatedEvent(encoded);
     case SESSION_QUEUE_CHANGED_KIND:
       return decode5(encoded, sessionQueueChangedSchema);
     case AGENT_ACTIVITY_KIND:
@@ -32569,6 +32557,17 @@ var AgentProbeFailed = class extends UnavailableAgent {
     this.message = message;
   }
 };
+var UnsupportedAgentVersion = class extends UnavailableInstalledAgent {
+  code = "agent_version_unsupported";
+  message;
+  minimumSupportedVersion;
+  status = "unsupported_version";
+  constructor(specification, agent, minimumSupportedVersion) {
+    super(specification, agent);
+    this.minimumSupportedVersion = minimumSupportedVersion;
+    this.message = `Agent version ${agent.agentVersion} is below the minimum supported version ${minimumSupportedVersion}`;
+  }
+};
 var IntegrationProbeFailed = class extends UnavailableInstalledAgent {
   code;
   message;
@@ -32596,12 +32595,25 @@ var AuthenticationRequiredAgent = class extends UnavailableInstalledAgent {
     super(specification, agent);
   }
 };
+var AgentDiscoveryResult = class {
+  detectionMilliseconds;
+  discovery;
+  constructor(discovery, detectionMilliseconds) {
+    if (!Number.isFinite(detectionMilliseconds) || detectionMilliseconds < 0) {
+      throw new Error("The Agent detection duration is invalid");
+    }
+    this.detectionMilliseconds = Math.round(detectionMilliseconds * 1e3) / 1e3;
+    this.discovery = discovery;
+  }
+};
 var LocalAgentInventory = class {
   available;
   discoveries;
   installable;
+  results;
   unavailable;
-  constructor(discoveries) {
+  constructor(results) {
+    const discoveries = results.map((result) => result.discovery);
     const available = [];
     const unavailable = [];
     for (const discovery of discoveries) {
@@ -32620,8 +32632,17 @@ var LocalAgentInventory = class {
         (discovery) => discovery instanceof UnavailableInstalledAgent ? discovery.agent : new MissingAgentDefinition(discovery.specification.id, discovery.specification.label)
       )
     );
+    this.results = Object.freeze([...results]);
     this.unavailable = Object.freeze(unavailable);
   }
+  detectionMillisecondsFor = (discovery) => {
+    for (const result of this.results) {
+      if (result.discovery === discovery) {
+        return result.detectionMilliseconds;
+      }
+    }
+    throw new Error("The Agent discovery result is unavailable");
+  };
   readyAgents = () => this.available.map((discovery) => discovery.agent);
 };
 
@@ -36540,15 +36561,20 @@ async function discoverAgent(specification, context) {
       );
       continue;
     }
-    if (!supportedVersion) {
-      continue;
-    }
     const installedAgent = new AgentIntegrationDefinition(
       specification.id,
       specification.label,
       agent.identity.requestedPath,
       agentVersion
     );
+    if (!supportedVersion) {
+      lastFailure = new UnsupportedAgentVersion(
+        specification,
+        installedAgent,
+        specification.minimumSupportedAgentVersion
+      );
+      continue;
+    }
     if (adapters.length === 0 && !(specification instanceof InProcessAcpAgentDefinition2)) {
       return new MissingAdapter(specification, installedAgent);
     }
@@ -36642,10 +36668,15 @@ async function discoverAgent(specification, context) {
 // src/agent-catalog/discover-local-agents.ts
 async function discoverLocalAgentInventory(options) {
   const specifications = options.specifications ?? supportedLocalAgentSpecifications();
-  const discoveries = await Promise.all(
-    specifications.map(async (specification) => await discoverAgent(specification, options))
+  const monotonicTimeMilliseconds = options.monotonicTimeMilliseconds ?? (() => performance.now());
+  const results = await Promise.all(
+    specifications.map(async (specification) => {
+      const startedAt = monotonicTimeMilliseconds();
+      const discovery = await discoverAgent(specification, options);
+      return new AgentDiscoveryResult(discovery, monotonicTimeMilliseconds() - startedAt);
+    })
   );
-  return new LocalAgentInventory(discoveries);
+  return new LocalAgentInventory(results);
 }
 
 // src/storage/runtime-installation-store.ts
@@ -38688,6 +38719,28 @@ var DaemonInstallationObserver = class {
 
 // src/daemon-active-turn.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+function activeMessageCharacters(message) {
+  return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
+}
+var ACTIVE_TURN_TEXT_CHUNK_LIMIT = Math.floor(SESSION_HISTORY_CHARACTER_LIMIT / 2);
+function boundedRecoveryMessages(messages) {
+  const selected = [];
+  let remainingCharacters = SESSION_HISTORY_CHARACTER_LIMIT;
+  for (let index = messages.length - 1; index >= 0 && selected.length < SESSION_HISTORY_MESSAGE_LIMIT; index -= 1) {
+    const message = messages[index];
+    if (message === void 0) {
+      break;
+    }
+    const characters = activeMessageCharacters(message);
+    if (characters <= remainingCharacters) {
+      selected.unshift(message);
+      remainingCharacters -= characters;
+      continue;
+    }
+    break;
+  }
+  return { hasOlder: selected.length !== messages.length, messages: selected };
+}
 var ActiveDaemonTurn = class {
   attemptId;
   command;
@@ -38695,9 +38748,7 @@ var ActiveDaemonTurn = class {
   #finished = Promise.withResolvers();
   #cancellationRequested = false;
   #dispatch;
-  #text = "";
   #activities = /* @__PURE__ */ new Map();
-  #content = /* @__PURE__ */ new Map();
   #timeline;
   #sequence = 0;
   #interaction = null;
@@ -38744,9 +38795,17 @@ var ActiveDaemonTurn = class {
   effectiveDisposition = () => this.#dispatch.kind === "promoted" ? SessionPromptDisposition.Steer : this.command.disposition;
   recordEvent = (event) => {
     if (event.kind === AGENT_MESSAGE_DELTA_KIND) {
-      this.#text += event.text;
+      const sequence = this.advance();
       this.appendMessageText(event.messageId, event.text);
-      return this.updated();
+      return {
+        commandId: this.command.commandId,
+        epoch: this.#epoch,
+        kind: AGENT_MESSAGE_DELTA_KIND,
+        messageId: event.messageId,
+        sequence,
+        sessionId: this.command.sessionId,
+        text: event.text
+      };
     }
     if (event.sessionId !== this.command.sessionId || "commandId" in event && event.commandId !== this.command.commandId) {
       return event;
@@ -38793,7 +38852,6 @@ var ActiveDaemonTurn = class {
         toolKind: previous?.toolKind ?? ""
       });
     } else if (event.kind === AGENT_CONTENT_KIND) {
-      this.#content.set(event.contentId, event.content);
       const target = this.#timeline.findLastIndex(
         (entry) => entry.kind === "message" && entry.sourceMessageId === event.messageId
       );
@@ -38819,7 +38877,7 @@ var ActiveDaemonTurn = class {
       this.#interaction = null;
     }
     if (event.kind === AGENT_ACTIVITY_KIND || event.kind === AGENT_ACTIVITY_NARRATION_KIND || event.kind === AGENT_CONTENT_KIND) {
-      return this.updated();
+      this.advance();
     }
     return event;
   };
@@ -38828,7 +38886,7 @@ var ActiveDaemonTurn = class {
     while (remaining.length > 0) {
       const latest = this.#timeline.at(-1);
       if (latest?.kind === "message" && latest.sourceMessageId === messageId) {
-        const available = SESSION_HISTORY_CHARACTER_LIMIT - latest.text.length;
+        const available = ACTIVE_TURN_TEXT_CHUNK_LIMIT - latest.text.length;
         if (available > 0) {
           this.#timeline = [
             ...this.#timeline.slice(0, -1),
@@ -38845,21 +38903,22 @@ var ActiveDaemonTurn = class {
           id: decodeIdentifier(randomUUID2()),
           kind: "message",
           sourceMessageId: messageId,
-          text: remaining.slice(0, SESSION_HISTORY_CHARACTER_LIMIT)
+          text: remaining.slice(0, ACTIVE_TURN_TEXT_CHUNK_LIMIT)
         }
       ];
-      remaining = remaining.slice(SESSION_HISTORY_CHARACTER_LIMIT);
+      remaining = remaining.slice(ACTIVE_TURN_TEXT_CHUNK_LIMIT);
     }
   }
   recordSteeringPrompt = (command) => {
     if (this.#dispatch.kind !== "running" || command.sessionId !== this.command.sessionId || command.targetCommandId !== this.command.commandId) {
-      return null;
+      return false;
     }
     this.#timeline = [
       ...this.#timeline,
       { id: decodeIdentifier(command.commandId), images: command.images, kind: "user", text: command.prompt }
     ];
-    return this.updated();
+    this.advance();
+    return true;
   };
   timelineMessages() {
     return this.#timeline.flatMap((entry) => {
@@ -38881,32 +38940,39 @@ var ActiveDaemonTurn = class {
       return activity2 === void 0 ? [] : [{ activities: [activity2], content: [], id: entry.id, role: "assistant", text: "" }];
     });
   }
-  updated = () => {
-    this.#sequence += 1;
-    const turn = this.snapshot();
-    if (turn === null) {
-      throw new Error("Only a running turn can publish a snapshot");
+  advance = () => {
+    if (this.#dispatch.kind !== "running") {
+      throw new Error("Only a running turn can advance its snapshot");
     }
-    return { kind: "session.turn.updated", sessionId: this.command.sessionId, turn };
+    this.#sequence += 1;
+    return this.#sequence;
   };
   snapshot = () => {
     if (this.#dispatch.kind !== "running") {
       return null;
     }
-    const completeMessages = this.timelineMessages();
-    const messages = completeMessages.slice(-SESSION_HISTORY_MESSAGE_LIMIT);
+    const bounded2 = boundedRecoveryMessages(this.timelineMessages());
     return {
-      activities: [...this.#activities.values()].sort((left, right) => left.sequence - right.sequence),
       commandId: decodeIdentifier(this.command.commandId),
-      content: [...this.#content.values()],
-      prompt: this.command.prompt,
-      text: this.#text,
-      truncated: messages.length !== completeMessages.length,
       epoch: this.#epoch,
+      hasOlder: bounded2.hasOlder,
       interaction: this.#interaction,
-      messages,
+      messages: bounded2.messages,
       sequence: this.#sequence,
-      state: "running"
+      state: "running",
+      truncated: false
+    };
+  };
+  recovery = () => {
+    if (this.#dispatch.kind !== "running") {
+      return null;
+    }
+    return {
+      commandId: decodeIdentifier(this.command.commandId),
+      epoch: this.#epoch,
+      messages: this.timelineMessages(),
+      state: "running",
+      truncated: false
     };
   };
   matches = (cancellation) => cancellation.commandId === this.command.commandId && cancellation.sessionId === this.command.sessionId;
@@ -38932,6 +38998,7 @@ var ActiveDaemonTurn = class {
 };
 
 // src/daemon-turn-registry.ts
+var COMPLETED_TURN_RECOVERY_LIMIT = 32;
 var waitForTurnCompletion = (turn, waitSignal) => {
   waitSignal.throwIfAborted();
   return new Promise((resolve9, reject) => {
@@ -38958,6 +39025,7 @@ var waitForTurnCompletion = (turn, waitSignal) => {
 };
 var DaemonTurnRegistry = class {
   #turns = /* @__PURE__ */ new Map();
+  #completed = /* @__PURE__ */ new Map();
   #operations;
   constructor(operations) {
     this.#operations = operations;
@@ -38969,7 +39037,22 @@ var DaemonTurnRegistry = class {
   };
   get = (commandId) => this.#turns.get(commandId);
   finish = (turn) => {
+    const recovery = turn.recovery();
     this.#turns.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);
+      }
+    }
     turn.finish();
   };
   recordEvent = (event) => {
@@ -38990,7 +39073,7 @@ var DaemonTurnRegistry = class {
   };
   recordSteeringPrompt = (command) => {
     const target = this.#turns.get(command.targetCommandId);
-    return target?.recordSteeringPrompt(command) ?? null;
+    return target?.recordSteeringPrompt(command) ?? false;
   };
   executionSnapshot = async (matches) => {
     const matching = [];
@@ -39021,12 +39104,30 @@ var DaemonTurnRegistry = class {
     }
     return null;
   };
+  recovery = (matches) => {
+    for (const turn of this.#turns.values()) {
+      if (!matches(turn.command)) {
+        continue;
+      }
+      const recovery = turn.recovery();
+      if (recovery !== null) {
+        return recovery;
+      }
+    }
+    for (const completed of this.#completed.values()) {
+      if (matches(completed.command)) {
+        return completed.recovery;
+      }
+    }
+    return null;
+  };
   close = async () => {
     const turns = [...this.#turns.values()];
     for (const turn of turns) {
       turn.abortDaemon();
     }
     await Promise.all(turns.map((turn) => turn.completion));
+    this.#completed.clear();
   };
   admitAndWait = async (turn, waitSignal, onQueued) => {
     const command = turn.command;
@@ -41334,10 +41435,10 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
 }
 
 // src/native-sessions/live-history-page.ts
-function liveHistoryCursor(sessionId, endIndex) {
-  return Buffer.from(JSON.stringify({ endIndex, sessionId }), "utf8").toString("base64url");
+function encodeLiveHistoryCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
 }
-function liveHistoryEndIndex(cursor, sessionId) {
+function decodeLiveHistoryCursor(cursor, sessionId) {
   try {
     if (!/^[A-Za-z0-9_-]{1,512}$/u.test(cursor)) {
       throw new Error("Invalid cursor alphabet");
@@ -41347,14 +41448,32 @@ function liveHistoryEndIndex(cursor, sessionId) {
       throw new Error("Invalid cursor shape");
     }
     const record2 = Object.fromEntries(Object.entries(value));
-    if (Object.keys(record2).sort().join(",") !== "endIndex,sessionId" || record2["sessionId"] !== sessionId || typeof record2["endIndex"] !== "number" || !Number.isSafeInteger(record2["endIndex"]) || record2["endIndex"] < 0) {
+    const keys = Object.keys(record2).sort().join(",");
+    const legacyNative = keys === "endIndex,sessionId";
+    const kind = legacyNative ? "native" : record2["kind"];
+    if (keys !== "endIndex,kind,sessionId" && keys !== "endIndex,epoch,kind,sessionId" && !legacyNative || record2["sessionId"] !== sessionId || kind !== "active" && kind !== "native" || typeof record2["endIndex"] !== "number" || !Number.isSafeInteger(record2["endIndex"]) || record2["endIndex"] < 0) {
       throw new Error("Invalid cursor target");
     }
-    return record2["endIndex"];
+    if (kind === "active") {
+      if (keys !== "endIndex,epoch,kind,sessionId" || typeof record2["epoch"] !== "string") {
+        throw new Error("Invalid active cursor target");
+      }
+      return { endIndex: record2["endIndex"], epoch: record2["epoch"], kind, sessionId };
+    }
+    if (keys !== "endIndex,kind,sessionId" && !legacyNative) {
+      throw new Error("Invalid native cursor target");
+    }
+    return { endIndex: record2["endIndex"], kind, sessionId };
   } catch (cause) {
     throw new AcpExecutionError("The native Session history cursor is invalid", { cause }, "invalid_cursor");
   }
 }
+function activeHistoryCursor(sessionId, epoch, endIndex) {
+  return encodeLiveHistoryCursor({ endIndex, epoch, kind: "active", sessionId });
+}
+function nativeHistoryCursor(sessionId, endIndex) {
+  return encodeLiveHistoryCursor({ endIndex, kind: "native", sessionId });
+}
 function liveHistoryCoveredTurnRanges(history) {
   const ranges = [];
   let historyIndex = history.messages.length;
@@ -41375,139 +41494,180 @@ function liveHistoryCoveredTurnRanges(history) {
 function historyMessageCharacters(message) {
   return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
 }
-function boundedActiveMessages(messages, messageLimit, characterLimit) {
+function isNativeHistoryImageMimeType(mimeType) {
+  return mimeType === "image/png" || mimeType === "image/jpeg" || mimeType === "image/gif" || mimeType === "image/webp";
+}
+function selectMessagesBefore(messages, endIndex, messageLimit, characterLimit) {
   const selected = [];
   let remainingCharacters = characterLimit;
-  for (let index = messages.length - 1; index >= 0 && selected.length < messageLimit; index -= 1) {
+  let startIndex = endIndex;
+  for (let index = endIndex - 1; index >= 0 && selected.length < messageLimit; index -= 1) {
     const message = messages[index];
     if (message === void 0) {
       break;
     }
     const characters = historyMessageCharacters(message);
-    if (characters <= remainingCharacters) {
-      selected.unshift(message);
-      remainingCharacters -= characters;
-      continue;
-    }
-    const structuredCharacters = characters - message.text.length;
-    if (selected.length === 0 && structuredCharacters <= remainingCharacters) {
-      const textCharacters = remainingCharacters - structuredCharacters;
-      selected.unshift({ ...message, text: textCharacters === 0 ? "" : message.text.slice(-textCharacters) });
-      remainingCharacters = 0;
+    if (characters > remainingCharacters) {
+      break;
     }
-    break;
+    selected.unshift(message);
+    remainingCharacters -= characters;
+    startIndex = index;
   }
-  return {
-    characters: characterLimit - remainingCharacters,
-    messages: selected,
-    truncated: selected.length !== messages.length
-  };
+  if (selected.length === 0 && endIndex > 0) {
+    throw new AcpExecutionError(
+      "A native Session history item exceeds the page budget",
+      {},
+      "history_item_too_large"
+    );
+  }
+  return { characters: characterLimit - remainingCharacters, messages: selected, startIndex };
 }
 function nativeActiveMessage(message) {
-  return message.role === "user" ? { role: "user", text: message.text } : {
-    activities: message.activities,
-    content: message.content,
-    role: "assistant",
-    text: message.text
-  };
+  if (message.role === "assistant") {
+    return {
+      activities: message.activities,
+      content: message.content,
+      role: "assistant",
+      text: message.text
+    };
+  }
+  const images = (message.images ?? []).flatMap((image) => {
+    if (image.data.length < 4 || image.data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(image.data) || !isNativeHistoryImageMimeType(image.mimeType)) {
+      return [];
+    }
+    return [{ data: image.data, mimeType: image.mimeType, name: image.name }];
+  });
+  return { ...images.length === 0 ? {} : { images }, role: "user", text: message.text };
+}
+function nativeHistoryCoversCompletedRecovery(history, recovery) {
+  const root = recovery.messages.find((message) => message.role === "user" && message.id === recovery.commandId);
+  if (root === void 0) {
+    return false;
+  }
+  const rootIndex = history.messages.findLastIndex(
+    (message) => message.role === "user" && message.text === root.text
+  );
+  if (rootIndex < 0) {
+    return false;
+  }
+  const nativeAssistant = history.messages.slice(rootIndex + 1).filter((message) => message.role === "assistant");
+  if (nativeAssistant.length === 0) {
+    return false;
+  }
+  const recoveryAssistant = recovery.messages.filter((message) => message.role === "assistant");
+  const recoveryText = recoveryAssistant.map((message) => message.text).join("");
+  const nativeText = nativeAssistant.map((message) => message.text).join("");
+  if (recoveryText.length > 0 && !nativeText.includes(recoveryText)) {
+    return false;
+  }
+  const nativeContent = new Set(
+    nativeAssistant.flatMap((message) => message.content).map((content) => JSON.stringify(content))
+  );
+  return recoveryAssistant.flatMap((message) => message.content).every((content) => nativeContent.has(JSON.stringify(content)));
 }
-function paginateAcpSessionHistory(history, sessionId, cursor, limit) {
+function historyBeforeActiveTurn(history, activeTurn) {
   if (history.status === "unavailable") {
-    if (cursor !== null) {
-      throw new AcpExecutionError("Unavailable native Session history has no cursor", {}, "invalid_cursor");
-    }
-    return { cause: history.cause, nextCursor: null, status: "unavailable" };
+    return history;
+  }
+  const activeRoot = activeTurn.messages.find(
+    (message) => message.role === "user" && message.id === activeTurn.commandId
+  );
+  const matchingActiveUserIndex = activeRoot === void 0 ? -1 : activeTurn.state === "completed" || history.messages.at(-1)?.role === "user" && history.messages.at(-1)?.text === activeRoot.text || history.coveredCommandIds.includes(activeTurn.commandId) ? history.messages.findLastIndex((message) => message.role === "user" && message.text === activeRoot.text) : -1;
+  const activeUserIndex = matchingActiveUserIndex >= 0 ? matchingActiveUserIndex : liveHistoryCoveredTurnRanges(history).find((range) => range.commandId === activeTurn.commandId)?.userIndex ?? -1;
+  if (activeUserIndex < 0) {
+    return history;
   }
-  const endIndex = cursor === null ? history.messages.length : liveHistoryEndIndex(cursor, sessionId);
+  return {
+    ...history,
+    coveredCommandIds: history.coveredCommandIds.filter((id) => id !== activeTurn.commandId),
+    coveredMessageIds: history.coveredMessageIds.filter(
+      (id) => id !== `${activeTurn.commandId}:user` && id !== `${activeTurn.commandId}:agent`
+    ),
+    messages: history.messages.slice(0, activeUserIndex)
+  };
+}
+function paginateAvailableNativeHistory(history, sessionId, endIndex, limit, characterLimit) {
   if (endIndex > history.messages.length) {
     throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
-  const startIndex = Math.max(0, endIndex - limit);
+  const selected = selectMessagesBefore(history.messages, endIndex, limit, characterLimit);
   const coveredMessageIds = new Set(history.coveredMessageIds);
   const ranges = liveHistoryCoveredTurnRanges(history);
   return {
-    coveredCommandIds: ranges.filter((range) => range.userIndex >= startIndex && range.assistantEndIndex <= endIndex).map((range) => range.commandId),
+    coveredCommandIds: ranges.filter((range) => range.userIndex >= selected.startIndex && range.assistantEndIndex <= endIndex).map((range) => range.commandId),
     coveredMessageIds: ranges.flatMap((range) => [
-      ...range.userIndex >= startIndex && range.userIndex < endIndex && coveredMessageIds.has(`${range.commandId}:user`) ? [`${range.commandId}:user`] : [],
-      ...range.assistantStartIndex >= startIndex && range.assistantEndIndex <= endIndex && coveredMessageIds.has(`${range.commandId}:agent`) ? [`${range.commandId}:agent`] : []
+      ...range.userIndex >= selected.startIndex && range.userIndex < endIndex && coveredMessageIds.has(`${range.commandId}:user`) ? [`${range.commandId}:user`] : [],
+      ...range.assistantStartIndex >= selected.startIndex && range.assistantEndIndex <= endIndex && coveredMessageIds.has(`${range.commandId}:agent`) ? [`${range.commandId}:agent`] : []
     ]),
-    messages: history.messages.slice(startIndex, endIndex),
-    nextCursor: startIndex > 0 ? liveHistoryCursor(sessionId, startIndex) : null,
+    messages: selected.messages,
+    nextCursor: selected.startIndex > 0 ? nativeHistoryCursor(sessionId, selected.startIndex) : null,
     status: "available",
     truncated: history.truncated
   };
 }
-function paginateLiveSessionHistory(history, activeTurn, sessionId, cursor, limit) {
-  if (activeTurn === null || cursor !== null) {
-    return paginateAcpSessionHistory(history, sessionId, cursor, limit);
+function paginateNativeHistory(history, sessionId, cursor, limit) {
+  if (cursor?.kind === "active") {
+    throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
   if (history.status === "unavailable") {
-    const bounded3 = boundedActiveMessages(
-      activeTurn.messages.map(nativeActiveMessage),
-      limit,
-      SESSION_HISTORY_CHARACTER_LIMIT
-    );
-    return {
-      coveredCommandIds: [],
-      coveredMessageIds: [],
-      messages: bounded3.messages,
-      nextCursor: null,
-      status: "available",
-      truncated: activeTurn.truncated || bounded3.truncated
-    };
+    if (cursor !== null) {
+      throw new AcpExecutionError("Unavailable native Session history has no cursor", {}, "invalid_cursor");
+    }
+    return { cause: history.cause, nextCursor: null, status: "unavailable" };
   }
-  const activeRoot = activeTurn.messages.find(
-    (message) => message.role === "user" && message.id === activeTurn.commandId
+  return paginateAvailableNativeHistory(
+    history,
+    sessionId,
+    cursor?.endIndex ?? history.messages.length,
+    limit,
+    SESSION_HISTORY_CHARACTER_LIMIT
   );
-  const coveredActiveRoot = history.coveredCommandIds.includes(activeTurn.commandId);
-  const matchingActiveUserIndex = coveredActiveRoot ? history.messages.findLastIndex(
-    (message) => message.role === "user" && message.text === (activeRoot?.text ?? activeTurn.prompt)
-  ) : -1;
-  const activeUserIndex = matchingActiveUserIndex >= 0 ? matchingActiveUserIndex : liveHistoryCoveredTurnRanges(history).find((range) => range.commandId === activeTurn.commandId)?.userIndex ?? -1;
-  if (activeUserIndex >= 0) {
-    history = {
-      ...history,
-      coveredCommandIds: history.coveredCommandIds.filter((id) => id !== activeTurn.commandId),
-      coveredMessageIds: history.coveredMessageIds.filter(
-        (id) => id !== `${activeTurn.commandId}:user` && id !== `${activeTurn.commandId}:agent`
-      ),
-      messages: history.messages.slice(0, activeUserIndex + 1)
-    };
-  }
-  const latestNativeMessage = history.messages.at(-1);
-  const firstActiveMessage = activeTurn.messages[0];
-  const preserveNativeRoot = activeUserIndex >= 0 || firstActiveMessage?.role === "user" && latestNativeMessage?.role === "user" && latestNativeMessage.text === firstActiveMessage.text;
-  const activeMessages = activeTurn.messages.slice(preserveNativeRoot ? 1 : 0).map(nativeActiveMessage);
-  const bounded2 = boundedActiveMessages(activeMessages, limit, SESSION_HISTORY_CHARACTER_LIMIT);
-  let historicalMessageCount = 0;
-  let remainingCharacters = SESSION_HISTORY_CHARACTER_LIMIT - bounded2.characters;
-  const historicalMessageLimit = Math.max(0, limit - bounded2.messages.length);
-  for (let index = history.messages.length - 1; index >= 0 && historicalMessageCount < historicalMessageLimit; index -= 1) {
-    const message = history.messages[index];
-    if (message === void 0) {
-      break;
-    }
-    const characters = historyMessageCharacters(message);
-    if (characters > remainingCharacters) {
-      break;
-    }
-    historicalMessageCount += 1;
-    remainingCharacters -= characters;
+}
+function paginateActiveTurn(history, activeTurn, sessionId, endIndex, limit) {
+  if (endIndex > activeTurn.messages.length) {
+    throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
-  const page = historicalMessageCount === 0 ? {
-    coveredCommandIds: [],
-    coveredMessageIds: [],
-    messages: [],
-    nextCursor: history.messages.length === 0 ? null : liveHistoryCursor(sessionId, history.messages.length),
-    status: "available",
-    truncated: history.truncated
-  } : paginateAcpSessionHistory(history, sessionId, null, historicalMessageCount);
+  const activeMessages = activeTurn.messages.map(nativeActiveMessage);
+  const active = selectMessagesBefore(activeMessages, endIndex, limit, SESSION_HISTORY_CHARACTER_LIMIT);
+  const historicalLimit = limit - active.messages.length;
+  const historicalCharacterLimit = SESSION_HISTORY_CHARACTER_LIMIT - active.characters;
+  const pendingHistoricalCursor = history.status === "available" && history.messages.length > 0 ? nativeHistoryCursor(sessionId, history.messages.length) : null;
+  const latestHistoricalMessage = history.status === "available" ? history.messages.at(-1) : void 0;
+  const historicalPageFits = latestHistoricalMessage === void 0 || historyMessageCharacters(latestHistoricalMessage) <= historicalCharacterLimit;
+  const historical = active.startIndex === 0 && history.status === "available" && historicalLimit > 0 && historicalPageFits ? paginateAvailableNativeHistory(
+    history,
+    sessionId,
+    history.messages.length,
+    historicalLimit,
+    historicalCharacterLimit
+  ) : null;
   return {
-    ...page,
-    messages: [...page.messages, ...bounded2.messages],
-    truncated: page.truncated || activeTurn.truncated || bounded2.truncated
+    coveredCommandIds: historical?.coveredCommandIds ?? [],
+    coveredMessageIds: [
+      ...historical?.coveredMessageIds ?? [],
+      ...active.startIndex === 0 ? [`${activeTurn.commandId}:user`, `${activeTurn.commandId}:agent`] : []
+    ],
+    messages: [...historical?.messages ?? [], ...active.messages],
+    nextCursor: active.startIndex > 0 ? activeHistoryCursor(sessionId, activeTurn.epoch, active.startIndex) : historical === null ? pendingHistoricalCursor : historical.nextCursor,
+    status: "available",
+    truncated: activeTurn.truncated || (historical?.truncated ?? false)
   };
 }
+function paginateLiveSessionHistory(history, activeTurn, sessionId, encodedCursor, limit) {
+  const cursor = encodedCursor === null ? null : decodeLiveHistoryCursor(encodedCursor, sessionId);
+  if (activeTurn === null || activeTurn.state === "completed" && history.status === "available" && nativeHistoryCoversCompletedRecovery(history, activeTurn)) {
+    return paginateNativeHistory(history, sessionId, cursor, limit);
+  }
+  const historical = historyBeforeActiveTurn(history, activeTurn);
+  if (cursor?.kind === "native") {
+    return paginateNativeHistory(historical, sessionId, cursor, limit);
+  }
+  if (cursor !== null && cursor.epoch !== activeTurn.epoch) {
+    throw new AcpExecutionError("The active Turn history cursor is stale", {}, "stale_cursor");
+  }
+  return paginateActiveTurn(historical, activeTurn, sessionId, cursor?.endIndex ?? activeTurn.messages.length, limit);
+}
 function mergeLiveSessionHistory(history, activeTurn, sessionId) {
   const page = paginateLiveSessionHistory(history, activeTurn, sessionId, null, 1e3);
   if (page.status === "unavailable") {
@@ -41518,7 +41678,7 @@ function mergeLiveSessionHistory(history, activeTurn, sessionId) {
     coveredMessageIds: page.coveredMessageIds,
     messages: page.messages,
     status: "available",
-    truncated: page.truncated
+    truncated: page.truncated || page.nextCursor !== null
   };
 }
 
@@ -42037,15 +42197,13 @@ async function executePrompt({
     });
     operations.transitionExecution(command.commandId, "running");
     if (availability.disposition === SessionPromptDisposition.Steer) {
-      const updated = recordSteeringPrompt();
-      if (updated === null) {
+      if (!recordSteeringPrompt()) {
         throw new AcpExecutionError(
           "The steering target is unavailable",
           {},
           "prompt_queue_target_unavailable"
         );
       }
-      publisher.publish(command.sessionId, updated);
     }
     const stream = activateAttempt();
     publisher.publish(command.sessionId, {
@@ -42433,7 +42591,7 @@ function createDaemonCommandHandler({
     resolveEnvironment: resolveAgentCatalogEnvironment
   });
   const queueChanged = (sessionId) => publisher.publish(sessionId, { kind: "session.queue.changed", sessionId });
-  const activeTurnSnapshot = (sessionId) => activeTurns.snapshot((command) => command.sessionId === sessionId);
+  const activeTurnRecovery = (sessionId) => activeTurns.recovery((command) => command.sessionId === sessionId);
   const nativeRequestHandler = createNativeSessionRequestHandler({
     audit,
     diagnostics,
@@ -42454,7 +42612,7 @@ function createDaemonCommandHandler({
           directories,
           audit,
           sessions,
-          activeTurnSnapshot,
+          activeTurnRecovery,
           signal
         );
         return;
@@ -42468,7 +42626,7 @@ function createDaemonCommandHandler({
           directories,
           audit,
           sessions,
-          activeTurnSnapshot,
+          activeTurnRecovery,
           signal
         );
         return;