@ycodium-ai/agent-codex 0.2.3369 → 0.2.3389

package/dist/index.js

@@ -435,321 +435,1188 @@ var probeCodexAccount = (accountPath) => {
   };
 };
 
-// src/codexInstance.ts
+// src/liveHistory.ts
+import * as NodeFSP4 from "node:fs/promises";
+import * as NodePath7 from "node:path";
 import * as NodeProcess from "node:process";
-import {
-  describeExecutorSpawnFailure,
-  ExecutorSpawnRefusedError as ExecutorSpawnRefusedError2,
-  raceAbort as raceAbort2
-} from "@ycodium-ai/plugin-api/executor";
-
-// src/appServerLaunch.ts
-import {
-  ExecutorSpawnAbortedError,
-  ExecutorSpawnRefusedError,
-  throwIfExecutorSpawnAborted
-} from "@ycodium-ai/plugin-api/executor";
-
-// src/connection.ts
-import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
-
-// src/config.ts
-import { modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
 
-// src/apiKeyEnv.ts
-var CODEX_INSTANCE_API_KEY_ENV = "YCODIUM_CODEX_API_KEY";
+// ../../packages/ycodium-jsonl-stream/src/historyErrors.ts
+var NativeHistoryCursorError = class extends Error {
+  name = "NativeHistoryCursorError";
+};
+var NativeHistoryPendingError = class extends Error {
+  name = "NativeHistoryPendingError";
+};
 
-// src/config.ts
-var CODEX_INSTANCE_MODEL_PROVIDER = "ycodium_api";
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString2(value) {
-  return typeof value === "string" ? value : "";
-}
-function readTrimmed(value) {
-  return readString2(value).trim();
-}
-function readAuthMode(value) {
-  return value === "chatgpt" || value === "apiKey" ? value : "default";
-}
-function readEnvironment(value) {
-  if (!Array.isArray(value)) return {};
-  const env = {};
-  for (const entry of value) {
-    if (!isRecord2(entry)) continue;
-    const name = readTrimmed(entry["name"]);
-    if (name.length === 0) continue;
-    env[name] = readString2(entry["value"]);
-  }
-  return env;
-}
-function parseCodexInstanceConfig(config) {
-  if (!isRecord2(config)) {
-    return {
-      binaryPath: "",
-      launchArgs: CODEX_DEFAULT_LAUNCH_ARGS,
-      homePath: "",
-      shadowHomePath: "",
-      homeEnvVar: "",
-      authMode: "default",
-      apiBaseUrl: "",
-      environment: {},
-      envelopeDriver: void 0
-    };
-  }
-  const nested = isRecord2(config["config"]) ? config["config"] : void 0;
-  const settings = nested ?? config;
-  return {
-    binaryPath: readTrimmed(settings["binaryPath"]),
-    launchArgs: readString2(settings["launchArgs"]) || CODEX_DEFAULT_LAUNCH_ARGS,
-    homePath: readTrimmed(settings["homePath"]) || readTrimmed(config["homePath"]),
-    shadowHomePath: readTrimmed(settings["shadowHomePath"]),
-    homeEnvVar: readTrimmed(settings["homeEnvVar"]) || readTrimmed(config["homeEnvVar"]),
-    authMode: readAuthMode(settings["authMode"]),
-    apiBaseUrl: readTrimmed(settings["apiBaseUrl"]),
-    environment: readEnvironment(config["environment"]),
-    envelopeDriver: readTrimmed(config["driver"]) || void 0
+// ../../packages/ycodium-jsonl-stream/src/historyWaiting.ts
+import * as NodeFS3 from "node:fs";
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodePath4 from "node:path";
+var pending = (error) => error instanceof NativeHistoryPendingError || error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+var waitForJsonlHistory = (input) => {
+  const controller = new AbortController();
+  const sources = /* @__PURE__ */ new Set();
+  const operations = /* @__PURE__ */ new Set();
+  const own = (promise) => {
+    operations.add(promise);
+    void promise.finally(() => operations.delete(promise)).catch(() => void 0);
+    return promise;
   };
-}
-function tokenizeLaunchArgs(value) {
-  const input = value.trim();
-  if (!input) return [];
-  const tokens = [];
-  let current = "";
-  let quote;
-  let quoted = false;
-  for (let index = 0; index < input.length; index++) {
-    const char = input[index];
-    if (char === void 0) continue;
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        quoted = true;
-      } else if (char === "\\" && quote === '"') {
-        const next = input[index + 1];
-        if (next !== void 0 && ['"', "\\", "$", "`"].includes(next)) {
-          current += next;
-          index++;
-        } else {
-          current += char;
+  const iterators = /* @__PURE__ */ new Set();
+  const open2 = () => own(
+    (async () => {
+      const signal = AbortSignal.any([
+        controller.signal,
+        ...input.signal ? [input.signal] : []
+      ]);
+      const source = await input.open(signal);
+      if (source === void 0) throw new NativeHistoryPendingError();
+      sources.add(source);
+      return source;
+    })()
+  );
+  const release = async (source) => {
+    await source.close();
+    sources.delete(source);
+  };
+  return {
+    page: (options) => own(
+      (async () => {
+        const source = await open2();
+        try {
+          return await source.page(options);
+        } finally {
+          await release(source);
         }
-      } else {
-        current += char;
-      }
-      continue;
+      })()
+    ),
+    follow: (options) => {
+      let iterator;
+      iterator = (async function* () {
+        const signal = AbortSignal.any([
+          controller.signal,
+          ...input.signal ? [input.signal] : [],
+          ...options.signal ? [options.signal] : []
+        ]);
+        let root = NodePath4.resolve(input.root);
+        while (true) {
+          try {
+            if ((await NodeFSP2.stat(root)).isDirectory()) break;
+          } catch (error2) {
+            if (!pending(error2)) throw error2;
+          }
+          const parent = NodePath4.dirname(root);
+          if (parent === root) throw new NativeHistoryPendingError();
+          root = parent;
+        }
+        let dirty = true;
+        let wake;
+        let error;
+        const notify = () => {
+          dirty = true;
+          wake?.();
+          wake = void 0;
+        };
+        const watcher = NodeFS3.watch(root, { recursive: true, signal }, (_event, name) => {
+          if (name == null || input.accepts(NodePath4.resolve(root, String(name)))) notify();
+        });
+        watcher.on("error", (cause) => {
+          error = cause;
+          notify();
+        });
+        signal.addEventListener("abort", notify, { once: true });
+        let announced = false;
+        try {
+          while (true) {
+            signal.throwIfAborted();
+            if (error !== void 0) throw error;
+            if (!dirty)
+              await new Promise((resolve4) => {
+                wake = resolve4;
+              });
+            signal.throwIfAborted();
+            dirty = false;
+            let source;
+            try {
+              source = await open2();
+            } catch (cause) {
+              if (!pending(cause)) throw cause;
+              if (!announced) {
+                announced = true;
+                yield { _tag: "unavailable", reason: "native-session-unavailable" };
+                yield { _tag: "synchronized" };
+              }
+              continue;
+            }
+            announced = false;
+            try {
+              for await (const frame of source.follow({ ...options, signal })) yield frame;
+            } catch (cause) {
+              if (!pending(cause)) throw cause;
+            } finally {
+              await release(source);
+            }
+          }
+        } finally {
+          watcher.close();
+          signal.removeEventListener("abort", notify);
+          wake?.();
+          if (iterator !== void 0) iterators.delete(iterator);
+        }
+      })();
+      iterators.add(iterator);
+      return iterator;
+    },
+    close: async () => {
+      controller.abort();
+      await Promise.all([...sources].map(release));
+      await Promise.all([...iterators].map((iterator) => iterator.return(void 0)));
+      await Promise.allSettled(operations);
     }
-    if (char === "'" || char === '"') {
-      quote = char;
-      quoted = true;
-    } else if (/\s/.test(char)) {
-      if (current || quoted) {
-        tokens.push(current);
-        current = "";
-        quoted = false;
-      }
-    } else if (char === "\\") {
-      const next = input[index + 1];
-      if (next !== void 0 && /\s/.test(next)) {
-        current += next;
-        index++;
-      } else {
-        current += char;
+  };
+};
+
+// ../../packages/ycodium-jsonl-stream/src/history.ts
+import * as NodeFS4 from "node:fs";
+import * as NodePath5 from "node:path";
+
+// ../../packages/ycodium-jsonl-stream/src/historyFile.ts
+import * as NodeFSP3 from "node:fs/promises";
+import * as NodeCrypto from "node:crypto";
+var HISTORY_READ_BYTES = 65536;
+async function* historyBytes(path, start, end, signal) {
+  const file = await NodeFSP3.open(path, "r");
+  try {
+    let offset = start;
+    while (offset < end) {
+      signal?.throwIfAborted();
+      const buffer = Buffer.allocUnsafe(Math.min(HISTORY_READ_BYTES, end - offset));
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, offset);
+      if (bytesRead === 0) throw new Error("Native history changed during a read.");
+      offset += bytesRead;
+      yield buffer.subarray(0, bytesRead);
+    }
+  } finally {
+    await file.close();
+  }
+}
+async function* historyText(path, range, signal) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  for await (const bytes of historyBytes(path, range.start, range.end, signal)) {
+    const text = decoder.decode(bytes, { stream: true });
+    if (text) yield text;
+  }
+  const last = decoder.decode();
+  if (last) yield last;
+}
+async function* historyLines(path, start, end, backwards, signal) {
+  if (!backwards) {
+    let lineStart = start;
+    let offset = start;
+    for await (const bytes of historyBytes(path, start, end, signal)) {
+      for (let index = 0; index < bytes.length; index += 1) {
+        if (bytes[index] !== 10) continue;
+        const lineEnd = offset + index;
+        if (lineEnd > lineStart)
+          yield { start: lineStart, end: lineEnd, commit: lineEnd + 1, terminated: true };
+        lineStart = lineEnd + 1;
       }
-    } else {
-      current += char;
+      offset += bytes.length;
     }
+    if (lineStart < end) yield { start: lineStart, end, commit: end, terminated: false };
+    return;
   }
-  if (current || quoted) tokens.push(current);
-  return tokens;
-}
-function encodeQuotedArgs(args) {
-  return args.map((arg) => `"${arg.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`).join(" ");
-}
-function codexExecLaunchArgs(launchArgs) {
-  const args = tokenizeLaunchArgs(launchArgs ?? "");
-  const execArgs = [];
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (arg === void 0) continue;
-    if (arg === "--strict-config" || arg.startsWith("--config=") || arg.startsWith("-c=")) {
-      execArgs.push(arg);
-    } else if (arg === "--config" || arg === "-c" || arg === "--enable" || arg === "--disable") {
-      const value = args[index + 1];
-      if (value !== void 0 && !value.startsWith("-")) {
-        execArgs.push(arg, value);
-        index++;
+  const file = await NodeFSP3.open(path, "r");
+  try {
+    let scan = end;
+    let lineEnd = end;
+    let terminated = false;
+    while (scan > start) {
+      signal?.throwIfAborted();
+      const from = Math.max(start, scan - HISTORY_READ_BYTES);
+      const buffer = Buffer.allocUnsafe(scan - from);
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, from);
+      if (bytesRead !== buffer.length) throw new Error("Native history changed during a read.");
+      for (let index = buffer.length - 1; index >= 0; index -= 1) {
+        if (buffer[index] !== 10) continue;
+        const at = from + index;
+        if (at + 1 < lineEnd)
+          yield { start: at + 1, end: lineEnd, commit: lineEnd + (terminated ? 1 : 0), terminated };
+        lineEnd = at;
+        terminated = true;
       }
-    } else if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
-      execArgs.push(arg);
+      scan = from;
     }
+    if (lineEnd > start)
+      yield { start, end: lineEnd, commit: lineEnd + (terminated ? 1 : 0), terminated };
+  } finally {
+    await file.close();
   }
-  return execArgs;
 }
-function codexMcpThreadConfig(servers) {
+var historyIdentity = async (path) => {
+  const stat4 = await NodeFSP3.stat(path);
   return {
-    mcp_servers: Object.fromEntries(
-      servers.map(({ name, transport }) => [
-        name,
-        transport.type === "stdio" ? { command: transport.command, args: transport.args ?? [], env: transport.env ?? {} } : { url: transport.url, http_headers: transport.headers ?? {} }
-      ])
-    )
+    size: stat4.size,
+    mtimeMs: stat4.mtimeMs,
+    ctimeMs: stat4.ctimeMs,
+    identity: NodeCrypto.createHash("sha256").update(`${path}/${stat4.dev}/${stat4.ino}/${stat4.birthtimeMs}`).digest("hex")
   };
-}
-function modelIdFromSelection(selection) {
-  if (typeof selection !== "object" || selection === null || Array.isArray(selection)) {
-    return void 0;
+};
+var historyCommittedFingerprint = async (path, sequence, signal) => {
+  const hash = NodeCrypto.createHash("sha256");
+  const starts = [
+    0,
+    Math.max(0, Math.floor(sequence / 3) - 512),
+    Math.max(0, Math.floor(sequence * 2 / 3) - 512),
+    Math.max(0, sequence - 1024)
+  ];
+  for (const start of new Set(starts)) {
+    const end = Math.min(sequence, start + 1024);
+    hash.update(`${start}:${end}:`);
+    for await (const bytes of historyBytes(path, start, end, signal)) hash.update(bytes);
   }
-  const model = selection["model"];
-  return typeof model === "string" ? model.trim() || void 0 : void 0;
-}
+  return hash.digest("hex");
+};
+var historyBoundary = async (path, identity, sequence, signal) => {
+  const hash = NodeCrypto.createHash("sha256");
+  for await (const bytes of historyBytes(path, Math.max(0, sequence - 128), sequence, signal))
+    hash.update(bytes);
+  hash.update(await historyCommittedFingerprint(path, sequence, signal));
+  return { epoch: `${identity}.${hash.digest("hex")}`, sequence };
+};
 
-// src/connection.ts
-function codexApiConnectionError(recipe, environment) {
-  if (recipe.authMode !== "apiKey") return null;
-  try {
-    const url = new URL(recipe.apiBaseUrl);
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      return "Codex API base URL must use HTTP or HTTPS.";
+// ../../packages/ycodium-jsonl-stream/src/historyRecord.ts
+import * as NodeCrypto2 from "node:crypto";
+
+// ../../packages/ycodium-jsonl-stream/src/jsonlStream.ts
+var DEFAULT_MAX_RETAINED_CHARS = 8e6;
+var MAX_DEPTH = 128;
+var MAX_KEY_CHARS = 256;
+var MAX_BARE_CHARS = 64;
+var NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+var OversizedRecordParser = class {
+  #fields;
+  #budget;
+  #options;
+  #retained = 0;
+  #malformed = false;
+  #done = false;
+  #result = void 0;
+  #stack = [];
+  // 词法状态。
+  #inString = false;
+  #stringIsKey = false;
+  #escape = false;
+  #unicodeLeft = 0;
+  #unicodeValue = 0;
+  #bare = "";
+  // 当前字符串的保留规则与累积。
+  #strObserver;
+  #strRetain = false;
+  #strCap = void 0;
+  #strHead = "";
+  #strTail = "";
+  #strLength = 0;
+  #key = "";
+  #keyOverflow = false;
+  // 值之间的位置。
+  #expectKey = false;
+  #expectColon = false;
+  #expectComma = false;
+  #expectValue = true;
+  constructor(fields2, maxRetainedChars = DEFAULT_MAX_RETAINED_CHARS, options) {
+    this.#fields = fields2;
+    this.#budget = maxRetainedChars;
+    this.#options = options;
+  }
+  write(chunk) {
+    if (this.#malformed) return;
+    try {
+      this.#consume(chunk);
+    } catch (cause) {
+      if (cause instanceof MalformedRecord) {
+        this.#malformed = true;
+        return;
+      }
+      throw cause;
     }
-  } catch {
-    return "Codex API base URL is missing or invalid.";
-  }
-  return environment[CODEX_INSTANCE_API_KEY_ENV]?.trim() ? null : "An API key is required for this Codex account.";
-}
-function connectionArgv(recipe, layout) {
-  const args = [...tokenizeLaunchArgs(recipe.launchArgs)];
-  const override = (key, value) => {
-    args.push("-c", `${key}=${JSON.stringify(value)}`);
-  };
-  if (layout.mode === "authOverlay" || recipe.authMode !== "default") {
-    override("sqlite_home", layout.sharedHomePath);
   }
-  if (layout.mode === "authOverlay") {
-    override("cli_auth_credentials_store", "file");
+  /** 完整且合法才返回记录；其余（含空行）返回 `undefined`。 */
+  finish() {
+    if (this.#malformed) return void 0;
+    try {
+      if (this.#bare.length > 0) this.#finishBare();
+    } catch (cause) {
+      if (cause instanceof MalformedRecord) return void 0;
+      throw cause;
+    }
+    if (!this.#done || this.#inString || this.#result === SKIPPED) return void 0;
+    return this.#result;
+  }
+  #fail() {
+    throw new MalformedRecord();
+  }
+  #charge(chars) {
+    this.#retained += chars;
+    if (this.#retained > this.#budget) this.#fail();
+  }
+  #consume(chunk) {
+    const n = chunk.length;
+    let i = 0;
+    while (i < n) {
+      if (this.#inString) {
+        i = this.#consumeString(chunk, i);
+        continue;
+      }
+      const c = chunk.charCodeAt(i);
+      if (this.#bare.length > 0) {
+        if (isBareChar(c)) {
+          if (this.#bare.length >= MAX_BARE_CHARS) this.#fail();
+          this.#bare += chunk[i];
+          i += 1;
+          continue;
+        }
+        this.#finishBare();
+      }
+      i += 1;
+      if (c === 32 || c === 9 || c === 10 || c === 13) continue;
+      if (this.#done) this.#fail();
+      switch (c) {
+        case 123:
+          this.#requireValue();
+          this.#openContainer(false);
+          break;
+        case 91:
+          this.#requireValue();
+          this.#openContainer(true);
+          break;
+        case 125:
+          this.#closeContainer(false);
+          break;
+        case 93:
+          this.#closeContainer(true);
+          break;
+        case 44:
+          this.#comma();
+          break;
+        case 58:
+          if (!this.#expectColon) this.#fail();
+          this.#expectColon = false;
+          this.#expectValue = true;
+          break;
+        case 34:
+          this.#openString();
+          break;
+        default:
+          if (isBareChar(c)) {
+            this.#requireValue();
+            this.#bare = chunk[i - 1] ?? "";
+          } else this.#fail();
+      }
+    }
   }
-  if (recipe.authMode === "chatgpt") {
-    override("model_provider", "openai");
-    override("forced_login_method", "chatgpt");
-  } else if (recipe.authMode === "apiKey") {
-    override("model_provider", CODEX_INSTANCE_MODEL_PROVIDER);
-    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.name`, "Ycodium API");
-    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.base_url`, recipe.apiBaseUrl);
-    override(
-      `model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.env_key`,
-      CODEX_INSTANCE_API_KEY_ENV
+  #top() {
+    return this.#stack[this.#stack.length - 1];
+  }
+  #requireValue() {
+    if (!this.#expectValue) this.#fail();
+    this.#expectValue = false;
+  }
+  /** 当前要读的值（刚要开始）落在什么模式；`isContainer` 决定 scalarOnly 清单项是否适用。 */
+  #childMode(isContainer) {
+    const parent = this.#top();
+    if (parent === void 0) return this.#classify([], isContainer);
+    if (parent.mode === "skip") return { mode: "skip", cap: void 0, path: [] };
+    if (parent.mode === "keep") return { mode: "keep", cap: parent.cap, path: [] };
+    const segment = parent.isArray ? String(parent.index) : parent.key ?? "";
+    if (parent.skipValue) return { mode: "skip", cap: void 0, path: [] };
+    return this.#classify([...parent.path, segment], isContainer);
+  }
+  #classify(path, isContainer) {
+    let descend = false;
+    for (const field of this.#fields) {
+      const fieldPath = field.path;
+      if (fieldPath.length <= path.length) {
+        if (field.scalarOnly === true && (isContainer || fieldPath.length !== path.length)) {
+          continue;
+        }
+        if (matchesPrefix(fieldPath, path, fieldPath.length)) {
+          return { mode: "keep", cap: field.maxChars, path };
+        }
+      } else if (matchesPrefix(fieldPath, path, path.length)) {
+        descend = true;
+      }
+    }
+    return { mode: descend ? "descend" : "skip", cap: void 0, path };
+  }
+  #openContainer(isArray2) {
+    if (this.#stack.length >= MAX_DEPTH) this.#fail();
+    const { mode, cap, path } = this.#childMode(true);
+    const keeping = mode !== "skip";
+    let target = null;
+    if (keeping) {
+      this.#charge(16);
+      target = isArray2 ? [] : {};
+    }
+    this.#stack.push({ isArray: isArray2, mode, path, cap, target, key: null, skipValue: false, index: 0 });
+    this.#expectValue = isArray2;
+    this.#expectKey = !isArray2;
+    this.#expectComma = false;
+    this.#expectColon = false;
+  }
+  #closeContainer(isArray2) {
+    const top = this.#top();
+    if (top === void 0 || top.isArray !== isArray2) this.#fail();
+    if (!this.#expectComma && top.index > 0) this.#fail();
+    if (this.#expectColon || !isArray2 && this.#expectValue) this.#fail();
+    this.#stack.pop();
+    this.#expectValue = false;
+    this.#expectKey = false;
+    this.#expectColon = false;
+    this.#expectComma = true;
+    const empty = top.target !== null && Object.keys(top.target).length === 0;
+    this.#store(
+      this.#options?.pruneEmpty && top.mode === "descend" && empty && this.#stack.length > 0 ? SKIPPED : top.target ?? SKIPPED
     );
-    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.requires_openai_auth`, false);
-    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.wire_api`, "responses");
   }
-  return args;
-}
-function codexSpawnArgs(recipe, layout) {
-  const needsOverrides = layout.mode === "authOverlay" || recipe.authMode !== "default";
-  if (!needsOverrides) return tokenizeLaunchArgs(recipe.launchArgs);
-  return connectionArgv(recipe, layout);
-}
-function encodeCodexConnectionArgs(recipe, layout) {
-  return encodeQuotedArgs(connectionArgv(recipe, layout));
-}
-var CRUSHED_API_KEYS = {
-  OPENAI_API_KEY: void 0,
-  CODEX_API_KEY: void 0
+  #comma() {
+    const top = this.#top();
+    if (top === void 0 || !this.#expectComma) this.#fail();
+    this.#expectComma = false;
+    if (top.isArray) {
+      this.#expectValue = true;
+    } else {
+      this.#expectKey = true;
+    }
+  }
+  /** 一个值读完：交给外层容器，或成为整条记录。 */
+  #store(value) {
+    const parent = this.#top();
+    if (parent === void 0) {
+      this.#result = value;
+      this.#done = true;
+      this.#expectComma = false;
+      return;
+    }
+    this.#expectComma = true;
+    if (parent.isArray) {
+      parent.index += 1;
+      if (parent.target !== null && value !== SKIPPED) {
+        parent.target.push(value);
+        this.#charge(8);
+      }
+      return;
+    }
+    parent.index += 1;
+    const key = parent.key;
+    parent.key = null;
+    parent.skipValue = false;
+    if (parent.target !== null && value !== SKIPPED && key !== null) {
+      Object.defineProperty(parent.target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+      this.#charge(key.length + 8);
+    }
+  }
+  #openString() {
+    const parent = this.#top();
+    const asKey = parent !== void 0 && !parent.isArray && this.#expectKey;
+    if (!asKey) this.#requireValue();
+    this.#inString = true;
+    this.#stringIsKey = asKey;
+    this.#escape = false;
+    this.#unicodeLeft = 0;
+    this.#strLength = 0;
+    this.#strHead = "";
+    this.#strTail = "";
+    this.#key = "";
+    if (asKey) {
+      this.#keyOverflow = false;
+      this.#strRetain = true;
+      this.#strCap = void 0;
+      return;
+    }
+    const { mode, cap, path } = this.#childMode(false);
+    this.#strObserver = this.#fields.find(
+      (field) => field.path.length === path.length && matchesPrefix(field.path, path, path.length)
+    );
+    this.#strRetain = mode === "keep" && this.#strObserver?.onChunk === void 0;
+    this.#strCap = cap;
+  }
+  /** 字符串里的一个解码后片段；按保留规则累积。 */
+  #append(text) {
+    if (text.length === 0) return;
+    if (this.#stringIsKey) {
+      if (this.#keyOverflow) return;
+      this.#key += text;
+      if (this.#key.length > MAX_KEY_CHARS) {
+        this.#keyOverflow = true;
+        this.#key = "";
+      }
+      return;
+    }
+    this.#strLength += text.length;
+    this.#strObserver?.onChunk?.(text);
+    if (!this.#strRetain) return;
+    const cap = this.#strCap;
+    if (cap === void 0) {
+      this.#strHead += text;
+      this.#charge(text.length);
+      return;
+    }
+    if (this.#strHead.length < cap) {
+      const room = cap - this.#strHead.length;
+      this.#strHead += text.slice(0, room);
+      text = text.slice(room);
+      if (text.length === 0) return;
+    }
+    this.#strTail += text;
+    if (this.#strTail.length > cap * 2) this.#strTail = this.#strTail.slice(-cap);
+  }
+  #consumeString(chunk, start) {
+    const n = chunk.length;
+    let i = start;
+    while (i < n) {
+      if (this.#unicodeLeft > 0) {
+        const digit = hexValue(chunk.charCodeAt(i));
+        if (digit < 0) this.#fail();
+        this.#unicodeValue = this.#unicodeValue * 16 + digit;
+        this.#unicodeLeft -= 1;
+        i += 1;
+        if (this.#unicodeLeft === 0) this.#append(String.fromCharCode(this.#unicodeValue));
+        continue;
+      }
+      if (this.#escape) {
+        this.#escape = false;
+        const c2 = chunk[i] ?? "";
+        i += 1;
+        switch (c2) {
+          case '"':
+          case "\\":
+          case "/":
+            this.#append(c2);
+            break;
+          case "b":
+            this.#append("\b");
+            break;
+          case "f":
+            this.#append("\f");
+            break;
+          case "n":
+            this.#append("\n");
+            break;
+          case "r":
+            this.#append("\r");
+            break;
+          case "t":
+            this.#append("	");
+            break;
+          case "u":
+            this.#unicodeLeft = 4;
+            this.#unicodeValue = 0;
+            break;
+          default:
+            this.#fail();
+        }
+        continue;
+      }
+      const runStart = i;
+      while (i < n) {
+        const c2 = chunk.charCodeAt(i);
+        if (c2 === 34 || c2 === 92 || c2 < 32) break;
+        i += 1;
+      }
+      if (i > runStart) this.#append(chunk.slice(runStart, i));
+      if (i >= n) break;
+      const c = chunk.charCodeAt(i);
+      i += 1;
+      if (c === 92) {
+        this.#escape = true;
+      } else if (c === 34) {
+        this.#inString = false;
+        this.#endString();
+        return i;
+      } else {
+        this.#fail();
+      }
+    }
+    return i;
+  }
+  #endString() {
+    if (this.#stringIsKey) {
+      const parent = this.#top();
+      if (parent === void 0) this.#fail();
+      parent.key = this.#key;
+      parent.skipValue = this.#keyOverflow;
+      this.#key = "";
+      this.#expectKey = false;
+      this.#expectColon = true;
+      return;
+    }
+    this.#strObserver?.onEnd?.(this.#strLength);
+    this.#strObserver = void 0;
+    if (!this.#strRetain) {
+      this.#store(SKIPPED);
+      return;
+    }
+    const cap = this.#strCap;
+    let text = this.#strHead;
+    if (cap !== void 0) {
+      let tail = this.#strTail;
+      if (tail.length > cap) tail = tail.slice(-cap);
+      if (this.#strLength > text.length + tail.length) {
+        if (isHighSurrogate(text.charCodeAt(text.length - 1))) text = text.slice(0, -1);
+        if (isLowSurrogate(tail.charCodeAt(0))) tail = tail.slice(1);
+        const omitted = this.#strLength - text.length - tail.length;
+        text = `${text}
+[\u2026 ${omitted} chars omitted \u2026]
+${tail}`;
+      } else {
+        text = `${text}${tail}`;
+      }
+      this.#charge(text.length);
+    }
+    this.#strHead = "";
+    this.#strTail = "";
+    this.#store(text);
+  }
+  #finishBare() {
+    const text = this.#bare;
+    this.#bare = "";
+    const { mode, path } = this.#childMode(false);
+    let value;
+    if (text === "true") value = true;
+    else if (text === "false") value = false;
+    else if (text === "null") value = null;
+    else if (NUMBER_PATTERN.test(text)) value = Number(text);
+    else this.#fail();
+    const observer = this.#fields.find(
+      (field) => field.path.length === path.length && matchesPrefix(field.path, path, path.length)
+    );
+    if (observer?.onScalar !== void 0) {
+      observer.onScalar(value);
+      this.#store(SKIPPED);
+    } else this.#store(mode === "keep" ? value : SKIPPED);
+  }
 };
-function buildCodexSpawnEnv(input) {
-  const { HOME: _instanceHome, ...instanceTable } = input.recipe.environment;
-  return mergeLaunchEnv({
-    accountHome: input.layout.effectiveHomePath !== void 0 ? { CODEX_HOME: input.layout.effectiveHomePath } : {},
-    instanceTable,
-    handOverrides: input.crushApiKeys ? CRUSHED_API_KEYS : {}
-  });
-}
-function nativeLoginSpawnEnv(processEnv, isolatedHome) {
-  return mergeLaunchEnv({
-    inherited: processEnv,
-    handOverrides: { ...CRUSHED_API_KEYS, CODEX_HOME: isolatedHome }
-  });
-}
-function shouldCrushApiKeys(authMode) {
-  return authMode === "chatgpt";
-}
-
-// src/appServerLaunch.ts
-function throwIfCodexSpawnControlled(error) {
-  if (error instanceof ExecutorSpawnRefusedError || error instanceof ExecutorSpawnAbortedError) {
+var SKIPPED = /* @__PURE__ */ Symbol("skipped");
+var MalformedRecord = class extends Error {
+};
+function isBareChar(c) {
+  return c >= 48 && c <= 57 || // 0-9
+  c >= 97 && c <= 122 || // a-z
+  c >= 65 && c <= 90 || // A-Z
+  c === 43 || c === 45 || c === 46;
+}
+function hexValue(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  if (c >= 97 && c <= 102) return c - 97 + 10;
+  if (c >= 65 && c <= 70) return c - 65 + 10;
+  return -1;
+}
+var isHighSurrogate = (c) => c >= 55296 && c <= 56319;
+var isLowSurrogate = (c) => c >= 56320 && c <= 57343;
+function matchesPrefix(pattern, path, length) {
+  for (let index = 0; index < length; index += 1) {
+    const expected = pattern[index];
+    if (expected !== "*" && expected !== path[index]) return false;
+  }
+  return true;
+}
+
+// ../../packages/ycodium-jsonl-stream/src/historyRecord.ts
+var textFields = (paths, accept) => {
+  let completed = 0;
+  let started = false;
+  const begin = () => {
+    if (started) return;
+    if (completed > 0) accept("\n");
+    started = true;
+  };
+  return paths.map((path) => ({
+    path,
+    scalarOnly: true,
+    onChunk: (text) => {
+      begin();
+      accept(text);
+    },
+    onEnd: () => {
+      begin();
+      completed += 1;
+      started = false;
+    }
+  }));
+};
+var createHistoryRecordAccumulator = (layout) => {
+  const selected = layout();
+  let rawTotal = 0;
+  let messageTotal = 0;
+  const hash = NodeCrypto2.createHash("sha256");
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const parser = new OversizedRecordParser(
+    [
+      ...selected.fields,
+      ...textFields(selected.textPaths, (text) => {
+        messageTotal += text.length;
+      })
+    ],
+    Number.MAX_SAFE_INTEGER,
+    { pruneEmpty: true }
+  );
+  const accept = (text) => {
+    rawTotal += text.length;
+    parser.write(text);
+  };
+  return {
+    write: (bytes) => {
+      hash.update(bytes);
+      accept(decoder.decode(bytes, { stream: true }));
+    },
+    finish: (range) => {
+      accept(decoder.decode());
+      const metadata = parser.finish();
+      if (metadata === void 0) {
+        if (!range.terminated) return void 0;
+        throw new SyntaxError("Malformed complete native history record.");
+      }
+      return {
+        range,
+        hash: hash.digest("hex"),
+        rawTotal,
+        messageTotal,
+        items: selected.describe(metadata).map(
+          (item) => item.text === "message" && messageTotal === 0 ? { ...item, text: "raw" } : item
+        )
+      };
+    }
+  };
+};
+var inspectHistoryRecord = async (path, range, layout, signal) => {
+  const accumulator = createHistoryRecordAccumulator(layout);
+  try {
+    for await (const bytes of historyBytes(path, range.start, range.end, signal))
+      accumulator.write(bytes);
+    return accumulator.finish(range);
+  } catch (error) {
+    if (!range.terminated && error instanceof TypeError) return void 0;
     throw error;
   }
-}
-async function spawnCodexAppServer(input) {
-  await materializeCodexShadowHome(input.layout, input.host.log);
-  throwIfExecutorSpawnAborted(input.signal);
-  const env = input.env ?? buildCodexSpawnEnv({
-    recipe: input.recipe,
-    layout: input.layout,
-    crushApiKeys: shouldCrushApiKeys(input.recipe.authMode)
+};
+async function* historyRecordWindows(path, info, mode, from, until, limit, layout, signal) {
+  let seen = 0;
+  let offset = from;
+  let pending2 = "";
+  const ready = [];
+  const accept = (text) => {
+    const begin = Math.max(0, from - seen);
+    const end = Math.min(text.length, until - seen);
+    seen += text.length;
+    if (end > begin) pending2 += text.slice(begin, end);
+    while (pending2.length >= limit) {
+      let size = limit;
+      const code = pending2.charCodeAt(size - 1);
+      if (code >= 55296 && code <= 56319) size -= 1;
+      ready.push({ offset, text: pending2.slice(0, size) });
+      pending2 = pending2.slice(size);
+      offset += size;
+    }
+  };
+  const selected = layout();
+  const parser = mode === "raw" ? void 0 : new OversizedRecordParser(textFields(selected.textPaths, accept), Number.MAX_SAFE_INTEGER, {
+    pruneEmpty: true
   });
-  const args = input.args ?? codexSpawnArgs(input.recipe, input.layout);
-  const handle = await input.host.process.spawn({
-    program: input.recipe.binaryPath,
-    args,
-    owner: { bindingId: input.host.bindingId },
-    ...input.cwd === void 0 ? {} : { cwd: input.cwd },
-    ...input.env !== void 0 || Object.keys(env).length > 0 ? { env } : {},
-    ...input.signal === void 0 ? {} : { signal: input.signal }
+  for await (const text of historyText(path, info.range, signal)) {
+    if (parser === void 0) accept(text);
+    else parser.write(text);
+    while (ready.length > 0) yield ready.shift();
+    if (seen >= until) break;
+  }
+  if (pending2) yield { offset, text: pending2 };
+}
+var verifyHistoryRecord = async (path, range, layout, signal) => {
+  const selected = layout();
+  const parser = new OversizedRecordParser(selected.fields, Number.MAX_SAFE_INTEGER, {
+    pruneEmpty: true
   });
-  return { handle, args };
-}
-
-// src/cliVersion.ts
-var CODEX_VERSION_TIMEOUT_MS = 15e3;
-var VERSION_PATTERN = /(?<![\d.])(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)/;
-async function collect(stream) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(Buffer.from(chunk));
-    if (Buffer.concat(chunks).length > 64 * 1024) break;
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-async function readCodexCliVersion(input) {
-  if (input.recipe.binaryPath.length === 0) return null;
-  let handle;
   try {
-    handle = await input.host.process.spawn({
-      program: input.recipe.binaryPath,
-      args: ["--version"],
-      owner: { bindingId: input.host.bindingId }
-    });
-  } catch {
-    return null;
+    for await (const text of historyText(path, range, signal)) parser.write(text);
+  } catch (error) {
+    if (!range.terminated && error instanceof TypeError) return false;
+    throw error;
   }
-  const collected = Promise.all([collect(handle.stdout), collect(handle.stderr), handle.exited]);
-  let timer;
-  const timeout = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2("timeout"), CODEX_VERSION_TIMEOUT_MS);
-    timer.unref?.();
-  });
+  const metadata = parser.finish();
+  if (metadata === void 0 && range.terminated)
+    throw new SyntaxError("Malformed complete native history record.");
+  return selected.verify(metadata);
+};
+
+// ../../packages/ycodium-jsonl-stream/src/history.ts
+var RECORD_CACHE_LIMIT = 32;
+var TEXT_CACHE_CHARS = 262144;
+var recordCache = /* @__PURE__ */ new Map();
+var headCache = /* @__PURE__ */ new Map();
+var cacheKey = (path, identity) => `${path}\0${identity.identity}\0${identity.size}\0${identity.mtimeMs}\0${identity.ctimeMs}`;
+var remember = (cache, key, value, limit = RECORD_CACHE_LIMIT) => {
+  cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > limit) cache.delete(cache.keys().next().value);
+  return value;
+};
+var encode = (position) => Buffer.from(JSON.stringify(position)).toString("base64url");
+var decode = (value) => {
+  let p;
   try {
-    const settled = await Promise.race([collected, timeout]);
-    if (settled === "timeout") {
-      collected.catch(() => void 0);
-      return null;
-    }
-    const [stdout, stderr, exitCode] = settled;
-    if (exitCode !== 0) return null;
-    return VERSION_PATTERN.exec(`${stdout}
-${stderr}`)?.[1] ?? null;
+    p = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
   } catch {
-    return null;
-  } finally {
-    if (timer !== void 0) clearTimeout(timer);
-    await handle.kill("SIGTERM").catch(() => void 0);
+    throw new NativeHistoryCursorError();
   }
+  if (!p || typeof p.e !== "string" || typeof p.h !== "string" || ![p.p, p.k, p.o].every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0))
+    throw new NativeHistoryCursorError();
+  return p;
+};
+var width = (n) => String(n).padStart(20, "0");
+var high = (n) => n >= 55296 && n <= 56319;
+var low = (n) => n >= 56320 && n <= 57343;
+var totalOf = (info, index) => info.items[index].text === "raw" ? info.rawTotal : info.messageTotal;
+var nativeItem = (identity, info, index, offset, text) => {
+  const { text: _mode, ...item } = info.items[index];
+  const total = totalOf(info, index);
+  const position = { e: identity, p: info.range.start, k: index, h: info.hash };
+  return {
+    ...item,
+    id: `${identity}:${info.range.start}:${index}`,
+    orderKey: `${width(info.range.start)}:${width(index)}`,
+    beforeCursor: encode({ ...position, o: offset }),
+    afterCursor: encode({ ...position, o: offset + text.length }),
+    text,
+    textWindow: {
+      offset,
+      returned: text.length,
+      total,
+      nextOffset: offset + text.length < total ? offset + text.length : null
+    }
+  };
+};
+var readWindow = async (path, info, index, from, until, layout, signal, cached) => {
+  const base = Math.max(0, from - 1);
+  const end = Math.min(totalOf(info, index), until + 1);
+  const mode = info.items[index].text;
+  if (cached.text === void 0 && totalOf(info, index) <= TEXT_CACHE_CHARS) {
+    const parts = [];
+    for await (const window of historyRecordWindows(
+      path,
+      info,
+      mode,
+      0,
+      totalOf(info, index),
+      65536,
+      layout,
+      signal
+    ))
+      parts.push(window.text);
+    cached.text = parts.join("");
+    cached.mode = mode;
+  }
+  let text = cached.mode === mode ? cached.text?.slice(base, end) ?? "" : "";
+  if (cached.mode !== mode) {
+    for await (const window of historyRecordWindows(
+      path,
+      info,
+      mode,
+      base,
+      end,
+      Math.max(2, end - base),
+      layout,
+      signal
+    ))
+      text += window.text;
+  }
+  let startIndex = from - base;
+  let endIndex = until - base;
+  if (low(text.charCodeAt(startIndex)) && high(text.charCodeAt(startIndex - 1))) startIndex -= 1;
+  if (low(text.charCodeAt(endIndex)) && high(text.charCodeAt(endIndex - 1))) endIndex -= 1;
+  return { offset: base + startIndex, text: text.slice(startIndex, endIndex) };
+};
+async function openJsonlHistory(path, layout, signal) {
+  const controller = new AbortController();
+  const combined = (next) => AbortSignal.any([controller.signal, ...signal ? [signal] : [], ...next ? [next] : []]);
+  let verified;
+  const verify = async (readSignal) => {
+    const identity = await historyIdentity(path);
+    if (verified?.identity === identity.identity && verified.size === identity.size && verified.mtimeMs === identity.mtimeMs && verified.ctimeMs === identity.ctimeMs)
+      return identity;
+    let checked = 0;
+    for await (const range of historyLines(path, 0, identity.size, false, readSignal)) {
+      if (await verifyHistoryRecord(path, range, layout, readSignal)) {
+        verified = identity;
+        return identity;
+      }
+      if (++checked >= 100) break;
+    }
+    throw new NativeHistoryPendingError();
+  };
+  await verify(combined());
+  const active = /* @__PURE__ */ new Set();
+  const iterators = /* @__PURE__ */ new Set();
+  const tracked = (promise) => {
+    active.add(promise);
+    void promise.finally(() => active.delete(promise)).catch(() => void 0);
+    return promise;
+  };
+  const inspect = async (range, identity, readSignal) => {
+    const key = `${cacheKey(path, identity)}\0${range.start}`;
+    const cached = recordCache.get(key);
+    if (cached?.info.range.end === range.end) return cached;
+    const info = await inspectHistoryRecord(path, range, layout, readSignal);
+    return info === void 0 ? void 0 : remember(recordCache, key, { info });
+  };
+  const head = async (identity, readSignal) => {
+    const key = cacheKey(path, identity);
+    const saved = headCache.get(key);
+    if (saved !== void 0) return saved;
+    for await (const range of historyLines(path, 0, identity.size, true, readSignal)) {
+      const info = await inspect(range, identity, readSignal);
+      if (info !== void 0)
+        return remember(
+          headCache,
+          key,
+          await historyBoundary(path, identity.identity, range.commit, readSignal)
+        );
+    }
+    return remember(headCache, key, await historyBoundary(path, identity.identity, 0, readSignal));
+  };
+  const page = async (input) => {
+    const readSignal = combined(input.signal);
+    readSignal.throwIfAborted();
+    if (input.before !== void 0 && input.after !== void 0)
+      throw new NativeHistoryCursorError();
+    if (input.fromStart && input.before !== void 0) throw new NativeHistoryCursorError();
+    const identity = await verify(readSignal);
+    const position = input.before !== void 0 ? decode(input.before) : input.after !== void 0 ? decode(input.after) : void 0;
+    if (position !== void 0 && (position.e !== identity.identity || position.p > identity.size))
+      throw new NativeHistoryCursorError();
+    const backwards = input.after === void 0 && input.fromStart !== true;
+    const initialRange = position === void 0 ? void 0 : await (async () => {
+      const cached = recordCache.get(`${cacheKey(path, identity)}\0${position.p}`);
+      if (cached !== void 0) return cached.info.range;
+      for await (const range of historyLines(
+        path,
+        position.p,
+        identity.size,
+        false,
+        readSignal
+      ))
+        return range;
+      throw new NativeHistoryCursorError();
+    })();
+    const ranges = async function* () {
+      if (initialRange !== void 0) yield initialRange;
+      yield* backwards ? historyLines(path, 0, position?.p ?? identity.size, true, readSignal) : historyLines(path, initialRange?.commit ?? 0, identity.size, false, readSignal);
+    };
+    const items = [];
+    let budget = Math.min(12e3, input.textLimit ?? 12e3);
+    const limit = Math.min(50, input.limit ?? 20);
+    let more = false;
+    for await (const range of ranges()) {
+      if (items.length >= limit || budget < 2) {
+        more = true;
+        break;
+      }
+      const cached = await inspect(range, identity, readSignal);
+      if (cached === void 0) continue;
+      const info = cached.info;
+      const first = position !== void 0 && range.start === position.p;
+      if (first && (position.h !== info.hash || position.k >= info.items.length || position.o > totalOf(info, position.k)))
+        throw new NativeHistoryCursorError();
+      const indices = Array.from({ length: info.items.length }, (_, index) => index);
+      if (backwards) indices.reverse();
+      for (const index of indices) {
+        if (first && (backwards ? index > position.k : index < position.k)) continue;
+        const total = totalOf(info, index);
+        if (first && index === position.k && total === 0) continue;
+        const boundary = first && index === position.k ? position.o : backwards ? total : 0;
+        if (total > 0 && (backwards ? boundary === 0 : boundary === total)) continue;
+        if (items.length >= limit || budget < 2) {
+          more = true;
+          break;
+        }
+        const from = backwards ? Math.max(0, boundary - budget) : boundary;
+        const until = backwards ? boundary : Math.min(total, from + budget);
+        const window = await readWindow(path, info, index, from, until, layout, readSignal, cached);
+        const item = nativeItem(identity.identity, info, index, window.offset, window.text);
+        if (backwards) items.unshift(item);
+        else items.push(item);
+        budget -= window.text.length;
+        if (backwards ? window.offset > 0 : window.offset + window.text.length < total) {
+          more = true;
+          break;
+        }
+      }
+      if (more) break;
+    }
+    const liveCursor = await head(identity, readSignal);
+    return {
+      sourceEpoch: identity.identity,
+      items,
+      olderCursor: items.length === 0 ? null : backwards && !more && position === void 0 ? null : items[0].beforeCursor,
+      newerCursor: items.length === 0 ? null : !backwards && !more ? null : backwards ? input.before !== void 0 ? items.at(-1).afterCursor : null : more ? items.at(-1).afterCursor : null,
+      liveCursor
+    };
+  };
+  const follow = (input) => {
+    let iterator;
+    iterator = (async function* () {
+      const readSignal = combined(input.signal);
+      let dirty = true;
+      let wake;
+      let failure;
+      const notify = () => {
+        dirty = true;
+        wake?.();
+        wake = void 0;
+      };
+      const watcher = NodeFS4.watch(
+        NodePath5.dirname(path),
+        { signal: readSignal },
+        (_event, file) => {
+          if (file == null || String(file) === NodePath5.basename(path)) notify();
+        }
+      );
+      watcher.on("error", (error) => {
+        failure = error;
+        notify();
+      });
+      const abort = () => notify();
+      readSignal.addEventListener("abort", abort, { once: true });
+      let committed = input.after;
+      const reset = async () => page({
+        ...input.limit === void 0 ? {} : { limit: input.limit },
+        ...input.textLimit === void 0 ? {} : { textLimit: input.textLimit },
+        signal: readSignal
+      });
+      try {
+        let identity = await verify(readSignal);
+        const boundary = committed !== void 0 && committed.sequence <= identity.size ? await historyBoundary(path, identity.identity, committed.sequence, readSignal) : void 0;
+        if (committed === void 0 || boundary?.epoch !== committed.epoch || identity.size - committed.sequence > 1048576) {
+          const value = await reset();
+          committed = value.liveCursor;
+          yield { _tag: "snapshot", cursor: committed, value };
+        }
+        let synchronized = false;
+        let scanned = committed.sequence;
+        let pendingStart = scanned;
+        let accumulator = createHistoryRecordAccumulator(layout);
+        const appended = async function* (end) {
+          for await (const bytes of historyBytes(path, scanned, end, readSignal)) {
+            let from = 0;
+            const chunkStart = scanned;
+            for (let index = 0; index < bytes.length; index += 1) {
+              if (bytes[index] !== 10) continue;
+              accumulator.write(bytes.subarray(from, index));
+              const at = chunkStart + index;
+              const info = at > pendingStart ? accumulator.finish({
+                start: pendingStart,
+                end: at,
+                commit: at + 1,
+                terminated: true
+              }) : void 0;
+              pendingStart = at + 1;
+              accumulator = createHistoryRecordAccumulator(layout);
+              from = index + 1;
+              if (info !== void 0) yield info;
+            }
+            accumulator.write(bytes.subarray(from));
+            scanned += bytes.length;
+          }
+        };
+        while (true) {
+          readSignal.throwIfAborted();
+          if (failure !== void 0) throw failure;
+          if (!dirty)
+            await new Promise((resolve4) => {
+              wake = resolve4;
+            });
+          readSignal.throwIfAborted();
+          dirty = false;
+          identity = await historyIdentity(path);
+          const current = committed;
+          const valid = scanned <= identity.size && current.sequence <= identity.size && (await historyBoundary(path, identity.identity, current.sequence, readSignal)).epoch === current.epoch;
+          if (!valid) {
+            const value = await reset();
+            synchronized = false;
+            committed = value.liveCursor;
+            scanned = committed.sequence;
+            pendingStart = scanned;
+            accumulator = createHistoryRecordAccumulator(layout);
+            yield { _tag: "snapshot", cursor: committed, value };
+          } else {
+            for await (const info of appended(identity.size)) {
+              const next = await historyBoundary(
+                path,
+                identity.identity,
+                info.range.commit,
+                readSignal
+              );
+              for (let index = 0; index < info.items.length; index += 1) {
+                const total = totalOf(info, index);
+                if (total === 0) {
+                  yield {
+                    _tag: "delta",
+                    cursor: index === info.items.length - 1 ? next : committed,
+                    items: [nativeItem(identity.identity, info, index, 0, "")]
+                  };
+                  continue;
+                }
+                for await (const window of historyRecordWindows(
+                  path,
+                  info,
+                  info.items[index].text,
+                  0,
+                  total,
+                  Math.min(12e3, input.textLimit ?? 12e3),
+                  layout,
+                  readSignal
+                )) {
+                  const done = index === info.items.length - 1 && window.offset + window.text.length === total;
+                  yield {
+                    _tag: "delta",
+                    cursor: done ? next : committed,
+                    items: [nativeItem(identity.identity, info, index, window.offset, window.text)]
+                  };
+                }
+              }
+              committed = next;
+            }
+          }
+          if (!synchronized) {
+            synchronized = true;
+            yield { _tag: "synchronized" };
+          }
+        }
+      } finally {
+        watcher.close();
+        readSignal.removeEventListener("abort", abort);
+        wake?.();
+        if (iterator !== void 0) iterators.delete(iterator);
+      }
+    })();
+    iterators.add(iterator);
+    return iterator;
+  };
+  return {
+    page: (input) => tracked(page(input)),
+    follow,
+    close: async () => {
+      controller.abort();
+      await Promise.all([...iterators].map((iterator) => iterator.return(void 0)));
+      await Promise.allSettled(active);
+    }
+  };
 }
 
-// src/failureCategory.ts
-var codexProcessExitCategory = (session) => session !== void 0 && !session.stopRequested && typeof session.nativeThreadId === "string" && session.nativeThreadId.length > 0 ? "transport" : void 0;
-
 // src/protocol.ts
 var CODEX_INITIALIZE_PARAMS = {
   clientInfo: { name: "ycodium", title: "Ycodium", version: "0" },
@@ -870,7 +1737,7 @@ function codexCollaborationMode(input) {
     }
   };
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asString(value) {
@@ -885,11 +1752,11 @@ function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function codexVersionFromInitialize(initializeResult) {
-  const userAgent = isRecord3(initializeResult) ? asString(initializeResult["userAgent"]) : null;
+  const userAgent = isRecord2(initializeResult) ? asString(initializeResult["userAgent"]) : null;
   return userAgent?.match(/\/(\S+)/)?.[1] ?? null;
 }
 function decodeThreadOpen(result) {
-  const thread = isRecord3(result) ? isRecord3(result["thread"]) ? result["thread"] : result : null;
+  const thread = isRecord2(result) ? isRecord2(result["thread"]) ? result["thread"] : result : null;
   const id = thread ? asString(thread["id"]) : null;
   if (!id) throw new Error("codex thread/start|resume returned no thread id");
   return {
@@ -899,22 +1766,22 @@ function decodeThreadOpen(result) {
   };
 }
 function decodeTurnStart(result) {
-  const turn = isRecord3(result) ? isRecord3(result["turn"]) ? result["turn"] : result : null;
+  const turn = isRecord2(result) ? isRecord2(result["turn"]) ? result["turn"] : result : null;
   const id = turn ? asString(turn["id"]) : null;
   if (!id) throw new Error("codex turn/start returned no turn id");
   return { turnId: id };
 }
 function decodeTurnSteer(result) {
-  const id = isRecord3(result) ? asString(result["turnId"]) : null;
+  const id = isRecord2(result) ? asString(result["turnId"]) : null;
   if (!id) throw new Error("codex turn/steer returned no turn id");
   return { turnId: id };
 }
 function inProgressTurnIdFromThreadRead(result) {
-  if (!isRecord3(result)) return void 0;
-  const thread = isRecord3(result["thread"]) ? result["thread"] : result;
+  if (!isRecord2(result)) return void 0;
+  const thread = isRecord2(result["thread"]) ? result["thread"] : result;
   const turns = Array.isArray(thread["turns"]) ? thread["turns"] : [];
   for (const turn of turns) {
-    if (!isRecord3(turn)) continue;
+    if (!isRecord2(turn)) continue;
     const status = asString(turn["status"]);
     if (status === "inProgress" || status === "in_progress" || status === "active") {
       return asString(turn["id"]) ?? void 0;
@@ -997,28 +1864,643 @@ function isMemoryConsolidationThread(name) {
   return (name ?? "").toLowerCase().includes(MEMORY_CONSOLIDATION_NAME);
 }
 function parseCodexResumeCursor(value) {
-  if (!isRecord3(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const threadId = asString(value["threadId"])?.trim();
   return threadId ? { threadId } : void 0;
 }
 function conversationIdFromNotification(params) {
-  if (!isRecord3(params)) return void 0;
-  return asString(params["threadId"]) ?? asString(params["conversationId"]) ?? (isRecord3(params["thread"]) ? asString(params["thread"]["id"]) : null) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["threadId"]) : null) ?? void 0;
+  if (!isRecord2(params)) return void 0;
+  return asString(params["threadId"]) ?? asString(params["conversationId"]) ?? (isRecord2(params["thread"]) ? asString(params["thread"]["id"]) : null) ?? (isRecord2(params["turn"]) ? asString(params["turn"]["threadId"]) : null) ?? void 0;
 }
 function itemTypeOf(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   return asString(item["type"]) ?? asString(item["itemType"]) ?? void 0;
 }
-function jsonRpcErrorMessage(error) {
-  if (isRecord3(error) && typeof error["message"] === "string") return error["message"];
+function jsonRpcErrorMessage(error) {
+  if (isRecord2(error) && typeof error["message"] === "string") return error["message"];
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/sessions.ts
+import * as NodeFS5 from "node:fs";
+import * as NodePath6 from "node:path";
+import * as NodeReadline from "node:readline";
+var EXTENDED_LENGTH_UNC = "//?/UNC/";
+var EXTENDED_LENGTH = "//?/";
+function normalize(value, caseInsensitive) {
+  let unified = value.trim().replace(/\\/gu, "/");
+  const upper = unified.toUpperCase();
+  if (upper.startsWith(EXTENDED_LENGTH_UNC)) {
+    unified = `//${unified.slice(EXTENDED_LENGTH_UNC.length)}`;
+  } else if (upper.startsWith(EXTENDED_LENGTH)) {
+    unified = unified.slice(EXTENDED_LENGTH.length);
+  }
+  const isUnc = unified.startsWith("//");
+  unified = unified.replace(/\/+/gu, "/").replace(/\/+$/u, "");
+  if (isUnc) unified = `/${unified}`;
+  return caseInsensitive ? unified.toLowerCase() : unified;
+}
+function isWithinDirectory(candidate, root, caseInsensitive) {
+  const normalizedRoot = normalize(root, caseInsensitive);
+  if (normalizedRoot.length === 0 || normalizedRoot === "/") return false;
+  const normalizedCandidate = normalize(candidate, caseInsensitive);
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
+var PAGE_LIMIT = 50;
+var MAX_PAGES = 10;
+var MAX_ROWS = 50;
+var PREVIEW_LIMIT = 200;
+function truncate(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0) return null;
+  return trimmed.length <= PREVIEW_LIMIT ? trimmed : `${trimmed.slice(0, PREVIEW_LIMIT)}\u2026`;
+}
+var nativeModel = (value) => {
+  const model = asString(value)?.trim();
+  return model && model !== "<synthetic>" ? model : null;
+};
+function readListPage(response) {
+  if (!response || typeof response !== "object") return { threads: [], nextCursor: null };
+  const typed = response;
+  const rows = Array.isArray(typed.data) ? typed.data : [];
+  const threads = [];
+  for (const row of rows) {
+    if (!isRecord2(row)) continue;
+    if (typeof row.id !== "string" || typeof row.cwd !== "string") continue;
+    threads.push({
+      id: row.id,
+      cwd: row.cwd,
+      name: asString(row.name),
+      preview: asString(row.preview),
+      model: asString(row.model),
+      updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : 0
+    });
+  }
+  return { threads, nextCursor: asString(typed.nextCursor) };
+}
+function readThreadTurns(response) {
+  if (!isRecord2(response)) return [];
+  const thread = isRecord2(response.thread) ? response.thread : null;
+  if (!thread) return [];
+  const turns = Array.isArray(thread.turns) ? thread.turns : [];
+  return turns.flatMap((turn) => {
+    if (!isRecord2(turn)) return [];
+    return [
+      {
+        ...typeof turn.id === "string" && turn.id.length > 0 ? { id: turn.id } : {},
+        ...typeof turn.model === "string" && turn.model.length > 0 ? { model: turn.model } : {},
+        startedAt: typeof turn.startedAt === "number" ? turn.startedAt : null,
+        items: Array.isArray(turn.items) ? turn.items : []
+      }
+    ];
+  });
+}
+function itemText(item) {
+  if (!isRecord2(item)) return void 0;
+  const type = (asString(item.type) ?? "").toLowerCase();
+  const text = asString(item.text) ?? asString(item.content) ?? (Array.isArray(item.content) ? item.content.map((entry) => isRecord2(entry) ? asString(entry.text) : null).filter((entry) => typeof entry === "string").join("\n") : null);
+  if (!text || text.trim().length === 0) return void 0;
+  if (type.includes("user")) return { role: "user", text };
+  if (type.includes("agent") || type.includes("assistant")) return { role: "assistant", text };
+  if (type.includes("system")) return { role: "system", text };
+  return void 0;
+}
+async function scanCodexSessions(input) {
+  const threads = [];
+  let cursor = null;
+  for (let page = 0; page < MAX_PAGES && threads.length < MAX_ROWS; page += 1) {
+    const listed = readListPage(
+      await input.client.request("thread/list", {
+        limit: PAGE_LIMIT,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        ...cursor === null ? {} : { cursor }
+      })
+    );
+    for (const thread of listed.threads) {
+      if (!isWithinDirectory(thread.cwd, input.directory, input.caseInsensitive)) continue;
+      threads.push(thread);
+      if (threads.length >= MAX_ROWS) break;
+    }
+    if (listed.nextCursor === null || listed.nextCursor.length === 0) break;
+    cursor = listed.nextCursor;
+  }
+  const rows = [];
+  for (const thread of threads) {
+    const turnCount = await input.client.request("thread/read", { threadId: thread.id, includeTurns: true }).then((response) => readThreadTurns(response).length).catch(() => 0);
+    rows.push({
+      nativeSessionId: thread.id,
+      cwd: thread.cwd,
+      title: truncate(thread.name),
+      preview: truncate(thread.preview),
+      model: truncate(thread.model),
+      turnCount,
+      updatedAt: thread.updatedAt * 1e3,
+      availability: "importable",
+      openElsewhere: false
+    });
+  }
+  return rows;
+}
+async function readCodexSession(input) {
+  const response = await input.client.request("thread/read", {
+    threadId: input.threadId,
+    includeTurns: true
+  });
+  const record = isRecord2(response) ? response : null;
+  const thread = record && isRecord2(record.thread) ? record.thread : null;
+  const path = input.caseInsensitive ? NodePath6.win32 : NodePath6;
+  const sameDirectory = (left, right) => isWithinDirectory(path.resolve(left), path.resolve(right), input.caseInsensitive) && isWithinDirectory(path.resolve(right), path.resolve(left), input.caseInsensitive);
+  if (!isRecord2(thread) || thread.id !== input.threadId || typeof thread.cwd !== "string" || !path.isAbsolute(thread.cwd) || !path.isAbsolute(input.cwd) || !sameDirectory(thread.cwd, input.cwd)) {
+    throw new Error("The native Codex session does not match the requested session and directory.");
+  }
+  const model = nativeModel(thread.model) ?? await readRolloutModel(
+    {
+      threadId: input.threadId,
+      cwd: input.cwd,
+      homePath: input.homePath,
+      caseInsensitive: input.caseInsensitive
+    },
+    thread.path,
+    sameDirectory
+  );
+  const messages = [];
+  for (const turn of readThreadTurns(response)) {
+    for (const item of turn.items) {
+      const mapped = itemText(item);
+      if (mapped) {
+        messages.push({
+          ...mapped,
+          ...typeof turn.startedAt === "number" ? { createdAt: turn.startedAt * 1e3 } : {}
+        });
+      }
+    }
+  }
+  return {
+    nativeSessionId: input.threadId,
+    messages,
+    resumeCursor: { threadId: input.threadId },
+    model
+  };
+}
+async function readRolloutModel(input, rolloutPath, sameDirectory) {
+  const path = input.caseInsensitive ? NodePath6.win32 : NodePath6;
+  if (typeof rolloutPath !== "string" || !path.isAbsolute(rolloutPath) || path.extname(rolloutPath).toLowerCase() !== ".jsonl") {
+    return null;
+  }
+  const resolved = path.resolve(rolloutPath);
+  const roots = input.homePath ? [path.join(input.homePath, "sessions"), path.join(input.homePath, "archived_sessions")] : [];
+  if (!roots.some((root) => isWithinDirectory(resolved, path.resolve(root), input.caseInsensitive))) {
+    return null;
+  }
+  let verified = false;
+  let model = null;
+  try {
+    const stream = NodeFS5.createReadStream(resolved, { encoding: "utf8" });
+    const rl = NodeReadline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.includes('"session_meta"') && !line.includes('"turn_context"')) continue;
+      let record;
+      try {
+        record = isRecord2(JSON.parse(line)) ? JSON.parse(line) : null;
+      } catch {
+        continue;
+      }
+      const payload = isRecord2(record?.payload) ? record.payload : null;
+      if (!record || !payload) continue;
+      if (record.type === "session_meta" && !verified) {
+        if ((payload.id ?? payload.session_id) !== input.threadId || typeof payload.cwd !== "string" || !path.isAbsolute(payload.cwd) || !sameDirectory(payload.cwd, input.cwd)) {
+          return null;
+        }
+        verified = true;
+      } else if (record.type === "turn_context" && verified) {
+        model = nativeModel(payload.model) ?? model;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return model;
+}
+
+// src/liveHistory.ts
+var valueAt = (value, keys) => keys.reduce((next, key) => isRecord2(next) ? next[key] : void 0, value);
+var fields = [
+  "type",
+  "timestamp",
+  "payload.type",
+  "payload.id",
+  "payload.cwd",
+  "payload.role",
+  "payload.name",
+  "payload.call_id",
+  "payload.truncated",
+  "payload.inputTruncated",
+  "payload.outputTruncated",
+  "payload.source.subagent.thread_spawn.parent_thread_id",
+  "payload.source.subAgent.thread_spawn.parent_thread_id"
+].map((path) => ({ path: path.split("."), maxChars: 2048, scalarOnly: true }));
+var codexHistoryLayout = (input) => () => {
+  let nonText = false;
+  let blockType = "";
+  const verify = (metadata) => {
+    if (!isRecord2(metadata) || metadata.type !== "session_meta") return false;
+    const cwd = valueAt(metadata, ["payload", "cwd"]);
+    const parent = valueAt(metadata, ["payload", "source", "subagent", "thread_spawn", "parent_thread_id"]) ?? valueAt(metadata, ["payload", "source", "subAgent", "thread_spawn", "parent_thread_id"]);
+    if (valueAt(metadata, ["payload", "id"]) !== input.nativeSessionId || parent !== input.parentNativeSessionId || typeof cwd !== "string" || !isWithinDirectory(cwd, input.cwd, NodeProcess.platform === "win32") || !isWithinDirectory(input.cwd, cwd, NodeProcess.platform === "win32"))
+      throw new Error("Native session ownership does not match the recorded agent.");
+    return true;
+  };
+  return {
+    fields: [
+      ...fields,
+      {
+        path: ["payload", "content", "*", "type"],
+        onChunk: (text) => {
+          blockType = (blockType + text).slice(0, 64);
+        },
+        onEnd: () => {
+          nonText ||= !["input_text", "output_text", "text"].includes(blockType);
+          blockType = "";
+        }
+      }
+    ],
+    textPaths: [["payload", "content", "*", "text"]],
+    verify,
+    describe: (metadata) => {
+      if (!isRecord2(metadata) || metadata.type !== "response_item" || !isRecord2(metadata.payload))
+        return [];
+      const item = metadata.payload;
+      const type = typeof item.type === "string" ? item.type : "record";
+      const kind = type === "message" ? "message" : type.endsWith("_call_output") ? "tool_result" : type.endsWith("_call") ? "tool_call" : "record";
+      const role = item.role === "developer" ? "system" : item.role === "user" || item.role === "assistant" || item.role === "system" ? item.role : void 0;
+      return [
+        {
+          kind,
+          text: kind === "message" && !nonText ? "message" : "raw",
+          ...role === void 0 ? {} : { role },
+          ...typeof item.name === "string" ? { name: item.name } : {},
+          ...typeof item.call_id === "string" ? { toolCallId: item.call_id } : {},
+          ...typeof metadata.timestamp === "string" ? { createdAt: metadata.timestamp } : {},
+          ...item.truncated === true || item.inputTruncated === true || item.outputTruncated === true ? { sourceTruncated: true } : {}
+        }
+      ];
+    }
+  };
+};
+var findCodexHistory = async (input) => {
+  if (!/^[A-Za-z0-9_-]+$/u.test(input.nativeSessionId))
+    throw new Error("Invalid native session identifier.");
+  for (const directory of ["sessions", "archived_sessions"]) {
+    let entries;
+    try {
+      entries = await NodeFSP4.opendir(NodePath7.join(input.homePath, directory), {
+        recursive: true,
+        bufferSize: 32
+      });
+    } catch (error) {
+      if (isRecord2(error) && error.code === "ENOENT") continue;
+      throw error;
+    }
+    for await (const entry of entries) {
+      input.signal?.throwIfAborted();
+      if (entry.isFile() && entry.name.endsWith(`-${input.nativeSessionId}.jsonl`))
+        return openJsonlHistory(
+          NodePath7.join(entry.parentPath, entry.name),
+          codexHistoryLayout(input),
+          input.signal
+        );
+    }
+  }
+  return void 0;
+};
+var openCodexHistory = (input) => waitForJsonlHistory({
+  root: input.homePath,
+  accepts: (path) => path.endsWith(`-${input.nativeSessionId}.jsonl`) || NodePath7.resolve(input.homePath).startsWith(path + NodePath7.sep),
+  open: (signal) => findCodexHistory({ ...input, signal }),
+  ...input.signal === void 0 ? {} : { signal: input.signal }
+});
+
+// src/codexInstance.ts
+import * as NodeProcess2 from "node:process";
+import {
+  describeExecutorSpawnFailure,
+  ExecutorSpawnRefusedError as ExecutorSpawnRefusedError2,
+  raceAbort as raceAbort2
+} from "@ycodium-ai/plugin-api/executor";
+
+// src/appServerLaunch.ts
+import {
+  ExecutorSpawnAbortedError,
+  ExecutorSpawnRefusedError,
+  throwIfExecutorSpawnAborted
+} from "@ycodium-ai/plugin-api/executor";
+
+// src/connection.ts
+import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
+
+// src/config.ts
+import { modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
+
+// src/apiKeyEnv.ts
+var CODEX_INSTANCE_API_KEY_ENV = "YCODIUM_CODEX_API_KEY";
+
+// src/config.ts
+var CODEX_INSTANCE_MODEL_PROVIDER = "ycodium_api";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function readTrimmed(value) {
+  return readString2(value).trim();
+}
+function readAuthMode(value) {
+  return value === "chatgpt" || value === "apiKey" ? value : "default";
+}
+function readEnvironment(value) {
+  if (!Array.isArray(value)) return {};
+  const env = {};
+  for (const entry of value) {
+    if (!isRecord3(entry)) continue;
+    const name = readTrimmed(entry["name"]);
+    if (name.length === 0) continue;
+    env[name] = readString2(entry["value"]);
+  }
+  return env;
+}
+function parseCodexInstanceConfig(config) {
+  if (!isRecord3(config)) {
+    return {
+      binaryPath: "",
+      launchArgs: CODEX_DEFAULT_LAUNCH_ARGS,
+      homePath: "",
+      shadowHomePath: "",
+      homeEnvVar: "",
+      authMode: "default",
+      apiBaseUrl: "",
+      environment: {},
+      envelopeDriver: void 0
+    };
+  }
+  const nested = isRecord3(config["config"]) ? config["config"] : void 0;
+  const settings = nested ?? config;
+  return {
+    binaryPath: readTrimmed(settings["binaryPath"]),
+    launchArgs: readString2(settings["launchArgs"]) || CODEX_DEFAULT_LAUNCH_ARGS,
+    homePath: readTrimmed(settings["homePath"]) || readTrimmed(config["homePath"]),
+    shadowHomePath: readTrimmed(settings["shadowHomePath"]),
+    homeEnvVar: readTrimmed(settings["homeEnvVar"]) || readTrimmed(config["homeEnvVar"]),
+    authMode: readAuthMode(settings["authMode"]),
+    apiBaseUrl: readTrimmed(settings["apiBaseUrl"]),
+    environment: readEnvironment(config["environment"]),
+    envelopeDriver: readTrimmed(config["driver"]) || void 0
+  };
+}
+function tokenizeLaunchArgs(value) {
+  const input = value.trim();
+  if (!input) return [];
+  const tokens = [];
+  let current = "";
+  let quote;
+  let quoted = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    if (char === void 0) continue;
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        quoted = true;
+      } else if (char === "\\" && quote === '"') {
+        const next = input[index + 1];
+        if (next !== void 0 && ['"', "\\", "$", "`"].includes(next)) {
+          current += next;
+          index++;
+        } else {
+          current += char;
+        }
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      quoted = true;
+    } else if (/\s/.test(char)) {
+      if (current || quoted) {
+        tokens.push(current);
+        current = "";
+        quoted = false;
+      }
+    } else if (char === "\\") {
+      const next = input[index + 1];
+      if (next !== void 0 && /\s/.test(next)) {
+        current += next;
+        index++;
+      } else {
+        current += char;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current || quoted) tokens.push(current);
+  return tokens;
+}
+function encodeQuotedArgs(args) {
+  return args.map((arg) => `"${arg.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`).join(" ");
+}
+function codexExecLaunchArgs(launchArgs) {
+  const args = tokenizeLaunchArgs(launchArgs ?? "");
+  const execArgs = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--strict-config" || arg.startsWith("--config=") || arg.startsWith("-c=")) {
+      execArgs.push(arg);
+    } else if (arg === "--config" || arg === "-c" || arg === "--enable" || arg === "--disable") {
+      const value = args[index + 1];
+      if (value !== void 0 && !value.startsWith("-")) {
+        execArgs.push(arg, value);
+        index++;
+      }
+    } else if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
+      execArgs.push(arg);
+    }
+  }
+  return execArgs;
+}
+function codexMcpThreadConfig(servers) {
+  return {
+    mcp_servers: Object.fromEntries(
+      servers.map(({ name, transport }) => [
+        name,
+        transport.type === "stdio" ? { command: transport.command, args: transport.args ?? [], env: transport.env ?? {} } : { url: transport.url, http_headers: transport.headers ?? {} }
+      ])
+    )
+  };
+}
+function modelIdFromSelection(selection) {
+  if (typeof selection !== "object" || selection === null || Array.isArray(selection)) {
+    return void 0;
+  }
+  const model = selection["model"];
+  return typeof model === "string" ? model.trim() || void 0 : void 0;
+}
+
+// src/connection.ts
+function codexApiConnectionError(recipe, environment) {
+  if (recipe.authMode !== "apiKey") return null;
+  try {
+    const url = new URL(recipe.apiBaseUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return "Codex API base URL must use HTTP or HTTPS.";
+    }
+  } catch {
+    return "Codex API base URL is missing or invalid.";
+  }
+  return environment[CODEX_INSTANCE_API_KEY_ENV]?.trim() ? null : "An API key is required for this Codex account.";
+}
+function connectionArgv(recipe, layout) {
+  const args = [...tokenizeLaunchArgs(recipe.launchArgs)];
+  const override = (key, value) => {
+    args.push("-c", `${key}=${JSON.stringify(value)}`);
+  };
+  if (layout.mode === "authOverlay" || recipe.authMode !== "default") {
+    override("sqlite_home", layout.sharedHomePath);
+  }
+  if (layout.mode === "authOverlay") {
+    override("cli_auth_credentials_store", "file");
+  }
+  if (recipe.authMode === "chatgpt") {
+    override("model_provider", "openai");
+    override("forced_login_method", "chatgpt");
+  } else if (recipe.authMode === "apiKey") {
+    override("model_provider", CODEX_INSTANCE_MODEL_PROVIDER);
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.name`, "Ycodium API");
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.base_url`, recipe.apiBaseUrl);
+    override(
+      `model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.env_key`,
+      CODEX_INSTANCE_API_KEY_ENV
+    );
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.requires_openai_auth`, false);
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.wire_api`, "responses");
+  }
+  return args;
+}
+function codexSpawnArgs(recipe, layout) {
+  const needsOverrides = layout.mode === "authOverlay" || recipe.authMode !== "default";
+  if (!needsOverrides) return tokenizeLaunchArgs(recipe.launchArgs);
+  return connectionArgv(recipe, layout);
+}
+function encodeCodexConnectionArgs(recipe, layout) {
+  return encodeQuotedArgs(connectionArgv(recipe, layout));
+}
+var CRUSHED_API_KEYS = {
+  OPENAI_API_KEY: void 0,
+  CODEX_API_KEY: void 0
+};
+function buildCodexSpawnEnv(input) {
+  const { HOME: _instanceHome, ...instanceTable } = input.recipe.environment;
+  return mergeLaunchEnv({
+    accountHome: input.layout.effectiveHomePath !== void 0 ? { CODEX_HOME: input.layout.effectiveHomePath } : {},
+    instanceTable,
+    handOverrides: input.crushApiKeys ? CRUSHED_API_KEYS : {}
+  });
+}
+function nativeLoginSpawnEnv(processEnv, isolatedHome) {
+  return mergeLaunchEnv({
+    inherited: processEnv,
+    handOverrides: { ...CRUSHED_API_KEYS, CODEX_HOME: isolatedHome }
+  });
+}
+function shouldCrushApiKeys(authMode) {
+  return authMode === "chatgpt";
+}
+
+// src/appServerLaunch.ts
+function throwIfCodexSpawnControlled(error) {
+  if (error instanceof ExecutorSpawnRefusedError || error instanceof ExecutorSpawnAbortedError) {
+    throw error;
+  }
+}
+async function spawnCodexAppServer(input) {
+  await materializeCodexShadowHome(input.layout, input.host.log);
+  throwIfExecutorSpawnAborted(input.signal);
+  const env = input.env ?? buildCodexSpawnEnv({
+    recipe: input.recipe,
+    layout: input.layout,
+    crushApiKeys: shouldCrushApiKeys(input.recipe.authMode)
+  });
+  const args = input.args ?? codexSpawnArgs(input.recipe, input.layout);
+  const handle = await input.host.process.spawn({
+    program: input.recipe.binaryPath,
+    args,
+    owner: { bindingId: input.host.bindingId },
+    ...input.cwd === void 0 ? {} : { cwd: input.cwd },
+    ...input.env !== void 0 || Object.keys(env).length > 0 ? { env } : {},
+    ...input.signal === void 0 ? {} : { signal: input.signal }
+  });
+  return { handle, args };
+}
+
+// src/cliVersion.ts
+var CODEX_VERSION_TIMEOUT_MS = 15e3;
+var VERSION_PATTERN = /(?<![\d.])(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)/;
+async function collect(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+    if (Buffer.concat(chunks).length > 64 * 1024) break;
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function readCodexCliVersion(input) {
+  if (input.recipe.binaryPath.length === 0) return null;
+  let handle;
   try {
-    return JSON.stringify(error);
+    handle = await input.host.process.spawn({
+      program: input.recipe.binaryPath,
+      args: ["--version"],
+      owner: { bindingId: input.host.bindingId }
+    });
   } catch {
-    return String(error);
+    return null;
+  }
+  const collected = Promise.all([collect(handle.stdout), collect(handle.stderr), handle.exited]);
+  let timer;
+  const timeout = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4("timeout"), CODEX_VERSION_TIMEOUT_MS);
+    timer.unref?.();
+  });
+  try {
+    const settled = await Promise.race([collected, timeout]);
+    if (settled === "timeout") {
+      collected.catch(() => void 0);
+      return null;
+    }
+    const [stdout, stderr, exitCode] = settled;
+    if (exitCode !== 0) return null;
+    return VERSION_PATTERN.exec(`${stdout}
+${stderr}`)?.[1] ?? null;
+  } catch {
+    return null;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    await handle.kill("SIGTERM").catch(() => void 0);
   }
 }
 
+// src/failureCategory.ts
+var codexProcessExitCategory = (session) => session !== void 0 && !session.stopRequested && typeof session.nativeThreadId === "string" && session.nativeThreadId.length > 0 ? "transport" : void 0;
+
 // src/rpc.ts
 function createLineAssembler() {
   const fragments = [];
@@ -1060,7 +2542,7 @@ function classifyStderrLine(line) {
 var CodexRpcResponseError = class extends Error {
 };
 async function createCodexRpcClient(handle, handlers) {
-  const pending = /* @__PURE__ */ new Map();
+  const pending2 = /* @__PURE__ */ new Map();
   const decoder = new TextDecoder();
   let nextId = 1;
   let stderrTail = "";
@@ -1071,10 +2553,10 @@ async function createCodexRpcClient(handle, handlers) {
   const failAll = (reason, failureCategory) => {
     if (exitReason === null) exitFailureCategory = failureCategory;
     exitReason = reason;
-    for (const [, entry] of pending) {
+    for (const [, entry] of pending2) {
       entry.reject(attach(new Error(`codex app-server ${entry.method} failed: ${reason}`)));
     }
-    pending.clear();
+    pending2.clear();
   };
   const dispatch = (line) => {
     if (line.trim().length === 0) return;
@@ -1097,9 +2579,9 @@ async function createCodexRpcClient(handle, handlers) {
       return;
     }
     if (hasId && !hasMethod) {
-      const entry = pending.get(typed.id);
+      const entry = pending2.get(typed.id);
       if (entry === void 0) return;
-      pending.delete(typed.id);
+      pending2.delete(typed.id);
       if (typed.error !== void 0 && typed.error !== null) {
         entry.reject(
           new CodexRpcResponseError(
@@ -1164,8 +2646,8 @@ async function createCodexRpcClient(handle, handlers) {
     }
     const id = nextId;
     nextId += 1;
-    const settled = new Promise((resolve2, reject) => {
-      pending.set(id, { resolve: resolve2, reject, method });
+    const settled = new Promise((resolve4, reject) => {
+      pending2.set(id, { resolve: resolve4, reject, method });
     });
     const limit = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     let timer;
@@ -1184,7 +2666,7 @@ async function createCodexRpcClient(handle, handlers) {
       ]);
       return await Promise.race([settled, timedOut]);
     } catch (error) {
-      pending.delete(id);
+      pending2.delete(id);
       throw error;
     } finally {
       if (timer !== void 0) clearTimeout(timer);
@@ -1220,10 +2702,10 @@ async function createCodexRpcClient(handle, handlers) {
       try {
         await Promise.race([
           drained,
-          new Promise((resolve2) => {
+          new Promise((resolve4) => {
             timer = setTimeout(() => {
               options.onDrainTimeout();
-              resolve2();
+              resolve4();
             }, options.drainTimeoutMs);
           })
         ]);
@@ -1240,12 +2722,12 @@ async function createCodexRpcClient(handle, handlers) {
     respondError,
     close,
     pid: handle.pid,
-    pendingCountForTests: () => pending.size
+    pendingCountForTests: () => pending2.size
   };
 }
 
 // src/sessionRuntime.ts
-import * as NodeCrypto2 from "node:crypto";
+import * as NodeCrypto4 from "node:crypto";
 
 // src/approvalGrant.ts
 function codexApprovalGrantKey(kind, identity) {
@@ -1471,8 +2953,8 @@ function buildCodexDeveloperInstructions(interactionMode, runtime, browserToolsA
 // src/codexArtifacts.ts
 function imageGenerationArtifacts(input) {
   if (input.itemType !== "imageGeneration" || input.status !== "completed") return [];
-  if (!isRecord3(input.params)) return [];
-  const item = isRecord3(input.params["item"]) ? input.params["item"] : input.params;
+  if (!isRecord2(input.params)) return [];
+  const item = isRecord2(input.params["item"]) ? input.params["item"] : input.params;
   const savedPath = item["savedPath"];
   if (typeof savedPath !== "string" || savedPath.trim().length === 0) return [];
   return [{ path: savedPath, ...input.itemId ? { toolCallId: input.itemId } : {} }];
@@ -1506,9 +2988,9 @@ function toCanonicalItemType(raw) {
 }
 
 // src/events/base.ts
-import * as NodeCrypto from "node:crypto";
+import * as NodeCrypto3 from "node:crypto";
 var CODEX_PROVIDER = "codex";
-var EVENT_ID_PREFIX = `codex-evt-${NodeCrypto.randomUUID()}`;
+var EVENT_ID_PREFIX = `codex-evt-${NodeCrypto3.randomUUID()}`;
 var eventSeq = 0;
 function nextEventId() {
   eventSeq += 1;
@@ -1544,28 +3026,28 @@ function baseEvent(input) {
 
 // src/events/fields.ts
 function itemIdOf(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   return asString(item["id"]) ?? asString(params["itemId"]) ?? void 0;
 }
 function itemStatusOf(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   return asString(item["status"]) ?? void 0;
 }
 function turnIdOf(params) {
-  if (!isRecord3(params)) return void 0;
-  return asString(params["turnId"]) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["id"]) : null) ?? void 0;
+  if (!isRecord2(params)) return void 0;
+  return asString(params["turnId"]) ?? (isRecord2(params["turn"]) ? asString(params["turn"]["id"]) : null) ?? void 0;
 }
 function itemTitle(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   return trimText(item["title"]) ?? trimText(item["name"]) ?? trimText(item["command"]) ?? trimText(item["summary"]) ?? void 0;
 }
 function itemDetail(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
-  const query = isRecord3(item["action"]) ? item["action"]["queries"] : item["query"];
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
+  const query = isRecord2(item["action"]) ? item["action"]["queries"] : item["query"];
   if (Array.isArray(query)) {
     const joined = query.filter((entry) => typeof entry === "string").join(", ");
     if (joined.length > 0) return joined;
@@ -1586,7 +3068,7 @@ function toTurnStatus(status) {
   }
 }
 function threadStateFromStatus(status) {
-  const type = isRecord3(status) ? asString(status["type"]) : asString(status);
+  const type = isRecord2(status) ? asString(status["type"]) : asString(status);
   if (type === "idle") return "idle";
   if (type === "systemError" || type === "error") return "error";
   return "active";
@@ -1595,9 +3077,9 @@ function codexCompactionId(threadId, turnId) {
   return `codex:${threadId}:${turnId ?? "session"}`;
 }
 function normalizeCodexTokenUsage(tokenUsage) {
-  if (!isRecord3(tokenUsage)) return void 0;
-  const last = isRecord3(tokenUsage["last"]) ? tokenUsage["last"] : void 0;
-  const total = isRecord3(tokenUsage["total"]) ? tokenUsage["total"] : void 0;
+  if (!isRecord2(tokenUsage)) return void 0;
+  const last = isRecord2(tokenUsage["last"]) ? tokenUsage["last"] : void 0;
+  const total = isRecord2(tokenUsage["total"]) ? tokenUsage["total"] : void 0;
   const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
   const usedTokens = count(last?.["totalTokens"]);
   if (usedTokens === void 0 || usedTokens <= 0) return void 0;
@@ -1620,9 +3102,9 @@ function normalizeCodexTokenUsage(tokenUsage) {
   };
 }
 function turnCompletedControlFlow(params) {
-  const turn = isRecord3(params) ? isRecord3(params["turn"]) ? params["turn"] : params : {};
+  const turn = isRecord2(params) ? isRecord2(params["turn"]) ? params["turn"] : params : {};
   const state = toTurnStatus(asString(turn["status"]) ?? void 0);
-  const error = isRecord3(turn["error"]) ? trimText(turn["error"]["message"]) : void 0;
+  const error = isRecord2(turn["error"]) ? trimText(turn["error"]["message"]) : void 0;
   return error ? { state, errorMessage: error } : { state };
 }
 
@@ -1647,7 +3129,7 @@ function pathLeaf(value) {
   return parts.at(-1);
 }
 function mapCollabAgentEvent(input) {
-  if (!isRecord3(input.params)) return [];
+  if (!isRecord2(input.params)) return [];
   const agentThreadId = asString(input.params["agentThreadId"]) ?? asString(input.params["threadId"]);
   if (!agentThreadId) return [];
   const agentPath = asString(input.params["agentPath"]) ?? asString(input.params["path"]) ?? void 0;
@@ -1657,8 +3139,10 @@ function mapCollabAgentEvent(input) {
   const title = knownName ?? agentThreadId;
   const model = trimText(input.params["model"]);
   const effort = trimText(input.params["effort"]);
+  const parentNativeId = asString(input.params["parentThreadId"]) ?? void 0;
   const linkage = {
     role,
+    ...parentNativeId ? { parentAgentId: parentNativeId } : {},
     ...knownName ? { title: knownName } : {},
     ...model ? { model } : {},
     ...effort ? { effort } : {},
@@ -1747,8 +3231,8 @@ function mapCollabAgentEvent(input) {
     ];
   }
   if (method === "collabAgent/tokenUsage") {
-    const tokenUsage = isRecord3(input.params["tokenUsage"]) ? input.params["tokenUsage"] : void 0;
-    const total = tokenUsage && isRecord3(tokenUsage["total"]) ? tokenUsage["total"] : void 0;
+    const tokenUsage = isRecord2(input.params["tokenUsage"]) ? input.params["tokenUsage"] : void 0;
+    const total = tokenUsage && isRecord2(tokenUsage["total"]) ? tokenUsage["total"] : void 0;
     const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
     const totalTokens = total ? count(total["totalTokens"]) : void 0;
     if (total === void 0 || totalTokens === void 0) return [];
@@ -1783,18 +3267,18 @@ function mapCollabAgentEvent(input) {
 
 // src/events/userInput.ts
 function toUserInputQuestions(params) {
-  if (!isRecord3(params)) return void 0;
+  if (!isRecord2(params)) return void 0;
   const questions = Array.isArray(params["questions"]) ? params["questions"] : [];
   const mapped = [];
   for (const question of questions) {
-    if (!isRecord3(question)) return void 0;
+    if (!isRecord2(question)) return void 0;
     const id = asString(question["id"]);
     const header = asString(question["header"]);
     const text = asString(question["question"]);
     const rawOptions = Array.isArray(question["options"]) ? question["options"] : [];
     const options = [];
     for (const option of rawOptions) {
-      if (!isRecord3(option)) continue;
+      if (!isRecord2(option)) continue;
       const label = trimText(option["label"]);
       if (!label) continue;
       options.push({
@@ -1815,12 +3299,12 @@ function toUserInputQuestions(params) {
   return mapped.length > 0 ? mapped : void 0;
 }
 function toAsyncQuestions(params) {
-  if (!isRecord3(params)) return void 0;
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return void 0;
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   if (item["delivery"] !== "async" || !Array.isArray(item["questions"])) return void 0;
   const mapped = [];
   item["questions"].forEach((question, index) => {
-    if (!isRecord3(question)) return;
+    if (!isRecord2(question)) return;
     const title = trimText(question["title"]);
     if (!title) return;
     const labels = Array.isArray(question["options"]) ? question["options"] : [];
@@ -1837,7 +3321,7 @@ function toAsyncQuestions(params) {
   return mapped.length > 0 ? mapped : void 0;
 }
 function toCodexUserInputAnswers(answers) {
-  if (!isRecord3(answers)) return void 0;
+  if (!isRecord2(answers)) return void 0;
   const out = {};
   for (const [questionId, value] of Object.entries(answers)) {
     if (typeof value === "string") {
@@ -1848,7 +3332,7 @@ function toCodexUserInputAnswers(answers) {
       out[questionId] = { answers: [...value] };
       continue;
     }
-    if (isRecord3(value) && Array.isArray(value["answers"]) && value["answers"].every((entry) => typeof entry === "string")) {
+    if (isRecord2(value) && Array.isArray(value["answers"]) && value["answers"].every((entry) => typeof entry === "string")) {
       out[questionId] = { answers: [...value["answers"]] };
       continue;
     }
@@ -1867,8 +3351,8 @@ function toCanonicalUserInputAnswers(answers) {
 
 // src/windowsSandbox.ts
 function windowsSandboxWarnings(input) {
-  const item = isRecord3(input.params) ? input.params["item"] : void 0;
-  if (!isRecord3(item) || item["type"] !== "commandExecution" || item["source"] !== "unifiedExecStartup" || item["status"] !== "failed" || item["processId"] !== null || item["exitCode"] !== -1 || item["durationMs"] !== 0)
+  const item = isRecord2(input.params) ? input.params["item"] : void 0;
+  if (!isRecord2(item) || item["type"] !== "commandExecution" || item["source"] !== "unifiedExecStartup" || item["status"] !== "failed" || item["processId"] !== null || item["exitCode"] !== -1 || item["durationMs"] !== 0)
     return [];
   const output = item["aggregatedOutput"];
   if (typeof output !== "string" || !/^Failed to create unified exec process: (?:CreateProcessWithLogonW failed: \d+\b|orchestrator_helper_launch_canceled: ShellExecuteExW failed to launch setup helper: \d+\b)/.test(
@@ -2209,10 +3693,10 @@ function mapNotificationToEvents(input) {
     return mapCollabAgentEvent({ method, params, rootThreadId: threadId, providerInstanceId });
   }
   if (method === "error") {
-    if (isUsageLimitExceeded(isRecord3(params) ? params["error"] : void 0)) return [];
-    const willRetry = isRecord3(params) && params["willRetry"] === true;
-    const nested = isRecord3(params) && isRecord3(params["error"]) ? params["error"] : void 0;
-    const message = (nested ? trimText(nested["message"]) : void 0) ?? (isRecord3(params) ? trimText(params["message"]) : void 0) ?? "Codex error";
+    if (isUsageLimitExceeded(isRecord2(params) ? params["error"] : void 0)) return [];
+    const willRetry = isRecord2(params) && params["willRetry"] === true;
+    const nested = isRecord2(params) && isRecord2(params["error"]) ? params["error"] : void 0;
+    const message = (nested ? trimText(nested["message"]) : void 0) ?? (isRecord2(params) ? trimText(params["message"]) : void 0) ?? "Codex error";
     const payload = { message };
     if (!willRetry) payload["class"] = "provider_error";
     if (params !== void 0) payload["detail"] = params;
@@ -2228,7 +3712,7 @@ function mapNotificationToEvents(input) {
     ];
   }
   if (method === "process/stderr") {
-    const text = isRecord3(params) ? trimText(params["text"]) ?? "" : "";
+    const text = isRecord2(params) ? trimText(params["text"]) ?? "" : "";
     if (!text) return [];
     if (isFatalStderr(text)) {
       return [
@@ -2256,8 +3740,8 @@ function mapNotificationToEvents(input) {
   const type = itemTypeOf(params);
   switch (method) {
     case "thread/started": {
-      const startedThread = isRecord3(params) ? params["thread"] : void 0;
-      const providerThreadId = isRecord3(startedThread) ? trimText(startedThread["id"]) : void 0;
+      const startedThread = isRecord2(params) ? params["thread"] : void 0;
+      const providerThreadId = isRecord2(startedThread) ? trimText(startedThread["id"]) : void 0;
       return [
         baseEvent({
           type: "thread.started",
@@ -2269,7 +3753,7 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "thread/status/changed": {
-      const status = isRecord3(params) ? params["status"] : void 0;
+      const status = isRecord2(params) ? params["status"] : void 0;
       return [
         baseEvent({
           type: "thread.state.changed",
@@ -2329,8 +3813,8 @@ function mapNotificationToEvents(input) {
         })
       ];
     case "thread/name/updated": {
-      const threadName = isRecord3(params) ? trimText(params["threadName"]) ?? trimText(params["name"]) : void 0;
-      const nativeThreadId = isRecord3(params) ? asString(params["threadId"]) : void 0;
+      const threadName = isRecord2(params) ? trimText(params["threadName"]) ?? trimText(params["name"]) : void 0;
+      const nativeThreadId = isRecord2(params) ? asString(params["threadId"]) : void 0;
       return [
         baseEvent({
           type: "thread.metadata.updated",
@@ -2351,7 +3835,7 @@ function mapNotificationToEvents(input) {
     }
     case "thread/tokenUsage/updated": {
       const usage = normalizeCodexTokenUsage(
-        isRecord3(params) ? params["tokenUsage"] ?? params["usage"] : void 0
+        isRecord2(params) ? params["tokenUsage"] ?? params["usage"] : void 0
       );
       if (!usage) return [];
       return [
@@ -2388,8 +3872,8 @@ function mapNotificationToEvents(input) {
       ];
     case "turn/completed": {
       const controlFlow = turnCompletedControlFlow(params);
-      const turn = isRecord3(params) ? isRecord3(params["turn"]) ? params["turn"] : params : {};
-      const turnError = isRecord3(turn["error"]) ? turn["error"] : void 0;
+      const turn = isRecord2(params) ? isRecord2(params["turn"]) ? params["turn"] : params : {};
+      const turnError = isRecord2(turn["error"]) ? turn["error"] : void 0;
       if (controlFlow.state === "failed" && isUsageLimitExceeded(turnError)) {
         const message = codexUsageLimitMessage(
           rateLimits,
@@ -2434,7 +3918,7 @@ function mapNotificationToEvents(input) {
           threadId,
           turnId,
           payload: {
-            reason: (isRecord3(params) ? trimText(params["reason"]) : void 0) ?? (isRecord3(params) ? trimText(params["message"]) : void 0) ?? "Turn aborted"
+            reason: (isRecord2(params) ? trimText(params["reason"]) : void 0) ?? (isRecord2(params) ? trimText(params["message"]) : void 0) ?? "Turn aborted"
           },
           method,
           providerInstanceId
@@ -2442,12 +3926,12 @@ function mapNotificationToEvents(input) {
       ];
     case "turn/plan":
     case "turn/plan/updated": {
-      const rawPlan = isRecord3(params) && Array.isArray(params["plan"]) ? params["plan"] : [];
-      const plan = rawPlan.filter(isRecord3).map((step) => ({
+      const rawPlan = isRecord2(params) && Array.isArray(params["plan"]) ? params["plan"] : [];
+      const plan = rawPlan.filter(isRecord2).map((step) => ({
         step: trimText(step["step"]) ?? "step",
         status: step["status"] === "completed" || step["status"] === "inProgress" ? step["status"] : "pending"
       }));
-      const explanation = isRecord3(params) ? trimText(params["explanation"]) : void 0;
+      const explanation = isRecord2(params) ? trimText(params["explanation"]) : void 0;
       return [
         baseEvent({
           type: "turn.plan.updated",
@@ -2463,7 +3947,7 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "turn/diff/updated": {
-      const unifiedDiff = isRecord3(params) ? asString(params["diff"]) : void 0;
+      const unifiedDiff = isRecord2(params) ? asString(params["diff"]) : void 0;
       if (unifiedDiff === void 0) return [];
       return [
         baseEvent({
@@ -2611,7 +4095,7 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "item/plan/delta": {
-      const delta = isRecord3(params) ? asString(params["delta"]) : void 0;
+      const delta = isRecord2(params) ? asString(params["delta"]) : void 0;
       if (!delta) return [];
       return [
         baseEvent({
@@ -2630,11 +4114,11 @@ function mapNotificationToEvents(input) {
     case "item/reasoning/summaryTextDelta":
     case "item/commandExecution/outputDelta":
     case "item/fileChange/outputDelta": {
-      const delta = isRecord3(params) ? asString(params["delta"]) ?? asString(params["text"]) ?? "" : "";
+      const delta = isRecord2(params) ? asString(params["delta"]) ?? asString(params["text"]) ?? "" : "";
       if (delta.length === 0) return [];
       const streamKind = method === "item/agentMessage/delta" ? "assistant_text" : method === "item/reasoning/textDelta" ? "reasoning_text" : method === "item/reasoning/summaryTextDelta" ? "reasoning_summary_text" : method === "item/commandExecution/outputDelta" ? "command_output" : "file_change_output";
-      const summaryIndex = method === "item/reasoning/summaryTextDelta" && isRecord3(params) ? asNumber(params["summaryIndex"]) : null;
-      const contentIndex = method === "item/reasoning/textDelta" && isRecord3(params) ? asNumber(params["contentIndex"]) : null;
+      const summaryIndex = method === "item/reasoning/summaryTextDelta" && isRecord2(params) ? asNumber(params["summaryIndex"]) : null;
+      const contentIndex = method === "item/reasoning/textDelta" && isRecord2(params) ? asNumber(params["contentIndex"]) : null;
       return [
         baseEvent({
           type: "content.delta",
@@ -2653,7 +4137,7 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "item/reasoning/summaryPartAdded": {
-      const summaryIndex = isRecord3(params) ? asNumber(params["summaryIndex"]) : null;
+      const summaryIndex = isRecord2(params) ? asNumber(params["summaryIndex"]) : null;
       if (summaryIndex === null) return [];
       return [
         baseEvent({
@@ -2672,7 +4156,7 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "item/mcpToolCall/progress": {
-      const summary = isRecord3(params) ? trimText(params["message"]) : void 0;
+      const summary = isRecord2(params) ? trimText(params["message"]) : void 0;
       if (!summary) return [];
       return [
         baseEvent({
@@ -2717,16 +4201,16 @@ function mapNotificationToEvents(input) {
           type: "account.rate-limits.updated",
           threadId,
           payload: {
-            rateLimits: isRecord3(params) && "rateLimits" in params ? params["rateLimits"] : params ?? {}
+            rateLimits: isRecord2(params) && "rateLimits" in params ? params["rateLimits"] : params ?? {}
           },
           method,
           providerInstanceId
         })
       ];
     case "model/rerouted": {
-      const fromModel = isRecord3(params) ? trimText(params["fromModel"]) : void 0;
-      const toModel = isRecord3(params) ? trimText(params["toModel"]) : void 0;
-      const reason = isRecord3(params) ? trimText(params["reason"]) : void 0;
+      const fromModel = isRecord2(params) ? trimText(params["fromModel"]) : void 0;
+      const toModel = isRecord2(params) ? trimText(params["toModel"]) : void 0;
+      const reason = isRecord2(params) ? trimText(params["reason"]) : void 0;
       if (!fromModel || !toModel || !reason) return [];
       return [
         baseEvent({
@@ -2741,9 +4225,9 @@ function mapNotificationToEvents(input) {
     }
     case "configWarning":
     case "deprecationNotice": {
-      const summary = isRecord3(params) ? trimText(params["summary"]) : void 0;
+      const summary = isRecord2(params) ? trimText(params["summary"]) : void 0;
       if (!summary) return [];
-      const details = isRecord3(params) ? trimText(params["details"]) : void 0;
+      const details = isRecord2(params) ? trimText(params["details"]) : void 0;
       return [
         baseEvent({
           type: method === "configWarning" ? "config.warning" : "deprecation.notice",
@@ -2751,7 +4235,7 @@ function mapNotificationToEvents(input) {
           payload: {
             summary,
             ...details ? { details } : {},
-            ...method === "configWarning" && isRecord3(params) ? {
+            ...method === "configWarning" && isRecord2(params) ? {
               ...trimText(params["path"]) ? { path: trimText(params["path"]) } : {},
               ...params["range"] !== void 0 && params["range"] !== null ? { range: params["range"] } : {}
             } : {}
@@ -2762,10 +4246,10 @@ function mapNotificationToEvents(input) {
       ];
     }
     case "mcpServer/oauthLogin/completed": {
-      const success = isRecord3(params) ? params["success"] : void 0;
+      const success = isRecord2(params) ? params["success"] : void 0;
       if (typeof success !== "boolean") return [];
-      const name = isRecord3(params) ? trimText(params["name"]) : void 0;
-      const error = isRecord3(params) ? trimText(params["error"]) : void 0;
+      const name = isRecord2(params) ? trimText(params["name"]) : void 0;
+      const error = isRecord2(params) ? trimText(params["error"]) : void 0;
       return [
         baseEvent({
           type: "mcp.oauth.completed",
@@ -2787,17 +4271,17 @@ function mapNotificationToEvents(input) {
 
 // src/approvalMapping.ts
 function fileChangeEntries(params) {
-  if (!isRecord3(params)) return [];
-  const item = isRecord3(params["item"]) ? params["item"] : params;
+  if (!isRecord2(params)) return [];
+  const item = isRecord2(params["item"]) ? params["item"] : params;
   const changes = item["changes"] ?? item["fileChanges"] ?? params["fileChanges"];
-  if (!isRecord3(changes) && !Array.isArray(changes)) return [];
+  if (!isRecord2(changes) && !Array.isArray(changes)) return [];
   const entries = Array.isArray(changes) ? changes : Object.entries(changes).map(([path, change]) => ({
     path,
-    ...isRecord3(change) ? change : {}
+    ...isRecord2(change) ? change : {}
   }));
   const out = [];
   for (const entry of entries) {
-    if (!isRecord3(entry)) continue;
+    if (!isRecord2(entry)) continue;
     const path = asString(entry["path"]) ?? asString(entry["file"]);
     if (!path) continue;
     out.push({
@@ -2855,7 +4339,7 @@ function toApplyPatchFileChanges(params) {
   return out;
 }
 function describeCommandApproval(params) {
-  const record = isRecord3(params) ? params : {};
+  const record = isRecord2(params) ? params : {};
   const commandValue = record["command"];
   const command = Array.isArray(commandValue) ? commandValue.filter((entry) => typeof entry === "string").join(" ") : asString(commandValue) ?? "";
   const cwd = asString(record["cwd"]);
@@ -2869,7 +4353,7 @@ function describeCommandApproval(params) {
   };
 }
 function describeFileChangeApproval(params) {
-  const record = isRecord3(params) ? params : {};
+  const record = isRecord2(params) ? params : {};
   const reason = trimText(record["reason"]);
   const grantRoot = asString(record["grantRoot"]);
   const callId = asString(record["callId"]);
@@ -2883,16 +4367,16 @@ function describeFileChangeApproval(params) {
   };
 }
 function describePermissionsApproval(params) {
-  const record = isRecord3(params) ? params : {};
-  const permissions = isRecord3(record["permissions"]) ? record["permissions"] : {};
-  const fileSystem = isRecord3(permissions["fileSystem"]) ? permissions["fileSystem"] : {};
-  const network = isRecord3(permissions["network"]) ? permissions["network"] : {};
+  const record = isRecord2(params) ? params : {};
+  const permissions = isRecord2(record["permissions"]) ? record["permissions"] : {};
+  const fileSystem = isRecord2(permissions["fileSystem"]) ? permissions["fileSystem"] : {};
+  const network = isRecord2(permissions["network"]) ? permissions["network"] : {};
   const pathsOf = (value) => Array.isArray(value) ? value.flatMap((entry) => typeof entry === "string" && entry.length > 0 ? [entry] : []) : [];
   const read = pathsOf(fileSystem["read"]);
   const write = pathsOf(fileSystem["write"]);
   const entries = Array.isArray(fileSystem["entries"]) ? fileSystem["entries"] : [];
   for (const entry of entries) {
-    if (!isRecord3(entry) || !isRecord3(entry["path"])) continue;
+    if (!isRecord2(entry) || !isRecord2(entry["path"])) continue;
     const target = entry["path"];
     const path = target["type"] === "path" ? asString(target["path"]) : target["type"] === "glob_pattern" ? asString(target["pattern"]) : void 0;
     if (!path) continue;
@@ -2909,7 +4393,7 @@ function describePermissionsApproval(params) {
 }
 function toPermissionsResponse(decision, params, persistent) {
   if (decision !== "allow") return { permissions: {} };
-  const requested = isRecord3(params) && isRecord3(params["permissions"]) ? params["permissions"] : {};
+  const requested = isRecord2(params) && isRecord2(params["permissions"]) ? params["permissions"] : {};
   return {
     permissions: {
       ...requested["fileSystem"] !== void 0 ? { fileSystem: requested["fileSystem"] } : {},
@@ -2919,7 +4403,7 @@ function toPermissionsResponse(decision, params, persistent) {
   };
 }
 function describeMcpElicitation(params) {
-  const record = isRecord3(params) ? params : {};
+  const record = isRecord2(params) ? params : {};
   const appName = asString(record["appName"]) ?? asString(record["serverName"]) ?? void 0;
   const serverName = asString(record["serverName"]);
   const message = trimText(record["message"]);
@@ -2936,7 +4420,7 @@ function describeMcpElicitation(params) {
   };
 }
 function persistFromMeta(meta) {
-  if (!isRecord3(meta)) return void 0;
+  if (!isRecord2(meta)) return void 0;
   const persist = asString(meta["persist"]) ?? asString(meta["persistence"]);
   if (persist === "session" || persist === "acceptForSession") return "session";
   if (persist === "always" || persist === "permanent" || persist === "forever" || persist === "persistent" || persist === "acceptAlways") {
@@ -2951,16 +4435,16 @@ function toMcpElicitationResponse(decision, params) {
       action: decision === "allow" ? "decline" : decision === "cancel" ? "cancel" : "decline"
     };
   }
-  const schema = isRecord3(described.schema) ? described.schema : void 0;
-  const properties = schema && isRecord3(schema["properties"]) ? schema["properties"] : {};
+  const schema = isRecord2(described.schema) ? described.schema : void 0;
+  const properties = schema && isRecord2(schema["properties"]) ? schema["properties"] : {};
   const required = schema && Array.isArray(schema["required"]) ? schema["required"] : [];
   const content = {};
   for (const [key, spec] of Object.entries(properties)) {
-    if (!isRecord3(spec)) continue;
+    if (!isRecord2(spec)) continue;
     if (Array.isArray(spec["oneOf"]) || Array.isArray(spec["enum"])) {
       const options = Array.isArray(spec["oneOf"]) ? spec["oneOf"] : Array.isArray(spec["enum"]) ? spec["enum"] : [];
       const first = options[0];
-      content[key] = isRecord3(first) ? first["const"] ?? first["value"] ?? first : first;
+      content[key] = isRecord2(first) ? first["const"] ?? first["value"] ?? first : first;
     } else if (spec["type"] === "boolean") {
       content[key] = true;
     } else if (typeof spec["default"] !== "undefined") {
@@ -2972,7 +4456,7 @@ function toMcpElicitationResponse(decision, params) {
       return { action: "decline" };
     }
   }
-  const persist = persistFromMeta(isRecord3(params) ? params["_meta"] : void 0);
+  const persist = persistFromMeta(isRecord2(params) ? params["_meta"] : void 0);
   return {
     action: "accept",
     content,
@@ -3023,7 +4507,7 @@ function toRequestTypeFromMethod(method) {
   }
 }
 function elicitationOptions(params) {
-  const persist = persistFromMeta(isRecord3(params) ? params["_meta"] : void 0);
+  const persist = persistFromMeta(isRecord2(params) ? params["_meta"] : void 0);
   return [
     { decision: "cancel", label: "Cancel" },
     { decision: "decline", label: "Decline" },
@@ -3122,15 +4606,15 @@ function posixCommandMatches(expected, argv) {
   return posixShellCommandMatches({ shell, script }, argv);
 }
 var windowsPath = (path) => path.replaceAll("/", "\\").toLowerCase();
-function basename(path) {
+function basename2(path) {
   const parts = path.split(/[\\/]/);
   return (parts[parts.length - 1] ?? "").toLowerCase();
 }
 function codexCommandMatcher(display) {
   const expected = splitPosixCommand(display);
   if (expected === null || expected.length === 0) return void 0;
-  return (argv, platform2) => {
-    if (platform2 !== "win32") return posixCommandMatches(expected, argv);
+  return (argv, platform3) => {
+    if (platform3 !== "win32") return posixCommandMatches(expected, argv);
     if (argv.length !== expected.length) return false;
     const [actualExe, ...actualRest] = argv;
     const [expectedExe, ...expectedRest] = expected;
@@ -3140,32 +4624,32 @@ function codexCommandMatcher(display) {
     return expectedRest.every((arg, index) => {
       const actual = actualRest[index];
       if (actual === arg) return true;
-      return index === lastIndex && index >= 1 && expectedRest[index - 1]?.toLowerCase() === "-command" && isPowerShellExecutableName(basename(expectedExe)) && actual === WINDOWS_POWERSHELL_PREFIX + arg;
+      return index === lastIndex && index >= 1 && expectedRest[index - 1]?.toLowerCase() === "-command" && isPowerShellExecutableName(basename2(expectedExe)) && actual === WINDOWS_POWERSHELL_PREFIX + arg;
     });
   };
 }
-function trackOpenCommand(open, method, params) {
-  if (!isRecord3(params)) return;
+function trackOpenCommand(open2, method, params) {
+  if (!isRecord2(params)) return;
   const turnId = turnIdOf(params);
   if (method === "turn/completed") {
-    for (const [id2, entry] of open) {
-      if (turnId === void 0 || entry.turnId === turnId) open.delete(id2);
+    for (const [id2, entry] of open2) {
+      if (turnId === void 0 || entry.turnId === turnId) open2.delete(id2);
     }
     return;
   }
   const item = params["item"];
-  if (!isRecord3(item) || item["type"] !== "commandExecution") return;
+  if (!isRecord2(item) || item["type"] !== "commandExecution") return;
   const id = item["id"];
   if (typeof id !== "string") return;
   if (method === "item/completed") {
-    open.delete(id);
+    open2.delete(id);
     return;
   }
   if (method !== "item/started") return;
   const startedAtMs = params["startedAtMs"];
   const command = item["command"];
   if (typeof startedAtMs !== "number" || typeof command !== "string") return;
-  open.set(id, { turnId, startedAtMs, command });
+  open2.set(id, { turnId, startedAtMs, command });
 }
 function codexSessionProcessMatcher(appServerArgs) {
   return (argv) => argv.length === appServerArgs.length + 1 && sameArgv(argv.slice(1), appServerArgs);
@@ -3253,7 +4737,7 @@ function isRootChild(agentPath, agentThreadId, rootThreadId) {
 function readSubAgentActivity(method, params) {
   if (method !== "item/started" && method !== "item/completed") return void 0;
   if (itemTypeOf(params) !== "subAgentActivity") return void 0;
-  const item = isRecord3(params) ? isRecord3(params["item"]) ? params["item"] : params : {};
+  const item = isRecord2(params) ? isRecord2(params["item"]) ? params["item"] : params : {};
   return {
     agentThreadId: asString(item["agentThreadId"]) ?? void 0,
     agentPath: asString(item["agentPath"]) ?? void 0
@@ -3265,17 +4749,18 @@ var CodexSessionCollab = class {
     this.runtime = runtime;
   }
   interceptCollab(method, params, conversationId) {
-    const thread = isRecord3(params) && isRecord3(params["thread"]) ? params["thread"] : void 0;
+    const thread = isRecord2(params) && isRecord2(params["thread"]) ? params["thread"] : void 0;
     const source = thread === void 0 ? void 0 : thread["source"];
-    const subAgent = isRecord3(source) ? source["subAgent"] : void 0;
-    const spawn = isRecord3(subAgent) ? subAgent["thread_spawn"] : void 0;
-    if (method === "thread/started" && thread !== void 0 && isRecord3(spawn)) {
+    const subAgent = isRecord2(source) ? source["subAgent"] : void 0;
+    const spawn = isRecord2(subAgent) ? subAgent["thread_spawn"] : void 0;
+    if (method === "thread/started" && thread !== void 0 && isRecord2(spawn)) {
       const agentPath = asString(spawn["agent_path"]) ?? void 0;
       const knownPath = agentPath ?? this.runtime.collabChildren.get(conversationId)?.agentPath;
       if (isRootChild(knownPath, conversationId, this.runtime.nativeThreadId ?? this.runtime.threadId))
         return;
       this.upsertCollabChild(conversationId, {
         agentPath,
+        parentThreadId: asString(spawn["parent_thread_id"]) ?? void 0,
         role: asString(spawn["agent_role"]) ?? asString(thread["agentRole"]) ?? void 0,
         nickname: asString(spawn["agent_nickname"]) ?? asString(thread["agentNickname"]) ?? void 0
       });
@@ -3283,7 +4768,7 @@ var CodexSessionCollab = class {
     }
     const itemType = itemTypeOf(params);
     if ((method === "item/started" || method === "item/completed") && itemType === "collabAgentToolCall") {
-      const item = isRecord3(params) ? isRecord3(params["item"]) ? params["item"] : params : {};
+      const item = isRecord2(params) ? isRecord2(params["item"]) ? params["item"] : params : {};
       const receiver = asString(item["receiverThreadId"]) ?? asString(item["agentThreadId"]);
       if (receiver && this.runtime.activeTurnId)
         this.runtime.collabReceiverTurns.set(receiver, this.runtime.activeTurnId);
@@ -3299,13 +4784,15 @@ var CodexSessionCollab = class {
       )) {
         return;
       }
-      this.upsertCollabChild(agentThreadId, { agentPath: activity.agentPath });
+      this.upsertCollabChild(agentThreadId, {
+        agentPath: activity.agentPath
+      });
     }
     if (method === "thread/settings/updated" || method === "model/rerouted") {
-      const settings = isRecord3(params) && isRecord3(params["threadSettings"]) ? params["threadSettings"] : {};
+      const settings = isRecord2(params) && isRecord2(params["threadSettings"]) ? params["threadSettings"] : {};
       const reroute = method === "model/rerouted";
       const model = metaValue(
-        reroute ? isRecord3(params) ? params["toModel"] : void 0 : settings["model"]
+        reroute ? isRecord2(params) ? params["toModel"] : void 0 : settings["model"]
       );
       const effort = reroute ? void 0 : metaValue(settings["effort"]);
       this.updateCollabChildMeta(conversationId, { model, effort }, true);
@@ -3333,7 +4820,7 @@ var CodexSessionCollab = class {
       return;
     }
     if (method === "turn/completed") {
-      const turn = isRecord3(params) && isRecord3(params["turn"]) ? params["turn"] : void 0;
+      const turn = isRecord2(params) && isRecord2(params["turn"]) ? params["turn"] : void 0;
       const turnStatus = turn === void 0 ? void 0 : asString(turn["status"]) ?? void 0;
       child.status = collabTurnEndStatus(turnStatus);
       this.emitCollab(
@@ -3344,7 +4831,7 @@ var CodexSessionCollab = class {
       return;
     }
     if (method === "error") {
-      const willRetry = isRecord3(params) ? params["willRetry"] === true : false;
+      const willRetry = isRecord2(params) ? params["willRetry"] === true : false;
       if (willRetry) return;
       child.status = "failed";
       this.emitCollab("collabAgent/statusChanged", child, { status: "systemError" });
@@ -3361,8 +4848,8 @@ var CodexSessionCollab = class {
   }
   /**
    * 两条登记路（根线程的 subAgentActivity、子线程的 thread/started）都走这里。
-   * 第一次见到就登记并宣布；已登记的只合并身份：已有的字段保留，缺的补上，补到了就发
-   * 一条带当前状态的元数据更新。不能再宣布一次：一轮结束之后才到的宣布，会让宿主把
+   * 第一次见到就登记并宣布；普通身份字段只补缺，出生父号以 thread_spawn 为准并可纠正旧值。
+   * 补到身份后发一条带当前状态的元数据更新。不能再宣布一次：一轮结束之后才到的宣布，会让宿主把
    * idle 当成新一轮开始。
    */
   upsertCollabChild(agentThreadId, identity) {
@@ -3371,6 +4858,7 @@ var CodexSessionCollab = class {
     const agentPath = fill(existing?.agentPath, identity.agentPath);
     const role = fill(existing?.role, identity.role);
     const nickname = fill(existing?.nickname, identity.nickname);
+    const parentThreadId = identity.parentThreadId !== void 0 && identity.parentThreadId.length > 0 ? identity.parentThreadId : existing?.parentThreadId;
     if (existing === void 0) {
       const spawnTurnId = this.runtime.activeTurnId;
       const child = {
@@ -3378,6 +4866,7 @@ var CodexSessionCollab = class {
         ...agentPath ? { agentPath } : {},
         ...role ? { role } : {},
         ...nickname ? { nickname } : {},
+        ...parentThreadId ? { parentThreadId } : {},
         ...spawnTurnId ? { spawnTurnId } : {},
         status: "running"
       };
@@ -3386,14 +4875,15 @@ var CodexSessionCollab = class {
       this.startCollabChildMetaLookup(agentThreadId);
       return;
     }
-    if (agentPath === existing.agentPath && role === existing.role && nickname === existing.nickname) {
+    if (agentPath === existing.agentPath && role === existing.role && nickname === existing.nickname && parentThreadId === existing.parentThreadId) {
       return;
     }
     const merged = {
       ...existing,
       ...agentPath ? { agentPath } : {},
       ...role ? { role } : {},
-      ...nickname ? { nickname } : {}
+      ...nickname ? { nickname } : {},
+      ...parentThreadId ? { parentThreadId } : {}
     };
     this.runtime.collabChildren.set(agentThreadId, merged);
     this.emitCollab("collabAgent/metadata", merged, { status: merged.status });
@@ -3437,9 +4927,9 @@ var CodexSessionCollab = class {
       { threadId: agentThreadId, excludeTurns: true },
       COLLAB_META_LOOKUP_TIMEOUT_MS
     ).then((response) => {
-      if (this.runtime.closed || meta.closed || !isRecord3(response)) return;
+      if (this.runtime.closed || meta.closed || !isRecord2(response)) return;
       const thread = response["thread"];
-      if (!isRecord3(thread) || thread["id"] !== agentThreadId) return;
+      if (!isRecord2(thread) || thread["id"] !== agentThreadId) return;
       this.updateCollabChildMeta(
         agentThreadId,
         { model: metaValue(response["model"]), effort: metaValue(response["reasoningEffort"]) },
@@ -3454,9 +4944,10 @@ var CodexSessionCollab = class {
       agentPath: child.agentPath,
       agentRole: child.role ?? pathLeaf(child.agentPath) ?? "general-purpose",
       agentNickname: child.nickname,
+      ...child.parentThreadId && child.parentThreadId !== (this.runtime.nativeThreadId ?? this.runtime.threadId) ? { parentThreadId: child.parentThreadId } : {},
       ...meta?.model ? { model: meta.model } : {},
       ...meta?.effort ? { effort: meta.effort } : {},
-      ...isRecord3(extra) ? extra : {}
+      ...isRecord2(extra) ? extra : {}
     };
     for (const event of mapNotificationToEvents({
       method,
@@ -3470,9 +4961,9 @@ var CodexSessionCollab = class {
 };
 
 // src/sessionRequests.ts
-function cancelWireFor(pending) {
-  if (pending.kind === "permission") return toPermissionsResponse("cancel", pending.params, false);
-  return pending.kind === "mcp-elicitation" ? toMcpElicitationResponse("cancel", pending.params) : { decision: "cancel" };
+function cancelWireFor(pending2) {
+  if (pending2.kind === "permission") return toPermissionsResponse("cancel", pending2.params, false);
+  return pending2.kind === "mcp-elicitation" ? toMcpElicitationResponse("cancel", pending2.params) : { decision: "cancel" };
 }
 function unconfirmedAnswerError(requestId, delivery) {
   return new Error(
@@ -3526,7 +5017,7 @@ var CodexSessionRequests = class {
         method,
         params,
         "permission",
-        isRecord3(params) ? asString(params["itemId"]) ?? "permission" : "permission"
+        isRecord2(params) ? asString(params["itemId"]) ?? "permission" : "permission"
       );
       return;
     }
@@ -3543,12 +5034,12 @@ var CodexSessionRequests = class {
         await this.runtime.rpc.respond(id, {});
         return;
       }
-      await new Promise((resolve2) => {
+      await new Promise((resolve4) => {
         this.runtime.pendingUserInputs.set(requestId, {
           jsonRpcId: id,
           settle: (result) => {
             this.runtime.pendingUserInputs.delete(requestId);
-            void this.runtime.rpc.respond(id, result).catch((error) => this.#warnAnswerWriteFailed(method, id, error)).finally(resolve2);
+            void this.runtime.rpc.respond(id, result).catch((error) => this.#warnAnswerWriteFailed(method, id, error)).finally(resolve4);
           }
         });
         for (const event of events) this.runtime.emit(event);
@@ -3573,7 +5064,7 @@ var CodexSessionRequests = class {
       providerInstanceId: this.runtime.host.instanceId
     });
     this.runtime.requestKinds.set(requestId, kind);
-    await new Promise((resolve2) => {
+    await new Promise((resolve4) => {
       this.runtime.pendingApprovals.set(requestId, {
         jsonRpcId: id,
         method,
@@ -3582,35 +5073,35 @@ var CodexSessionRequests = class {
         identity,
         settle: (decision) => {
           this.runtime.pendingApprovals.delete(requestId);
-          void this.runtime.rpc.respond(id, decision).catch((error) => this.#warnAnswerWriteFailed(method, id, error)).finally(resolve2);
+          void this.runtime.rpc.respond(id, decision).catch((error) => this.#warnAnswerWriteFailed(method, id, error)).finally(resolve4);
         },
         release: () => {
           this.runtime.pendingApprovals.delete(requestId);
-          resolve2();
+          resolve4();
         }
       });
       for (const event of events) this.runtime.emit(event);
     });
   }
   async respondToRequest(requestId, decision, reason, persist) {
-    const pending = this.runtime.pendingApprovals.get(requestId);
-    if (!pending) throw new Error(`Unknown pending Codex approval request: ${requestId}`);
+    const pending2 = this.runtime.pendingApprovals.get(requestId);
+    if (!pending2) throw new Error(`Unknown pending Codex approval request: ${requestId}`);
     if (decision === "deny" && reason)
       this.runtime.declineRelay.queue(this.runtime.threadId, reason);
     let wire = { decision: decision === "allow" ? "accept" : "decline" };
-    if (decision === "allow" && pending.kind === "mcp-elicitation") {
-      wire = toMcpElicitationResponse("allow", pending.params);
+    if (decision === "allow" && pending2.kind === "mcp-elicitation") {
+      wire = toMcpElicitationResponse("allow", pending2.params);
     }
-    if (pending.kind === "permission") {
-      wire = toPermissionsResponse(decision, pending.params, persist !== void 0);
+    if (pending2.kind === "permission") {
+      wire = toPermissionsResponse(decision, pending2.params, persist !== void 0);
     } else if (decision === "allow" && persist) {
-      this.runtime.grants.remember(codexApprovalGrantKey(pending.kind, pending.identity), persist);
-      if (pending.kind !== "mcp-elicitation") {
-        wire = { decision: wireDecisionFromPersist(pending.kind, persist) };
+      this.runtime.grants.remember(codexApprovalGrantKey(pending2.kind, pending2.identity), persist);
+      if (pending2.kind !== "mcp-elicitation") {
+        wire = { decision: wireDecisionFromPersist(pending2.kind, persist) };
       }
     }
-    const ack = this.runtime.registerWriteAck(pending.jsonRpcId);
-    pending.settle(wire);
+    const ack = this.runtime.registerWriteAck(pending2.jsonRpcId);
+    pending2.settle(wire);
     const delivery = await ack.catch(() => "closed");
     this.runtime.emit({
       eventId: nextEventId(),
@@ -3621,7 +5112,7 @@ var CodexSessionRequests = class {
       requestId,
       // requestType 是契约必填；缺了它宿主整条解不动，卡片停在「等待决议」。
       payload: {
-        requestType: toRequestTypeFromKind(pending.kind),
+        requestType: toRequestTypeFromKind(pending2.kind),
         decision,
         ...reason ? { reason } : {}
       }
@@ -3629,14 +5120,14 @@ var CodexSessionRequests = class {
     if (delivery !== "written") throw unconfirmedAnswerError(requestId, delivery);
   }
   async respondToUserInput(requestId, answers) {
-    const pending = this.runtime.pendingUserInputs.get(requestId);
-    if (!pending) throw new Error(`Unknown pending Codex user input request: ${requestId}`);
+    const pending2 = this.runtime.pendingUserInputs.get(requestId);
+    if (!pending2) throw new Error(`Unknown pending Codex user input request: ${requestId}`);
     const mapped = toCodexUserInputAnswers(answers);
     if (mapped === void 0) {
       throw new Error(`invalid user input answers for request ${requestId}`);
     }
-    const ack = this.runtime.registerWriteAck(pending.jsonRpcId);
-    pending.settle({ answers: mapped });
+    const ack = this.runtime.registerWriteAck(pending2.jsonRpcId);
+    pending2.settle({ answers: mapped });
     const delivery = await ack.catch(() => "closed");
     this.runtime.emit({
       eventId: nextEventId(),
@@ -3652,8 +5143,8 @@ var CodexSessionRequests = class {
   }
   /** 把还挂着的审批答成「取消」，逐条发 request.resolved。 */
   cancelPendingApprovals() {
-    for (const [requestId, pending] of this.runtime.pendingApprovals) {
-      pending.settle(cancelWireFor(pending));
+    for (const [requestId, pending2] of this.runtime.pendingApprovals) {
+      pending2.settle(cancelWireFor(pending2));
       this.runtime.emit({
         eventId: nextEventId(),
         provider: CODEX_DRIVER_KIND,
@@ -3661,20 +5152,20 @@ var CodexSessionRequests = class {
         createdAt: nowIso(),
         type: "request.resolved",
         requestId,
-        payload: { requestType: toRequestTypeFromKind(pending.kind), decision: "cancel" }
+        payload: { requestType: toRequestTypeFromKind(pending2.kind), decision: "cancel" }
       });
     }
   }
   /** 会话收口时把还挂着的审批答成「取消」：应答形状按审批种类，权限审批不认 decision。 */
   settlePendingApprovals() {
-    for (const [requestId, pending] of this.runtime.pendingApprovals) {
-      pending.settle(cancelWireFor(pending));
+    for (const [requestId, pending2] of this.runtime.pendingApprovals) {
+      pending2.settle(cancelWireFor(pending2));
       this.runtime.pendingApprovals.delete(requestId);
     }
   }
   settlePendingUserInputs(result) {
-    for (const [requestId, pending] of this.runtime.pendingUserInputs) {
-      pending.settle(result);
+    for (const [requestId, pending2] of this.runtime.pendingUserInputs) {
+      pending2.settle(result);
       this.runtime.pendingUserInputs.delete(requestId);
     }
   }
@@ -3692,8 +5183,8 @@ async function markProviderRejection(run) {
 }
 
 // src/sessionRuntime.ts
-var sleep = (ms) => new Promise((resolve2) => {
-  setTimeout(resolve2, ms);
+var sleep = (ms) => new Promise((resolve4) => {
+  setTimeout(resolve4, ms);
 });
 var CodexSessionRuntime = class {
   threadId;
@@ -3747,7 +5238,7 @@ var CodexSessionRuntime = class {
    * 对外 requestId 的前缀，每个会话（即每个 app-server 进程）一份。JSON-RPC id 每个进程
    * 都从 0 数起，宿主按 requestId 记「已接受」，不加前缀的话重启后的新请求会撞上旧请求。
    */
-  #requestIdPrefix = `codex-${NodeCrypto2.randomUUID()}:`;
+  #requestIdPrefix = `codex-${NodeCrypto4.randomUUID()}:`;
   /** JSON-RPC id → 对外 requestId。`serverRequest/resolved` 里的 id 可能是数字也可能是字符串。 */
   requestIdFor(jsonRpcId) {
     return `${this.#requestIdPrefix}${String(jsonRpcId)}`;
@@ -3800,8 +5291,8 @@ var CodexSessionRuntime = class {
   }
   registerWriteAck(jsonRpcId) {
     if (this.closing) return Promise.resolve("closed");
-    return new Promise((resolve2) => {
-      this.writeAcks.set(jsonRpcId, { resolve: resolve2 });
+    return new Promise((resolve4) => {
+      this.writeAcks.set(jsonRpcId, { resolve: resolve4 });
     });
   }
   settleNativeWrite(requestId, status) {
@@ -3818,11 +5309,11 @@ var CodexSessionRuntime = class {
   async confirmAfterNativeWrite(jsonRpcId) {
     const existing = this.writeAcks.get(jsonRpcId);
     if (existing) {
-      return await new Promise((resolve2) => {
+      return await new Promise((resolve4) => {
         const previous = existing.resolve;
         existing.resolve = (status) => {
           previous(status);
-          resolve2(status);
+          resolve4(status);
         };
       });
     }
@@ -3862,7 +5353,7 @@ var CodexSessionRuntime = class {
       return;
     }
     if (method === "thread/started") {
-      const name = isRecord3(params) ? asString(params["name"]) ?? (isRecord3(params["thread"]) ? asString(params["thread"]["name"]) : null) : null;
+      const name = isRecord2(params) ? asString(params["name"]) ?? (isRecord2(params["thread"]) ? asString(params["thread"]["name"]) : null) : null;
       if (isMemoryConsolidationThread(name ?? void 0) && conversationId) {
         this.memoryThreadIds.add(conversationId);
         return;
@@ -3870,18 +5361,20 @@ var CodexSessionRuntime = class {
     }
     const activity = readSubAgentActivity(method, params);
     if (activity?.agentThreadId !== void 0 && !isRootChild(activity.agentPath, activity.agentThreadId, this.nativeThreadId ?? this.threadId)) {
-      this.#collab.upsertCollabChild(activity.agentThreadId, { agentPath: activity.agentPath });
+      this.#collab.upsertCollabChild(activity.agentThreadId, {
+        agentPath: activity.agentPath
+      });
     }
     this.dispatchMapped(method, params);
   }
   dispatchMapped(method, params) {
     if (method === "serverRequest/resolved") {
-      const rawId = isRecord3(params) ? params["requestId"] : void 0;
+      const rawId = isRecord2(params) ? params["requestId"] : void 0;
       if (typeof rawId !== "number" && typeof rawId !== "string") return;
       const resolvedId = this.requestIdFor(rawId);
-      const pending = this.pendingApprovals.get(resolvedId);
-      if (pending === void 0) return;
-      pending.release();
+      const pending2 = this.pendingApprovals.get(resolvedId);
+      if (pending2 === void 0) return;
+      pending2.release();
       this.emit({
         eventId: nextEventId(),
         provider: CODEX_DRIVER_KIND,
@@ -3897,7 +5390,7 @@ var CodexSessionRuntime = class {
       return;
     }
     trackOpenCommand(this.openCommands, method, params);
-    if (method === "account/rateLimits/updated" && isRecord3(params)) {
+    if (method === "account/rateLimits/updated" && isRecord2(params)) {
       this.rateLimits = mergeCodexRateLimits(this.rateLimits, params["rateLimits"]);
     }
     for (const event of mapNotificationToEvents({
@@ -4022,7 +5515,7 @@ var CodexSessionRuntime = class {
   async #imageInputs(attachments) {
     const items = [];
     for (const attachment of attachments ?? []) {
-      if (!isRecord3(attachment) || attachment["type"] !== "image") continue;
+      if (!isRecord2(attachment) || attachment["type"] !== "image") continue;
       const id = asString(attachment["id"]);
       const mimeType = asString(attachment["mimeType"]);
       if (!id || !mimeType) {
@@ -4141,10 +5634,10 @@ var CodexSessionRuntime = class {
         },
         0
       );
-      const thread = isRecord3(result) && isRecord3(result["thread"]) ? result["thread"] : null;
+      const thread = isRecord2(result) && isRecord2(result["thread"]) ? result["thread"] : null;
       const turnsRaw = thread && Array.isArray(thread["turns"]) ? thread["turns"] : [];
       const turns = turnsRaw.flatMap((turn) => {
-        if (!isRecord3(turn)) return [];
+        if (!isRecord2(turn)) return [];
         const id = asString(turn["id"]);
         if (!id) return [];
         return [{ id, items: Array.isArray(turn["items"]) ? turn["items"] : [] }];
@@ -4208,216 +5701,14 @@ var EventBus = class {
         const queued = this.#queued.shift();
         if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
         if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
-        return new Promise((resolve2) => {
-          this.#waiters.push(resolve2);
+        return new Promise((resolve4) => {
+          this.#waiters.push(resolve4);
         });
       }
     };
   }
 };
 
-// src/sessions.ts
-import * as NodeFS3 from "node:fs";
-import * as NodePath4 from "node:path";
-import * as NodeReadline from "node:readline";
-var EXTENDED_LENGTH_UNC = "//?/UNC/";
-var EXTENDED_LENGTH = "//?/";
-function normalize(value, caseInsensitive) {
-  let unified = value.trim().replace(/\\/gu, "/");
-  const upper = unified.toUpperCase();
-  if (upper.startsWith(EXTENDED_LENGTH_UNC)) {
-    unified = `//${unified.slice(EXTENDED_LENGTH_UNC.length)}`;
-  } else if (upper.startsWith(EXTENDED_LENGTH)) {
-    unified = unified.slice(EXTENDED_LENGTH.length);
-  }
-  const isUnc = unified.startsWith("//");
-  unified = unified.replace(/\/+/gu, "/").replace(/\/+$/u, "");
-  if (isUnc) unified = `/${unified}`;
-  return caseInsensitive ? unified.toLowerCase() : unified;
-}
-function isWithinDirectory(candidate, root, caseInsensitive) {
-  const normalizedRoot = normalize(root, caseInsensitive);
-  if (normalizedRoot.length === 0 || normalizedRoot === "/") return false;
-  const normalizedCandidate = normalize(candidate, caseInsensitive);
-  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
-}
-var PAGE_LIMIT = 50;
-var MAX_PAGES = 10;
-var MAX_ROWS = 50;
-var PREVIEW_LIMIT = 200;
-function truncate(value) {
-  const trimmed = value?.trim() ?? "";
-  if (trimmed.length === 0) return null;
-  return trimmed.length <= PREVIEW_LIMIT ? trimmed : `${trimmed.slice(0, PREVIEW_LIMIT)}\u2026`;
-}
-var nativeModel = (value) => {
-  const model = asString(value)?.trim();
-  return model && model !== "<synthetic>" ? model : null;
-};
-function readListPage(response) {
-  if (!response || typeof response !== "object") return { threads: [], nextCursor: null };
-  const typed = response;
-  const rows = Array.isArray(typed.data) ? typed.data : [];
-  const threads = [];
-  for (const row of rows) {
-    if (!isRecord3(row)) continue;
-    if (typeof row.id !== "string" || typeof row.cwd !== "string") continue;
-    threads.push({
-      id: row.id,
-      cwd: row.cwd,
-      name: asString(row.name),
-      preview: asString(row.preview),
-      model: asString(row.model),
-      updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : 0
-    });
-  }
-  return { threads, nextCursor: asString(typed.nextCursor) };
-}
-function readThreadTurns(response) {
-  if (!isRecord3(response)) return [];
-  const thread = isRecord3(response.thread) ? response.thread : null;
-  if (!thread) return [];
-  const turns = Array.isArray(thread.turns) ? thread.turns : [];
-  return turns.flatMap((turn) => {
-    if (!isRecord3(turn)) return [];
-    return [
-      {
-        ...typeof turn.id === "string" && turn.id.length > 0 ? { id: turn.id } : {},
-        ...typeof turn.model === "string" && turn.model.length > 0 ? { model: turn.model } : {},
-        startedAt: typeof turn.startedAt === "number" ? turn.startedAt : null,
-        items: Array.isArray(turn.items) ? turn.items : []
-      }
-    ];
-  });
-}
-function itemText(item) {
-  if (!isRecord3(item)) return void 0;
-  const type = (asString(item.type) ?? "").toLowerCase();
-  const text = asString(item.text) ?? asString(item.content) ?? (Array.isArray(item.content) ? item.content.map((entry) => isRecord3(entry) ? asString(entry.text) : null).filter((entry) => typeof entry === "string").join("\n") : null);
-  if (!text || text.trim().length === 0) return void 0;
-  if (type.includes("user")) return { role: "user", text };
-  if (type.includes("agent") || type.includes("assistant")) return { role: "assistant", text };
-  if (type.includes("system")) return { role: "system", text };
-  return void 0;
-}
-async function scanCodexSessions(input) {
-  const threads = [];
-  let cursor = null;
-  for (let page = 0; page < MAX_PAGES && threads.length < MAX_ROWS; page += 1) {
-    const listed = readListPage(
-      await input.client.request("thread/list", {
-        limit: PAGE_LIMIT,
-        sortKey: "updated_at",
-        sortDirection: "desc",
-        ...cursor === null ? {} : { cursor }
-      })
-    );
-    for (const thread of listed.threads) {
-      if (!isWithinDirectory(thread.cwd, input.directory, input.caseInsensitive)) continue;
-      threads.push(thread);
-      if (threads.length >= MAX_ROWS) break;
-    }
-    if (listed.nextCursor === null || listed.nextCursor.length === 0) break;
-    cursor = listed.nextCursor;
-  }
-  const rows = [];
-  for (const thread of threads) {
-    const turnCount = await input.client.request("thread/read", { threadId: thread.id, includeTurns: true }).then((response) => readThreadTurns(response).length).catch(() => 0);
-    rows.push({
-      nativeSessionId: thread.id,
-      cwd: thread.cwd,
-      title: truncate(thread.name),
-      preview: truncate(thread.preview),
-      model: truncate(thread.model),
-      turnCount,
-      updatedAt: thread.updatedAt * 1e3,
-      availability: "importable",
-      openElsewhere: false
-    });
-  }
-  return rows;
-}
-async function readCodexSession(input) {
-  const response = await input.client.request("thread/read", {
-    threadId: input.threadId,
-    includeTurns: true
-  });
-  const record = isRecord3(response) ? response : null;
-  const thread = record && isRecord3(record.thread) ? record.thread : null;
-  const path = input.caseInsensitive ? NodePath4.win32 : NodePath4;
-  const sameDirectory = (left, right) => isWithinDirectory(path.resolve(left), path.resolve(right), input.caseInsensitive) && isWithinDirectory(path.resolve(right), path.resolve(left), input.caseInsensitive);
-  if (!isRecord3(thread) || thread.id !== input.threadId || typeof thread.cwd !== "string" || !path.isAbsolute(thread.cwd) || !path.isAbsolute(input.cwd) || !sameDirectory(thread.cwd, input.cwd)) {
-    throw new Error("The native Codex session does not match the requested session and directory.");
-  }
-  const model = nativeModel(thread.model) ?? await readRolloutModel(
-    {
-      threadId: input.threadId,
-      cwd: input.cwd,
-      homePath: input.homePath,
-      caseInsensitive: input.caseInsensitive
-    },
-    thread.path,
-    sameDirectory
-  );
-  const messages = [];
-  for (const turn of readThreadTurns(response)) {
-    for (const item of turn.items) {
-      const mapped = itemText(item);
-      if (mapped) {
-        messages.push({
-          ...mapped,
-          ...typeof turn.startedAt === "number" ? { createdAt: turn.startedAt * 1e3 } : {}
-        });
-      }
-    }
-  }
-  return {
-    nativeSessionId: input.threadId,
-    messages,
-    resumeCursor: { threadId: input.threadId },
-    model
-  };
-}
-async function readRolloutModel(input, rolloutPath, sameDirectory) {
-  const path = input.caseInsensitive ? NodePath4.win32 : NodePath4;
-  if (typeof rolloutPath !== "string" || !path.isAbsolute(rolloutPath) || path.extname(rolloutPath).toLowerCase() !== ".jsonl") {
-    return null;
-  }
-  const resolved = path.resolve(rolloutPath);
-  const roots = input.homePath ? [path.join(input.homePath, "sessions"), path.join(input.homePath, "archived_sessions")] : [];
-  if (!roots.some((root) => isWithinDirectory(resolved, path.resolve(root), input.caseInsensitive))) {
-    return null;
-  }
-  let verified = false;
-  let model = null;
-  try {
-    const stream = NodeFS3.createReadStream(resolved, { encoding: "utf8" });
-    const rl = NodeReadline.createInterface({ input: stream, crlfDelay: Infinity });
-    for await (const line of rl) {
-      if (!line.includes('"session_meta"') && !line.includes('"turn_context"')) continue;
-      let record;
-      try {
-        record = isRecord3(JSON.parse(line)) ? JSON.parse(line) : null;
-      } catch {
-        continue;
-      }
-      const payload = isRecord3(record?.payload) ? record.payload : null;
-      if (!record || !payload) continue;
-      if (record.type === "session_meta" && !verified) {
-        if ((payload.id ?? payload.session_id) !== input.threadId || typeof payload.cwd !== "string" || !path.isAbsolute(payload.cwd) || !sameDirectory(payload.cwd, input.cwd)) {
-          return null;
-        }
-        verified = true;
-      } else if (record.type === "turn_context" && verified) {
-        model = nativeModel(payload.model) ?? model;
-      }
-    }
-  } catch {
-    return null;
-  }
-  return model;
-}
-
 // src/mcpOAuth.ts
 function codexMcpOAuthLaunchConfig(name, transport) {
   const key = `mcp_servers.${name}`;
@@ -4457,13 +5748,13 @@ async function startCodexMcpOAuth(input) {
     env
   });
   let settle;
-  const completed = new Promise((resolve2) => {
-    settle = resolve2;
+  const completed = new Promise((resolve4) => {
+    settle = resolve4;
   });
   const rpc = await createCodexRpcClient(handle, {
     onNotification: (notification) => {
       if (notification.method !== "mcpServer/oauthLogin/completed") return;
-      const params = isRecord3(notification.params) ? notification.params : {};
+      const params = isRecord2(notification.params) ? notification.params : {};
       if (asString(params["name"]) !== input.server.name) return;
       const error = asString(params["error"]);
       settle?.({
@@ -4485,7 +5776,7 @@ async function startCodexMcpOAuth(input) {
       name: input.server.name,
       ...input.timeoutSecs === void 0 ? {} : { timeoutSecs: input.timeoutSecs }
     });
-    const authorizationUrl = isRecord3(response) ? asString(response["authorizationUrl"]) : void 0;
+    const authorizationUrl = isRecord2(response) ? asString(response["authorizationUrl"]) : void 0;
     if (!authorizationUrl) {
       await close();
       throw new Error(`Codex did not return an authorization URL for '${input.server.name}'.`);
@@ -4511,7 +5802,7 @@ function reasoningDescriptor(row) {
   if (!Array.isArray(supported) || supported.length === 0) return null;
   const defaultEffort = asString(row["defaultReasoningEffort"]);
   const options = supported.flatMap((entry) => {
-    if (!isRecord3(entry)) return [];
+    if (!isRecord2(entry)) return [];
     const id = asString(entry["reasoningEffort"]);
     if (!id) return [];
     const description = asString(entry["description"]);
@@ -4536,7 +5827,7 @@ function reasoningDescriptor(row) {
 function serviceTierDescriptor(row) {
   const declared = Array.isArray(row["serviceTiers"]) ? row["serviceTiers"] : [];
   const tiers = declared.length > 0 ? declared.flatMap((entry) => {
-    if (!isRecord3(entry)) return [];
+    if (!isRecord2(entry)) return [];
     const id = asString(entry["id"]);
     if (!id) return [];
     const name = asString(entry["name"]);
@@ -4572,7 +5863,7 @@ function serviceTierDescriptor(row) {
   };
 }
 function codexProbeModel(row) {
-  if (!isRecord3(row)) return null;
+  if (!isRecord2(row)) return null;
   const slug = asString(row["model"]);
   if (!slug) return null;
   const displayName = asString(row["displayName"]);
@@ -4603,7 +5894,7 @@ async function listCodexModels(rpc) {
     } catch {
       return void 0;
     }
-    if (!isRecord3(response) || !Array.isArray(response["data"])) return void 0;
+    if (!isRecord2(response) || !Array.isArray(response["data"])) return void 0;
     for (const row of response["data"]) {
       const model = codexProbeModel(row);
       if (model !== null) models.push(model);
@@ -4618,12 +5909,12 @@ async function listCodexModels(rpc) {
 // src/skills.ts
 var SKILLS_LIST_TIMEOUT_MS = 15e3;
 function codexProbeSkill(raw, includeRepo = false) {
-  if (!isRecord3(raw)) return null;
+  if (!isRecord2(raw)) return null;
   const name = asString(raw["name"]);
   const path = asString(raw["path"]);
   const scope = asString(raw["scope"]);
   if (!name || !path || scope === "repo" && !includeRepo) return null;
-  const face = isRecord3(raw["interface"]) ? raw["interface"] : void 0;
+  const face = isRecord2(raw["interface"]) ? raw["interface"] : void 0;
   const description = asString(raw["description"]);
   const displayName = asString(face?.["displayName"]);
   const shortDescription = asString(face?.["shortDescription"]) || asString(raw["shortDescription"]);
@@ -4639,12 +5930,12 @@ function codexProbeSkill(raw, includeRepo = false) {
 }
 async function listCodexWorkspaceSkills(rpc, cwd) {
   const response = await rpc.request("skills/list", { cwds: [cwd] }, SKILLS_LIST_TIMEOUT_MS);
-  if (!isRecord3(response) || !Array.isArray(response["data"])) {
+  if (!isRecord2(response) || !Array.isArray(response["data"])) {
     throw new Error("skills/list returned an unexpected shape");
   }
   const skills = /* @__PURE__ */ new Map();
   for (const entry of response["data"]) {
-    if (!isRecord3(entry) || !Array.isArray(entry["skills"])) continue;
+    if (!isRecord2(entry) || !Array.isArray(entry["skills"])) continue;
     for (const raw of entry["skills"]) {
       const skill = codexProbeSkill(raw, true);
       if (skill !== null) skills.set(skill.path, skill);
@@ -4659,10 +5950,10 @@ async function listCodexSkills(rpc) {
   } catch {
     return void 0;
   }
-  if (!isRecord3(response) || !Array.isArray(response["data"])) return void 0;
+  if (!isRecord2(response) || !Array.isArray(response["data"])) return void 0;
   const skills = /* @__PURE__ */ new Map();
   for (const entry of response["data"]) {
-    if (!isRecord3(entry) || !Array.isArray(entry["skills"])) continue;
+    if (!isRecord2(entry) || !Array.isArray(entry["skills"])) continue;
     for (const raw of entry["skills"]) {
       const skill = codexProbeSkill(raw);
       if (skill !== null) skills.set(skill.path, skill);
@@ -4683,25 +5974,25 @@ async function setCodexSessionSkillRoots(rpc, skills, log, threadId) {
 }
 
 // src/workspaceInventory.ts
-import * as NodeFS4 from "node:fs";
-import * as NodePath5 from "node:path";
+import * as NodeFS6 from "node:fs";
+import * as NodePath8 from "node:path";
 var MAX_ANCESTORS = 12;
 var codexWorkspaceWatchPaths = (cwd, skills) => {
   const watched = /* @__PURE__ */ new Set();
   let directory = cwd;
   for (let level = 0; level < MAX_ANCESTORS; level += 1) {
-    watched.add(NodePath5.join(directory, ".agents", "skills"));
-    watched.add(NodePath5.join(directory, ".codex", "skills"));
-    if (NodeFS4.existsSync(NodePath5.join(directory, ".git"))) break;
-    const parent = NodePath5.dirname(directory);
+    watched.add(NodePath8.join(directory, ".agents", "skills"));
+    watched.add(NodePath8.join(directory, ".codex", "skills"));
+    if (NodeFS6.existsSync(NodePath8.join(directory, ".git"))) break;
+    const parent = NodePath8.dirname(directory);
     if (parent === directory) break;
     directory = parent;
   }
   for (const skill of skills) {
     watched.add(skill.path);
-    const skillDirectory = NodePath5.dirname(skill.path);
+    const skillDirectory = NodePath8.dirname(skill.path);
     watched.add(skillDirectory);
-    watched.add(NodePath5.dirname(skillDirectory));
+    watched.add(NodePath8.dirname(skillDirectory));
   }
   return [...watched];
 };
@@ -4803,7 +6094,7 @@ async function startCodexSignIn(input) {
       const rpc = await createCodexRpcClient(handle2, {
         onNotification: (notification) => {
           if (notification.method !== "account/login/completed") return;
-          const params = isRecord3(notification.params) ? notification.params : {};
+          const params = isRecord2(notification.params) ? notification.params : {};
           const loginId = asString(params["loginId"]);
           receiveCompletion({
             loginId,
@@ -4830,7 +6121,7 @@ async function startCodexSignIn(input) {
           rpc.request("account/login/start", { type: "chatgptDeviceCode" }),
           lifetime.signal
         );
-        if (!isRecord3(started) || asString(started["type"]) !== "chatgptDeviceCode") {
+        if (!isRecord2(started) || asString(started["type"]) !== "chatgptDeviceCode") {
           await closeSignInRpc(rpc, input.host, handle2);
           return void 0;
         }
@@ -4892,7 +6183,7 @@ async function startCodexSignIn(input) {
       const combined2 = `${stdout.text}
 ${stderr.text}`;
       if (deviceCodeUrl(combined2) && deviceCodeValue(combined2)) break;
-      await new Promise((resolve2) => setTimeout(resolve2, 50));
+      await new Promise((resolve4) => setTimeout(resolve4, 50));
     }
     const combined = `${stdout.text}
 ${stderr.text}`;
@@ -4970,8 +6261,8 @@ async function verifyCodexSignIn(input) {
     );
     await rpc.notify("initialized");
     const account = await rpc.request("account/read", { refreshToken: true }, 15e3);
-    const details = isRecord3(account) && isRecord3(account["account"]) ? account["account"] : account;
-    const type = isRecord3(details) ? asString(details["type"]) : null;
+    const details = isRecord2(account) && isRecord2(account["account"]) ? account["account"] : account;
+    const type = isRecord2(details) ? asString(details["type"]) : null;
     if (type !== "chatgpt") {
       return {
         installed: true,
@@ -4989,7 +6280,7 @@ async function verifyCodexSignIn(input) {
       auth: {
         ...auth,
         status: "authenticated",
-        ...isRecord3(details) && asString(details["email"]) ? { email: asString(details["email"]) } : {}
+        ...isRecord2(details) && asString(details["email"]) ? { email: asString(details["email"]) } : {}
       },
       ...models === void 0 ? {} : { models },
       ...CODEX_NATIVE_MODE_REPORT
@@ -5069,9 +6360,9 @@ function buildTurnSummaryPrompt(raw) {
 }
 
 // src/textGeneration.ts
-import * as NodeFSP2 from "node:fs/promises";
+import * as NodeFSP5 from "node:fs/promises";
 import * as NodeOS3 from "node:os";
-import * as NodePath6 from "node:path";
+import * as NodePath9 from "node:path";
 import {
   mergeLaunchEnv as mergeLaunchEnv2
 } from "@ycodium-ai/plugin-api/executor";
@@ -5098,7 +6389,7 @@ function unwrapNestedTitleObject(raw) {
   if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return raw;
   try {
     const parsed = JSON.parse(trimmed);
-    if (isRecord3(parsed) && typeof parsed.title === "string") return parsed.title;
+    if (isRecord2(parsed) && typeof parsed.title === "string") return parsed.title;
   } catch {
   }
   return raw;
@@ -5221,9 +6512,9 @@ function absoluteImagePaths(attachments) {
   if (!Array.isArray(attachments)) return [];
   const paths = [];
   for (const attachment of attachments) {
-    if (!isRecord3(attachment) || attachment.type !== "image") continue;
+    if (!isRecord2(attachment) || attachment.type !== "image") continue;
     const candidate = asString(attachment.path) ?? asString(attachment.filePath) ?? asString(attachment.savedPath);
-    if (candidate && NodePath6.isAbsolute(candidate)) paths.push(candidate);
+    if (candidate && NodePath9.isAbsolute(candidate)) paths.push(candidate);
   }
   return paths;
 }
@@ -5238,11 +6529,11 @@ function createCodexTextGeneration(input) {
     if (input.recipe.binaryPath.length === 0) {
       throw new Error("Codex CLI is required but not available on PATH.");
     }
-    const tmp = await NodeFSP2.mkdtemp(NodePath6.join(NodeOS3.tmpdir(), "ycodium-codex-tg-"));
-    const schemaPath = NodePath6.join(tmp, "schema.json");
-    const outputPath = NodePath6.join(tmp, "output.json");
-    await NodeFSP2.writeFile(schemaPath, JSON.stringify(schema));
-    await NodeFSP2.writeFile(outputPath, "");
+    const tmp = await NodeFSP5.mkdtemp(NodePath9.join(NodeOS3.tmpdir(), "ycodium-codex-tg-"));
+    const schemaPath = NodePath9.join(tmp, "schema.json");
+    const outputPath = NodePath9.join(tmp, "output.json");
+    await NodeFSP5.writeFile(schemaPath, JSON.stringify(schema));
+    await NodeFSP5.writeFile(outputPath, "");
     const reasoningEffort = modelSelectionStringOption(modelSelection, "reasoningEffort") ?? DEFAULT_TEXT_GENERATION_REASONING_EFFORT;
     const serviceTier = modelSelectionStringOption(modelSelection, "serviceTier");
     const model = modelIdFromSelection(modelSelection) ?? "gpt-5.6-luna";
@@ -5286,8 +6577,8 @@ function createCodexTextGeneration(input) {
       await handle.closeStdin();
       const timedOut = await Promise.race([
         handle.exited.then(() => false),
-        new Promise((resolve2) => {
-          timer = setTimeout(() => resolve2(true), CODEX_TIMEOUT_MS);
+        new Promise((resolve4) => {
+          timer = setTimeout(() => resolve4(true), CODEX_TIMEOUT_MS);
         })
       ]);
       if (timedOut) {
@@ -5305,27 +6596,27 @@ function createCodexTextGeneration(input) {
           detail.length > 0 ? `Codex CLI command failed: ${detail}` : `Codex CLI command failed with code ${String(exitCode)}.`
         );
       }
-      const raw = await NodeFSP2.readFile(outputPath, "utf8");
+      const raw = await NodeFSP5.readFile(outputPath, "utf8");
       let parsed;
       try {
         parsed = JSON.parse(raw);
       } catch (cause) {
         throw new Error("Codex returned invalid structured output.", { cause });
       }
-      if (!isRecord3(parsed)) throw new Error("Codex returned invalid structured output.");
+      if (!isRecord2(parsed)) throw new Error("Codex returned invalid structured output.");
       return parsed;
     } finally {
       if (timer !== void 0) clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      await NodeFSP2.rm(tmp, { recursive: true, force: true }).catch(() => void 0);
+      await NodeFSP5.rm(tmp, { recursive: true, force: true }).catch(() => void 0);
       void operation;
     }
   };
   return {
     generateCommitMessage: async (raw, signal) => {
-      const inputRecord = isRecord3(raw) ? raw : {};
+      const inputRecord = isRecord2(raw) ? raw : {};
       const includeBranch = inputRecord.includeBranch === true;
-      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const policy = isRecord2(inputRecord.policy) ? inputRecord.policy : {};
       const prompt = [
         "You write concise git commit messages.",
         includeBranch ? "Return a JSON object with keys: subject, body, branch." : "Return a JSON object with keys: subject, body.",
@@ -5360,8 +6651,8 @@ function createCodexTextGeneration(input) {
       };
     },
     generatePrContent: async (raw, signal) => {
-      const inputRecord = isRecord3(raw) ? raw : {};
-      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const inputRecord = isRecord2(raw) ? raw : {};
+      const policy = isRecord2(inputRecord.policy) ? inputRecord.policy : {};
       const template = asString(inputRecord.changeRequestTemplate)?.trim();
       const bodyRules = template ? [
         "- body must be markdown and follow the repository change request template structure",
@@ -5409,11 +6700,11 @@ function createCodexTextGeneration(input) {
       };
     },
     generateBranchName: async (raw, signal) => {
-      const inputRecord = isRecord3(raw) ? raw : {};
-      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const inputRecord = isRecord2(raw) ? raw : {};
+      const policy = isRecord2(inputRecord.policy) ? inputRecord.policy : {};
       const attachments = Array.isArray(inputRecord.attachments) ? inputRecord.attachments : [];
       const attachmentLines = attachments.flatMap((attachment) => {
-        if (!isRecord3(attachment)) return [];
+        if (!isRecord2(attachment)) return [];
         const name = asString(attachment.name) ?? "attachment";
         const mime = asString(attachment.mimeType) ?? "application/octet-stream";
         const size = typeof attachment.sizeBytes === "number" ? attachment.sizeBytes : 0;
@@ -5445,11 +6736,11 @@ function createCodexTextGeneration(input) {
       return { branch: sanitizeBranchFragment(readStringField(generated, "branch")) };
     },
     generateThreadTitle: async (raw, signal) => {
-      const inputRecord = isRecord3(raw) ? raw : {};
-      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const inputRecord = isRecord2(raw) ? raw : {};
+      const policy = isRecord2(inputRecord.policy) ? inputRecord.policy : {};
       const attachments = Array.isArray(inputRecord.attachments) ? inputRecord.attachments : [];
       const attachmentLines = attachments.flatMap((attachment) => {
-        if (!isRecord3(attachment)) return [];
+        if (!isRecord2(attachment)) return [];
         const name = asString(attachment.name) ?? "attachment";
         const mime = asString(attachment.mimeType) ?? "application/octet-stream";
         const size = typeof attachment.sizeBytes === "number" ? attachment.sizeBytes : 0;
@@ -5491,7 +6782,7 @@ ${extra}` : ""}`;
       };
     },
     summarizeTurn: async (raw, signal) => {
-      const input2 = isRecord3(raw) ? raw : {};
+      const input2 = isRecord2(raw) ? raw : {};
       const generated = await run(
         "summarizeTurn",
         asString(input2.cwd) ?? ".",
@@ -5504,7 +6795,7 @@ ${extra}` : ""}`;
       return { summary: readStringField(generated, "summary").trim() };
     },
     summarizeHandover: async (raw, signal) => {
-      const inputRecord = isRecord3(raw) ? raw : {};
+      const inputRecord = isRecord2(raw) ? raw : {};
       const prompt = [
         "You write handover notes so a different coding agent can pick up work already in progress.",
         "Return a JSON object with exactly one key: summary.",
@@ -5535,19 +6826,19 @@ ${extra}` : ""}`;
 }
 
 // src/usage/codexUsage.ts
-import * as NodeFS7 from "node:fs";
-import * as NodePath10 from "node:path";
+import * as NodeFS9 from "node:fs";
+import * as NodePath13 from "node:path";
 
 // src/usage/codexTokenUsage.ts
-import * as NodeFS6 from "node:fs";
-import * as NodePath9 from "node:path";
+import * as NodeFS8 from "node:fs";
+import * as NodePath12 from "node:path";
 
 // src/usage/codexScanCache.ts
-import * as NodePath8 from "node:path";
+import * as NodePath11 from "node:path";
 
 // src/usage/codexTranscriptScan.ts
-import * as NodeFS5 from "node:fs";
-import * as NodePath7 from "node:path";
+import * as NodeFS7 from "node:fs";
+import * as NodePath10 from "node:path";
 
 // src/usage/codexTranscripts.ts
 var int = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
@@ -5641,21 +6932,21 @@ var listTranscriptFiles = async (root, sinceMs) => {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await NodeFS5.promises.readdir(dir, { withFileTypes: true });
+      entries = await NodeFS7.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const child = NodePath7.join(dir, entry.name);
+      const child = NodePath10.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(child);
         continue;
       }
       if (!entry.isFile() || !entry.name.endsWith(TRANSCRIPT_SUFFIX)) continue;
       try {
-        const stat2 = await NodeFS5.promises.stat(child);
-        if (stat2.mtimeMs >= sinceMs)
-          found.push({ path: child, size: stat2.size, mtimeMs: stat2.mtimeMs });
+        const stat4 = await NodeFS7.promises.stat(child);
+        if (stat4.mtimeMs >= sinceMs)
+          found.push({ path: child, size: stat4.size, mtimeMs: stat4.mtimeMs });
       } catch {
       }
     }
@@ -5680,7 +6971,7 @@ var readMatchingGuard = async (filePath, position) => {
   if (guardLength <= 0 || guardLength > GUARD_LENGTH || guardLength > resumeOffset) return null;
   try {
     const chunks = [];
-    for await (const chunk of NodeFS5.createReadStream(filePath, {
+    for await (const chunk of NodeFS7.createReadStream(filePath, {
       start: resumeOffset - guardLength,
       end: resumeOffset - 1
     })) {
@@ -5719,7 +7010,7 @@ var readCodexRollout = async (filePath, resumeFrom) => {
     const records = [];
     let resumeOffset = start;
     let pendingChunks = [];
-    for await (const raw of NodeFS5.createReadStream(filePath, start > 0 ? { start } : void 0)) {
+    for await (const raw of NodeFS7.createReadStream(filePath, start > 0 ? { start } : void 0)) {
       const chunk = asBuffer(raw);
       if (!chunk.includes(NEWLINE)) {
         pendingChunks.push(chunk);
@@ -5741,8 +7032,8 @@ var readCodexRollout = async (filePath, resumeFrom) => {
     }
     const tailRecords = [];
     if (pendingChunks.length > 0) {
-      const pending = pendingChunks.length === 1 ? pendingChunks[0] : Buffer.concat(pendingChunks);
-      if (pending.length > 0) parseLine(toLineString(pending), { ...state }, tailRecords);
+      const pending2 = pendingChunks.length === 1 ? pendingChunks[0] : Buffer.concat(pendingChunks);
+      if (pending2.length > 0) parseLine(toLineString(pending2), { ...state }, tailRecords);
     }
     return {
       records,
@@ -5879,8 +7170,8 @@ var pruneScanCache = (cache, options) => {
   for (const [path, entry] of cache) {
     const agedOut = entry.mtimeMs < options.retentionCutoffMs;
     const underWalkedRoot = options.walkedRoots.some((root) => {
-      const relative2 = NodePath8.relative(root, path);
-      return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${NodePath8.sep}`) && !NodePath8.isAbsolute(relative2);
+      const relative2 = NodePath11.relative(root, path);
+      return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${NodePath11.sep}`) && !NodePath11.isAbsolute(relative2);
     });
     const deleted = underWalkedRoot && entry.mtimeMs >= options.windowStartMs && !options.livePaths.has(path);
     if (agedOut || deleted) {
@@ -5923,9 +7214,9 @@ var persistCache = async (state, sharedHomePath, cache) => {
 };
 var statDirectory = async (path) => {
   try {
-    const stat2 = await NodeFS6.promises.stat(path, { bigint: true });
-    if (!stat2.isDirectory()) return null;
-    return { volumeId: stat2.ino === 0n ? "" : `${String(stat2.dev)}:${String(stat2.ino)}` };
+    const stat4 = await NodeFS8.promises.stat(path, { bigint: true });
+    if (!stat4.isDirectory()) return null;
+    return { volumeId: stat4.ino === 0n ? "" : `${String(stat4.dev)}:${String(stat4.ino)}` };
   } catch {
     return null;
   }
@@ -5966,7 +7257,7 @@ var readOnce = async (input) => {
   const home = await statDirectory(input.sharedHomePath);
   const roots = [];
   for (const subdirectory of TRANSCRIPT_SUBDIRECTORIES) {
-    const root = NodePath9.join(input.sharedHomePath, subdirectory);
+    const root = NodePath12.join(input.sharedHomePath, subdirectory);
     if (await statDirectory(root) !== null) roots.push(root);
   }
   if (home === null || roots.length === 0) {
@@ -6054,7 +7345,7 @@ var createCodexUsage = (input) => {
     if (fromLaunchArgs !== null) return fromLaunchArgs;
     let contents;
     try {
-      contents = await NodeFS7.promises.readFile(NodePath10.join(accountHome, "config.toml"), "utf8");
+      contents = await NodeFS9.promises.readFile(NodePath13.join(accountHome, "config.toml"), "utf8");
     } catch (error) {
       const code = error.code;
       return code === "ENOENT" || code === "ENOTDIR" ? null : "config.toml:unreadable";
@@ -6084,7 +7375,7 @@ var createCodexUsage = (input) => {
         reason: error instanceof CodexRpcResponseError ? classifyRateLimitsError(error.message) : "unreachable"
       };
     }
-    return mapCodexRateLimits(response, NodePath10.join(accountHome, "auth.json")) ?? {
+    return mapCodexRateLimits(response, NodePath13.join(accountHome, "auth.json")) ?? {
       status: "unavailable",
       reason: "unreachable"
     };
@@ -6126,8 +7417,8 @@ function missingBinaryDetail(binaryPath) {
   const relyOnPath = !/[\\/]/.test(binaryPath);
   return `Could not start Codex (${binaryPath}). Check the "Program path" setting of this provider on this machine.` + (relyOnPath ? " The Codex desktop app may not add codex to PATH; enter the full path to the codex executable there." : " Make sure the configured file exists and can be run.");
 }
-var yieldTick = () => new Promise((resolve2) => {
-  setImmediate(resolve2);
+var yieldTick = () => new Promise((resolve4) => {
+  setImmediate(resolve4);
 });
 function accountToAuth2(account) {
   switch (account.state) {
@@ -6496,6 +7787,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
       inheritedEnvironment: process.env
     }),
     sessions: {
+      openHistory: async (input) => openCodexHistory({ ...input, homePath: layoutFor(recipe).sharedHomePath }),
       scan: async (input) => {
         if (recipe.binaryPath.length === 0) {
           throw new Error("Codex program path is not configured");
@@ -6515,7 +7807,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
           const candidates = await scanCodexSessions({
             client: rpc,
             directory: input.directory ?? host.workspacePath(input.projectId),
-            caseInsensitive: NodeProcess.platform === "win32"
+            caseInsensitive: NodeProcess2.platform === "win32"
           });
           return { candidates };
         } finally {
@@ -6547,7 +7839,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
             threadId: input.nativeSessionId,
             cwd: input.cwd,
             homePath: accountHomeFromLayout(layout),
-            caseInsensitive: NodeProcess.platform === "win32"
+            caseInsensitive: NodeProcess2.platform === "win32"
           });
         } finally {
           await rpc.close().catch(() => void 0);
@@ -6596,10 +7888,10 @@ var createCodexInstance = (config, host, attachments, cache) => {
       if (signal.aborted) return;
       await Promise.race([
         Promise.all(waiters),
-        new Promise((resolve2) => {
+        new Promise((resolve4) => {
           const onAbort = () => {
             signal.removeEventListener("abort", onAbort);
-            resolve2();
+            resolve4();
           };
           signal.addEventListener("abort", onAbort);
         })
@@ -6632,7 +7924,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-codex",
-  apiVersion: 35,
+  apiVersion: 37,
   executors,
   activate(ctx) {
     capturedAttachments = ctx.attachments;