@moxt-ai/mobius 0.0.307 → 0.0.308

package/dist/runtime.js

@@ -21783,8 +21783,6 @@ function encodeSessionPromptDispositionCommand(message) {
 var NATIVE_SESSION_REQUEST_KIND = "native.session.request";
 var NATIVE_SESSION_RESULT_KIND = "native.session.result";
 var NATIVE_SESSION_CANCEL_KIND = "native.session.cancel";
-var SESSION_HISTORY_CHARACTER_LIMIT = 256e3;
-var SESSION_HISTORY_MESSAGE_LIMIT = 1e3;
 var envelope = {
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
@@ -22247,6 +22245,7 @@ var sessionEventOmissionSchema = external_exports.literal("agent-reasoning");
 var 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();
 var queuedPromptRequestEventLogSchema = external_exports.object({
@@ -22294,6 +22293,7 @@ var SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND = "session.preview-history.page.loa
 var 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
@@ -22691,7 +22691,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var 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: {
@@ -62173,11 +62173,11 @@ var SessionModeManager = class {
     }
     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);
     }
   }
 };
@@ -66838,6 +66838,9 @@ import {
   PROTOCOL_VERSION
 } from "@agentclientprotocol/sdk";
 
+// src/acp/harness/codex/app-server-client.ts
+import { spawn as spawn4 } from "node:child_process";
+
 // src/infra/operation-error.ts
 var OperationError = class extends Error {
   code;
@@ -66875,9 +66878,6 @@ var AcpConfigurationValueUnavailableError = class extends AcpExecutionError {
   }
 };
 
-// src/acp/harness/codex/app-server-client.ts
-import { spawn as spawn4 } from "node:child_process";
-
 // src/acp/agent/in-process-endpoint.ts
 function acpEndpointTerminationError(termination) {
   switch (termination.kind) {
@@ -67129,6 +67129,7 @@ var threadStartResponseSchema = external_exports.object({
 var 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)
 });
 var threadTurnsSchema = external_exports.array(threadTurnSchema).max(1e5);
@@ -67596,12 +67597,12 @@ function presentToolItem(item) {
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn9 = item.tool === "spawnAgent";
+    const spawn8 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn9 ? {
+      rawInput: spawn8 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -67609,10 +67610,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn9 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn8 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn9 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn8 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -67922,6 +67923,277 @@ var CodexBorrowedAcpAgent = class {
   };
 };
 
+// src/acp/harness/codex/history.ts
+import { createHash } from "node:crypto";
+
+// src/acp/content/raster.ts
+import { basename as basename4, isAbsolute as isAbsolute9, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// 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(path7) {
+  return await realpath6(path7);
+}
+async function readPathMetadata(path7) {
+  const metadata = await stat5(path7);
+  return {
+    kind: metadata.isDirectory() ? "directory" : metadata.isFile() ? "file" : "other",
+    modifiedAt: metadata.mtime,
+    modifiedMilliseconds: metadata.mtimeMs,
+    size: metadata.size
+  };
+}
+async function listDirectory(path7) {
+  const entries = await readdir4(path7, { withFileTypes: true });
+  return entries.map((entry) => ({ kind: entryKind(entry), name: entry.name }));
+}
+async function ensurePrivateDirectory(path7) {
+  await mkdir3(path7, { mode: 448, recursive: true });
+}
+async function ensureCanonicalDirectory(path7) {
+  await ensurePrivateDirectory(path7);
+  const resolved = await realpath6(path7);
+  return (await stat5(resolved)).isDirectory() ? resolved : null;
+}
+async function readFileStart(path7, byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  const handle = await open4(path7, "r");
+  try {
+    await handle.read(bytes, 0, byteLength, 0);
+  } finally {
+    await handle.close();
+  }
+  return bytes;
+}
+async function readFileBytes(path7) {
+  return await readFile5(path7);
+}
+function readFileChunks(path7, chunkBytes, signal) {
+  return createReadStream2(path7, { highWaterMark: chunkBytes, signal });
+}
+
+// src/acp/content/raster.ts
+var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
+var PNG_SIGNATURE = Uint8Array.of(137, 80, 78, 71);
+var JPEG_SIGNATURE = Uint8Array.of(255, 216, 255);
+var GIF87_SIGNATURE = new TextEncoder().encode("GIF87a");
+var GIF89_SIGNATURE = new TextEncoder().encode("GIF89a");
+var RIFF_SIGNATURE = new TextEncoder().encode("RIFF");
+var WEBP_SIGNATURE = new TextEncoder().encode("WEBP");
+var 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");
+};
+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);
+}
+
+// src/acp/native-history/codex/history-images.ts
+var IMAGE_MARKER = /\[@image\]\(([^)\r\n]*)(?:\)|$)/g;
+var DATA_IMAGE_HEADER = /^data:(image\/[a-z+]+);base64,/;
+var BASE_64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var SESSION_HISTORY_IMAGE_CHARACTER_LIMIT = 4e6;
+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)}`;
+}
+
 // src/acp/harness/codex/owned-agent.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
@@ -68574,6 +68846,115 @@ var CodexOwnedAcpAgent = class {
   };
 };
 
+// src/acp/harness/codex/history.ts
+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;
+  }
+}
+
 // src/acp/harness/codex/settings.ts
 var APPROVAL_TIMEOUT_MILLISECONDS2 = 36e5;
 var MODEL_SETTING_ID = "model";
@@ -69240,83 +69621,7 @@ var CodexAcpAgent = class {
   // 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
@@ -69364,7 +69669,7 @@ var CodexAgentSpecification = class extends InProcessAcpAgentSpecification {
 };
 
 // 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
@@ -69377,7 +69682,7 @@ import { agent as createAgentApp2, methods as methods5 } from "@agentclientproto
 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 realpathSync4, statSync as statSync4, 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";
 
 // src/acp/harness/pi/upstream/dist/pi-rpc/process.js
@@ -69893,7 +70198,7 @@ function toAvailableCommandsFromPiGetCommands(data, opts) {
 
 // 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 statSync3 } 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";
 var DEFAULT_TAIL_BYTES = 256 * 1024;
 var DEFAULT_HEAD_BYTES = 64 * 1024;
 function getPiAgentDir(environment) {
@@ -69915,7 +70220,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;
   }
@@ -70286,7 +70591,7 @@ function getQuietStartup(cwd, environment = process.env) {
 // 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";
 
 // src/acp/harness/pi/upstream/dist/acp/extension-questions.js
@@ -70819,7 +71124,7 @@ function toToolCallLocations(args, cwd, line) {
   if (!path7) {
     return void 0;
   }
-  const resolvedPath = isAbsolute10(path7) ? path7 : resolvePath(cwd, path7);
+  const resolvedPath = isAbsolute11(path7) ? path7 : resolvePath(cwd, path7);
   return [{ path: resolvedPath, ...typeof line === "number" ? { line } : {} }];
 }
 var SessionManager = class {
@@ -71359,7 +71664,7 @@ var PiAcpSession = class {
           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") {
@@ -71442,7 +71747,7 @@ var PiAcpSession = class {
         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;
@@ -71836,7 +72141,7 @@ var PiAcpAgent = class {
     };
   }
   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;
@@ -72433,7 +72738,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);
@@ -72499,7 +72804,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);
@@ -72570,7 +72875,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);
@@ -73064,7 +73369,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 {
   }
@@ -73244,7 +73549,7 @@ var PiAgentSpecification = class extends InProcessAcpAgentSpecification {
   // 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",
@@ -73760,11 +74065,11 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // 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);
@@ -74272,8 +74577,27 @@ var AdapterRegistry = class {
 import { randomUUID as randomUUID8 } from "node:crypto";
 
 // src/session/history/session-event-history-projection.ts
+var MAXIMUM_PROJECTED_REASONING_BYTES = 24 * 1024;
+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) {
@@ -74324,11 +74648,11 @@ 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 };
 }
@@ -75792,12 +76116,30 @@ function sessionConfigProtocolForAgent(_agentId) {
 }
 
 // src/acp/adapter/session-events.ts
+var MAXIMUM_REASONING_UPDATE_CHARACTERS = 1e6;
+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 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();
@@ -75805,58 +76147,60 @@ var AdapterSessionConnection = class {
         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: truncate(command.description, 500),
-              inputHint: truncate(command.input?.hint ?? "", 255),
-              name: truncate(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: truncate(update.title ?? "", 500) });
-          }
-          if (Object.hasOwn(update, "updatedAt")) {
-            changes.push({ kind: "updated-at", value: truncate(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: truncate(command.description, 500),
+                inputHint: truncate(command.input?.hint ?? "", 255),
+                name: truncate(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: truncate(update.title ?? "", 500) });
+            }
+            if (Object.hasOwn(update, "updatedAt")) {
+              changes.push({ kind: "updated-at", value: truncate(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 = {
@@ -75903,10 +76247,12 @@ var AdapterSessionConnection = class {
 };
 var 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(
@@ -75924,7 +76270,8 @@ var AcpSessionConnector = class {
           onElicitationComplete: rejectInteraction
         }
       },
-      this.#externalizer
+      this.#externalizer,
+      this.#normalizeEvent
     );
   };
 };
@@ -75944,1042 +76291,8 @@ var ClaudeAdapter = class {
   close = async () => await this.#queryProcesses.close();
 };
 
-// src/acp/native-history/codex/codex-history.ts
-import { spawn as spawn8 } from "node:child_process";
-
-// src/acp/content/raster.ts
-import { basename as basename5, isAbsolute as isAbsolute13, normalize } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// 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(path7) {
-  return await realpath6(path7);
-}
-async function readPathMetadata(path7) {
-  const metadata = await stat5(path7);
-  return {
-    kind: metadata.isDirectory() ? "directory" : metadata.isFile() ? "file" : "other",
-    modifiedAt: metadata.mtime,
-    modifiedMilliseconds: metadata.mtimeMs,
-    size: metadata.size
-  };
-}
-async function listDirectory(path7) {
-  const entries = await readdir4(path7, { withFileTypes: true });
-  return entries.map((entry) => ({ kind: entryKind(entry), name: entry.name }));
-}
-async function ensurePrivateDirectory(path7) {
-  await mkdir3(path7, { mode: 448, recursive: true });
-}
-async function ensureCanonicalDirectory(path7) {
-  await ensurePrivateDirectory(path7);
-  const resolved = await realpath6(path7);
-  return (await stat5(resolved)).isDirectory() ? resolved : null;
-}
-async function readFileStart(path7, byteLength) {
-  const bytes = new Uint8Array(byteLength);
-  const handle = await open4(path7, "r");
-  try {
-    await handle.read(bytes, 0, byteLength, 0);
-  } finally {
-    await handle.close();
-  }
-  return bytes;
-}
-async function readFileBytes(path7) {
-  return await readFile5(path7);
-}
-function readFileChunks(path7, chunkBytes, signal) {
-  return createReadStream2(path7, { highWaterMark: chunkBytes, signal });
-}
-
-// src/acp/content/raster.ts
-var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
-var PNG_SIGNATURE = Uint8Array.of(137, 80, 78, 71);
-var JPEG_SIGNATURE = Uint8Array.of(255, 216, 255);
-var GIF87_SIGNATURE = new TextEncoder().encode("GIF87a");
-var GIF89_SIGNATURE = new TextEncoder().encode("GIF89a");
-var RIFF_SIGNATURE = new TextEncoder().encode("RIFF");
-var WEBP_SIGNATURE = new TextEncoder().encode("WEBP");
-var 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");
-};
-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);
-}
-
-// src/acp/native-history/codex/history-images.ts
-var IMAGE_MARKER = /\[@image\]\(([^)\r\n]*)(?:\)|$)/g;
-var DATA_IMAGE_HEADER = /^data:(image\/[a-z+]+);base64,/;
-var BASE_64 = /^[A-Za-z0-9+/]*={0,2}$/;
-var SESSION_HISTORY_IMAGE_CHARACTER_LIMIT = 4e6;
-var SESSION_HISTORY_PREVIEW_TURN_LIMIT = 10;
-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)}`;
-}
-
-// src/acp/native-history/codex/codex-history.ts
-var 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() })
-]);
-var threadSchema = external_exports.object({
-  thread: external_exports.object({
-    id: nativeSessionIdSchema,
-    cwd: external_exports.string().min(1).max(2048).refine((path7) => !path7.includes("\0"))
-  })
-});
-var 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()
-});
-var itemTypeSchema = external_exports.object({ type: external_exports.string().min(1).max(80) });
-var userMessageSchema = external_exports.object({
-  content: external_exports.array(external_exports.unknown()).max(1e4),
-  type: external_exports.literal("userMessage")
-});
-var textSchema = external_exports.object({ text: external_exports.string() });
-var imageSchema = external_exports.object({ url: external_exports.string() });
-var agentMessageSchema = textSchema.extend({
-  id: external_exports.string().optional(),
-  phase: external_exports.string().nullish(),
-  type: external_exports.literal("agentMessage")
-});
-var 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")
-});
-var 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")
-});
-var 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")
-});
-var 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")
-});
-var 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")
-});
-var planSchema = external_exports.object({ id: external_exports.string(), text: external_exports.string(), type: external_exports.literal("plan") });
-var historyItemSchema = external_exports.discriminatedUnion("type", [
-  userMessageSchema,
-  agentMessageSchema,
-  reasoningSchema,
-  commandExecutionSchema,
-  fileChangeSchema,
-  mcpToolCallSchema,
-  dynamicToolCallSchema,
-  planSchema
-]);
-var CodexHistoryResponseError = class extends Error {
-  code;
-  constructor(response) {
-    super(response.message);
-    this.code = response.code;
-    this.name = "CodexHistoryResponseError";
-  }
-};
-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(path7, newText) {
-  return { newText, path: path7, type: "diff" };
-}
-function messageSize(message) {
-  return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
-}
-var SESSION_HISTORY_MESSAGE_CHARACTER_LIMIT = Math.floor(SESSION_HISTORY_CHARACTER_LIMIT / 2);
-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 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((path7) => ({ path: path7 })),
-      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);
-}
+// src/acp/adapter/codex/adapter.ts
+import { createHash as createHash4 } from "node:crypto";
 
 // src/storage/session/temporary-session-event-cache.ts
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
@@ -82189,13 +81502,85 @@ function openPreviewEventCache() {
   }
 }
 
+// src/acp/adapter/codex/tool-event.ts
+var toolEventSchema = external_exports.looseObject({
+  sessionUpdate: external_exports.enum(["tool_call", "tool_call_update"]),
+  rawInput: external_exports.unknown().optional(),
+  rawOutput: external_exports.unknown().optional()
+});
+var TRUNCATED_TOOL_PAYLOAD_CHARACTER_LIMIT = 32768;
+var MAX_TOOL_PAYLOAD_DEPTH = 16;
+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)
+  };
+}
+
 // src/acp/adapter/codex/adapter.ts
 var 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);
@@ -82209,21 +81594,73 @@ var CodexAdapter = class {
     }
   };
   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);
   };
 };
 
@@ -82262,18 +81699,6 @@ var harnessAdapters = (agent, dependencies) => {
 
 // src/acp/content/content-externalizer.ts
 var MAXIMUM_ENCODED_CONTENT_CHARACTERS = 4e6;
-var MAXIMUM_REASONING_CHUNK_BYTES = 24 * 1024;
-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");
@@ -82469,24 +81894,7 @@ var AcpContentExternalizer = class {
   }
   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": {
@@ -82648,7 +82056,7 @@ import { randomUUID as randomUUID10 } from "node:crypto";
 import { resolve as resolve14 } from "node:path";
 
 // 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";
 
@@ -82675,7 +82083,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(path7) {
   let handle;
@@ -86984,7 +86392,7 @@ async function settleAbandonedTurn(projection, operations, cancellation) {
 }
 
 // src/session/turn/execution-receipts.ts
-import { createHash as createHash5, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID12 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
@@ -87100,7 +86508,7 @@ var ExecutionReceipts = class {
     ];
   });
   claimExecution = (commandId, sessionId, commandJson) => {
-    const commandHash = createHash5("sha256").update(commandJson).digest("hex");
+    const commandHash = createHash6("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") {
@@ -87453,9 +86861,9 @@ var SessionTurns = class {
   #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) => {
@@ -87788,7 +87196,7 @@ function buildSessionLayer(options) {
 }
 
 // src/session/content/external-content-store.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { join as join27 } from "node:path";
 
 // src/storage/files/scratch-directory.ts
@@ -87912,7 +87320,7 @@ var LocalExternalContentStore = class {
     const active = AbortSignal.any([signal, this.#lifetime.signal]);
     active.throwIfAborted();
     const metadata = metadataSchema.parse({ kind, mediaType, name: name2 });
-    const key = createHash6("sha256").update(bytes).digest("hex");
+    const key = createHash7("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()) {
@@ -88777,7 +88185,7 @@ var SessionError = class extends OperationError {
 };
 
 // src/session/settings/discover-agent-settings.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // src/agent/settings/agent-settings-base.ts
 var AgentSettingsLaunchSelectionResult = class {
@@ -89095,7 +88503,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
     unsupportedModelIds: modelEffort.unsupportedModelIds,
     valuesByModel: {}
   };
-  return createHash7("sha256").update(
+  return createHash8("sha256").update(
     JSON.stringify({
       adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
       agentId: agent.id,
@@ -89404,35 +88812,7 @@ async function resolveSessionDirectories(directories, bindingId, directoryId, ad
 }
 
 // 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;
@@ -89459,9 +88839,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;
@@ -89469,8 +88847,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: {
@@ -89512,7 +88889,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)
     );
@@ -89559,7 +88935,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)
     );
@@ -90292,7 +89667,7 @@ async function executePrompt({
 }
 
 // src/runtime/relay/artifact-download.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { fetch as fetch4 } from "undici";
 var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
 function downloadUrl(config2, artifact) {
@@ -90380,7 +89755,7 @@ async function downloadPromptArtifact(config2, artifact, signal) {
       );
     }
     const bytes = await responseBytes(response, artifact.byteLength, requestSignal);
-    if (createHash8("sha256").update(bytes).digest("hex") !== artifact.sha256) {
+    if (createHash9("sha256").update(bytes).digest("hex") !== artifact.sha256) {
       throw new PromptArtifactError(
         "artifact_integrity_failed",
         "The prompt artifact failed integrity validation"