@moxt-ai/mobius 0.0.307 → 0.0.308

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.307",
+      version: "0.0.308",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -65111,11 +65111,11 @@ var init_session_mode = __esm({
         }
         return modes;
       }
-      async trySyncMode(query, mode, errorMessage2) {
+      async trySyncMode(query, mode, errorMessage) {
         try {
           await query.setPermissionMode(mode);
         } catch (error62) {
-          this.options.logError(errorMessage2, error62);
+          this.options.logError(errorMessage, error62);
         }
       }
     };
@@ -71089,6 +71089,7 @@ var init_app_server_protocol = __esm({
     threadTurnSchema = external_exports.object({
       id: boundedText(256).optional(),
       status: turnStatusSchema.optional(),
+      error: external_exports.object({ message: external_exports.string().transform((message) => message.slice(0, 4096)) }).nullish(),
       items: external_exports.array(external_exports.unknown()).max(1e5)
     });
     threadTurnsSchema = external_exports.array(threadTurnSchema).max(1e5);
@@ -71563,12 +71564,12 @@ function presentToolItem(item) {
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn11 = item.tool === "spawnAgent";
+    const spawn10 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn11 ? {
+      rawInput: spawn10 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -71576,10 +71577,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn11 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn10 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn11 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn10 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -71912,6 +71913,291 @@ var init_borrowed_agent = __esm({
   }
 });
 
+// src/storage/files/local-files.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { mkdir as mkdir3, open as open4, readdir as readdir4, readFile as readFile5, realpath as realpath6, stat as stat5 } from "node:fs/promises";
+function entryKind(entry) {
+  if (entry.isDirectory()) {
+    return "directory";
+  }
+  if (entry.isFile()) {
+    return "file";
+  }
+  if (entry.isSymbolicLink()) {
+    return "symbolic-link";
+  }
+  if (entry.isBlockDevice() || entry.isCharacterDevice()) {
+    return "device";
+  }
+  if (entry.isFIFO()) {
+    return "fifo";
+  }
+  return entry.isSocket() ? "socket" : "unknown";
+}
+async function canonicalPath(path8) {
+  return await realpath6(path8);
+}
+async function readPathMetadata(path8) {
+  const metadata = await stat5(path8);
+  return {
+    kind: metadata.isDirectory() ? "directory" : metadata.isFile() ? "file" : "other",
+    modifiedAt: metadata.mtime,
+    modifiedMilliseconds: metadata.mtimeMs,
+    size: metadata.size
+  };
+}
+async function listDirectory(path8) {
+  const entries = await readdir4(path8, { withFileTypes: true });
+  return entries.map((entry) => ({ kind: entryKind(entry), name: entry.name }));
+}
+async function ensurePrivateDirectory(path8) {
+  await mkdir3(path8, { mode: 448, recursive: true });
+}
+async function ensureCanonicalDirectory(path8) {
+  await ensurePrivateDirectory(path8);
+  const resolved = await realpath6(path8);
+  return (await stat5(resolved)).isDirectory() ? resolved : null;
+}
+async function readFileStart(path8, byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  const handle = await open4(path8, "r");
+  try {
+    await handle.read(bytes, 0, byteLength, 0);
+  } finally {
+    await handle.close();
+  }
+  return bytes;
+}
+async function readFileBytes(path8) {
+  return await readFile5(path8);
+}
+function readFileChunks(path8, chunkBytes, signal) {
+  return createReadStream2(path8, { highWaterMark: chunkBytes, signal });
+}
+var init_local_files = __esm({
+  "src/storage/files/local-files.ts"() {
+    "use strict";
+  }
+});
+
+// src/acp/content/raster.ts
+import { basename as basename4, isAbsolute as isAbsolute9, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+function startsWith(bytes, signature, offset = 0) {
+  if (bytes.byteLength < offset + signature.byteLength) {
+    return false;
+  }
+  return signature.every((value, index2) => bytes[offset + index2] === value);
+}
+function sniffRasterMime(bytes) {
+  if (startsWith(bytes, PNG_SIGNATURE)) {
+    return "image/png";
+  }
+  if (startsWith(bytes, JPEG_SIGNATURE)) {
+    return "image/jpeg";
+  }
+  if (startsWith(bytes, GIF87_SIGNATURE) || startsWith(bytes, GIF89_SIGNATURE)) {
+    return "image/gif";
+  }
+  if (startsWith(bytes, RIFF_SIGNATURE) && startsWith(bytes, WEBP_SIGNATURE, 8)) {
+    return "image/webp";
+  }
+  return null;
+}
+async function resolveCanonicalPath(requested, signal) {
+  signal.throwIfAborted();
+  if (!isAbsolute9(requested) || requested.includes("\0") || normalize(requested) !== requested) {
+    return null;
+  }
+  try {
+    const target = await canonicalPath(requested);
+    signal.throwIfAborted();
+    if (!isAbsolute9(target) || normalize(target) !== target) {
+      return null;
+    }
+    return target;
+  } catch (cause) {
+    signal.throwIfAborted();
+    if (cause instanceof Error && cause.name === "AbortError") {
+      throw cause;
+    }
+    return null;
+  }
+}
+function parseLocalImageUri(uri) {
+  const trimmed = uri.trim();
+  if (trimmed.length === 0 || trimmed.length > 2048 || trimmed.includes("\0")) {
+    return null;
+  }
+  if (trimmed.startsWith("data:")) {
+    return null;
+  }
+  if (trimmed.startsWith("file:")) {
+    try {
+      const url2 = new URL(trimmed);
+      if (url2.protocol !== "file:" || url2.host.length > 0) {
+        return null;
+      }
+      return fileURLToPath(url2);
+    } catch {
+      return null;
+    }
+  }
+  if (!isAbsolute9(trimmed) && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+async function readLocalRaster(uri, signal) {
+  signal.throwIfAborted();
+  const requested = parseLocalImageUri(uri);
+  if (requested === null) {
+    return null;
+  }
+  const target = await resolveCanonicalPath(requested, signal);
+  if (target === null) {
+    return null;
+  }
+  const targetMetadata = await readPathMetadata(target);
+  signal.throwIfAborted();
+  if (targetMetadata.kind !== "file" || targetMetadata.size < 1 || targetMetadata.size > MAX_LOCAL_RASTER_BYTES) {
+    return null;
+  }
+  const header = await readFileStart(target, 12);
+  signal.throwIfAborted();
+  const mimeType = sniffRasterMime(header);
+  if (mimeType === null) {
+    return null;
+  }
+  return new LocalRasterImage(basename4(target) || "Image", mimeType, target);
+}
+var MAX_LOCAL_RASTER_BYTES, PNG_SIGNATURE, JPEG_SIGNATURE, GIF87_SIGNATURE, GIF89_SIGNATURE, RIFF_SIGNATURE, WEBP_SIGNATURE, LocalRasterImage;
+var init_raster = __esm({
+  "src/acp/content/raster.ts"() {
+    "use strict";
+    init_local_files();
+    MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
+    PNG_SIGNATURE = Uint8Array.of(137, 80, 78, 71);
+    JPEG_SIGNATURE = Uint8Array.of(255, 216, 255);
+    GIF87_SIGNATURE = new TextEncoder().encode("GIF87a");
+    GIF89_SIGNATURE = new TextEncoder().encode("GIF89a");
+    RIFF_SIGNATURE = new TextEncoder().encode("RIFF");
+    WEBP_SIGNATURE = new TextEncoder().encode("WEBP");
+    LocalRasterImage = class {
+      mimeType;
+      name;
+      sourceUri;
+      constructor(name2, mimeType, sourceUri) {
+        this.mimeType = mimeType;
+        this.name = name2;
+        this.sourceUri = sourceUri;
+      }
+      base64 = async () => Buffer.from(await readFileBytes(this.sourceUri)).toString("base64");
+    };
+  }
+});
+
+// src/acp/native-history/codex/history-images.ts
+function isRasterMime(value) {
+  return value === "image/png" || value === "image/jpeg" || value === "image/gif" || value === "image/webp";
+}
+function parseNativeHistoryImage(uri) {
+  const header = DATA_IMAGE_HEADER.exec(uri);
+  if (header === null) {
+    return null;
+  }
+  const mimeType = header[1] ?? "";
+  const data = uri.slice(header[0].length);
+  if (!isRasterMime(mimeType) || data.length < 4 || data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
+    return null;
+  }
+  if (data.length % 4 !== 0 || !BASE_64.test(data)) {
+    return null;
+  }
+  return { data, mimeType, name: "" };
+}
+async function embedLocalHistoryImages(history, signal) {
+  if (history.status !== "available") {
+    return history;
+  }
+  const messages = [];
+  let imageCharacters = 0;
+  for (const message of history.messages) {
+    signal.throwIfAborted();
+    const resolved = await resolveMessageImages(message, imageCharacters, signal);
+    imageCharacters += (resolved.images ?? []).reduce((size, image) => size + image.data.length, 0);
+    messages.push(resolved);
+  }
+  return {
+    ...history,
+    messages
+  };
+}
+async function resolveMessageImages(message, usedCharacters, signal) {
+  const images = [...message.images ?? []];
+  let imageCharacters = images.reduce((size, image) => size + image.data.length, 0);
+  const text2 = await replaceImageMarkers(message.text, async (uri) => {
+    if (images.length >= 8 || usedCharacters + imageCharacters >= SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
+      return "[Image unavailable]";
+    }
+    const embedded = parseNativeHistoryImage(uri);
+    if (embedded !== null) {
+      if (usedCharacters + imageCharacters + embedded.data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
+        return "[Image unavailable]";
+      }
+      images.push({ ...embedded, name: `Image ${(images.length + 1).toString()}` });
+      imageCharacters += embedded.data.length;
+      return "";
+    }
+    const local = await readLocalRaster(uri, signal);
+    if (local === null) {
+      return "[Image unavailable]";
+    }
+    const data = await local.base64();
+    if (usedCharacters + imageCharacters + data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
+      return "[Image unavailable]";
+    }
+    images.push({
+      data,
+      mimeType: local.mimeType,
+      name: local.name
+    });
+    imageCharacters += data.length;
+    return "";
+  });
+  return {
+    ...message,
+    text: text2,
+    ...images.length > 0 ? { images } : {}
+  };
+}
+async function replaceImageMarkers(text2, replace) {
+  const matches = [...text2.matchAll(IMAGE_MARKER)];
+  if (matches.length === 0) {
+    return text2;
+  }
+  let cursor = 0;
+  let rewritten = "";
+  for (const match of matches) {
+    const index2 = match.index ?? 0;
+    rewritten += text2.slice(cursor, index2);
+    rewritten += await replace(match[1] ?? "");
+    cursor = index2 + match[0].length;
+  }
+  return `${rewritten}${text2.slice(cursor)}`;
+}
+var IMAGE_MARKER, DATA_IMAGE_HEADER, BASE_64, SESSION_HISTORY_IMAGE_CHARACTER_LIMIT;
+var init_history_images = __esm({
+  "src/acp/native-history/codex/history-images.ts"() {
+    "use strict";
+    init_raster();
+    IMAGE_MARKER = /\[@image\]\(([^)\r\n]*)(?:\)|$)/g;
+    DATA_IMAGE_HEADER = /^data:(image\/[a-z+]+);base64,/;
+    BASE_64 = /^[A-Za-z0-9+/]*={0,2}$/;
+    SESSION_HISTORY_IMAGE_CHARACTER_LIMIT = 4e6;
+  }
+});
+
 // src/acp/harness/codex/owned-agent.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
@@ -72574,6 +72860,126 @@ var init_owned_agent = __esm({
   }
 });
 
+// src/acp/harness/codex/history.ts
+import { createHash } from "node:crypto";
+async function replayCodexHistory(client2, threadId, emit, signal) {
+  const deadline = AbortSignal.any([signal, AbortSignal.timeout(6e4)]);
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor = null;
+  let turnIndex = 0;
+  for (; ; ) {
+    deadline.throwIfAborted();
+    const page = threadTurnsPageSchema.parse(
+      await client2.request(
+        "thread/turns/list",
+        {
+          threadId,
+          limit: CODEX_HISTORY_TURN_PAGE_LIMIT,
+          sortDirection: "asc",
+          itemsView: "full",
+          ...cursor === null ? {} : { cursor }
+        },
+        deadline
+      )
+    );
+    for (const turn of page.data) {
+      for (const rawItem of turn.items) {
+        deadline.throwIfAborted();
+        const item = decodeThreadItem(rawItem);
+        if (item === null) {
+          continue;
+        }
+        if (item.type === "userMessage") {
+          const text2 = item.content.flatMap((content) => {
+            if (typeof content !== "object" || content === null) {
+              return [];
+            }
+            const type = Reflect.get(content, "type");
+            const text3 = Reflect.get(content, "text");
+            const url2 = Reflect.get(content, "url");
+            if (type === "image" && typeof url2 === "string") {
+              return [`[@image](${url2})`];
+            }
+            return type === "text" && typeof text3 === "string" ? [text3] : [];
+          }).join("");
+          const history = await embedLocalHistoryImages(
+            { status: "available", truncated: false, messages: [{ role: "user", text: text2 }] },
+            deadline
+          );
+          if (history.status !== "available") {
+            continue;
+          }
+          const message = history.messages[0];
+          for (const image of message?.images ?? []) {
+            await emit({
+              content: { type: "image", data: image.data, mimeType: image.mimeType },
+              messageId: item.id,
+              sessionUpdate: "user_message_chunk"
+            });
+          }
+          const restoredText = message?.text ?? "";
+          if (restoredText.length > 0) {
+            await emit({
+              content: { text: restoredText, type: "text" },
+              messageId: item.id,
+              sessionUpdate: "user_message_chunk"
+            });
+          }
+        } else if (item.type === "agentMessage") {
+          await emit(agentMessageUpdate(item.id, item.text));
+        } else if (item.type === "reasoning") {
+          const text2 = reasoningText(item);
+          if (text2 !== null && text2.length > 0) {
+            await emit({
+              content: { text: text2, type: "text" },
+              messageId: item.id,
+              sessionUpdate: "agent_thought_chunk"
+            });
+          }
+        } else if (item.type === "contextCompaction") {
+          await emit({ compactionId: item.id, sessionUpdate: "compaction_update", status: "completed" });
+        } else {
+          const update = toolCallUpdate(item, "snapshot");
+          if (update !== null) {
+            await emit({ ...update, sessionUpdate: "tool_call" });
+          }
+        }
+      }
+      if (turn.error != null) {
+        const identity2 = createHash("sha256").update(threadId).update("\0").update(turn.id ?? turnIndex.toString()).digest("hex");
+        await emit({
+          sessionUpdate: "tool_call",
+          toolCallId: `agent-error-${identity2}`,
+          title: "Agent error",
+          kind: "other",
+          status: "failed",
+          rawOutput: { message: turn.error.message },
+          content: [{ type: "content", content: { type: "text", text: turn.error.message } }]
+        });
+      }
+      turnIndex += 1;
+    }
+    if (page.nextCursor == null) {
+      return;
+    }
+    if (page.data.length === 0 || seenCursors.has(page.nextCursor)) {
+      throw new AcpExecutionError("Codex repeated a history page cursor", {}, "invalid_native_session_response");
+    }
+    seenCursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+}
+var init_history = __esm({
+  "src/acp/harness/codex/history.ts"() {
+    "use strict";
+    init_acp_error();
+    init_history_images();
+    init_app_server_protocol();
+    init_items();
+    init_owned_agent();
+  }
+});
+
 // ../mobius-sdk/src/protocol/platform/mobius-api.ts
 function parseMobiusApiPrefix(value) {
   if (typeof value !== "string" || !API_PREFIX_PATTERN.test(value)) {
@@ -73856,7 +74262,7 @@ function decode3(schema, encoded) {
     throw new ProtocolMessageError("Invalid native session message", { cause });
   }
 }
-var NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_RESULT_KIND, NATIVE_SESSION_CANCEL_KIND, SESSION_HISTORY_CHARACTER_LIMIT, SESSION_HISTORY_MESSAGE_LIMIT, envelope, activeTurnSnapshotSchema, identity, nativeSessionRequestSchema, nativeSessionCommandSchema, nativeSessionEntrySchema, resultEnvelope, nativeSessionResultSchema, nativeSessionCancelSchema, decodeNativeSessionCommand, encodeNativeSessionCommand, decodeNativeSessionResult, encodeNativeSessionResult, decodeNativeSessionCancel, encodeNativeSessionCancel;
+var NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_RESULT_KIND, NATIVE_SESSION_CANCEL_KIND, envelope, activeTurnSnapshotSchema, identity, nativeSessionRequestSchema, nativeSessionCommandSchema, nativeSessionEntrySchema, resultEnvelope, nativeSessionResultSchema, nativeSessionCancelSchema, decodeNativeSessionCommand, encodeNativeSessionCommand, decodeNativeSessionResult, encodeNativeSessionResult, decodeNativeSessionCancel, encodeNativeSessionCancel;
 var init_native = __esm({
   "../mobius-sdk/src/protocol/session/native/index.ts"() {
     "use strict";
@@ -73871,8 +74277,6 @@ var init_native = __esm({
     NATIVE_SESSION_REQUEST_KIND = "native.session.request";
     NATIVE_SESSION_RESULT_KIND = "native.session.result";
     NATIVE_SESSION_CANCEL_KIND = "native.session.cancel";
-    SESSION_HISTORY_CHARACTER_LIMIT = 256e3;
-    SESSION_HISTORY_MESSAGE_LIMIT = 1e3;
     envelope = {
       requestId: identifierStringSchema,
       sessionId: identifierStringSchema
@@ -74362,6 +74766,7 @@ var init_event_log = __esm({
     nativeEventPageRequestSchema = external_exports.object({
       cursor: external_exports.string().min(1).max(512).nullable(),
       eventLimit: external_exports.number().int().min(1).max(1e4),
+      // Legacy callers may still send this option; readers must ignore it.
       omit: external_exports.array(sessionEventOmissionSchema).max(1).readonly().optional()
     }).readonly();
     queuedPromptRequestEventLogSchema = external_exports.object({
@@ -74391,7 +74796,7 @@ function decode5(schema, encoded) {
   }
 }
 var SESSION_HISTORY_PAGE_LOAD_KIND, SESSION_HISTORY_PAGE_LOADED_KIND, SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND, SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND, pageRequestFields, sessionHistoryPageLoadSchema, sessionPreviewHistoryPageLoadSchema, pageLoadedFields, sessionHistoryPageLoadedSchema, sessionPreviewHistoryPageLoadedSchema, decodeSessionHistoryPageLoad, decodeSessionHistoryPageLoaded, decodeSessionPreviewHistoryPageLoad, decodeSessionPreviewHistoryPageLoaded, encodeSessionHistoryPageLoad, encodeSessionHistoryPageLoaded, encodeSessionPreviewHistoryPageLoad, encodeSessionPreviewHistoryPageLoaded;
-var init_history = __esm({
+var init_history2 = __esm({
   "../mobius-sdk/src/protocol/session/observability/history.ts"() {
     "use strict";
     init_zod();
@@ -74406,6 +74811,7 @@ var init_history = __esm({
     pageRequestFields = {
       cursor: external_exports.string().min(1).max(512).nullable(),
       eventLimit: external_exports.number().int().min(1).max(1e4),
+      // Decode old clients without rejecting their request; omission has no effect.
       omit: external_exports.array(sessionEventOmissionSchema).max(1).readonly().optional(),
       requestId: identifierStringSchema,
       sessionId: identifierStringSchema
@@ -74912,7 +75318,7 @@ var init_daemon_transport = __esm({
     init_lifecycle();
     init_native();
     init_event_log();
-    init_history();
+    init_history2();
     init_commands();
     init_workspace();
     init_message_codec();
@@ -75178,7 +75584,7 @@ var init_protocol = __esm({
     init_lifecycle();
     init_native();
     init_event_log();
-    init_history();
+    init_history2();
     init_commands();
     init_usage();
     init_turn_history();
@@ -75651,11 +76057,10 @@ var init_agent = __esm({
     "use strict";
     init_zod();
     init_executable();
-    init_acp_error();
     init_app_server_client();
     init_app_server_protocol();
     init_borrowed_agent();
-    init_items();
+    init_history();
     init_owned_agent();
     init_settings3();
     APPROVAL_TIMEOUT_MILLISECONDS3 = 36e5;
@@ -75885,83 +76290,7 @@ var init_agent = __esm({
       // ACP load requires chronological replay. Resume only restores execution;
       // native pages supply history without a single full-transcript response.
       #replaySavedHistory = async (signal) => {
-        const deadline = AbortSignal.any([signal, AbortSignal.timeout(6e4)]);
-        const seenCursors = /* @__PURE__ */ new Set();
-        let cursor = null;
-        for (; ; ) {
-          deadline.throwIfAborted();
-          const page = threadTurnsPageSchema.parse(
-            await this.#appServer.request(
-              "thread/turns/list",
-              {
-                threadId: this.#nativeSessionId,
-                limit: CODEX_HISTORY_TURN_PAGE_LIMIT,
-                sortDirection: "asc",
-                itemsView: "full",
-                ...cursor === null ? {} : { cursor }
-              },
-              deadline
-            )
-          );
-          await this.#replayHistory(page.data, deadline);
-          if (page.nextCursor == null) {
-            return;
-          }
-          if (page.data.length === 0 || seenCursors.has(page.nextCursor)) {
-            throw new AcpExecutionError(
-              "Codex repeated a history page cursor",
-              {},
-              "invalid_native_session_response"
-            );
-          }
-          seenCursors.add(page.nextCursor);
-          cursor = page.nextCursor;
-        }
-      };
-      #replayHistory = async (turns, signal) => {
-        for (const turn of turns) {
-          for (const rawItem of turn.items) {
-            signal.throwIfAborted();
-            const item = decodeThreadItem(rawItem);
-            if (item === null) {
-              continue;
-            }
-            if (item.type === "userMessage") {
-              const text2 = item.content.flatMap((content) => {
-                if (typeof content !== "object" || content === null) {
-                  return [];
-                }
-                const type = Reflect.get(content, "type");
-                const text3 = Reflect.get(content, "text");
-                return type === "text" && typeof text3 === "string" ? [text3] : [];
-              }).join("");
-              if (text2.length > 0) {
-                await this.#emit({
-                  content: { text: text2, type: "text" },
-                  messageId: item.id,
-                  sessionUpdate: "user_message_chunk"
-                });
-              }
-              continue;
-            }
-            if (item.type === "agentMessage") {
-              await this.#emit(agentMessageUpdate(item.id, item.text));
-              continue;
-            }
-            if (item.type === "contextCompaction") {
-              await this.#emit({
-                compactionId: item.id,
-                sessionUpdate: "compaction_update",
-                status: "completed"
-              });
-              continue;
-            }
-            const update = toolCallUpdate(item, "snapshot");
-            if (update !== null) {
-              await this.#emit({ ...update, sessionUpdate: "tool_call" });
-            }
-          }
-        }
+        await replayCodexHistory(this.#appServer, this.#nativeSessionId, this.#emit, signal);
       };
       /** Announces the manual compact command after every session entry point —
        *  new, load, resume, and fork — so clients on restored sessions discover
@@ -76567,7 +76896,7 @@ var init_pi_commands = __esm({
 
 // src/acp/harness/pi/upstream/dist/acp/pi-sessions.js
 import { closeSync as closeSync2, existsSync as existsSync4, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync3, readSync as readSync2, statSync as statSync2 } from "node:fs";
-import { isAbsolute as isAbsolute9, join as join14, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute10, join as join14, resolve as resolve9 } from "node:path";
 function getPiAgentDir(environment) {
   const configured = environment["PI_CODING_AGENT_DIR"];
   return configured ? resolve9(configured) : join14(environmentHome(environment), ".pi", "agent");
@@ -76587,7 +76916,7 @@ function readSessionDirFromSettings(agentDir) {
     if (typeof sessionDir !== "string" || !sessionDir.trim()) {
       return null;
     }
-    return isAbsolute9(sessionDir) ? sessionDir : resolve9(agentDir, sessionDir);
+    return isAbsolute10(sessionDir) ? sessionDir : resolve9(agentDir, sessionDir);
   } catch {
     return null;
   }
@@ -77438,7 +77767,7 @@ var init_pi_tools = __esm({
 // src/acp/harness/pi/upstream/dist/acp/session.js
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { readFileSync as readFileSync7 } from "node:fs";
-import { isAbsolute as isAbsolute10, resolve as resolvePath } from "node:path";
+import { isAbsolute as isAbsolute11, resolve as resolvePath } from "node:path";
 import { RequestError as RequestError6 } from "@agentclientprotocol/sdk";
 function toUsageUpdate(stats) {
   const used = stats?.contextUsage?.tokens;
@@ -77534,7 +77863,7 @@ function toToolCallLocations(args, cwd, line) {
   if (!path8) {
     return void 0;
   }
-  const resolvedPath = isAbsolute10(path8) ? path8 : resolvePath(cwd, path8);
+  const resolvedPath = isAbsolute11(path8) ? path8 : resolvePath(cwd, path8);
   return [{ path: resolvedPath, ...typeof line === "number" ? { line } : {} }];
 }
 function stringProp(source, key) {
@@ -78102,7 +78431,7 @@ var init_session = __esm({
               const p = getToolPath(args);
               if (p) {
                 try {
-                  const abs = isAbsolute10(p) ? p : resolvePath(this.cwd, p);
+                  const abs = isAbsolute11(p) ? p : resolvePath(this.cwd, p);
                   snapshotOldText = readFileSync7(abs, "utf8");
                   this.fileSnapshots.set(toolCallId, { path: p, oldText: snapshotOldText });
                   if (toolName === "edit") {
@@ -78185,7 +78514,7 @@ var init_session = __esm({
             let hasStructuredDiff = false;
             if (!isError && snapshot) {
               try {
-                const abs = isAbsolute10(snapshot.path) ? snapshot.path : resolvePath(this.cwd, snapshot.path);
+                const abs = isAbsolute11(snapshot.path) ? snapshot.path : resolvePath(this.cwd, snapshot.path);
                 const newText = readFileSync7(abs, "utf8");
                 if (snapshot.oldText === null || newText !== snapshot.oldText) {
                   hasStructuredDiff = true;
@@ -78364,7 +78693,7 @@ var init_prompt = __esm({
 import { spawnSync } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute11, join as join17 } from "node:path";
+import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute12, join as join17 } from "node:path";
 import { RequestError as RequestError7 } from "@agentclientprotocol/sdk";
 function thinkingLevelName(id) {
   return id.split(/[_-]/u).map((part) => part.length === 0 ? part : `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
@@ -78703,7 +79032,7 @@ function buildStartupInfo(opts) {
   try {
     const prompts = readdirSync6(promptsDir).filter((f) => f.endsWith(".md"));
     for (const f of prompts) {
-      promptsItems.push(`/${basename4(f, ".md")}`);
+      promptsItems.push(`/${basename5(f, ".md")}`);
     }
   } catch {
   }
@@ -78922,7 +79251,7 @@ var init_agent2 = __esm({
         };
       }
       async newSession(params) {
-        if (!isAbsolute11(params.cwd)) {
+        if (!isAbsolute12(params.cwd)) {
           throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.lastSessionCwd = params.cwd;
@@ -79519,7 +79848,7 @@ ${JSON.stringify(stats, null, 2)}`;
         return { sessions, nextCursor, _meta: {} };
       }
       async forkSession(params) {
-        if (!isAbsolute11(params.cwd)) {
+        if (!isAbsolute12(params.cwd)) {
           throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         const source = this.findStoredSession(params.sessionId);
@@ -79585,7 +79914,7 @@ ${JSON.stringify(stats, null, 2)}`;
         return { sessionId: session.sessionId, configOptions, modes };
       }
       async resumeSession(params) {
-        if (!isAbsolute11(params.cwd)) {
+        if (!isAbsolute12(params.cwd)) {
           throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.sessions.close(params.sessionId);
@@ -79656,7 +79985,7 @@ ${JSON.stringify(stats, null, 2)}`;
         return response;
       }
       async loadSession(params) {
-        if (!isAbsolute11(params.cwd)) {
+        if (!isAbsolute12(params.cwd)) {
           throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.sessions.close(params.sessionId);
@@ -80025,7 +80354,7 @@ var init_agent_probe_error = __esm({
 });
 
 // src/agent/specification/vendors/pi-agent.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { join as join19 } from "node:path";
 import {
   methods as methods6
@@ -80046,7 +80375,7 @@ var init_pi_agent = __esm({
       // The Pi ACP fork inlines embedded prompt resources into the turn message, so Mobius
       // keeps the adapter's opt-in capability flag enabled for every launch it owns.
       createLaunchEnvironment = async (_agent, context) => {
-        const workspaceHash = createHash("sha256").update(context.defaultWorkspace).digest("hex").slice(0, 24);
+        const workspaceHash = createHash2("sha256").update(context.defaultWorkspace).digest("hex").slice(0, 24);
         const sessionDirectory = join19(
           readStateDirectory(context.environment),
           "agents",
@@ -80253,7 +80582,7 @@ var init_agent_discovery = __esm({
 
 // src/util/process/local-executable.ts
 import { realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
-import { realpath as realpath6, stat as stat5 } from "node:fs/promises";
+import { realpath as realpath7, stat as stat6 } from "node:fs/promises";
 function readExecutableIdentity(path8) {
   const resolvedPath = realpathSync4(path8);
   const metadata = statSync4(resolvedPath);
@@ -80267,9 +80596,9 @@ function readExecutableIdentity(path8) {
   );
 }
 async function resolveLaunchFiles(entry, executable) {
-  const resolvedEntry = await realpath6(entry);
-  const resolvedExecutable = await realpath6(executable);
-  if (!(await stat5(resolvedEntry)).isFile() || !(await stat5(resolvedExecutable)).isFile()) {
+  const resolvedEntry = await realpath7(entry);
+  const resolvedExecutable = await realpath7(executable);
+  if (!(await stat6(resolvedEntry)).isFile() || !(await stat6(resolvedExecutable)).isFile()) {
     return null;
   }
   return { entry: resolvedEntry, executable: resolvedExecutable };
@@ -80787,11 +81116,11 @@ var init_agent_version = __esm({
 });
 
 // src/agent/discovery/executable-discovery.ts
-import { isAbsolute as isAbsolute12 } from "node:path";
+import { isAbsolute as isAbsolute13 } from "node:path";
 async function resolveSpecificationExecutables(executableName, overrideVariable, resolveInstalled, context) {
   const override = context.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute12(override)) {
+    if (override.length === 0 || !isAbsolute13(override)) {
       return [];
     }
     const executable = await resolveExecutablePath(override, context.platform);
@@ -81366,8 +81695,26 @@ var init_adapter_registry = __esm({
 });
 
 // src/session/history/session-event-history-projection.ts
+function boundReasoning(payload) {
+  if (payload.content.type !== "text" || Buffer.byteLength(payload.content.text, "utf8") <= MAXIMUM_PROJECTED_REASONING_BYTES) {
+    return payload;
+  }
+  const bytes = Buffer.from(payload.content.text, "utf8");
+  let start = bytes.length - MAXIMUM_PROJECTED_REASONING_BYTES;
+  while (start < bytes.length && (bytes.readUInt8(start) & 192) === 128) {
+    start += 1;
+  }
+  return {
+    ...payload,
+    content: { ...payload.content, text: bytes.toString("utf8", start) },
+    meta: { ...payload.meta, truncated: true }
+  };
+}
 function projectNewEvent(liveEvent2, eventId) {
   const { position: _position, eventId: _liveEventId, ...event } = liveEvent2;
+  if (event.type === "acp" && event.payload.sessionUpdate === "agent_thought_chunk") {
+    return { ...event, eventId, payload: boundReasoning(event.payload) };
+  }
   return { ...event, eventId };
 }
 function replaceAcpPayload(event, payload) {
@@ -81418,18 +81765,19 @@ function mergeTextChunk(previous, incoming) {
   }
   const content = { text: `${previous.content.text}${incoming.content.text}`, type: "text" };
   if (previous.sessionUpdate === "agent_thought_chunk" && incoming.sessionUpdate === "agent_thought_chunk") {
-    return {
+    return boundReasoning({
       ...previous,
       content,
       ...previous.meta?.truncated === true || incoming.meta?.truncated === true ? { meta: { ...previous.meta, ...incoming.meta, truncated: true } } : {}
-    };
+    });
   }
   return { ...previous, content };
 }
-var SessionEventHistoryProjection;
+var MAXIMUM_PROJECTED_REASONING_BYTES, SessionEventHistoryProjection;
 var init_session_event_history_projection = __esm({
   "src/session/history/session-event-history-projection.ts"() {
     "use strict";
+    MAXIMUM_PROJECTED_REASONING_BYTES = 24 * 1024;
     SessionEventHistoryProjection = class {
       #toolCallEventIds = /* @__PURE__ */ new Map();
       #latestEvent = null;
@@ -82979,7 +83327,24 @@ var init_session_config_protocol = __esm({
 
 // src/acp/adapter/session-events.ts
 import { setImmediate as yieldToRuntime2 } from "node:timers/promises";
-var AdapterSessionConnection, AcpSessionConnector;
+function* reasoningWireUpdates(update) {
+  if (update.sessionUpdate !== "agent_thought_chunk" || update.content.type !== "text" || update.content.text.length <= MAXIMUM_REASONING_UPDATE_CHARACTERS) {
+    yield update;
+    return;
+  }
+  const text2 = update.content.text;
+  for (let start = 0; start < text2.length; ) {
+    let end = Math.min(start + MAXIMUM_REASONING_UPDATE_CHARACTERS, text2.length);
+    const last = text2.charCodeAt(end - 1);
+    const next = text2.charCodeAt(end);
+    if (last >= 55296 && last <= 56319 && next >= 56320 && next <= 57343) {
+      end -= 1;
+    }
+    yield { ...update, content: { ...update.content, text: text2.slice(start, end) } };
+    start = end;
+  }
+}
+var MAXIMUM_REASONING_UPDATE_CHARACTERS, AdapterSessionConnection, AcpSessionConnector;
 var init_session_events = __esm({
   "src/acp/adapter/session-events.ts"() {
     "use strict";
@@ -82989,12 +83354,13 @@ var init_session_events = __esm({
     init_agent_connection();
     init_agent_update_stream();
     init_session_config_protocol();
+    MAXIMUM_REASONING_UPDATE_CHARACTERS = 1e6;
     AdapterSessionConnection = class {
       #connection;
       #updates;
       #lifetime = new AbortController();
       events;
-      constructor(options, externalizer) {
+      constructor(options, externalizer, normalizeEvent) {
         const protocol = sessionConfigProtocolForAgent(options.agent.id);
         this.#updates = new AgentUpdateStream(async (notification) => {
           this.#lifetime.signal.throwIfAborted();
@@ -83002,58 +83368,60 @@ var init_session_events = __esm({
             throw new AcpExecutionError("ACP agent referenced an unknown session", {}, "invalid_agent_session");
           }
           const signal = AbortSignal.any([this.#lifetime.signal, AbortSignal.timeout(3e4)]);
-          const externalized = await externalizer.update(options.sessionId(), notification.update, signal);
-          signal.throwIfAborted();
-          const update = externalized.agent;
-          const payload = decodeAcpSessionUpdate(JSON.stringify(externalized.event));
-          let event;
-          switch (update.sessionUpdate) {
-            case "available_commands_update":
-              event = {
-                kind: "commands",
-                payload,
-                commands: update.availableCommands.slice(0, 500).map((command) => ({
-                  description: truncate2(command.description, 500),
-                  inputHint: truncate2(command.input?.hint ?? "", 255),
-                  name: truncate2(command.name, 128)
-                })).filter((command) => command.name.length > 0)
-              };
-              break;
-            case "config_option_update":
-              event = {
-                kind: "configuration",
-                payload,
-                configOptions: protocol.normalizeUpdate(options.configOptions(), update.configOptions)
-              };
-              break;
-            case "current_mode_update":
-              event = { kind: "mode", payload, modeId: update.currentModeId };
-              break;
-            case "session_info_update": {
-              const changes = [];
-              if (Object.hasOwn(update, "title")) {
-                changes.push({ kind: "title", value: truncate2(update.title ?? "", 500) });
-              }
-              if (Object.hasOwn(update, "updatedAt")) {
-                changes.push({ kind: "updated-at", value: truncate2(update.updatedAt ?? "", 128) });
+          for (const incoming of reasoningWireUpdates(notification.update)) {
+            const externalized = await externalizer.update(options.sessionId(), incoming, signal);
+            signal.throwIfAborted();
+            const update = externalized.agent;
+            const payload = decodeAcpSessionUpdate(JSON.stringify(normalizeEvent(externalized.event)));
+            let event;
+            switch (update.sessionUpdate) {
+              case "available_commands_update":
+                event = {
+                  kind: "commands",
+                  payload,
+                  commands: update.availableCommands.slice(0, 500).map((command) => ({
+                    description: truncate2(command.description, 500),
+                    inputHint: truncate2(command.input?.hint ?? "", 255),
+                    name: truncate2(command.name, 128)
+                  })).filter((command) => command.name.length > 0)
+                };
+                break;
+              case "config_option_update":
+                event = {
+                  kind: "configuration",
+                  payload,
+                  configOptions: protocol.normalizeUpdate(options.configOptions(), update.configOptions)
+                };
+                break;
+              case "current_mode_update":
+                event = { kind: "mode", payload, modeId: update.currentModeId };
+                break;
+              case "session_info_update": {
+                const changes = [];
+                if (Object.hasOwn(update, "title")) {
+                  changes.push({ kind: "title", value: truncate2(update.title ?? "", 500) });
+                }
+                if (Object.hasOwn(update, "updatedAt")) {
+                  changes.push({ kind: "updated-at", value: truncate2(update.updatedAt ?? "", 128) });
+                }
+                event = { kind: "info", payload, changes };
+                break;
               }
-              event = { kind: "info", payload, changes };
-              break;
+              case "user_message_chunk":
+              case "agent_message_chunk":
+              case "agent_thought_chunk":
+              case "tool_call":
+              case "tool_call_update":
+              case "plan":
+              case "plan_update":
+              case "plan_removed":
+                event = { kind: "content", payload };
+                break;
+              default:
+                event = { kind: "other", payload };
             }
-            case "user_message_chunk":
-            case "agent_message_chunk":
-            case "agent_thought_chunk":
-            case "tool_call":
-            case "tool_call_update":
-            case "plan":
-            case "plan_update":
-            case "plan_removed":
-              event = { kind: "content", payload };
-              break;
-            default:
-              event = { kind: "other", payload };
+            await options.onEvent(event);
           }
-          await options.onEvent(event);
         });
         this.events = this.#updates;
         const client2 = {
@@ -83100,10 +83468,12 @@ var init_session_events = __esm({
     };
     AcpSessionConnector = class {
       #externalizer;
-      constructor(externalizer) {
+      #normalizeEvent;
+      constructor(externalizer, normalizeEvent = (event) => event) {
         this.#externalizer = externalizer;
+        this.#normalizeEvent = normalizeEvent;
       }
-      connectSession = (options) => new AdapterSessionConnection(options, this.#externalizer);
+      connectSession = (options) => new AdapterSessionConnection(options, this.#externalizer, this.#normalizeEvent);
       connectQuerySession = (options) => {
         const rejectInteraction = async () => {
           throw new AcpExecutionError(
@@ -83121,7 +83491,8 @@ var init_session_events = __esm({
               onElicitationComplete: rejectInteraction
             }
           },
-          this.#externalizer
+          this.#externalizer,
+          this.#normalizeEvent
         );
       };
     };
@@ -83151,1075 +83522,6 @@ var init_adapter = __esm({
   }
 });
 
-// src/storage/files/local-files.ts
-import { createReadStream as createReadStream2 } from "node:fs";
-import { mkdir as mkdir3, open as open4, readdir as readdir4, readFile as readFile5, realpath as realpath7, stat as stat6 } from "node:fs/promises";
-function entryKind(entry) {
-  if (entry.isDirectory()) {
-    return "directory";
-  }
-  if (entry.isFile()) {
-    return "file";
-  }
-  if (entry.isSymbolicLink()) {
-    return "symbolic-link";
-  }
-  if (entry.isBlockDevice() || entry.isCharacterDevice()) {
-    return "device";
-  }
-  if (entry.isFIFO()) {
-    return "fifo";
-  }
-  return entry.isSocket() ? "socket" : "unknown";
-}
-async function canonicalPath(path8) {
-  return await realpath7(path8);
-}
-async function readPathMetadata(path8) {
-  const metadata = await stat6(path8);
-  return {
-    kind: metadata.isDirectory() ? "directory" : metadata.isFile() ? "file" : "other",
-    modifiedAt: metadata.mtime,
-    modifiedMilliseconds: metadata.mtimeMs,
-    size: metadata.size
-  };
-}
-async function listDirectory(path8) {
-  const entries = await readdir4(path8, { withFileTypes: true });
-  return entries.map((entry) => ({ kind: entryKind(entry), name: entry.name }));
-}
-async function ensurePrivateDirectory(path8) {
-  await mkdir3(path8, { mode: 448, recursive: true });
-}
-async function ensureCanonicalDirectory(path8) {
-  await ensurePrivateDirectory(path8);
-  const resolved = await realpath7(path8);
-  return (await stat6(resolved)).isDirectory() ? resolved : null;
-}
-async function readFileStart(path8, byteLength) {
-  const bytes = new Uint8Array(byteLength);
-  const handle = await open4(path8, "r");
-  try {
-    await handle.read(bytes, 0, byteLength, 0);
-  } finally {
-    await handle.close();
-  }
-  return bytes;
-}
-async function readFileBytes(path8) {
-  return await readFile5(path8);
-}
-function readFileChunks(path8, chunkBytes, signal) {
-  return createReadStream2(path8, { highWaterMark: chunkBytes, signal });
-}
-var init_local_files = __esm({
-  "src/storage/files/local-files.ts"() {
-    "use strict";
-  }
-});
-
-// src/acp/content/raster.ts
-import { basename as basename5, isAbsolute as isAbsolute13, normalize } from "node:path";
-import { fileURLToPath } from "node:url";
-function startsWith(bytes, signature, offset = 0) {
-  if (bytes.byteLength < offset + signature.byteLength) {
-    return false;
-  }
-  return signature.every((value, index2) => bytes[offset + index2] === value);
-}
-function sniffRasterMime(bytes) {
-  if (startsWith(bytes, PNG_SIGNATURE)) {
-    return "image/png";
-  }
-  if (startsWith(bytes, JPEG_SIGNATURE)) {
-    return "image/jpeg";
-  }
-  if (startsWith(bytes, GIF87_SIGNATURE) || startsWith(bytes, GIF89_SIGNATURE)) {
-    return "image/gif";
-  }
-  if (startsWith(bytes, RIFF_SIGNATURE) && startsWith(bytes, WEBP_SIGNATURE, 8)) {
-    return "image/webp";
-  }
-  return null;
-}
-async function resolveCanonicalPath(requested, signal) {
-  signal.throwIfAborted();
-  if (!isAbsolute13(requested) || requested.includes("\0") || normalize(requested) !== requested) {
-    return null;
-  }
-  try {
-    const target = await canonicalPath(requested);
-    signal.throwIfAborted();
-    if (!isAbsolute13(target) || normalize(target) !== target) {
-      return null;
-    }
-    return target;
-  } catch (cause) {
-    signal.throwIfAborted();
-    if (cause instanceof Error && cause.name === "AbortError") {
-      throw cause;
-    }
-    return null;
-  }
-}
-function parseLocalImageUri(uri) {
-  const trimmed = uri.trim();
-  if (trimmed.length === 0 || trimmed.length > 2048 || trimmed.includes("\0")) {
-    return null;
-  }
-  if (trimmed.startsWith("data:")) {
-    return null;
-  }
-  if (trimmed.startsWith("file:")) {
-    try {
-      const url2 = new URL(trimmed);
-      if (url2.protocol !== "file:" || url2.host.length > 0) {
-        return null;
-      }
-      return fileURLToPath(url2);
-    } catch {
-      return null;
-    }
-  }
-  if (!isAbsolute13(trimmed) && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) {
-    return null;
-  }
-  return trimmed;
-}
-async function readLocalRaster(uri, signal) {
-  signal.throwIfAborted();
-  const requested = parseLocalImageUri(uri);
-  if (requested === null) {
-    return null;
-  }
-  const target = await resolveCanonicalPath(requested, signal);
-  if (target === null) {
-    return null;
-  }
-  const targetMetadata = await readPathMetadata(target);
-  signal.throwIfAborted();
-  if (targetMetadata.kind !== "file" || targetMetadata.size < 1 || targetMetadata.size > MAX_LOCAL_RASTER_BYTES) {
-    return null;
-  }
-  const header = await readFileStart(target, 12);
-  signal.throwIfAborted();
-  const mimeType = sniffRasterMime(header);
-  if (mimeType === null) {
-    return null;
-  }
-  return new LocalRasterImage(basename5(target) || "Image", mimeType, target);
-}
-var MAX_LOCAL_RASTER_BYTES, PNG_SIGNATURE, JPEG_SIGNATURE, GIF87_SIGNATURE, GIF89_SIGNATURE, RIFF_SIGNATURE, WEBP_SIGNATURE, LocalRasterImage;
-var init_raster = __esm({
-  "src/acp/content/raster.ts"() {
-    "use strict";
-    init_local_files();
-    MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
-    PNG_SIGNATURE = Uint8Array.of(137, 80, 78, 71);
-    JPEG_SIGNATURE = Uint8Array.of(255, 216, 255);
-    GIF87_SIGNATURE = new TextEncoder().encode("GIF87a");
-    GIF89_SIGNATURE = new TextEncoder().encode("GIF89a");
-    RIFF_SIGNATURE = new TextEncoder().encode("RIFF");
-    WEBP_SIGNATURE = new TextEncoder().encode("WEBP");
-    LocalRasterImage = class {
-      mimeType;
-      name;
-      sourceUri;
-      constructor(name2, mimeType, sourceUri) {
-        this.mimeType = mimeType;
-        this.name = name2;
-        this.sourceUri = sourceUri;
-      }
-      base64 = async () => Buffer.from(await readFileBytes(this.sourceUri)).toString("base64");
-    };
-  }
-});
-
-// src/acp/native-history/codex/history-images.ts
-function isRasterMime(value) {
-  return value === "image/png" || value === "image/jpeg" || value === "image/gif" || value === "image/webp";
-}
-function parseNativeHistoryImage(uri) {
-  const header = DATA_IMAGE_HEADER.exec(uri);
-  if (header === null) {
-    return null;
-  }
-  const mimeType = header[1] ?? "";
-  const data = uri.slice(header[0].length);
-  if (!isRasterMime(mimeType) || data.length < 4 || data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
-    return null;
-  }
-  if (data.length % 4 !== 0 || !BASE_64.test(data)) {
-    return null;
-  }
-  return { data, mimeType, name: "" };
-}
-async function embedLocalHistoryImages(history, signal) {
-  if (history.status !== "available") {
-    return history;
-  }
-  const messages = [];
-  let imageCharacters = 0;
-  for (const message of history.messages) {
-    signal.throwIfAborted();
-    const resolved = await resolveMessageImages(message, imageCharacters, signal);
-    imageCharacters += (resolved.images ?? []).reduce((size, image) => size + image.data.length, 0);
-    messages.push(resolved);
-  }
-  return {
-    ...history,
-    messages
-  };
-}
-async function resolveMessageImages(message, usedCharacters, signal) {
-  const images = [...message.images ?? []];
-  let imageCharacters = images.reduce((size, image) => size + image.data.length, 0);
-  const text2 = await replaceImageMarkers(message.text, async (uri) => {
-    if (images.length >= 8 || usedCharacters + imageCharacters >= SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
-      return "[Image unavailable]";
-    }
-    const embedded = parseNativeHistoryImage(uri);
-    if (embedded !== null) {
-      if (usedCharacters + imageCharacters + embedded.data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
-        return "[Image unavailable]";
-      }
-      images.push({ ...embedded, name: `Image ${(images.length + 1).toString()}` });
-      imageCharacters += embedded.data.length;
-      return "";
-    }
-    const local = await readLocalRaster(uri, signal);
-    if (local === null) {
-      return "[Image unavailable]";
-    }
-    const data = await local.base64();
-    if (usedCharacters + imageCharacters + data.length > SESSION_HISTORY_IMAGE_CHARACTER_LIMIT) {
-      return "[Image unavailable]";
-    }
-    images.push({
-      data,
-      mimeType: local.mimeType,
-      name: local.name
-    });
-    imageCharacters += data.length;
-    return "";
-  });
-  return {
-    ...message,
-    text: text2,
-    ...images.length > 0 ? { images } : {}
-  };
-}
-async function replaceImageMarkers(text2, replace) {
-  const matches = [...text2.matchAll(IMAGE_MARKER)];
-  if (matches.length === 0) {
-    return text2;
-  }
-  let cursor = 0;
-  let rewritten = "";
-  for (const match of matches) {
-    const index2 = match.index ?? 0;
-    rewritten += text2.slice(cursor, index2);
-    rewritten += await replace(match[1] ?? "");
-    cursor = index2 + match[0].length;
-  }
-  return `${rewritten}${text2.slice(cursor)}`;
-}
-var IMAGE_MARKER, DATA_IMAGE_HEADER, BASE_64, SESSION_HISTORY_IMAGE_CHARACTER_LIMIT, SESSION_HISTORY_PREVIEW_TURN_LIMIT;
-var init_history_images = __esm({
-  "src/acp/native-history/codex/history-images.ts"() {
-    "use strict";
-    init_raster();
-    IMAGE_MARKER = /\[@image\]\(([^)\r\n]*)(?:\)|$)/g;
-    DATA_IMAGE_HEADER = /^data:(image\/[a-z+]+);base64,/;
-    BASE_64 = /^[A-Za-z0-9+/]*={0,2}$/;
-    SESSION_HISTORY_IMAGE_CHARACTER_LIMIT = 4e6;
-    SESSION_HISTORY_PREVIEW_TURN_LIMIT = 10;
-  }
-});
-
-// src/acp/native-history/codex/codex-history.ts
-import { spawn as spawn8 } from "node:child_process";
-function bounded(value, maximum) {
-  return value.slice(0, maximum);
-}
-function activity(activityId, activityType, sequence, fields) {
-  return {
-    activityId: bounded(activityId, 128) || `history-${sequence.toString()}`,
-    activityType,
-    content: [],
-    input: bounded(fields.input, 1e5),
-    locations: fields.locations.filter((location) => location.length > 0).map((location) => bounded(location, 2048)).slice(0, 100),
-    name: bounded(fields.name, 128),
-    output: bounded(fields.output, 1e5),
-    sequence,
-    status: bounded(fields.status, 64),
-    title: bounded(fields.title, 500),
-    toolKind: bounded(fields.toolKind, 64)
-  };
-}
-function errorMessage(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "object" && value !== null) {
-    const message = Reflect.get(value, "message");
-    if (typeof message === "string") {
-      return message;
-    }
-  }
-  return JSON.stringify(value) ?? "Codex stopped before completing this turn.";
-}
-function formatted(value) {
-  if (value === void 0) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return JSON.stringify(value) ?? "";
-}
-function toolStatus(status) {
-  return status === "inProgress" ? "running" : status === "completed" ? "completed" : "failed";
-}
-function diffContent(path8, newText) {
-  return { newText, path: path8, type: "diff" };
-}
-function messageSize(message) {
-  return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
-}
-function fitActivity(activity2, maximumCharacters) {
-  const truncate4 = (limit) => ({
-    ...activity2,
-    input: bounded(activity2.input, limit),
-    locations: activity2.locations.map((location) => bounded(location, Math.max(1, limit))),
-    name: bounded(activity2.name, limit),
-    output: bounded(activity2.output, limit),
-    title: bounded(activity2.title, limit),
-    toolKind: bounded(activity2.toolKind, limit)
-  });
-  let minimum = 1;
-  let maximum = 1e5;
-  let fitted = truncate4(0);
-  while (minimum <= maximum) {
-    const limit = Math.floor((minimum + maximum) / 2);
-    const candidate = truncate4(limit);
-    if (JSON.stringify(candidate).length <= maximumCharacters) {
-      fitted = candidate;
-      minimum = limit + 1;
-    } else {
-      maximum = limit - 1;
-    }
-  }
-  return fitted;
-}
-function fitActivities(activities, maximumCharacters) {
-  if (activities.length === 0) {
-    return activities;
-  }
-  const arrayCharacters = 2 + activities.length - 1;
-  const maximumActivityCharacters = Math.floor(Math.max(0, maximumCharacters - arrayCharacters) / activities.length);
-  return activities.map((activity2) => fitActivity(activity2, maximumActivityCharacters));
-}
-function fitHistoryMessage(message, maximumCharacters = SESSION_HISTORY_MESSAGE_CHARACTER_LIMIT) {
-  const text2 = message.text.slice(-maximumCharacters);
-  if (message.role === "user") {
-    return {
-      message: { ...message, text: text2 },
-      truncated: text2.length < message.text.length
-    };
-  }
-  let activities = message.activities;
-  const content = message.content;
-  let fitted = { ...message, activities, content, text: text2 };
-  if (messageSize(fitted) > maximumCharacters && activities.length > 0) {
-    const maximumActivityCharacters = maximumCharacters - text2.length - JSON.stringify(content).length;
-    activities = fitActivities(activities, maximumActivityCharacters);
-    fitted = { ...fitted, activities };
-  }
-  const excess = Math.max(0, messageSize(fitted) - maximumCharacters);
-  if (excess > 0) {
-    const maximumTextLength = Math.max(0, fitted.text.length - excess);
-    fitted = {
-      ...fitted,
-      text: maximumTextLength === 0 ? "" : fitted.text.slice(-maximumTextLength)
-    };
-  }
-  return {
-    message: fitted,
-    truncated: fitted.text.length < message.text.length || JSON.stringify(activities).length < JSON.stringify(message.activities).length
-  };
-}
-function turnOutcome2(status) {
-  switch (status) {
-    case "completed":
-      return "succeeded";
-    case "interrupted":
-      return "cancelled";
-    case "failed":
-      return "failed";
-    case "inProgress":
-      return void 0;
-    default: {
-      const unhandled = status;
-      throw new Error(`Unknown Codex turn status: ${String(unhandled)}`);
-    }
-  }
-}
-function decodeHistory(thread, value, options) {
-  const page = turnsSchema.parse(value);
-  const nativeTurn = options.nativeTurn?.();
-  const coveredCommandIds = nativeTurn != null && page.data[0]?.id === nativeTurn.nativeTurnId ? [nativeTurn.commandId] : [];
-  const messages = [];
-  let characters = 0;
-  let truncated = page.nextCursor != null;
-  for (const turn of page.data.toReversed()) {
-    const outcome = turnOutcome2(turn.status);
-    const turnMessageCharacterLimit = Math.max(
-      1,
-      Math.floor(SESSION_HISTORY_CHARACTER_LIMIT / Math.max(1, turn.items.length + (turn.error == null ? 0 : 1)))
-    );
-    let sequence = 0;
-    let assistantMessageIndex = null;
-    const append = (message) => {
-      const fitted = fitHistoryMessage(message, turnMessageCharacterLimit);
-      if (fitted.message.text.length === 0 && (fitted.message.images?.length ?? 0) === 0 && (fitted.message.role === "user" || fitted.message.activities.length === 0 && fitted.message.content.length === 0)) {
-        return;
-      }
-      truncated ||= fitted.truncated;
-      messages.push(fitted.message);
-      if (fitted.message.role === "assistant") {
-        assistantMessageIndex = messages.length - 1;
-      }
-      characters += messageSize(fitted.message);
-    };
-    for (const item of turn.items) {
-      const decoded = historyItemSchema.safeParse(item);
-      if (!decoded.success) {
-        continue;
-      }
-      const historyItem = decoded.data;
-      if (historyItem.type === "userMessage") {
-        const text2 = historyItem.content.map((block) => {
-          const { type } = itemTypeSchema.parse(block);
-          if (type === "text") {
-            return textSchema.parse(block).text;
-          }
-          if (type === "image") {
-            return `[@image](${imageSchema.parse(block).url})`;
-          }
-          return "[Attachment]";
-        }).join("");
-        append({
-          role: "user",
-          text: text2
-        });
-      } else if (historyItem.type === "agentMessage") {
-        append({ activities: [], content: [], role: "assistant", text: historyItem.text });
-      } else if (historyItem.type === "reasoning") {
-        const output2 = (historyItem.content.length > 0 ? historyItem.content : historyItem.summary).join(
-          "\n\n"
-        );
-        if (output2.length > 0) {
-          append({
-            activities: [
-              activity(historyItem.id, "reasoning", sequence, {
-                input: "",
-                locations: [],
-                name: "",
-                output: output2,
-                status: "completed",
-                title: "Reasoning",
-                toolKind: ""
-              })
-            ],
-            content: [],
-            role: "assistant",
-            text: ""
-          });
-          sequence += 1;
-        }
-      } else if (historyItem.type === "commandExecution") {
-        const action = historyItem.commandActions[0]?.type ?? "execute";
-        append({
-          activities: [
-            activity(historyItem.id, "tool", sequence, {
-              input: JSON.stringify({ command: historyItem.command, cwd: historyItem.cwd }),
-              locations: [historyItem.cwd],
-              name: "",
-              output: JSON.stringify({
-                formatted_output: historyItem.aggregatedOutput ?? "",
-                ...historyItem.exitCode == null ? {} : { exit_code: historyItem.exitCode }
-              }),
-              status: toolStatus(historyItem.status),
-              title: historyItem.command,
-              toolKind: action
-            })
-          ],
-          content: [],
-          role: "assistant",
-          text: ""
-        });
-        sequence += 1;
-      } else if (historyItem.type === "fileChange") {
-        const paths = historyItem.changes.map((change) => change.path);
-        const content = historyItem.changes.map(
-          (change) => diffContent(change.path, change.diff)
-        );
-        append({
-          activities: [
-            activity(historyItem.id, "tool", sequence, {
-              input: JSON.stringify({ changes: paths }),
-              locations: paths,
-              name: "",
-              output: "",
-              status: toolStatus(historyItem.status),
-              title: paths.join(", "),
-              toolKind: "edit"
-            })
-          ].map((entry) => ({ ...entry, content })),
-          content: [],
-          role: "assistant",
-          text: ""
-        });
-        sequence += 1;
-      } else if (historyItem.type === "mcpToolCall") {
-        append({
-          activities: [
-            activity(historyItem.id, "tool", sequence, {
-              input: formatted(historyItem.arguments),
-              locations: [],
-              name: historyItem.tool,
-              output: formatted(historyItem.error ?? historyItem.result),
-              status: toolStatus(historyItem.status),
-              title: `${historyItem.server}/${historyItem.tool}`,
-              toolKind: "other"
-            })
-          ],
-          content: [],
-          role: "assistant",
-          text: ""
-        });
-        sequence += 1;
-      } else if (historyItem.type === "dynamicToolCall") {
-        append({
-          activities: [
-            activity(historyItem.id, "tool", sequence, {
-              input: formatted(historyItem.arguments),
-              locations: [],
-              name: historyItem.tool,
-              output: formatted(historyItem.contentItems),
-              status: toolStatus(historyItem.status),
-              title: historyItem.namespace == null ? historyItem.tool : `${historyItem.namespace}/${historyItem.tool}`,
-              toolKind: "other"
-            })
-          ],
-          content: [],
-          role: "assistant",
-          text: ""
-        });
-        sequence += 1;
-      } else if (historyItem.type === "plan") {
-        append({
-          activities: [
-            activity(historyItem.id, "plan", sequence, {
-              input: "",
-              locations: [],
-              name: "",
-              output: historyItem.text,
-              status: "completed",
-              title: "Plan",
-              toolKind: ""
-            })
-          ],
-          content: [],
-          role: "assistant",
-          text: ""
-        });
-        sequence += 1;
-      }
-    }
-    if (turn.error != null) {
-      append({
-        activities: [
-          activity(`agent-error-${sequence.toString()}`, "tool", sequence, {
-            input: "",
-            locations: [],
-            name: "",
-            output: errorMessage(turn.error),
-            status: "failed",
-            title: "Agent error",
-            toolKind: "other"
-          })
-        ],
-        content: [],
-        role: "assistant",
-        text: ""
-      });
-    }
-    if (assistantMessageIndex !== null) {
-      const assistant = messages[assistantMessageIndex];
-      if (assistant?.role === "assistant") {
-        characters -= messageSize(assistant);
-        const updated = {
-          ...assistant,
-          ...outcome === void 0 ? {} : { outcome }
-        };
-        const fitted = fitHistoryMessage(updated, turnMessageCharacterLimit);
-        truncated ||= fitted.truncated;
-        messages[assistantMessageIndex] = fitted.message;
-        characters += messageSize(fitted.message);
-      }
-    } else if (outcome !== void 0) {
-      const message = {
-        activities: [],
-        content: [],
-        role: "assistant",
-        ...outcome === void 0 ? {} : { outcome },
-        text: ""
-      };
-      const fitted = fitHistoryMessage(message, turnMessageCharacterLimit);
-      truncated ||= fitted.truncated;
-      messages.push(fitted.message);
-      characters += messageSize(fitted.message);
-    }
-    while (messages.length > SESSION_HISTORY_MESSAGE_LIMIT || characters > SESSION_HISTORY_CHARACTER_LIMIT) {
-      const removed = messages.shift();
-      if (removed !== void 0) {
-        characters -= messageSize(removed);
-      }
-      truncated = true;
-    }
-  }
-  return {
-    nativeSessionId: thread.id,
-    cwd: thread.cwd,
-    history: {
-      status: "available",
-      messages,
-      truncated,
-      coveredCommandIds,
-      coveredMessageIds: []
-    }
-  };
-}
-async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal, options) {
-  signal.throwIfAborted();
-  nativeSessionIdSchema.parse(nativeSessionId);
-  if (agent.id !== "codex" || !await revalidateExecutable(agent.agentIdentity)) {
-    throw new AcpExecutionError(
-      "The local Codex executable changed. Restart Mobius to discover it again.",
-      {},
-      "agent_executable_changed"
-    );
-  }
-  signal.throwIfAborted();
-  const launch = executableLaunch2(agent.agentIdentity.realPath, ["app-server"]);
-  const child = spawn8(launch.command, [...launch.arguments], {
-    cwd,
-    env: { ...process.env, ...agent.environment },
-    ...platformSpawnOptions,
-    shell: false,
-    stdio: ["pipe", "pipe", "ignore"]
-  });
-  const response = Promise.withResolvers();
-  let state = { kind: "initializing", requestId: 1 };
-  const seenCursors = /* @__PURE__ */ new Set();
-  let pendingBytes = 0;
-  let pendingFragments = [];
-  const fail = (cause) => response.reject(
-    cause instanceof AcpExecutionError ? cause : new AcpExecutionError(
-      "Saved Codex history could not be read.",
-      { cause },
-      "native_history_unavailable"
-    )
-  );
-  const send2 = (message) => {
-    child.stdin.write(`${JSON.stringify(message)}
-`);
-  };
-  const onData = (chunk) => {
-    try {
-      let cursor = 0;
-      let newline = chunk.indexOf("\n");
-      while (newline >= 0) {
-        const fragment = chunk.slice(cursor, newline);
-        const lineBytes = pendingBytes + Buffer.byteLength(fragment);
-        if (lineBytes > 32 * 1024 * 1024) {
-          throw new AcpExecutionError(
-            "This saved conversation is too large to preview.",
-            {},
-            "native_history_too_large"
-          );
-        }
-        const line = pendingFragments.length === 0 ? fragment : [...pendingFragments, fragment].join("");
-        pendingBytes = 0;
-        pendingFragments = [];
-        cursor = newline + 1;
-        newline = chunk.indexOf("\n", cursor);
-        if (line.trim().length === 0) {
-          continue;
-        }
-        const value = JSON.parse(line);
-        const message = responseSchema.parse(value);
-        if (!("id" in message)) {
-          continue;
-        }
-        if (message.id !== state.requestId) {
-          throw new AcpExecutionError(
-            "Codex returned an invalid history response.",
-            {},
-            "invalid_native_session_response"
-          );
-        }
-        if ("error" in message) {
-          fail(
-            new AcpExecutionError(
-              "Saved Codex history could not be read.",
-              { cause: new CodexHistoryResponseError(message.error) },
-              "native_history_unavailable"
-            )
-          );
-          return;
-        }
-        switch (state.kind) {
-          case "initializing":
-            state = { kind: "metadata", requestId: 2 };
-            send2({ method: "initialized", params: {} });
-            send2({
-              id: state.requestId,
-              method: "thread/read",
-              params: { threadId: nativeSessionId, includeTurns: false }
-            });
-            break;
-          case "metadata": {
-            const { thread } = threadSchema.parse(message.result);
-            state = { kind: "turns", requestId: 3, thread, pages: [] };
-            send2({
-              id: state.requestId,
-              method: "thread/turns/list",
-              params: {
-                threadId: nativeSessionId,
-                limit: SESSION_HISTORY_PREVIEW_TURN_LIMIT,
-                sortDirection: "desc",
-                itemsView: "full"
-              }
-            });
-            break;
-          }
-          case "turns": {
-            const page = turnsSchema.parse(message.result);
-            const pages = [...state.pages, ...page.data];
-            const maxTurns = SESSION_HISTORY_MESSAGE_LIMIT;
-            if (page.nextCursor == null || pages.length >= maxTurns) {
-              response.resolve(
-                decodeHistory(
-                  state.thread,
-                  {
-                    data: pages.slice(0, maxTurns),
-                    nextCursor: page.nextCursor
-                  },
-                  options
-                )
-              );
-              return;
-            }
-            if (page.data.length === 0 || seenCursors.has(page.nextCursor)) {
-              throw new AcpExecutionError(
-                "Codex repeated a history page cursor.",
-                {},
-                "invalid_native_session_response"
-              );
-            }
-            seenCursors.add(page.nextCursor);
-            state = { kind: "turns", requestId: state.requestId + 1, thread: state.thread, pages };
-            send2({
-              id: state.requestId,
-              method: "thread/turns/list",
-              params: {
-                threadId: nativeSessionId,
-                cursor: page.nextCursor,
-                limit: Math.min(SESSION_HISTORY_PREVIEW_TURN_LIMIT, maxTurns - pages.length),
-                sortDirection: "desc",
-                itemsView: "full"
-              }
-            });
-            break;
-          }
-          default: {
-            const unhandled = state;
-            throw new Error(`Unknown history read state: ${String(unhandled)}`);
-          }
-        }
-      }
-      const remainder = chunk.slice(cursor);
-      if (remainder.length > 0) {
-        pendingBytes += Buffer.byteLength(remainder);
-        if (pendingBytes > 32 * 1024 * 1024) {
-          throw new AcpExecutionError(
-            "This saved conversation is too large to preview.",
-            {},
-            "native_history_too_large"
-          );
-        }
-        pendingFragments.push(remainder);
-      }
-    } catch (cause) {
-      fail(cause);
-    }
-  };
-  const abort = () => response.reject(signal.reason);
-  const onExit = () => fail(
-    new AcpExecutionError(
-      "Codex stopped before its saved history was available.",
-      {},
-      "native_history_unavailable"
-    )
-  );
-  const timeout = setTimeout(
-    () => fail(new AcpExecutionError("Reading saved Codex history timed out.", {}, "native_history_timeout")),
-    6e4
-  );
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", onData);
-  child.stdin.on("error", fail);
-  child.on("error", fail);
-  child.on("exit", onExit);
-  signal.addEventListener("abort", abort, { once: true });
-  try {
-    if (signal.aborted) {
-      abort();
-    } else {
-      send2({
-        id: 1,
-        method: "initialize",
-        params: { clientInfo: { name: "mobius_history", version: "1.0.0" } }
-      });
-    }
-    const snapshot = await response.promise;
-    return {
-      ...snapshot,
-      history: await embedLocalHistoryImages(snapshot.history, signal)
-    };
-  } finally {
-    clearTimeout(timeout);
-    signal.removeEventListener("abort", abort);
-    child.stdout.removeListener("data", onData);
-    if (child.pid !== void 0) {
-      await stopProcessTree(child);
-    }
-    child.stdin.removeListener("error", fail);
-    child.removeListener("error", fail);
-    child.removeListener("exit", onExit);
-  }
-}
-var responseSchema, threadSchema, turnsSchema, itemTypeSchema, userMessageSchema, textSchema, imageSchema, agentMessageSchema, reasoningSchema, commandExecutionSchema, fileChangeSchema, mcpToolCallSchema, dynamicToolCallSchema, planSchema, historyItemSchema, CodexHistoryResponseError, SESSION_HISTORY_MESSAGE_CHARACTER_LIMIT, readCodexFullHistory;
-var init_codex_history = __esm({
-  "src/acp/native-history/codex/codex-history.ts"() {
-    "use strict";
-    init_protocol();
-    init_zod();
-    init_executable();
-    init_acp_error();
-    init_native_session();
-    init_history_images();
-    responseSchema = external_exports.union([
-      external_exports.object({
-        id: external_exports.number(),
-        error: external_exports.object({ code: external_exports.number(), message: external_exports.string() })
-      }),
-      external_exports.object({ id: external_exports.number(), result: external_exports.unknown() }),
-      external_exports.object({ method: external_exports.string() })
-    ]);
-    threadSchema = external_exports.object({
-      thread: external_exports.object({
-        id: nativeSessionIdSchema,
-        cwd: external_exports.string().min(1).max(2048).refine((path8) => !path8.includes("\0"))
-      })
-    });
-    turnsSchema = external_exports.object({
-      data: external_exports.array(
-        external_exports.object({
-          id: external_exports.string().min(1),
-          status: external_exports.enum(["completed", "interrupted", "failed", "inProgress"]),
-          error: external_exports.unknown().nullish(),
-          items: external_exports.array(external_exports.unknown()).max(1e5)
-        })
-      ).max(SESSION_HISTORY_MESSAGE_LIMIT),
-      nextCursor: external_exports.string().nullish()
-    });
-    itemTypeSchema = external_exports.object({ type: external_exports.string().min(1).max(80) });
-    userMessageSchema = external_exports.object({
-      content: external_exports.array(external_exports.unknown()).max(1e4),
-      type: external_exports.literal("userMessage")
-    });
-    textSchema = external_exports.object({ text: external_exports.string() });
-    imageSchema = external_exports.object({ url: external_exports.string() });
-    agentMessageSchema = textSchema.extend({
-      id: external_exports.string().optional(),
-      phase: external_exports.string().nullish(),
-      type: external_exports.literal("agentMessage")
-    });
-    reasoningSchema = external_exports.object({
-      id: external_exports.string(),
-      summary: external_exports.array(external_exports.string()).max(1e4),
-      content: external_exports.array(external_exports.string()).max(1e4),
-      type: external_exports.literal("reasoning")
-    });
-    commandExecutionSchema = external_exports.object({
-      id: external_exports.string(),
-      command: external_exports.string(),
-      cwd: external_exports.string(),
-      status: external_exports.string(),
-      commandActions: external_exports.array(external_exports.object({ type: external_exports.string() }).passthrough()).max(100),
-      aggregatedOutput: external_exports.string().nullish(),
-      exitCode: external_exports.number().int().nullish(),
-      type: external_exports.literal("commandExecution")
-    });
-    fileChangeSchema = external_exports.object({
-      changes: external_exports.array(external_exports.object({ diff: external_exports.string(), path: external_exports.string() })).max(1e4),
-      id: external_exports.string(),
-      status: external_exports.string(),
-      type: external_exports.literal("fileChange")
-    });
-    mcpToolCallSchema = external_exports.object({
-      arguments: external_exports.unknown().optional(),
-      error: external_exports.unknown().nullish(),
-      id: external_exports.string(),
-      result: external_exports.unknown().nullish(),
-      server: external_exports.string(),
-      status: external_exports.string(),
-      tool: external_exports.string(),
-      type: external_exports.literal("mcpToolCall")
-    });
-    dynamicToolCallSchema = external_exports.object({
-      arguments: external_exports.unknown().optional(),
-      contentItems: external_exports.array(external_exports.unknown()).max(1e4).nullish(),
-      id: external_exports.string(),
-      namespace: external_exports.string().nullish(),
-      status: external_exports.string(),
-      tool: external_exports.string(),
-      type: external_exports.literal("dynamicToolCall")
-    });
-    planSchema = external_exports.object({ id: external_exports.string(), text: external_exports.string(), type: external_exports.literal("plan") });
-    historyItemSchema = external_exports.discriminatedUnion("type", [
-      userMessageSchema,
-      agentMessageSchema,
-      reasoningSchema,
-      commandExecutionSchema,
-      fileChangeSchema,
-      mcpToolCallSchema,
-      dynamicToolCallSchema,
-      planSchema
-    ]);
-    CodexHistoryResponseError = class extends Error {
-      code;
-      constructor(response) {
-        super(response.message);
-        this.code = response.code;
-        this.name = "CodexHistoryResponseError";
-      }
-    };
-    SESSION_HISTORY_MESSAGE_CHARACTER_LIMIT = Math.floor(SESSION_HISTORY_CHARACTER_LIMIT / 2);
-    readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTurn) => await readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal, {
-      ...nativeTurn === void 0 ? {} : { nativeTurn }
-    });
-  }
-});
-
-// src/acp/native-history/codex/native-history-events.ts
-import { createHash as createHash2 } from "node:crypto";
-function toolKind(value) {
-  switch (value) {
-    case "read":
-    case "edit":
-    case "delete":
-    case "move":
-    case "search":
-    case "execute":
-    case "think":
-    case "fetch":
-    case "switch_mode":
-    case "other":
-      return value;
-    default:
-      return "other";
-  }
-}
-function toolStatus2(value) {
-  switch (value) {
-    case "pending":
-      return "pending";
-    case "running":
-    case "in_progress":
-      return "in_progress";
-    case "completed":
-      return "completed";
-    default:
-      return "failed";
-  }
-}
-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,
-      kind: toolKind(activity2.toolKind),
-      locations: activity2.locations.map((path8) => ({ path: path8 })),
-      rawInput: activity2.input,
-      rawOutput: activity2.output,
-      sessionUpdate: "tool_call",
-      status: toolStatus2(activity2.status),
-      title: activity2.title,
-      toolCallId: activity2.activityId,
-      ...activity2.name.length === 0 ? {} : { name: activity2.name }
-    },
-    type: "acp"
-  };
-}
-function contentEvent(sessionUpdate, messageId, content) {
-  return { payload: { content, messageId, sessionUpdate }, type: "acp" };
-}
-function historyEvents(history) {
-  return history.messages.flatMap((message, index2) => {
-    const messageId = `native-history-${index2.toString()}`;
-    const sessionUpdate = message.role === "user" ? "user_message_chunk" : "agent_message_chunk";
-    const images = (message.images ?? []).map(
-      (image) => contentEvent(sessionUpdate, messageId, {
-        data: image.data,
-        mimeType: image.mimeType,
-        type: "image"
-      })
-    );
-    const text2 = message.text.length === 0 ? [] : [contentEvent(sessionUpdate, messageId, { text: message.text, type: "text" })];
-    if (message.role === "user") {
-      return [...images, ...text2];
-    }
-    const activities = message.activities.map(activityEvent);
-    const content = message.content.map((block) => contentEvent(sessionUpdate, messageId, block));
-    return [...activities, ...content, ...images, ...text2];
-  });
-}
-function nativeHistoryEvents(sessionId, nativeSessionId, history, eventLimit, cursor, eventStore) {
-  const events = historyEvents(history);
-  const generationId = createHash2("sha256").update(nativeSessionId).update("\0").update(JSON.stringify(events)).digest("hex");
-  eventStore.materialize(sessionId, generationId, events);
-  return eventStore.page(sessionId, eventLimit, cursor);
-}
-var init_native_history_events = __esm({
-  "src/acp/native-history/codex/native-history-events.ts"() {
-    "use strict";
-  }
-});
-
 // src/generated/acp-session-store-migrations.ts
 var acpSessionStoreMigrations;
 var init_acp_session_store_migrations = __esm({
@@ -90035,23 +89337,108 @@ var init_preview_event_cache = __esm({
   }
 });
 
+// src/acp/adapter/codex/tool-event.ts
+function payloadText(value) {
+  let text2;
+  try {
+    text2 = JSON.stringify(value) ?? "";
+  } catch {
+    text2 = "Tool payload could not be represented as JSON.";
+  }
+  return text2.slice(0, TRUNCATED_TOOL_PAYLOAD_CHARACTER_LIMIT);
+}
+function fitNesting(value, depth = 0) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  if (depth === MAX_TOOL_PAYLOAD_DEPTH && Object.keys(value).length > 0) {
+    return `[truncated: nesting depth] ${payloadText(value)}`;
+  }
+  if (Array.isArray(value)) {
+    return value.map((child) => fitNesting(child, depth + 1));
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, fitNesting(child, depth + 1)]));
+}
+function prepareCodexToolUpdate(update) {
+  if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
+    return update;
+  }
+  return {
+    ...update,
+    ...update.rawOutput === void 0 ? {} : { rawOutput: fitNesting(update.rawOutput) },
+    ...update._meta == null ? {} : {
+      _meta: Object.fromEntries(
+        Object.entries(update._meta).map(([key, child]) => [key, fitNesting(child, 1)])
+      )
+    }
+  };
+}
+function fitPayload(value) {
+  if (value === void 0 || boundedJsonSchema.safeParse(value).success) {
+    return value;
+  }
+  return { truncated: true, text: payloadText(value) };
+}
+function fitCodexToolEvent(event) {
+  const decoded = toolEventSchema.safeParse(event);
+  if (!decoded.success) {
+    return event;
+  }
+  return {
+    ...decoded.data,
+    rawInput: fitPayload(decoded.data.rawInput),
+    rawOutput: fitPayload(decoded.data.rawOutput)
+  };
+}
+var toolEventSchema, TRUNCATED_TOOL_PAYLOAD_CHARACTER_LIMIT, MAX_TOOL_PAYLOAD_DEPTH;
+var init_tool_event = __esm({
+  "src/acp/adapter/codex/tool-event.ts"() {
+    "use strict";
+    init_protocol();
+    init_zod();
+    toolEventSchema = external_exports.looseObject({
+      sessionUpdate: external_exports.enum(["tool_call", "tool_call_update"]),
+      rawInput: external_exports.unknown().optional(),
+      rawOutput: external_exports.unknown().optional()
+    });
+    TRUNCATED_TOOL_PAYLOAD_CHARACTER_LIMIT = 32768;
+    MAX_TOOL_PAYLOAD_DEPTH = 16;
+  }
+});
+
 // src/acp/adapter/codex/adapter.ts
+import { createHash as createHash4 } from "node:crypto";
 var CodexAdapter;
 var init_adapter2 = __esm({
   "src/acp/adapter/codex/adapter.ts"() {
     "use strict";
+    init_protocol();
+    init_executable();
     init_acp_error();
-    init_codex_history();
-    init_native_history_events();
+    init_app_server_client();
+    init_history();
+    init_native_session();
     init_preview_event_cache();
     init_query_processes();
     init_session_events();
+    init_tool_event();
     CodexAdapter = class {
       #queryProcesses;
       #connector;
+      #dependencies;
+      #contentExternalizer;
       #previewCache = null;
       constructor(dependencies) {
-        this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
+        this.#dependencies = dependencies;
+        this.#contentExternalizer = {
+          update: async (sessionId, update, signal) => {
+            signal.throwIfAborted();
+            const prepared = prepareCodexToolUpdate(update);
+            signal.throwIfAborted();
+            return await dependencies.contentExternalizer.update(sessionId, prepared, signal);
+          }
+        };
+        this.#connector = new AcpSessionConnector(this.#contentExternalizer, fitCodexToolEvent);
         this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
       }
       capabilities = async (query) => await this.#queryProcesses.capabilities(query);
@@ -90065,21 +89452,73 @@ var init_adapter2 = __esm({
         }
       };
       previewSessionEvents = async (query, request) => {
-        const { agent, cwd, signal } = query;
+        const { agent, cwd } = query;
+        const signal = AbortSignal.any([query.signal, AbortSignal.timeout(6e4)]);
         const { sessionId } = request;
-        this.#previewCache ??= openPreviewEventCache();
-        const snapshot = await readCodexFullHistory(agent, cwd, request.nativeSessionId, signal);
-        if (snapshot.history.status === "unavailable") {
-          throw new AcpExecutionError(snapshot.history.cause.message, {}, snapshot.history.cause.code);
+        signal.throwIfAborted();
+        nativeSessionIdSchema.parse(request.nativeSessionId);
+        if (agent.id !== "codex") {
+          throw new AcpExecutionError(
+            "The Codex adapter cannot preview history for another agent.",
+            {},
+            "agent_adapter_mismatch"
+          );
         }
-        return nativeHistoryEvents(
-          sessionId,
-          request.nativeSessionId,
-          snapshot.history,
-          request.eventLimit,
-          request.cursor,
-          this.#previewCache.events
+        if (!await revalidateExecutable(agent.agentIdentity)) {
+          throw new AcpExecutionError(
+            "The local Codex executable changed. Restart Mobius to discover it again.",
+            {},
+            "agent_executable_changed"
+          );
+        }
+        this.#previewCache ??= openPreviewEventCache();
+        const events = [];
+        await this.#dependencies.processes.runTransient(
+          signal,
+          async () => {
+            const client2 = new CodexAppServerClient({
+              command: agent.command,
+              cwd,
+              environment: agent.environment,
+              handlers: {
+                onNotification: async () => void 0,
+                onServerRequest: async () => {
+                  throw new AcpExecutionError(
+                    "Unexpected request while reading saved history",
+                    {},
+                    "invalid_native_session_response"
+                  );
+                }
+              }
+            });
+            return {
+              client: client2,
+              closeProcess: async () => {
+                client2.detach();
+                await stopProcessTree(client2.child());
+              }
+            };
+          },
+          async ({ client: client2 }) => {
+            await client2.initialize(signal);
+            return await replayCodexHistory(
+              client2,
+              request.nativeSessionId,
+              async (update) => {
+                const externalized = await this.#contentExternalizer.update(sessionId, update, signal);
+                events.push({
+                  type: "acp",
+                  payload: decodeAcpSessionUpdate(JSON.stringify(fitCodexToolEvent(externalized.event)))
+                });
+              },
+              signal
+            );
+          },
+          async (runtime) => await runtime.closeProcess()
         );
+        const generationId = createHash4("sha256").update(request.nativeSessionId).update("\0").update(JSON.stringify(events)).digest("hex");
+        this.#previewCache.events.materialize(sessionId, generationId, events);
+        return this.#previewCache.events.page(sessionId, request.eventLimit, request.cursor);
       };
     };
   }
@@ -90137,17 +89576,6 @@ var init_registry = __esm({
 });
 
 // src/acp/content/content-externalizer.ts
-function reasoningTail(text2) {
-  if (Buffer.byteLength(text2, "utf8") <= MAXIMUM_REASONING_CHUNK_BYTES) {
-    return text2;
-  }
-  const bytes = Buffer.from(text2, "utf8");
-  let start = bytes.length - MAXIMUM_REASONING_CHUNK_BYTES;
-  while (start < bytes.length && (bytes.readUInt8(start) & 192) === 128) {
-    start += 1;
-  }
-  return bytes.toString("utf8", start);
-}
 function decodeBase64(data) {
   if (data.length > MAXIMUM_ENCODED_CONTENT_CHARACTERS || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(data)) {
     throw new Error("The ACP embedded content is not valid bounded base64");
@@ -90161,14 +89589,13 @@ function decodeBase64(data) {
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var MAXIMUM_ENCODED_CONTENT_CHARACTERS, MAXIMUM_REASONING_CHUNK_BYTES, embeddedImageSchema, inlineImageUrlSchema, toolImageSchema, AcpContentExternalizer;
+var MAXIMUM_ENCODED_CONTENT_CHARACTERS, embeddedImageSchema, inlineImageUrlSchema, toolImageSchema, AcpContentExternalizer;
 var init_content_externalizer = __esm({
   "src/acp/content/content-externalizer.ts"() {
     "use strict";
     init_zod();
     init_raster();
     MAXIMUM_ENCODED_CONTENT_CHARACTERS = 4e6;
-    MAXIMUM_REASONING_CHUNK_BYTES = 24 * 1024;
     embeddedImageSchema = external_exports.looseObject({
       type: external_exports.literal("image"),
       data: external_exports.string(),
@@ -90351,24 +89778,7 @@ var init_content_externalizer = __esm({
       }
       update = async (sessionId, update, signal) => {
         switch (update.sessionUpdate) {
-          case "agent_thought_chunk": {
-            if (update.content.type === "text") {
-              const text2 = reasoningTail(update.content.text);
-              const bounded2 = { ...update, content: { ...update.content, text: text2 } };
-              return {
-                agent: bounded2,
-                event: {
-                  ...bounded2,
-                  ...text2 === update.content.text ? {} : { meta: { truncated: true } }
-                }
-              };
-            }
-            const content = await this.#content(sessionId, update.content, signal);
-            return {
-              agent: { ...update, content: content.agent },
-              event: { ...update, content: content.event }
-            };
-          }
+          case "agent_thought_chunk":
           case "user_message_chunk":
           case "agent_message_chunk":
           case "compaction_summary_chunk": {
@@ -90565,7 +89975,7 @@ var init_node_error = __esm({
 });
 
 // src/storage/installation/installation-files.ts
-import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir4, open as open5, readdir as readdir5, rename as rename3, unlink as unlink3, writeFile } from "node:fs/promises";
 import { dirname as dirname9, join as join23 } from "node:path";
 function applicationDirectory(root, applicationId) {
@@ -90584,7 +89994,7 @@ function connectionFilePath(connectionDirectory2, connectionId2) {
   return join23(connectionDirectory2, `${connectionId2}.json`);
 }
 function channelIndexFilePath(installationDirectory2, channelId) {
-  return join23(installationDirectory2, "channels", `mci_${createHash4("sha256").update(channelId).digest("hex")}.json`);
+  return join23(installationDirectory2, "channels", `mci_${createHash5("sha256").update(channelId).digest("hex")}.json`);
 }
 async function readInstallationFile(path8) {
   let handle;
@@ -91276,10 +90686,10 @@ var init_control_token = __esm({
 });
 
 // src/daemon/control/local-client.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { createConnection } from "node:net";
 function controlSocketPath(stateDirectory, endpoint = "manager") {
-  const installationHash = createHash5("sha256").update(endpoint === "manager" ? stateDirectory : `${stateDirectory}:worker`).digest("hex").slice(0, 32);
+  const installationHash = createHash6("sha256").update(endpoint === "manager" ? stateDirectory : `${stateDirectory}:worker`).digest("hex").slice(0, 32);
   return managerPlatform.controlSocketPath(installationHash);
 }
 async function readSocketMessage(socket, signal) {
@@ -92360,7 +91770,7 @@ var init_worker_lifecycle_log = __esm({
 });
 
 // src/daemon/lifecycle/worker-process.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { isAbsolute as isAbsolute14 } from "node:path";
 async function decodeWorkerLaunch(value) {
   const { entry, executable, version: version2 } = workerLaunch.parse(value);
@@ -92409,7 +91819,7 @@ var init_worker_process = __esm({
       constructor(launch, signal, environment) {
         signal.throwIfAborted();
         this.launch = launch;
-        this.#child = spawn9(launch.executable, [launch.entry, "__worker"], {
+        this.#child = spawn8(launch.executable, [launch.entry, "__worker"], {
           env: environment,
           windowsHide: true,
           stdio: ["ignore", "pipe", "pipe", "ipc"]
@@ -92927,9 +92337,9 @@ var init_package2 = __esm({
 });
 
 // src/daemon/lifecycle/manager-client.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 async function spawnManager(launch) {
-  const child = spawn10(launch.executable, [launch.entry, "__manager"], {
+  const child = spawn9(launch.executable, [launch.entry, "__manager"], {
     detached: true,
     windowsHide: true,
     env: process.env,
@@ -96780,7 +96190,7 @@ var init_prompt_lifecycle = __esm({
 });
 
 // src/session/turn/execution-receipts.ts
-import { createHash as createHash6, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID13 } from "node:crypto";
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
 }
@@ -96902,7 +96312,7 @@ var init_execution_receipts = __esm({
         ];
       });
       claimExecution = (commandId, sessionId, commandJson) => {
-        const commandHash = createHash6("sha256").update(commandJson).digest("hex");
+        const commandHash = createHash7("sha256").update(commandJson).digest("hex");
         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") {
@@ -97284,9 +96694,9 @@ var init_session_turns = __esm({
       #bySessionId = /* @__PURE__ */ new Map();
       #operations;
       #activity;
-      constructor(operations, activity2 = new RuntimeTurnActivity()) {
+      constructor(operations, activity = new RuntimeTurnActivity()) {
         this.#operations = operations;
-        this.#activity = activity2;
+        this.#activity = activity;
       }
       acceptsPrompts = () => this.#activity.acceptsPrompts();
       session = (sessionId) => {
@@ -97728,7 +97138,7 @@ var init_scratch_directory = __esm({
 });
 
 // src/session/content/external-content-store.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { join as join34 } from "node:path";
 var contentRequest, CONTENT_LIFETIME_MILLISECONDS, metadataSchema, LocalExternalContentStore;
 var init_external_content_store = __esm({
@@ -97785,7 +97195,7 @@ var init_external_content_store = __esm({
         const active = AbortSignal.any([signal, this.#lifetime.signal]);
         active.throwIfAborted();
         const metadata = metadataSchema.parse({ kind, mediaType, name: name2 });
-        const key = createHash7("sha256").update(bytes).digest("hex");
+        const key = createHash8("sha256").update(bytes).digest("hex");
         const request = `mobius-content:${kind}:${key}`;
         const existing = this.#entries.get(request);
         if (existing !== void 0 && existing.expiresAt > Date.now()) {
@@ -98703,7 +98113,7 @@ var init_agent_settings_adapter = __esm({
 });
 
 // src/session/settings/discover-agent-settings.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function agentSettingsFailureDetails(agentId, failure2) {
   const details = { agentId, code: operationErrorCode(failure2) };
   return failure2 instanceof AcpConfigurationValueUnavailableError ? {
@@ -98968,7 +98378,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
     unsupportedModelIds: modelEffort.unsupportedModelIds,
     valuesByModel: {}
   };
-  return createHash8("sha256").update(
+  return createHash9("sha256").update(
     JSON.stringify({
       adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
       agentId: agent.id,
@@ -99327,35 +98737,7 @@ var init_resolve_session_directories = __esm({
 });
 
 // src/runtime/command/registry/history.ts
-function isAgentReasoning(event) {
-  return event?.type === "acp" && event.payload.sessionUpdate === "agent_thought_chunk";
-}
-function omitAgentReasoning(events) {
-  const retained = [];
-  let previousReasoningMessageId;
-  for (const positioned of events) {
-    const { event } = positioned;
-    if (event.type !== "acp" || event.payload.sessionUpdate !== "agent_thought_chunk") {
-      previousReasoningMessageId = void 0;
-      retained.push(positioned);
-      continue;
-    }
-    const messageId = event.payload.messageId ?? null;
-    if (previousReasoningMessageId === void 0 || previousReasoningMessageId !== messageId) {
-      retained.push({
-        ...positioned,
-        event: {
-          ...event,
-          mobiusMetadata: { omitted: true },
-          payload: { ...event.payload, content: { text: "", type: "text" } }
-        }
-      });
-    }
-    previousReasoningMessageId = messageId;
-  }
-  return retained;
-}
-async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoning, queuedPromptRequests, load) {
+async function loadHistoryPage(sessionId, eventLimit, initialCursor, queuedPromptRequests, load) {
   let cursor = initialCursor;
   let loaded = [];
   let sessionGenerationId = null;
@@ -99382,9 +98764,7 @@ async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoni
     });
     loaded = [...events, ...loaded];
     sourceNextCursor = replay.nextCursor;
-    const visible2 = omitReasoning ? omitAgentReasoning(loaded) : loaded;
-    const reasoningContinuesBeforePage = sourceNextCursor !== null && isAgentReasoning(loaded[0]?.event);
-    if (visible2.length >= eventLimit && !reasoningContinuesBeforePage) {
+    if (loaded.length >= eventLimit) {
       break;
     }
     cursor = sourceNextCursor;
@@ -99392,8 +98772,7 @@ async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoni
   if (sessionGenerationId === null || throughPosition === null) {
     throw new SessionError("session_history_unavailable", "The Session history is unavailable");
   }
-  const visible = omitReasoning ? omitAgentReasoning(loaded) : loaded;
-  const orderedEvents = visible.slice(-eventLimit);
+  const orderedEvents = loaded.slice(-eventLimit);
   const nextCursor = orderedEvents[0]?.cursor ?? null;
   return {
     events: {
@@ -99435,7 +98814,6 @@ async function executeSessionHistoryPageLoad(socket, command, config2, resolveAg
       command.sessionId,
       command.eventLimit,
       command.cursor,
-      command.omit?.includes("agent-reasoning") === true,
       recovery.queuedPromptRequests,
       async (eventLimit, cursor) => await sessions.loadSessionEvents(loadOptions, eventLimit, cursor)
     );
@@ -99482,7 +98860,6 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, re
       command.sessionId,
       command.eventLimit,
       command.cursor,
-      command.omit?.includes("agent-reasoning") === true,
       [],
       async (eventLimit, cursor) => await sessions.previewNativeSessionEvents(loadOptions, command.sessionId, eventLimit, cursor)
     );
@@ -99510,7 +98887,7 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, re
   }
 }
 var sessionHistoryPageLoadCommand, previewHistoryPageLoadCommand;
-var init_history2 = __esm({
+var init_history3 = __esm({
   "src/runtime/command/registry/history.ts"() {
     "use strict";
     init_protocol();
@@ -100277,7 +99654,7 @@ var init_execute_prompt = __esm({
 });
 
 // src/runtime/relay/artifact-download.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { fetch as fetch4 } from "undici";
 function downloadUrl(config2, artifact) {
   const url2 = relayHttpEndpoint(config2.relayUrl);
@@ -100364,7 +99741,7 @@ async function downloadPromptArtifact(config2, artifact, signal) {
       );
     }
     const bytes = await responseBytes(response, artifact.byteLength, requestSignal);
-    if (createHash9("sha256").update(bytes).digest("hex") !== artifact.sha256) {
+    if (createHash10("sha256").update(bytes).digest("hex") !== artifact.sha256) {
       throw new PromptArtifactError(
         "artifact_integrity_failed",
         "The prompt artifact failed integrity validation"
@@ -100924,7 +100301,7 @@ var init_registry2 = __esm({
     init_agent_catalog();
     init_agent_settings();
     init_file_read();
-    init_history2();
+    init_history3();
     init_interactions2();
     init_native_sessions();
     init_prompt2();
@@ -101963,11 +101340,11 @@ async function reportDaemonUpgradeAvailability(send2, signal) {
     send2({ ...base, kind: "runtime.upgrade.result", outcome: { status: "succeeded" } });
   }
 }
-async function runDaemonReleaseUpgrades(signal, activity2) {
+async function runDaemonReleaseUpgrades(signal, activity) {
   try {
     for await (const _tick of setInterval2(36e5, void 0, { signal })) {
       try {
-        await checkDaemonReleaseUpgrade(signal, activity2);
+        await checkDaemonReleaseUpgrade(signal, activity);
       } catch (cause) {
         signal.throwIfAborted();
         console.error("Daemon npm upgrade check failed", cause);
@@ -102029,7 +101406,7 @@ async function awaitDaemonReleaseSwitch(stateDirectory, id, signal) {
   }
   return outcome;
 }
-async function checkDaemonReleaseUpgrade(signal, activity2) {
+async function checkDaemonReleaseUpgrade(signal, activity) {
   var _stack = [];
   try {
     const control = await openMobiusControlInstallation(signal, process.env);
@@ -102042,17 +101419,17 @@ async function checkDaemonReleaseUpgrade(signal, activity2) {
       return;
     }
     const launch = await installDaemonReleaseVersion(version2, signal);
-    if (activity2.count() > 0) {
+    if (activity.count() > 0) {
       new RuntimeDiagnosticLog(control.stateDirectory).record(
         `Mobius daemon diagnostic ${JSON.stringify({
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           event: "daemon_upgrade_deferred",
           version: version2,
-          activeTurns: activity2.count()
+          activeTurns: activity.count()
         })}`
       );
     }
-    const _reservation = __using(_stack, await activity2.reserveWhenIdle(signal));
+    const _reservation = __using(_stack, await activity.reserveWhenIdle(signal));
     signal.throwIfAborted();
     await requestInstalledDaemonReleaseSwitch(control.stateDirectory, launch, signal);
     await new Promise((resolve19) => {