@moxt-ai/mobius 0.0.133 → 0.0.135

package/dist/daemon-turn-registry.d.ts

@@ -58,6 +58,19 @@ export declare class DaemonTurnRegistry {
             truncated: boolean;
             epoch: string;
             interaction: Readonly<{
+                commandId: string;
+                interactionId: string;
+                kind: "session.permission.requested";
+                options: readonly Readonly<{
+                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
+                    name: string;
+                    optionId: string;
+                }>[];
+                sessionId: string;
+                title: string;
+                toolCallId: string;
+                toolKind: string;
+            }> | Readonly<{
                 accepted: boolean;
                 commandId: string;
                 elicitationId: string;
@@ -89,19 +102,6 @@ export declare class DaemonTurnRegistry {
                 mode: "form" | "url";
                 sessionId: string;
                 url: string;
-            }> | Readonly<{
-                commandId: string;
-                interactionId: string;
-                kind: "session.permission.requested";
-                options: readonly Readonly<{
-                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
-                    name: string;
-                    optionId: string;
-                }>[];
-                sessionId: string;
-                title: string;
-                toolCallId: string;
-                toolKind: string;
             }> | null;
             sequence: number;
             state: "running";

package/dist/index.js

@@ -5068,9 +5068,9 @@ function isRecursive(inst, stack, resolve9) {
     return PROVEN;
   stack.add(inst);
   let result = NONE;
-  const check2 = (child) => {
-    if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve9);
+  const check2 = (child2) => {
+    if (result !== PROVEN && child2?._zod) {
+      const answer = isRecursive(child2, stack, resolve9);
       if (answer > result)
         result = answer;
     }
@@ -5081,9 +5081,9 @@ function isRecursive(inst, stack, resolve9) {
       const desc2 = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc2.enumerable)
         continue;
-      const child = desc2.get ? ASSUMED : desc2.value?._zod ? isRecursive(desc2.value, stack, resolve9) : NONE;
-      if (child > answer)
-        answer = child;
+      const child2 = desc2.get ? ASSUMED : desc2.value?._zod ? isRecursive(desc2.value, stack, resolve9) : NONE;
+      if (child2 > answer)
+        answer = child2;
     }
     return answer;
   };
@@ -20462,7 +20462,7 @@ var DIRECTORY_IDENTIFIER_PATTERN2 = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/;
 var MAX_PROMPT_LENGTH = 1e4;
 var MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
 var MAX_EVENT_TEXT_LENGTH = 1e5;
-var ACTIVITY_TYPES = /* @__PURE__ */ new Set(["plan", "progress", "reasoning", "tool"]);
+var ACTIVITY_TYPES = /* @__PURE__ */ new Set(["notice", "plan", "progress", "reasoning", "tool"]);
 var NARRATION_ACTIVITY_TYPES = /* @__PURE__ */ new Set(["progress", "reasoning"]);
 var ACTIVITY_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed"]);
 var TOOL_KINDS = /* @__PURE__ */ new Set([
@@ -21572,8 +21572,8 @@ function hasTrueChildField(value, childKey, fieldKey) {
   if (!isRecord2(value)) {
     return false;
   }
-  const child = Reflect.get(value, childKey);
-  return isRecord2(child) && Reflect.get(child, fieldKey) === true;
+  const child2 = Reflect.get(value, childKey);
+  return isRecord2(child2) && Reflect.get(child2, fieldKey) === true;
 }
 function unsupportedSessionCapabilities() {
   return Object.freeze({
@@ -21885,17 +21885,17 @@ function mergeProcessTrees(captured, current) {
   }
   return [...processes.values()];
 }
-async function captureProcessTree(child) {
-  if (process.platform === "win32" || child.pid === void 0) {
+async function captureProcessTree(child2) {
+  if (process.platform === "win32" || child2.pid === void 0) {
     return [];
   }
   if (process.platform === "linux") {
     const procfsEntries = readLinuxProcessTableSynchronously();
     if (procfsEntries.length > 0) {
-      return selectProcessTree(procfsEntries, child.pid);
+      return selectProcessTree(procfsEntries, child2.pid);
     }
   }
-  return selectProcessTree(await readProcessTable(), child.pid);
+  return selectProcessTree(await readProcessTable(), child2.pid);
 }
 function signalCapturedProcessGroups(processes, rootProcessId, signal) {
   const processIds = new Set(processes.map((identity2) => identity2.processId));
@@ -21952,63 +21952,63 @@ async function waitForCapturedProcessesExit(processes, rootProcessId) {
   }
   return processIds.every((processId) => !processExists(processId));
 }
-function terminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+function terminateProcess(child2) {
+  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
     return;
   }
   if (process.platform !== "win32") {
     try {
-      process.kill(-child.pid, "SIGTERM");
+      process.kill(-child2.pid, "SIGTERM");
       return;
     } catch {
     }
   }
-  child.kill("SIGTERM");
+  child2.kill("SIGTERM");
 }
-function forceTerminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+function forceTerminateProcess(child2) {
+  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
     return;
   }
   if (process.platform !== "win32") {
     try {
-      process.kill(-child.pid, "SIGKILL");
+      process.kill(-child2.pid, "SIGKILL");
       return;
     } catch {
     }
   }
-  child.kill("SIGKILL");
+  child2.kill("SIGKILL");
 }
-async function stopProcessTree(child, capturedProcesses = []) {
-  const childProcessId = child.pid;
+async function stopProcessTree(child2, capturedProcesses = []) {
+  const childProcessId = child2.pid;
   if (childProcessId === void 0) {
     return;
   }
-  const childExited = child.exitCode !== null || child.signalCode !== null;
-  const processes = mergeProcessTrees(capturedProcesses, await captureProcessTree(child));
+  const childExited = child2.exitCode !== null || child2.signalCode !== null;
+  const processes = mergeProcessTrees(capturedProcesses, await captureProcessTree(child2));
   if (childExited && processes.length === 0) {
     return;
   }
   signalCapturedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
-  terminateProcess(child);
+  terminateProcess(child2);
   const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
-    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
+    waitForProcessExit(child2, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
     waitForCapturedProcessesExit(processes, childProcessId)
   ]);
   if (exitedAfterTermination && descendantsExitedAfterTermination) {
     return;
   }
   signalCapturedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
-  forceTerminateProcess(child);
+  forceTerminateProcess(child2);
   const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
-    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
+    waitForProcessExit(child2, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
     waitForCapturedProcessesExit(processes, childProcessId)
   ]);
   if (!exitedAfterForce || !descendantsExitedAfterForce) {
     throw new ProcessExecutionError("process_termination_timeout", "The executable process could not be stopped");
   }
 }
-function waitForProcessExit(child, timeoutMilliseconds) {
-  if (child.exitCode !== null || child.signalCode !== null) {
+function waitForProcessExit(child2, timeoutMilliseconds) {
+  if (child2.exitCode !== null || child2.signalCode !== null) {
     return Promise.resolve(true);
   }
   return new Promise((resolveExit) => {
@@ -22019,13 +22019,13 @@ function waitForProcessExit(child, timeoutMilliseconds) {
       }
       settled = true;
       clearTimeout(timeout);
-      child.removeListener("exit", handleExit);
+      child2.removeListener("exit", handleExit);
       resolveExit(exited);
     };
     const handleExit = () => finish(true);
     const timeout = setTimeout(() => finish(false), timeoutMilliseconds);
-    child.once("exit", handleExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
+    child2.once("exit", handleExit);
+    if (child2.exitCode !== null || child2.signalCode !== null) {
       finish(true);
     }
   });
@@ -22033,7 +22033,7 @@ function waitForProcessExit(child, timeoutMilliseconds) {
 async function runBoundedProcess(options) {
   options.signal.throwIfAborted();
   const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
-  const child = spawn(options.command, [...options.arguments], {
+  const child2 = spawn(options.command, [...options.arguments], {
     cwd: options.cwd,
     detached: process.platform !== "win32",
     env: { ...options.environment },
@@ -22056,7 +22056,7 @@ async function runBoundedProcess(options) {
     interruptionFailure = failure2;
     const stop = async () => {
       try {
-        await stopProcessTree(child);
+        await stopProcessTree(child2);
       } catch (error62) {
         interruptionCleanupFailure = error62 instanceof ProcessExecutionError ? error62 : new ProcessExecutionError(
           "process_termination_failed",
@@ -22095,8 +22095,8 @@ async function runBoundedProcess(options) {
       interrupt(failure2);
     }
   };
-  child.stdout?.on("data", collectStdout);
-  child.stderr?.on("data", collectStderr);
+  child2.stdout?.on("data", collectStdout);
+  child2.stderr?.on("data", collectStderr);
   const timeout = setTimeout(() => {
     interrupt(new ProcessExecutionError("process_timeout", "The executable probe timed out"));
   }, options.timeoutMilliseconds);
@@ -22111,8 +22111,8 @@ async function runBoundedProcess(options) {
   }
   try {
     const exit = new Promise((resolveExit, rejectExit) => {
-      child.once("error", rejectExit);
-      child.once("exit", (code) => resolveExit(code ?? 1));
+      child2.once("error", rejectExit);
+      child2.once("exit", (code) => resolveExit(code ?? 1));
     });
     const exitCode = await Promise.race([exit, interrupted.promise.then(() => -1)]);
     if (interruptionCleanupFailure !== null) {
@@ -22135,12 +22135,12 @@ async function runBoundedProcess(options) {
   } finally {
     clearTimeout(timeout);
     options.signal.removeEventListener("abort", abort);
-    child.stdout?.removeListener("data", collectStdout);
-    child.stderr?.removeListener("data", collectStderr);
+    child2.stdout?.removeListener("data", collectStdout);
+    child2.stderr?.removeListener("data", collectStderr);
     if (stopping) {
       await interrupted.promise;
     } else {
-      await stopProcessTree(child);
+      await stopProcessTree(child2);
     }
   }
 }
@@ -23184,19 +23184,19 @@ var AgentConnection = class {
       this.connection = createAcpClient(client2).connect(inProcess.app());
       return;
     }
-    const child = spawn2(agent.adapterPath, [...agent.arguments], {
+    const child2 = spawn2(agent.adapterPath, [...agent.arguments], {
       cwd,
       detached: process.platform !== "win32",
       env: { ...process.env, ...agent.environment },
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    this.#process = { kind: "child", child };
-    const stdin = child.stdin;
-    const stdout = child.stdout;
-    const stderr = child.stderr;
+    this.#process = { kind: "child", child: child2 };
+    const stdin = child2.stdin;
+    const stdout = child2.stdout;
+    const stderr = child2.stderr;
     if (stdin === null || stdout === null || stderr === null) {
-      child.kill("SIGKILL");
+      child2.kill("SIGKILL");
       throw new AcpExecutionError("ACP process streams are unavailable");
     }
     stderr.setEncoding("utf8");
@@ -23204,10 +23204,10 @@ var AgentConnection = class {
       process.stderr.write(`[${agent.id}-acp] ${chunk}`);
     });
     this.termination = new Promise((resolve9) => {
-      child.once("error", (cause) => {
+      child2.once("error", (cause) => {
         resolve9({ kind: "failed", error: new AcpExecutionError("The ACP process could not run", { cause }) });
       });
-      child.once("exit", (code, signal) => {
+      child2.once("exit", (code, signal) => {
         resolve9({
           kind: "failed",
           error: new AcpExecutionError("The ACP process stopped", { cause: { code, signal } })
@@ -23342,6 +23342,7 @@ var AcpActivityTracker = class {
   #activities = /* @__PURE__ */ new Map();
   #identities = /* @__PURE__ */ new Map();
   #narrations = /* @__PURE__ */ new Map();
+  #noticeRevisions = /* @__PURE__ */ new Map();
   #onActivity;
   #onNarration;
   #prepareContent;
@@ -23377,6 +23378,30 @@ var AcpActivityTracker = class {
       await this.#onNarration(new AcpActivityNarration(identity2.id, activityType, identity2.sequence, text2));
     }
   };
+  recordNotice = async (id, revision, severity, text2) => {
+    const key = `notice:${id}`;
+    if ((this.#noticeRevisions.get(key) ?? 0) >= revision) {
+      return;
+    }
+    await this.finishNarrative();
+    this.#noticeRevisions.set(key, revision);
+    const identity2 = this.#identity(key);
+    await this.#record(
+      key,
+      new AcpActivity(
+        identity2.id,
+        "notice",
+        "",
+        [],
+        "",
+        truncate(text2, AGENT_ACTIVITY_DETAIL_LIMIT),
+        identity2.sequence,
+        severity === "error" ? "failed" : "completed",
+        severity === "error" ? "Agent error" : "Agent warning",
+        ""
+      )
+    );
+  };
   #narrativeSnapshot = (identity2, activityType, output2, status) => new AcpActivity(
     identity2.id,
     activityType,
@@ -23939,6 +23964,63 @@ var AcpAgentSettingsSnapshot = class {
   }
 };
 
+// src/acp/session-failure.ts
+var CATEGORIES = /* @__PURE__ */ new Set([
+  "access",
+  "connection",
+  "limit",
+  "request",
+  "service",
+  "unknown"
+]);
+function isCategory(value) {
+  return typeof value === "string" && CATEGORIES.has(value);
+}
+function child(value, key) {
+  return isRecord4(value) ? value[key] : void 0;
+}
+function readAcpSessionFailure(value) {
+  const meta3 = child(value, "_meta");
+  const jetbrains = child(meta3, "jetbrains");
+  const air = child(jetbrains, "air");
+  const failure2 = child(air, "sessionFailure");
+  if (!isRecord4(air) || !Number.isInteger(air["version"]) || Number(air["version"]) < 1 || !isRecord4(failure2)) {
+    return null;
+  }
+  const id = failure2["id"];
+  const revision = failure2["revision"];
+  const category = failure2["category"];
+  const severity = failure2["severity"];
+  const title2 = failure2["title"];
+  if (typeof id !== "string" || id.length === 0 || id.length > 512 || !Number.isInteger(revision) || Number(revision) < 1 || !isCategory(category) || severity !== "warning" && severity !== "error" || typeof title2 !== "string" || title2.length === 0) {
+    return null;
+  }
+  return {
+    category,
+    id,
+    revision: Number(revision),
+    severity,
+    title: truncate2(title2, 4096)
+  };
+}
+function sessionFailureMeta(failure2) {
+  return {
+    jetbrains: {
+      air: {
+        version: 1,
+        sessionFailure: {
+          actions: [],
+          category: failure2.category,
+          id: failure2.id,
+          revision: failure2.revision,
+          severity: failure2.severity,
+          title: failure2.title
+        }
+      }
+    }
+  };
+}
+
 // src/acp/session-history.ts
 var HISTORY_ACTIVITY_FIELD_LIMIT = 1e5;
 var HISTORY_ACTIVITY_LIMIT = 100;
@@ -30542,6 +30624,9 @@ var AgentSession = class _AgentSession {
         methods3.agent.initialize,
         {
           clientCapabilities: {
+            _meta: {
+              jetbrains: { air: { capabilities: ["sessionFailure"], version: 1 } }
+            },
             elicitation: { form: {}, url: {} },
             plan: {},
             session: { configOptions: { boolean: {} } }
@@ -30975,6 +31060,10 @@ var AgentSession = class _AgentSession {
           "acp_invalid_prompt_response"
         );
       }
+      const failure2 = readAcpSessionFailure(response);
+      if (failure2 !== null) {
+        await running.activities.recordNotice(failure2.id, failure2.revision, failure2.severity, failure2.title);
+      }
       if (result.usage != null || result._meta?.quota !== void 0) {
         await this.#getObserver().onUsage({
           _meta: result._meta ?? null,
@@ -31158,6 +31247,10 @@ var AgentSession = class _AgentSession {
       return;
     }
     if (update.sessionUpdate === "session_info_update") {
+      const failure2 = readAcpSessionFailure(update);
+      if (failure2 !== null && this.#turn.running) {
+        await this.#turn.activities.recordNotice(failure2.id, failure2.revision, failure2.severity, failure2.title);
+      }
       if (Object.hasOwn(update, "title")) {
         this.#sessionTitle = truncate2(update.title ?? "", 500);
       }
@@ -31745,7 +31838,7 @@ var AgentRuntimeManager = class {
     } finally {
       if (retained && this.#sessionIdentity === "native") {
         const stored = this.#store.read(sessionId);
-        if (stored instanceof FoundAcpStoredSession && isNativeChatSessionId(stored.session.agentId, sessionId)) {
+        if (stored instanceof FoundAcpStoredSession && stored.session.nativeSessionId === sessionId && isNativeChatSessionId(stored.session.agentId, sessionId)) {
           this.#store.remove(sessionId);
         }
       }
@@ -33043,6 +33136,12 @@ var turnNotificationSchema = external_exports.object({
   threadId: boundedText(256),
   turn: turnSchema
 });
+var errorNotificationSchema = external_exports.object({
+  error: external_exports.object({ message: boundedText(4096) }),
+  threadId: boundedText(256),
+  turnId: boundedText(256),
+  willRetry: external_exports.boolean()
+});
 var commandApprovalParamsSchema = external_exports.object({
   command: external_exports.string().nullish(),
   commandActions: external_exports.array(external_exports.unknown()).max(1e3).nullish(),
@@ -34052,6 +34151,7 @@ var CodexAcpAgent = class {
   #nativeSessionId = "";
   #streamedReasoningItemIds = /* @__PURE__ */ new Set();
   #streamedAgentMessageItemIds = /* @__PURE__ */ new Set();
+  #noticeRevisions = /* @__PURE__ */ new Map();
   #turn = null;
   #nativeTurnId = null;
   #updateTail = Promise.resolve();
@@ -34204,10 +34304,10 @@ var CodexAcpAgent = class {
     if (this.#closePromise === null) {
       this.#appServer.detach();
       this.#closePromise = (async () => {
-        const child = this.#appServer.child();
+        const child2 = this.#appServer.child();
         try {
-          const captured = await captureProcessTree(child);
-          await stopProcessTree(child, captured);
+          const captured = await captureProcessTree(child2);
+          await stopProcessTree(child2, captured);
         } finally {
           this.#connection?.close();
         }
@@ -34297,6 +34397,27 @@ var CodexAcpAgent = class {
     await pending;
   };
   #onNotification = async (method, params) => {
+    if (method === "error") {
+      const decoded = errorNotificationSchema.safeParse(params);
+      if (decoded.success && decoded.data.willRetry && decoded.data.threadId === this.#nativeSessionId && this.#turn !== null && decoded.data.turnId === this.#turn.turn.id) {
+        const id = `codex:${decoded.data.turnId}:error`;
+        const revision = (this.#noticeRevisions.get(id) ?? 0) + 1;
+        this.#noticeRevisions.set(id, revision);
+        await this.#enqueue(async () => {
+          await this.#emit({
+            _meta: sessionFailureMeta({
+              category: "service",
+              id,
+              revision,
+              severity: "warning",
+              title: decoded.data.error.message
+            }),
+            sessionUpdate: "session_info_update"
+          });
+        });
+      }
+      return;
+    }
     if (method === "turn/started") {
       const decoded = turnNotificationSchema.safeParse(params);
       if (decoded.success && decoded.data.threadId === this.#nativeSessionId && this.#turn !== null) {
@@ -35927,7 +36048,7 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
       signal.removeEventListener("abort", abort);
     }
   }
-  const child = spawn4(agent.adapterPath, [...agent.arguments], {
+  const child2 = spawn4(agent.adapterPath, [...agent.arguments], {
     cwd: defaultWorkspace,
     detached: process.platform !== "win32",
     env: { ...environment, ...agent.environment },
@@ -35936,17 +36057,17 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
   });
   const processExit = new Promise((_resolve, reject) => {
     const rejectExit = () => reject(new Error("ACP adapter exited during initialization"));
-    child.once("error", reject);
-    child.once("exit", rejectExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
+    child2.once("error", reject);
+    child2.once("exit", rejectExit);
+    if (child2.exitCode !== null || child2.signalCode !== null) {
       rejectExit();
     }
   });
-  const stdin = child.stdin;
-  const stdout = child.stdout;
-  const stderr = child.stderr;
+  const stdin = child2.stdin;
+  const stdout = child2.stdout;
+  const stderr = child2.stderr;
   if (stdin === null || stdout === null || stderr === null) {
-    await stopProcessTree(child);
+    await stopProcessTree(child2);
     throw new AgentProbeError("acp_incompatible", "ACP adapter streams are unavailable");
   }
   let stderrBytes = 0;
@@ -35998,11 +36119,11 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
   } finally {
     clearTimeout(timeout);
     signal.removeEventListener("abort", abort);
-    const capturedProcesses = await captureProcessTree(child);
+    const capturedProcesses = await captureProcessTree(child2);
     connection.close();
     stdin.end();
     stderr.removeListener("data", consumeStderr);
-    await stopProcessTree(child, capturedProcesses);
+    await stopProcessTree(child2, capturedProcesses);
   }
 }
 
@@ -37980,16 +38101,16 @@ var WorkspaceDirectoryService = class {
       const children = await readdir3(target, { withFileTypes: true });
       signal.throwIfAborted();
       const entries = [];
-      for (const child of children) {
+      for (const child2 of children) {
         if (entries.length === 500) {
           break;
         }
-        if (child.isFile() || child.isBlockDevice() || child.isCharacterDevice() || child.isFIFO() || child.isSocket()) {
+        if (child2.isFile() || child2.isBlockDevice() || child2.isCharacterDevice() || child2.isFIFO() || child2.isSocket()) {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join16(target, child.name), signal);
-          entries.push({ directoryId: encodePath(path2), name: child.name });
+          const path2 = await this.resolvePath(join16(target, child2.name), signal);
+          entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
           if (!(cause instanceof LocalAuthorizationError)) {
@@ -39008,7 +39129,7 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
     );
   }
   signal.throwIfAborted();
-  const child = spawn5(agent.agentIdentity.realPath, ["app-server"], {
+  const child2 = spawn5(agent.agentIdentity.realPath, ["app-server"], {
     cwd,
     env: { ...process.env, ...agent.environment },
     detached: process.platform !== "win32",
@@ -39028,7 +39149,7 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
     )
   );
   const send2 = (message) => {
-    child.stdin.write(`${JSON.stringify(message)}
+    child2.stdin.write(`${JSON.stringify(message)}
 `);
   };
   const onData = (chunk) => {
@@ -39158,11 +39279,11 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
     () => fail(new AcpExecutionError("Reading saved Codex history timed out.", {}, "native_history_timeout")),
     options.detail === "rich" ? 6e4 : 15e3
   );
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", onData);
-  child.stdin.on("error", fail);
-  child.on("error", fail);
-  child.on("exit", onExit);
+  child2.stdout.setEncoding("utf8");
+  child2.stdout.on("data", onData);
+  child2.stdin.on("error", fail);
+  child2.on("error", fail);
+  child2.on("exit", onExit);
   signal.addEventListener("abort", abort, { once: true });
   try {
     if (signal.aborted) {
@@ -39182,13 +39303,13 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
   } finally {
     clearTimeout(timeout);
     signal.removeEventListener("abort", abort);
-    child.stdout.removeListener("data", onData);
-    if (child.pid !== void 0) {
-      await stopProcessTree(child);
+    child2.stdout.removeListener("data", onData);
+    if (child2.pid !== void 0) {
+      await stopProcessTree(child2);
     }
-    child.stdin.removeListener("error", fail);
-    child.removeListener("error", fail);
-    child.removeListener("exit", onExit);
+    child2.stdin.removeListener("error", fail);
+    child2.removeListener("error", fail);
+    child2.removeListener("exit", onExit);
   }
 }
 var readCodexHistory = async (agent, cwd, nativeSessionId, signal) => await readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal, { detail: "messages" });