@bitkyc08/opencodex 2.7.36 → 2.7.37

package/src/bridge.ts

@@ -158,16 +158,16 @@ export function bridgeToResponsesSSE(
   // upstream silence so a stalled routed provider never trips "idle timeout waiting for SSE".
   let activity = false;
   let beat: ReturnType<typeof setInterval> | undefined;
-
-  return new ReadableStream<Uint8Array>({
-    async start(controller) {
-      let emittedSinceYield = false;
-      const emit = (name: string, data: Record<string, unknown>) => {
+  let controller: ReadableStreamDefaultController<Uint8Array>;
+  let emittedFrames = 0;
+  let gated = false;
+  let stepping = false;
+  const emit = (name: string, data: Record<string, unknown>) => {
         if (closed) return;
         activity = true;
         try {
           controller.enqueue(encoder.encode(sseEvent(name, { type: name, sequence_number: seq++, ...data })));
-          emittedSinceYield = true;
+          emittedFrames++;
         } catch {
           closed = true;
         }
@@ -176,6 +176,7 @@ export function bridgeToResponsesSSE(
         if (closed) return;
         try {
           controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          emittedFrames++;
         } catch {
           closed = true;
         }
@@ -191,40 +192,10 @@ export function bridgeToResponsesSSE(
         ...(endTurn !== undefined ? { end_turn: endTurn } : {}),
       });
 
-      emit("response.created", { response: responseSnapshot("in_progress", []) });
-
-      // Re-arm Codex's idle timer during silence with a parser-ignored heartbeat (RC3). Skips a tick
-      // whenever a real event was emitted since the last tick, so it only fires on a genuine stall.
       const heartbeatFrame = encoder.encode('event: response.heartbeat\ndata: {"type":"response.heartbeat"}\n\n');
       let stallTicks = 0;
       const stallSec = resolveStallTimeoutSec(options?.stallTimeoutSec);
       const maxStallTicks = Math.ceil((stallSec * 1000) / heartbeatMs);
-      beat = setInterval(() => {
-        if (closed) return;
-        if (activity) { activity = false; stallTicks = 0; return; }
-        if (++stallTicks >= maxStallTicks) {
-          if (currentMsg) closeCurrentMessage();
-          if (currentReasoning) closeCurrentReasoning();
-          if (currentRawReasoning) closeCurrentRawReasoning();
-          flushHiddenRawReasoning();
-          if (currentToolCall) closeCurrentToolCall();
-          if (currentWebSearch) closeCurrentWebSearch("failed", []);
-          emit("response.incomplete", {
-            response: {
-              ...responseSnapshot("incomplete", finishedItems),
-              incomplete_details: { reason: "upstream_stall_timeout" },
-            },
-          });
-          reportTerminal("incomplete");
-          terminated = true;
-          closed = true;
-          clearInterval(beat!);
-          beat = undefined;
-          onCancel?.();
-          return;
-        }
-        try { controller.enqueue(heartbeatFrame); } catch { closed = true; }
-      }, heartbeatMs);
 
       let currentMsg: { itemId: string; outputIndex: number; text: string; phase?: OcxMessagePhase } | null = null;
       let currentReasoning: { itemId: string; outputIndex: number; text: string } | null = null;
@@ -432,19 +403,46 @@ export function bridgeToResponsesSSE(
         firstOutputReported = true;
         try { options?.onFirstOutput?.(); } catch { /* metrics must not break the stream */ }
       };
-      let macrotaskFired = true;
-      let macrotaskTimer: ReturnType<typeof setTimeout> | undefined;
-
-      try {
-        for await (const event of events) {
-          if (!macrotaskFired && emittedSinceYield) {
-            await new Promise<void>(r => setTimeout(r, 0));
-            macrotaskFired = true;
+      const it = events[Symbol.asyncIterator]();
+      let iteratorStarted = false;
+      let iteratorReturned = false;
+      let upstreamDone = false;
+      const returnIterator = () => {
+        if (iteratorReturned) return;
+        iteratorReturned = true;
+        const finishReturn = () => {
+          try {
+            void it.return?.()?.catch(() => {});
+          } catch {
+            /* synchronous iterator cleanup failure is also best-effort */
           }
-          emittedSinceYield = false;
-          macrotaskFired = false;
-          if (macrotaskTimer !== undefined) clearTimeout(macrotaskTimer);
-          macrotaskTimer = setTimeout(() => { macrotaskFired = true; macrotaskTimer = undefined; }, 0);
+        };
+        // Async-generator return() before the first next() does not enter the generator, so its
+        // finally blocks cannot cancel prepared upstream bodies. The cancel hook has already
+        // aborted the turn; bootstrap one cleanup step, then close the iterator without awaiting it.
+        if (!iteratorStarted) {
+          iteratorStarted = true;
+          try {
+            void it.next().then(finishReturn, () => {}).catch(() => {});
+          } catch {
+            /* synchronous iterator start failure is also best-effort */
+          }
+          return;
+        }
+        finishReturn();
+      };
+      const step = async () => {
+        if (stepping || closed) return;
+        stepping = true;
+        gated = false;
+        const emittedAtStart = emittedFrames;
+        try {
+        while (!terminated && !closed && emittedFrames === emittedAtStart) {
+          iteratorStarted = true;
+          const next = await it.next();
+          if (next.done) { upstreamDone = true; break; }
+          const event = next.value;
+          let terminalEvent = false;
           activity = true;
           stallTicks = 0;
           reportFirstOutput(event);
@@ -650,15 +648,18 @@ export function bridgeToResponsesSSE(
                 finishedItems.push(item as OutputItem);
                 outputIndex++;
               }
-              if (event.stopReason === "max_tokens") {
-                // Upstream hit its output token cap. Surface as incomplete so the client can
-                // distinguish a truncated turn from a genuinely finished one (issue #246).
+              if (event.stopReason === "max_tokens" || event.stopReason === "content_filter") {
+                // Upstream stopped before a normal completion. Surface as incomplete so the
+                // client can distinguish a truncated/filtered turn from a finished one.
                 const response = {
                   ...responseSnapshot("incomplete", finishedItems, event.endTurn),
                   usage: responsesUsage(event.usage),
-                  incomplete_details: { reason: "max_output_tokens" },
+                  incomplete_details: {
+                    reason: event.stopReason === "max_tokens" ? "max_output_tokens" : "content_filter",
+                  },
                 };
-                // Still cache the partial output so previous_response_id replay works.
+                // Cache max-output partials so previous_response_id replay can continue them;
+                // rememberResponseState rejects content-filtered incomplete responses.
                 options?.onCompletedResponse?.(response, event.providerState);
                 emit("response.incomplete", { response });
                 reportTerminal("incomplete");
@@ -670,7 +671,7 @@ export function bridgeToResponsesSSE(
                 });
                 reportTerminal("completed");
               }
-              terminated = true;
+              terminalEvent = true;
               break;
             }
             case "incomplete": {
@@ -693,7 +694,7 @@ export function bridgeToResponsesSSE(
                 },
               });
               reportTerminal("incomplete");
-              terminated = true;
+              terminalEvent = true;
               break;
             }
             case "error": {
@@ -716,27 +717,41 @@ export function bridgeToResponsesSSE(
                 },
               });
               reportTerminal("failed");
-              terminated = true;
+              terminalEvent = true;
               break;
             }
           }
+          if (terminalEvent) {
+            onCancel?.();
+            terminated = true;
+            returnIterator();
+            break;
+          }
         }
       } catch (err) {
-        flushHiddenRawReasoning();
-        if (currentWebSearch) closeCurrentWebSearch("failed", []);
-        emit("response.failed", {
-          response: {
-            ...responseSnapshot("failed", finishedItems),
-            error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
-            last_error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
-          },
-        });
-        reportTerminal("failed");
-        terminated = true;
+        if (!terminated) {
+          flushHiddenRawReasoning();
+          if (currentWebSearch) closeCurrentWebSearch("failed", []);
+          emit("response.failed", {
+            response: {
+              ...responseSnapshot("failed", finishedItems),
+              error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
+              last_error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
+            },
+          });
+          reportTerminal("failed");
+          onCancel?.();
+          terminated = true;
+          returnIterator();
+        }
       }
 
-      if (beat) clearInterval(beat);
-      if (macrotaskTimer !== undefined) clearTimeout(macrotaskTimer);
+      if (!terminated && !upstreamDone) {
+        gated = true;
+        stepping = false;
+        return;
+      }
+      if (beat) { clearInterval(beat); beat = undefined; }
 
       if (!terminated) {
         // The adapter generator ended without an explicit done/error event. Mark as incomplete
@@ -755,6 +770,7 @@ export function bridgeToResponsesSSE(
           },
         });
         reportTerminal("incomplete");
+        terminated = true;
       }
 
       emitDone();
@@ -763,6 +779,59 @@ export function bridgeToResponsesSSE(
       } catch {
         /* already closed (e.g. client cancelled) */
       }
+      closed = true;
+      gated = true;
+      stepping = false;
+      };
+
+      const startStream = () => {
+        emit("response.created", { response: responseSnapshot("in_progress", []) });
+        // The default ReadableStream strategy has HWM=1. Once one event's frames fill that
+        // queue, pull stepping pauses; no custom FIFO or queuing strategy is layered on top.
+        gated = true;
+        beat = setInterval(() => {
+          if (closed || gated) return;
+          if (activity) { activity = false; stallTicks = 0; return; }
+          if (++stallTicks >= maxStallTicks) {
+            if (currentMsg) closeCurrentMessage();
+            if (currentReasoning) closeCurrentReasoning();
+            if (currentRawReasoning) closeCurrentRawReasoning();
+            flushHiddenRawReasoning();
+            if (currentToolCall) closeCurrentToolCall();
+            if (currentWebSearch) closeCurrentWebSearch("failed", []);
+            emit("response.incomplete", {
+              response: {
+                ...responseSnapshot("incomplete", finishedItems),
+                incomplete_details: { reason: "upstream_stall_timeout" },
+              },
+            });
+            reportTerminal("incomplete");
+            onCancel?.();
+            terminated = true;
+            returnIterator();
+            emitDone();
+            if (beat) clearInterval(beat);
+            beat = undefined;
+            try { controller.close(); } catch { /* already closed */ }
+            closed = true;
+            return;
+          }
+          try {
+            controller.enqueue(heartbeatFrame);
+            emittedFrames++;
+          } catch {
+            closed = true;
+          }
+        }, heartbeatMs);
+      };
+
+  return new ReadableStream<Uint8Array>({
+    start(streamController) {
+      controller = streamController;
+      startStream();
+    },
+    pull() {
+      return step();
     },
     cancel() {
       // Client (Codex) disconnected. Stop emitting and let the caller abort the upstream fetch so a
@@ -771,6 +840,7 @@ export function bridgeToResponsesSSE(
       closed = true;
       if (beat) clearInterval(beat);
       onCancel?.();
+      returnIterator();
     },
   });
 }

package/src/chat/outbound.ts

@@ -132,17 +132,22 @@ export function responsesSseToChatCompletionsSse(
   // tool call_id -> streaming index (OpenAI requires stable indices per tool call)
   const toolIndexByCallId = new Map<string, number>();
   const toolIndexByItemId = new Map<string, number>();
+  const toolCallIdByIndex = new Map<number, string>();
   const toolNameByIndex = new Map<number, string>();
+  const toolArgumentsByIndex = new Map<number, string>();
+  const emittedToolIndexes = new Set<number>();
   let nextToolIndex = 0;
   let sseIterator: AsyncGenerator<{ event?: string; data: string }> | undefined;
   const upstreamAbort = new AbortController();
-
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      let failed = false;
+  let controller: ReadableStreamDefaultController<Uint8Array>;
+  let failed = false;
+  let emittedFrames = 0;
+  let stepping = false;
+  let decoderStarted = false;
       const emit = (payload: Rec | "[DONE]") => {
         if (failed) return;
         controller.enqueue(encoder.encode(dataFrame(payload)));
+        emittedFrames++;
       };
       const ensureRole = () => {
         if (started) return;
@@ -166,8 +171,47 @@ export function responsesSseToChatCompletionsSse(
         frame.choices = [{ index: 0, delta: { reasoning_content: text }, finish_reason: null }];
         emit(frame);
       };
+      const resolveFinalArguments = (candidate: unknown, streamed: string) => {
+        if (typeof candidate !== "string") return streamed;
+        // Some compatible providers send an empty final snapshot. Do not let that erase
+        // non-empty streamed arguments; genuinely empty calls have no buffered content.
+        return candidate.length > 0 || streamed.length === 0 ? candidate : streamed;
+      };
+      const emitToolCall = (toolIndex: number, callId: string, name: string, args: string) => {
+        if (!callId || emittedToolIndexes.has(toolIndex)) return;
+        emittedToolIndexes.add(toolIndex);
+        ensureRole();
+        const frame = chunkBase(id, model, created);
+        frame.choices = [{
+          index: 0,
+          delta: {
+            tool_calls: [{
+              index: toolIndex,
+              id: callId,
+              type: "function",
+              function: { name, arguments: args },
+            }],
+          },
+          finish_reason: null,
+        }];
+        emit(frame);
+      };
+      const flushPendingToolCalls = () => {
+        const pending = [...toolCallIdByIndex.entries()].sort(([a], [b]) => a - b);
+        for (const [toolIndex, callId] of pending) {
+          emitToolCall(
+            toolIndex,
+            callId,
+            toolNameByIndex.get(toolIndex) ?? "",
+            toolArgumentsByIndex.get(toolIndex) ?? "",
+          );
+        }
+      };
       const finish = (finishReason: string, usage: unknown) => {
         if (terminated) return;
+        // A valid completed/incomplete terminal frame may arrive without output_item.done.
+        // Preserve any known tool call before emitting its finish reason.
+        flushPendingToolCalls();
         terminated = true;
         ensureRole();
         const frame = chunkBase(id, model, created);
@@ -199,6 +243,7 @@ export function responsesSseToChatCompletionsSse(
                 : null,
             },
           })));
+          emittedFrames++;
         } catch {
           /* controller may already be closed */
         }
@@ -232,24 +277,15 @@ export function responsesSseToChatCompletionsSse(
               toolIndex = nextToolIndex++;
               toolIndexByCallId.set(callId, toolIndex);
             }
+            toolCallIdByIndex.set(toolIndex, callId);
             if (typeof item.id === "string") toolIndexByItemId.set(item.id, toolIndex);
             if (name) toolNameByIndex.set(toolIndex, name);
-            const frame = chunkBase(id, model, created);
-            frame.choices = [{
-              index: 0,
-              delta: {
-                tool_calls: [{
-                  index: toolIndex,
-                  id: callId,
-                  type: "function",
-                  // Always include name so clients that replace (not merge) tool_calls
-                  // deltas never end up with function.name-less history.
-                  function: { name, arguments: "" },
-                }],
-              },
-              finish_reason: null,
-            }];
-            emit(frame);
+            if (!toolArgumentsByIndex.has(toolIndex)) {
+              toolArgumentsByIndex.set(
+                toolIndex,
+                typeof item.arguments === "string" ? item.arguments : "",
+              );
+            }
             break;
           }
           case "response.function_call_arguments.delta": {
@@ -258,23 +294,24 @@ export function responsesSseToChatCompletionsSse(
             const toolIndex = (itemId ? toolIndexByItemId.get(itemId) : undefined)
               ?? (nextToolIndex > 0 ? nextToolIndex - 1 : 0);
             ensureRole();
-            const knownName = toolNameByIndex.get(toolIndex) ?? "";
-            const fn: Rec = { arguments: data.delta };
-            // Re-emit name on every args delta: GitHub Copilot App / some ChatGPT clients
-            // replace the whole function object instead of merging, which otherwise drops name.
-            if (knownName) fn.name = knownName;
-            const frame = chunkBase(id, model, created);
-            frame.choices = [{
-              index: 0,
-              delta: {
-                tool_calls: [{
-                  index: toolIndex,
-                  function: fn,
-                }],
-              },
-              finish_reason: null,
-            }];
-            emit(frame);
+            toolArgumentsByIndex.set(
+              toolIndex,
+              (toolArgumentsByIndex.get(toolIndex) ?? "") + data.delta,
+            );
+            break;
+          }
+          case "response.function_call_arguments.done": {
+            const itemId = typeof data.item_id === "string" ? data.item_id : undefined;
+            const toolIndex = itemId ? toolIndexByItemId.get(itemId) : undefined;
+            if (toolIndex === undefined) break;
+            sawToolUse = true;
+            const name = typeof data.name === "string" ? data.name : "";
+            if (name) toolNameByIndex.set(toolIndex, name);
+            const streamedArgs = toolArgumentsByIndex.get(toolIndex) ?? "";
+            toolArgumentsByIndex.set(
+              toolIndex,
+              resolveFinalArguments(data.arguments, streamedArgs),
+            );
             break;
           }
           case "response.output_item.done": {
@@ -284,34 +321,25 @@ export function responsesSseToChatCompletionsSse(
               sawToolUse = true;
               const callId = typeof item.call_id === "string" ? item.call_id : "";
               const name = typeof item.name === "string" ? item.name : "";
-              const args = typeof item.arguments === "string" ? item.arguments : "";
               if (!callId) break;
-              const existingIndex = toolIndexByCallId.get(callId);
-              const isNew = existingIndex === undefined;
+              const itemId = typeof item.id === "string" ? item.id : undefined;
+              const existingIndex = toolIndexByCallId.get(callId)
+                ?? (itemId ? toolIndexByItemId.get(itemId) : undefined);
               const toolIndex = existingIndex ?? nextToolIndex++;
-              if (isNew) toolIndexByCallId.set(callId, toolIndex);
-              if (typeof item.id === "string") toolIndexByItemId.set(item.id, toolIndex);
+              toolIndexByCallId.set(callId, toolIndex);
+              toolCallIdByIndex.set(toolIndex, callId);
+              if (itemId) toolIndexByItemId.set(itemId, toolIndex);
               if (name) toolNameByIndex.set(toolIndex, name);
               const finalName = name || toolNameByIndex.get(toolIndex) || "";
-              // Last-write-wins: the done-frame snapshot is authoritative final arguments.
-              // Always re-emit full identity (id/type/name) so replace-style clients keep function.name.
-              if (args.length > 0 || isNew || finalName) {
-                ensureRole();
-                const frame = chunkBase(id, model, created);
-                frame.choices = [{
-                  index: 0,
-                  delta: {
-                    tool_calls: [{
-                      index: toolIndex,
-                      id: callId,
-                      type: "function",
-                      function: { name: finalName, arguments: args },
-                    }],
-                  },
-                  finish_reason: null,
-                }];
-                emit(frame);
-              }
+              const streamedArgs = toolArgumentsByIndex.get(toolIndex) ?? "";
+              // A Responses stream can carry incremental/finalized argument events plus an
+              // authoritative output_item.done snapshot. Chat Completions tool-call fields are
+              // append-only deltas, so forwarding multiple representations corrupts clients that
+              // accumulate them. Emit one complete call here; finish() flushes any item whose
+              // done event was omitted, and replace-style clients still get a complete object.
+              const args = resolveFinalArguments(item.arguments, streamedArgs);
+              toolArgumentsByIndex.set(toolIndex, args);
+              emitToolCall(toolIndex, callId, finalName, args);
             }
             break;
           }
@@ -325,8 +353,20 @@ export function responsesSseToChatCompletionsSse(
             const details = isRec(response.incomplete_details) ? response.incomplete_details : {};
             const reason = details.reason === "max_output_tokens" ? "length"
               : details.reason === "content_filter" ? "content_filter"
-              : sawToolUse ? "tool_calls" : "stop";
-            finish(reason, response.usage);
+              : undefined;
+            if (reason !== undefined) {
+              // Truthful OpenAI-compatible finish reasons: the turn ended, just early.
+              finish(reason, response.usage);
+            } else {
+              // upstream_stall_timeout / adapter_eof / proxy-synthesized incompletes are
+              // failures, not early finishes: emit an error frame and close WITHOUT
+              // [DONE] instead of a success-looking stop/tool_calls + [DONE].
+              const why = typeof details.reason === "string" ? details.reason : "unknown";
+              const message = typeof details.message === "string" && details.message.length > 0
+                ? details.message
+                : `upstream stream ended early (${why})`;
+              fail(message);
+            }
             break;
           }
           case "response.failed": {
@@ -345,9 +385,25 @@ export function responsesSseToChatCompletionsSse(
       // multi-line data, and a terminal event without a trailing blank line (Sol audit
       // blocker 3 — the hand-rolled "\n\n" splitter misreported those as truncation).
       sseIterator = decodeServerSentEvents(upstream, { signal: upstreamAbort.signal });
-      void (async () => {
+      const step = async () => {
+        if (stepping || cancelled) return;
+        stepping = true;
+        const emittedAtStart = emittedFrames;
         try {
-          for await (const record of sseIterator!) {
+          while (!cancelled && emittedFrames === emittedAtStart) {
+            decoderStarted = true;
+            const next = await sseIterator!.next();
+            if (next.done) {
+              if (!cancelled && !terminated) {
+                fail("upstream stream ended before a terminal frame (truncated response)");
+              }
+              // Success path: close after [DONE]. Failure path closes inside fail().
+              if (!cancelled && terminated && !failed) {
+                try { controller.close(); } catch { /* already closed */ }
+              }
+              break;
+            }
+            const record = next.value;
             const eventName = record.event ?? "";
             const dataLine = record.data.trim();
             if (!eventName || !dataLine) continue;
@@ -360,15 +416,18 @@ export function responsesSseToChatCompletionsSse(
         } catch (err) {
           fail(err instanceof Error ? err.message : String(err));
         } finally {
-          if (!cancelled && !terminated) {
-            fail("upstream stream ended before a terminal frame (truncated response)");
-          }
-          // Success path: close after [DONE]. Failure path closes inside fail().
-          if (!cancelled && terminated && !failed) {
-            try { controller.close(); } catch { /* already closed */ }
-          }
+          stepping = false;
         }
-      })();
+      };
+
+  return new ReadableStream<Uint8Array>({
+    start(streamController) {
+      controller = streamController;
+      // Default HWM=1: one Responses event is translated atomically, then upstream
+      // decoding pauses until the chat consumer creates demand again.
+    },
+    pull() {
+      return step();
     },
     cancel(reason) {
       cancelled = true;
@@ -376,6 +435,9 @@ export function responsesSseToChatCompletionsSse(
       // read() so the generator's return() below resolves promptly instead of hanging
       // behind an idle upstream (Sol re-verification blocker).
       upstreamAbort.abort(reason);
+      if (!decoderStarted) {
+        return upstream.cancel(reason).then(() => undefined, () => undefined);
+      }
       return sseIterator?.return(undefined).then(() => undefined, () => undefined) ?? Promise.resolve(undefined);
     },
   });

package/src/cli/codex-shim-autorestore.ts

@@ -0,0 +1,45 @@
+import { autoRestoreCodexShim } from "../codex/shim";
+import { codexShimAutoRestoreEnabled, readConfigDiagnostics } from "../config";
+
+export interface CodexShimAutoRestoreCliDeps {
+  env: NodeJS.ProcessEnv;
+  warn: (message: string) => void;
+  restore: typeof autoRestoreCodexShim;
+  readConfig: typeof readConfigDiagnostics;
+}
+
+const DEFAULT_DEPS: CodexShimAutoRestoreCliDeps = {
+  env: process.env,
+  warn: message => console.warn(message),
+  restore: autoRestoreCodexShim,
+  readConfig: readConfigDiagnostics,
+};
+
+export function skipsCodexShimAutoRestore(command: string | undefined, args: string[]): boolean {
+  if (command === "uninstall" || command === "remove") return true;
+  return command === "codex-shim" && ["install", "uninstall", "remove"].includes(args[1] ?? "");
+}
+
+export function maybeAutoRestoreCodexShim(
+  command: string | undefined,
+  args: string[],
+  deps: CodexShimAutoRestoreCliDeps = DEFAULT_DEPS,
+): void {
+  if (skipsCodexShimAutoRestore(command, args)) return;
+  try {
+    const result = deps.restore({
+      enabled: () => codexShimAutoRestoreEnabled(deps.readConfig().config, deps.env),
+    });
+    if (result.status === "restored") {
+      deps.warn(`⚠️  ${result.message} (automatic repair after Codex update)`);
+    } else if ((result.status === "deferred" || result.status === "ineligible") && result.message) {
+      deps.warn(`⚠️  ${result.message}`);
+    }
+  } catch (error) {
+    deps.warn(
+      `⚠️  Codex shim auto-restore failed; continuing without it: ${
+        error instanceof Error ? error.message : String(error)
+      }. Run 'ocx codex-shim install' after the Codex update finishes.`,
+    );
+  }
+}