@bryanhu/codexly 0.29.0 → 0.31.0

package/dist/{chunk-L5UNIA54.js → chunk-IQDWF7SH.js}

@@ -1,10 +1,12 @@
 import { createRequire } from 'node:module';
 import { WorkbenchPetProviderError, CUSTOM_MODEL_REASONING_FALLBACK, normalizeCustomModelReasoning, PendingRequestResolutionError } from './chunk-REIMOLGX.js';
-import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_IMAGE_BYTES, MAX_AGENT_TEXT_BYTES, MAX_AGENT_FILE_BYTES } from './chunk-W6U4V35J.js';
+import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_IMAGE_BYTES, MAX_AGENT_TEXT_BYTES, MAX_AGENT_FILE_BYTES } from './chunk-XAI75BER.js';
 import { __commonJS, __require, __toESM } from './chunk-K6J42667.js';
 import { randomUUID, createHash } from 'crypto';
 import { Buffer as Buffer$1 } from 'buffer';
 import { mkdtempSync, rmSync, constants, createReadStream, mkdirSync, unlinkSync, renameSync, writeFileSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync } from 'fs';
+import { pipeline } from 'stream';
+import { createZstdDecompress, constants as constants$1 } from 'zlib';
 import { readFile, mkdir, writeFile, rename, rm, readdir, realpath, stat, access, open, unlink, lstat, opendir } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
 import { resolve, join, basename, dirname, relative, sep, win32, posix, isAbsolute, extname } from 'path';
@@ -2643,7 +2645,7 @@ var require_transport = __commonJS({
       stream.flushSync();
     }
     function transport(fullOptions) {
-      const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
+      const { pipeline: pipeline2, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
       const options = {
         ...fullOptions.options
       };
@@ -2671,9 +2673,9 @@ var require_transport = __commonJS({
             };
           });
         });
-      } else if (pipeline) {
+      } else if (pipeline2) {
         target = bundlerOverrides["pino-worker"] || join10(__dirname, "worker.js");
-        options.pipelines = [pipeline.map((dest) => {
+        options.pipelines = [pipeline2.map((dest) => {
           return {
             ...dest,
             target: fixTarget(dest.target)
@@ -2687,7 +2689,7 @@ var require_transport = __commonJS({
         options.dedupe = dedupe;
       }
       options.pinoWillSendConfig = true;
-      const name = targets || pipeline ? "pino.transport" : target;
+      const name = targets || pipeline2 ? "pino.transport" : target;
       return buildStream(fixTarget(target), options, worker, sync, name);
       function fixTarget(origin) {
         origin = bundlerOverrides[origin] || origin;
@@ -3513,20 +3515,20 @@ var require_safe_stable_stringify = __commonJS({
       }
       return JSON.stringify(str);
     }
-    function sort(array, comparator) {
-      if (array.length > 200 || comparator) {
-        return array.sort(comparator);
+    function sort(array2, comparator) {
+      if (array2.length > 200 || comparator) {
+        return array2.sort(comparator);
       }
-      for (let i = 1; i < array.length; i++) {
-        const currentValue = array[i];
+      for (let i = 1; i < array2.length; i++) {
+        const currentValue = array2[i];
         let position = i;
-        while (position !== 0 && array[position - 1] > currentValue) {
-          array[position] = array[position - 1];
+        while (position !== 0 && array2[position - 1] > currentValue) {
+          array2[position] = array2[position - 1];
           position--;
         }
-        array[position] = currentValue;
+        array2[position] = currentValue;
       }
-      return array;
+      return array2;
     }
     var typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
       Object.getPrototypeOf(
@@ -3539,14 +3541,14 @@ var require_safe_stable_stringify = __commonJS({
     function isTypedArrayWithEntries(value) {
       return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
     }
-    function stringifyTypedArray(array, separator, maximumBreadth) {
-      if (array.length < maximumBreadth) {
-        maximumBreadth = array.length;
+    function stringifyTypedArray(array2, separator, maximumBreadth) {
+      if (array2.length < maximumBreadth) {
+        maximumBreadth = array2.length;
       }
       const whitespace = separator === "," ? "" : " ";
-      let res = `"0":${whitespace}${array[0]}`;
+      let res = `"0":${whitespace}${array2[0]}`;
       for (let i = 1; i < maximumBreadth; i++) {
-        res += `${separator}"${i}":${whitespace}${array[i]}`;
+        res += `${separator}"${i}":${whitespace}${array2[i]}`;
       }
       return res;
     }
@@ -5680,6 +5682,72 @@ function mapCodexGoal(value, expectedTaskId) {
     updatedAt: toDateTime(goal["updatedAt"], "Codex goal updatedAt")
   };
 }
+var MAX_READERS = 2;
+var IDLE_TIMEOUT_MS = 3e4;
+var readers = /* @__PURE__ */ new Set();
+var TranscriptZstdReader = class _TranscriptZstdReader {
+  #source;
+  #decoder;
+  #iterator;
+  #pending = Buffer.alloc(0);
+  #timer;
+  closed = false;
+  done = false;
+  constructor(path) {
+    this.#source = createReadStream(path, { highWaterMark: 64 * 1024 });
+    this.#decoder = createZstdDecompress({
+      chunkSize: 64 * 1024,
+      // 上游 level 3 的窗口小于此限制；拒绝异常大窗口，避免压缩文件放大内存占用。
+      params: { [constants$1.ZSTD_d_windowLogMax]: 23 }
+    });
+    this.#iterator = this.#decoder[Symbol.asyncIterator]();
+    pipeline(this.#source, this.#decoder, () => {
+    });
+    readers.add(this);
+  }
+  static open(path) {
+    if (readers.size >= MAX_READERS) return void 0;
+    return new _TranscriptZstdReader(path);
+  }
+  async read(limit, consume) {
+    clearTimeout(this.#timer);
+    let count = 0;
+    try {
+      while (count < limit && !this.closed) {
+        if (this.#pending.length === 0) {
+          const next = await this.#iterator.next();
+          if (next.done) {
+            this.done = true;
+            this.close();
+            break;
+          }
+          this.#pending = next.value;
+        }
+        const length = Math.min(limit - count, this.#pending.length);
+        consume(this.#pending.subarray(0, length));
+        this.#pending = this.#pending.subarray(length);
+        count += length;
+      }
+      return count;
+    } catch (error) {
+      this.close();
+      throw error;
+    } finally {
+      if (!this.closed)
+        this.#timer = setTimeout(() => {
+          this.close();
+        }, IDLE_TIMEOUT_MS).unref();
+    }
+  }
+  close() {
+    this.closed = true;
+    clearTimeout(this.#timer);
+    this.#pending = Buffer.alloc(0);
+    this.#source.destroy();
+    this.#decoder.destroy();
+    readers.delete(this);
+  }
+};
 var EXPANDED_SKILL_PATTERN = /^<skill>\s*<name>(?<name>[^<]+)<\/name>\s*<path>(?<path>[^<]+)<\/path>[\s\S]*<\/skill>\s*$/u;
 var LINKED_SKILL_PATTERN = /\[\$(?<name>[^\]\s]+)\]\((?<path>[^)]+\/SKILL\.md)\)/gu;
 var SAFE_THREAD_ID_PATTERN = /^[a-zA-Z0-9_-]+$/u;
@@ -5781,32 +5849,41 @@ function getTranscriptThreadCache(cacheKey) {
     if (oldestKey === void 0) {
       break;
     }
+    for (const file of transcriptCacheByThread.get(oldestKey)?.files.values() ?? [])
+      file.reader?.close();
     transcriptCacheByThread.delete(oldestKey);
   }
   return created;
 }
-async function discoverTranscriptPaths(cache, sessionsDirectory, threadId) {
+async function discoverTranscriptPaths(cache, codexHome, threadId) {
   const now = Date.now();
   if (cache.transcriptPaths.length > 0 || now - cache.lastDiscoveryAt < TRANSCRIPT_DISCOVERY_INTERVAL_MS) {
     return;
   }
   const transcriptPaths = [];
   const transcriptSuffix = `-${threadId}.jsonl`;
-  const directory = await opendir(sessionsDirectory, { recursive: true });
-  for await (const entry of directory) {
-    if (!entry.isFile() || !entry.name.startsWith("rollout-") || !entry.name.endsWith(transcriptSuffix)) {
-      continue;
+  for (const name of ["sessions", "archived_sessions"]) {
+    let directory;
+    try {
+      directory = await opendir(join(codexHome, name), { recursive: true });
+    } catch (error) {
+      if (isRecord2(error) && error["code"] === "ENOENT") continue;
+      throw error;
     }
-    transcriptPaths.push(join(entry.parentPath, entry.name));
-    if (transcriptPaths.length >= MAX_TRANSCRIPT_FILES_PER_THREAD) {
-      break;
+    for await (const entry of directory) {
+      if (!entry.isFile() || !entry.name.startsWith("rollout-") || !(entry.name.endsWith(transcriptSuffix) || entry.name.endsWith(`${transcriptSuffix}.zst`)))
+        continue;
+      transcriptPaths.push(join(entry.parentPath, entry.name));
+      if (transcriptPaths.length >= MAX_TRANSCRIPT_FILES_PER_THREAD) break;
     }
+    if (transcriptPaths.length >= MAX_TRANSCRIPT_FILES_PER_THREAD) break;
   }
   cache.transcriptPaths = transcriptPaths;
   cache.lastDiscoveryAt = now;
   const discoveredPaths = new Set(transcriptPaths);
   for (const cachedPath of cache.files.keys()) {
     if (!discoveredPaths.has(cachedPath)) {
+      cache.files.get(cachedPath)?.reader?.close();
       cache.files.delete(cachedPath);
       cache.mergedSkillsDirty = true;
     }
@@ -5814,11 +5891,12 @@ async function discoverTranscriptPaths(cache, sessionsDirectory, threadId) {
 }
 async function parseTranscriptFileIncrementally(transcriptPath, cache, remainingBytes) {
   const transcriptStats = await stat(transcriptPath);
+  const compressed = transcriptPath.endsWith(".zst");
   const cachedFile = cache.files.get(transcriptPath);
-  if (cachedFile?.mtimeMs === transcriptStats.mtimeMs && cachedFile.size === transcriptStats.size && cachedFile.offset === transcriptStats.size) {
+  if (cachedFile?.mtimeMs === transcriptStats.mtimeMs && cachedFile.size === transcriptStats.size && (compressed ? cachedFile.complete : cachedFile.offset === transcriptStats.size)) {
     return 0;
   }
-  const canContinue = cachedFile !== void 0 && transcriptStats.size >= cachedFile.size && transcriptStats.size >= cachedFile.offset && (transcriptStats.size > cachedFile.size || transcriptStats.mtimeMs === cachedFile.mtimeMs);
+  const canContinue = cachedFile !== void 0 && (compressed ? cachedFile.size === transcriptStats.size && cachedFile.mtimeMs === transcriptStats.mtimeMs && cachedFile.reader?.closed === false : transcriptStats.size >= cachedFile.size && transcriptStats.size >= cachedFile.offset && (transcriptStats.size > cachedFile.size || transcriptStats.mtimeMs === cachedFile.mtimeMs));
   const fileCache = canContinue ? cachedFile : {
     cachedSkillNameBytes: 0,
     discardUntilNewline: false,
@@ -5829,8 +5907,23 @@ async function parseTranscriptFileIncrementally(transcriptPath, cache, remaining
     skillNamesByTurnId: /* @__PURE__ */ new Map()
   };
   if (cachedFile !== void 0 && fileCache !== cachedFile) {
+    cachedFile.reader?.close();
     cache.mergedSkillsDirty = true;
   }
+  if (compressed) {
+    fileCache.reader ??= TranscriptZstdReader.open(transcriptPath);
+    if (fileCache.reader === void 0) return 0;
+    const bytes = await fileCache.reader.read(remainingBytes, (chunk) => {
+      consumeTranscriptChunk(chunk, fileCache);
+    });
+    fileCache.complete = fileCache.reader.done;
+    fileCache.offset += bytes;
+    fileCache.mtimeMs = transcriptStats.mtimeMs;
+    fileCache.size = transcriptStats.size;
+    cache.files.set(transcriptPath, fileCache);
+    cache.mergedSkillsDirty = true;
+    return bytes;
+  }
   const availableBytes = transcriptStats.size - fileCache.offset;
   const bytesToRead = Math.min(availableBytes, remainingBytes);
   if (bytesToRead <= 0) {
@@ -5844,27 +5937,7 @@ async function parseTranscriptFileIncrementally(transcriptPath, cache, remaining
     start: fileCache.offset
   });
   for await (const chunk of stream) {
-    const data = fileCache.pendingLine.length === 0 ? chunk : Buffer.concat([fileCache.pendingLine, chunk]);
-    fileCache.pendingLine = Buffer.alloc(0);
-    let lineStart = 0;
-    let lineEnd = data.indexOf(10, lineStart);
-    while (lineEnd >= 0) {
-      const line = data.subarray(lineStart, lineEnd);
-      if (!fileCache.discardUntilNewline && line.length <= MAX_TRANSCRIPT_LINE_BYTES) {
-        const contentEnd = line.at(-1) === 13 ? line.length - 1 : line.length;
-        collectTranscriptLineSkills(line.subarray(0, contentEnd).toString("utf8"), fileCache);
-      }
-      fileCache.discardUntilNewline = false;
-      lineStart = lineEnd + 1;
-      lineEnd = data.indexOf(10, lineStart);
-    }
-    const incompleteLine = data.subarray(lineStart);
-    if (!fileCache.discardUntilNewline && incompleteLine.length <= MAX_TRANSCRIPT_LINE_BYTES) {
-      fileCache.pendingLine = Buffer.from(incompleteLine);
-    } else if (incompleteLine.length > 0) {
-      fileCache.pendingLine = Buffer.alloc(0);
-      fileCache.discardUntilNewline = true;
-    }
+    consumeTranscriptChunk(chunk, fileCache);
   }
   fileCache.offset += bytesToRead;
   fileCache.mtimeMs = transcriptStats.mtimeMs;
@@ -5873,6 +5946,29 @@ async function parseTranscriptFileIncrementally(transcriptPath, cache, remaining
   cache.mergedSkillsDirty = true;
   return bytesToRead;
 }
+function consumeTranscriptChunk(chunk, fileCache) {
+  const data = fileCache.pendingLine.length === 0 ? chunk : Buffer.concat([fileCache.pendingLine, chunk]);
+  fileCache.pendingLine = Buffer.alloc(0);
+  let lineStart = 0;
+  let lineEnd = data.indexOf(10, lineStart);
+  while (lineEnd >= 0) {
+    const line = data.subarray(lineStart, lineEnd);
+    if (!fileCache.discardUntilNewline && line.length <= MAX_TRANSCRIPT_LINE_BYTES) {
+      const contentEnd = line.at(-1) === 13 ? line.length - 1 : line.length;
+      collectTranscriptLineSkills(line.subarray(0, contentEnd).toString("utf8"), fileCache);
+    }
+    fileCache.discardUntilNewline = false;
+    lineStart = lineEnd + 1;
+    lineEnd = data.indexOf(10, lineStart);
+  }
+  const incompleteLine = data.subarray(lineStart);
+  if (!fileCache.discardUntilNewline && incompleteLine.length <= MAX_TRANSCRIPT_LINE_BYTES) {
+    fileCache.pendingLine = Buffer.from(incompleteLine);
+  } else if (incompleteLine.length > 0) {
+    fileCache.pendingLine = Buffer.alloc(0);
+    fileCache.discardUntilNewline = true;
+  }
+}
 function mergeTranscriptSkills(cache) {
   if (!cache.mergedSkillsDirty) {
     return cache.mergedSkills;
@@ -5893,9 +5989,9 @@ function mergeTranscriptSkills(cache) {
   cache.mergedSkillsDirty = false;
   return cache.mergedSkills;
 }
-async function readCachedCodexTranscriptTurnSkills(cache, sessionsDirectory, threadId) {
+async function readCachedCodexTranscriptTurnSkills(cache, codexHome, threadId) {
   try {
-    await discoverTranscriptPaths(cache, sessionsDirectory, threadId);
+    await discoverTranscriptPaths(cache, codexHome, threadId);
     let remainingBytes = MAX_TRANSCRIPT_BYTES_PER_READ;
     for (const transcriptPath of cache.transcriptPaths) {
       if (remainingBytes <= 0) {
@@ -5909,10 +6005,19 @@ async function readCachedCodexTranscriptTurnSkills(cache, sessionsDirectory, thr
         );
       } catch (error) {
         if (isRecord2(error) && error["code"] === "ENOENT") {
-          cache.files.delete(transcriptPath);
-          cache.mergedSkillsDirty = true;
-          cache.transcriptPaths = cache.transcriptPaths.filter((path) => path !== transcriptPath);
+          cache.files.get(transcriptPath)?.reader?.close();
+          cache.transcriptPaths = [];
           cache.lastDiscoveryAt = 0;
+          await discoverTranscriptPaths(cache, codexHome, threadId);
+          for (const replacement of cache.transcriptPaths) {
+            if (remainingBytes <= 0) break;
+            remainingBytes -= await parseTranscriptFileIncrementally(
+              replacement,
+              cache,
+              remainingBytes
+            );
+          }
+          break;
         }
       }
     }
@@ -5924,13 +6029,12 @@ async function readCodexTranscriptTurnSkills(threadId, codexHome = process.env["
   if (!SAFE_THREAD_ID_PATTERN.test(threadId)) {
     return /* @__PURE__ */ new Map();
   }
-  const sessionsDirectory = join(codexHome, "sessions");
   const cacheKey = `${codexHome}\0${threadId}`;
   const cache = getTranscriptThreadCache(cacheKey);
   if (cache.pendingRead !== void 0) {
     return cache.pendingRead;
   }
-  const pendingRead = readCachedCodexTranscriptTurnSkills(cache, sessionsDirectory, threadId);
+  const pendingRead = readCachedCodexTranscriptTurnSkills(cache, codexHome, threadId);
   cache.pendingRead = pendingRead;
   try {
     return await pendingRead;
@@ -7093,15 +7197,15 @@ var JsonlFrameProcessor = class {
     );
     this.#worker.unref();
     this.#worker.on("message", (response) => {
-      const pending = this.#pending.get(response.id);
-      if (pending === void 0) return;
+      const pending2 = this.#pending.get(response.id);
+      if (pending2 === void 0) return;
       this.#pending.delete(response.id);
       if (response.type === "error") {
-        pending.reject(new JsonlFrameParseError(response.code));
+        pending2.reject(new JsonlFrameParseError(response.code));
         return;
       }
       this.#hydrateStagedImages(response.message);
-      pending.resolve(response.message);
+      pending2.resolve(response.message);
     });
     this.#worker.once("error", (error) => {
       this.#rejectPending(error);
@@ -7151,7 +7255,7 @@ var JsonlFrameProcessor = class {
     }
   }
   #rejectPending(error) {
-    for (const pending of this.#pending.values()) pending.reject(error);
+    for (const pending2 of this.#pending.values()) pending2.reject(error);
     this.#pending.clear();
   }
 };
@@ -7416,10 +7520,10 @@ var JsonlRpcClient = class {
     const id = this.#nextRequestId++;
     const request = params === void 0 ? { id, method } : { id, method, params };
     return new Promise((resolve7, reject) => {
-      const pending = new RpcPendingRequest({
+      const pending2 = new RpcPendingRequest({
         onTimeout: () => {
-          if (this.#removePending(id, pending)) {
-            pending.reject(new RpcTimeoutError(id, method, timeoutMs));
+          if (this.#removePending(id, pending2)) {
+            pending2.reject(new RpcTimeoutError(id, method, timeoutMs));
           }
         },
         reject,
@@ -7427,7 +7531,7 @@ var JsonlRpcClient = class {
         resolve: resolve7,
         timeoutMs
       });
-      this.#pending.set(id, pending);
+      this.#pending.set(id, pending2);
       try {
         void this.#sendMessage(request).catch(() => void 0);
       } catch {
@@ -7493,8 +7597,8 @@ var JsonlRpcClient = class {
     this.#input.off("end", this.#handleInputEnd);
     this.#input.off("error", this.#handleStreamError);
     this.#output.off("error", this.#handleStreamError);
-    for (const pending of this.#pending.values()) {
-      pending.reject(reason);
+    for (const pending2 of this.#pending.values()) {
+      pending2.reject(reason);
     }
     this.#pending.clear();
     this.#frameBuffer.clear();
@@ -7661,8 +7765,8 @@ var JsonlRpcClient = class {
     throw new RpcProtocolError("RPC frame is neither a response, server request, nor notification");
   }
   #handleResponse(id, message) {
-    const pending = this.#pending.get(id);
-    if (!pending) {
+    const pending2 = this.#pending.get(id);
+    if (!pending2) {
       return;
     }
     if ("error" in message) {
@@ -7671,12 +7775,12 @@ var JsonlRpcClient = class {
         throw new RpcProtocolError("RPC error response has an invalid error payload");
       }
       if (isExplicitlyUnqueuedOverload(error)) {
-        const scheduled = pending.scheduleOverloadRetry(this.#overloadRetryPolicy, () => {
-          if (this.#pending.get(id) !== pending) {
+        const scheduled = pending2.scheduleOverloadRetry(this.#overloadRetryPolicy, () => {
+          if (this.#pending.get(id) !== pending2) {
             return;
           }
           try {
-            void this.#sendMessage(pending.request).catch(() => void 0);
+            void this.#sendMessage(pending2.request).catch(() => void 0);
           } catch {
           }
         });
@@ -7684,22 +7788,22 @@ var JsonlRpcClient = class {
           return;
         }
       }
-      this.#removePending(id, pending);
-      pending.reject(new RpcResponseError(error));
+      this.#removePending(id, pending2);
+      pending2.reject(new RpcResponseError(error));
       return;
     }
     if (!("result" in message)) {
       throw new RpcProtocolError("RPC response is missing result or error");
     }
-    this.#removePending(id, pending);
-    pending.resolve(message["result"]);
+    this.#removePending(id, pending2);
+    pending2.resolve(message["result"]);
   }
-  #removePending(id, pending) {
-    if (this.#pending.get(id) !== pending) {
+  #removePending(id, pending2) {
+    if (this.#pending.get(id) !== pending2) {
       return false;
     }
     this.#pending.delete(id);
-    pending.clearTimers();
+    pending2.clearTimers();
     return true;
   }
   #assertOpen() {
@@ -8302,9 +8406,9 @@ var CodexPersistentHistoricalAttachmentStore = class {
     return [...this.#pending.get(taskId)?.values() ?? []];
   }
   markPersisted(taskId, attachmentId) {
-    const pending = this.#pending.get(taskId);
-    pending?.delete(attachmentId);
-    if (pending?.size === 0) this.#pending.delete(taskId);
+    const pending2 = this.#pending.get(taskId);
+    pending2?.delete(attachmentId);
+    if (pending2?.size === 0) this.#pending.delete(taskId);
   }
   async read(taskId, attachmentId) {
     const entry = this.#entries.get(attachmentId);
@@ -9606,8 +9710,8 @@ function readReviewWorkerThread(value) {
   };
 }
 var execFileAsync = promisify(execFile);
-var SUPPORTED_CODEX_VERSION = "0.159.0";
-var SUPPORTED_CODEX_VERSION_RANGE = ">=0.159.0,<0.160.0";
+var SUPPORTED_CODEX_VERSION = "0.160.0";
+var SUPPORTED_CODEX_VERSION_RANGE = ">=0.160.0,<0.161.0";
 var BUNDLED_CODEX_TARGETS = {
   "darwin-arm64": {
     executableName: "codex",
@@ -9749,7 +9853,7 @@ async function checkCodexVersion(binaryPath, options = {}) {
   }
   const [major, minor, patch] = version.split("-", 1)[0]?.split(".").map(Number) ?? [];
   const isPrerelease = version.includes("-");
-  if (major !== 0 || minor !== 159 || patch === void 0 || isPrerelease) {
+  if (major !== 0 || minor !== 160 || patch === void 0 || isPrerelease) {
     throw new Error(
       `Unsupported Codex version ${version}; expected ${SUPPORTED_CODEX_VERSION_RANGE}`
     );
@@ -11695,6 +11799,64 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
 };
 var CodexAgentProvider = class extends CodexAgentProviderEvents {
 };
+
+// packages/provider-codex/src/history-storage.ts
+function createHistoryStorage(client) {
+  let pending2;
+  return {
+    compress() {
+      pending2 ??= client.request("rollout/compress", void 0).then((response) => {
+        expectRecord(response, "rollout/compress response");
+        return { status: "scheduled" };
+      }).finally(() => {
+        pending2 = void 0;
+      });
+      return pending2;
+    }
+  };
+}
+
+// packages/provider-codex/src/plugin-reconcile.ts
+var pending = /* @__PURE__ */ new WeakMap();
+function array(value, name) {
+  if (!Array.isArray(value))
+    throw new CodexProtocolMappingError(`plugin/reconcile ${name} must be an array`);
+  return value;
+}
+async function reconcile(client) {
+  const result = expectRecord(
+    await client.request("plugin/reconcile", { reason: "codexly.refresh" }),
+    "plugin/reconcile response"
+  );
+  return {
+    changedPlugins: array(result["changedPlugins"], "changedPlugins").map((value) => {
+      const plugin = expectRecord(value, "plugin/reconcile plugin");
+      const id = expectString(plugin["id"], "plugin/reconcile id");
+      if (id.length === 0) throw new CodexProtocolMappingError("plugin/reconcile id is empty");
+      return {
+        id,
+        hasApps: expectBoolean(plugin["hasApps"], "plugin/reconcile hasApps"),
+        hasHooks: expectBoolean(plugin["hasHooks"], "plugin/reconcile hasHooks"),
+        hasMcps: expectBoolean(plugin["hasMcps"], "plugin/reconcile hasMcps"),
+        hasSkills: expectBoolean(plugin["hasSkills"], "plugin/reconcile hasSkills")
+      };
+    }),
+    failedRemotePluginIds: array(result["failedRemotePluginIds"], "failedRemotePluginIds").map(
+      (id) => expectString(id, "plugin/reconcile failedRemotePluginId")
+    ),
+    failedMaterializationRemotePluginIds: array(
+      result["failedMaterializationRemotePluginIds"],
+      "failedMaterializationRemotePluginIds"
+    ).map((id) => expectString(id, "plugin/reconcile failedMaterializationRemotePluginId"))
+  };
+}
+function reconcileCodexPlugins(client) {
+  const existing = pending.get(client);
+  if (existing !== void 0) return existing;
+  const request = reconcile(client).finally(() => pending.delete(client));
+  pending.set(client, request);
+  return request;
+}
 function taskTitlePrompt(text) {
   let bounded = "";
   let count = 0;
@@ -11886,13 +12048,13 @@ var CodexTaskTitles = class {
     this.#pending.set(taskId, { project, cwd });
   }
   start(taskId, input) {
-    const pending = this.#pending.get(taskId);
-    if (pending === void 0) return;
+    const pending2 = this.#pending.get(taskId);
+    if (pending2 === void 0) return;
     this.#pending.delete(taskId);
     const fallback = [...input.skills, ...input.files, ...input.textAttachments].map((item) => item.name.trim()).find(Boolean) ?? "\u65B0\u4EFB\u52A1";
     const prompt = taskTitlePrompt(input.text.trim() || fallback);
     const controller = new AbortController();
-    const active = { ...pending, controller, done: Promise.resolve() };
+    const active = { ...pending2, controller, done: Promise.resolve() };
     this.#active.set(taskId, active);
     active.done = Promise.resolve().then(async () => {
       const model = await this.readModel();
@@ -11905,7 +12067,7 @@ var CodexTaskTitles = class {
             this.#listeners.delete(listener);
           };
         },
-        pending.cwd,
+        pending2.cwd,
         model,
         prompt,
         controller.signal
@@ -11920,7 +12082,7 @@ var CodexTaskTitles = class {
           "thread/read response"
         );
         const thread = expectRecord(response["thread"], "task title thread");
-        const projectId = pending.project.kind === "temporary" ? null : pending.project.id;
+        const projectId = pending2.project.kind === "temporary" ? null : pending2.project.id;
         if (thread["id"] !== taskId || thread["projectId"] !== projectId) {
           throw new Error("Task title ownership mismatch");
         }
@@ -11954,8 +12116,8 @@ var CodexTaskTitles = class {
     this.#active.get(taskId)?.controller.abort();
   }
   async releaseProject(projectId) {
-    for (const [taskId, pending] of this.#pending) {
-      if (pending.project.id === projectId) this.#pending.delete(taskId);
+    for (const [taskId, pending2] of this.#pending) {
+      if (pending2.project.id === projectId) this.#pending.delete(taskId);
     }
     const active = [...this.#active.values()].filter((entry) => entry.project.id === projectId);
     for (const entry of active) entry.controller.abort();
@@ -12033,7 +12195,7 @@ async function readOptional(path) {
   }
 }
 function createGlobalInstructionsStore(home) {
-  let pending = Promise.resolve();
+  let pending2 = Promise.resolve();
   const read = async () => ({
     content: await readOptional(join(home, "AGENTS.md")),
     path: join(home, "AGENTS.md"),
@@ -12042,7 +12204,7 @@ function createGlobalInstructionsStore(home) {
   return {
     read,
     save(input) {
-      const result = pending.then(async () => {
+      const result = pending2.then(async () => {
         const path = join(home, "AGENTS.md");
         if (await readOptional(path) !== input.expectedContent) {
           throw Object.assign(new Error("Global instructions changed; reload before saving"), {
@@ -12080,7 +12242,7 @@ function createGlobalInstructionsStore(home) {
         }
         return read();
       });
-      pending = result.then(
+      pending2 = result.then(
         () => void 0,
         () => void 0
       );
@@ -12098,7 +12260,8 @@ async function readConfig(client) {
   return expectRecord(response["config"], "config/read config");
 }
 function section(config, key2) {
-  return config[key2] === void 0 ? {} : expectRecord(config[key2], key2);
+  const value = config[key2];
+  return value === void 0 || value === null ? {} : expectRecord(value, key2);
 }
 var edit = (keyPath, value) => ({ keyPath, value, mergeStrategy: "replace" });
 async function readMemorySettings(client) {
@@ -13373,9 +13536,9 @@ var CodexGitMetadataWatchService = class {
     const owner = this.#watchOwners.get(params["watchId"]);
     const state = owner === void 0 ? void 0 : this.#projects.get(owner.projectId);
     if (owner === void 0 || state === void 0 || state.released) return;
-    const pending = state.pendingRoots.get(owner.rootPath);
-    if (pending !== void 0) {
-      pending.refreshTopology ||= owner.refreshTopology;
+    const pending2 = state.pendingRoots.get(owner.rootPath);
+    if (pending2 !== void 0) {
+      pending2.refreshTopology ||= owner.refreshTopology;
       return;
     }
     const change = {
@@ -13398,7 +13561,7 @@ var CodexGitMetadataWatchService = class {
     if (state === void 0) return;
     this.#projects.delete(projectId);
     state.released = true;
-    for (const pending of state.pendingRoots.values()) clearTimeout(pending.timer);
+    for (const pending2 of state.pendingRoots.values()) clearTimeout(pending2.timer);
     state.pendingRoots.clear();
     await state.operation.catch(() => void 0);
     const registrations = [...state.registrationsByRoot.values()].flatMap((entries) => [
@@ -13849,6 +14012,7 @@ async function setCodexMcpServerEnabled(client, name, enabled) {
 // packages/provider-codex/src/runtime-provider.ts
 var CodexRuntimeProvider = class {
   personalization;
+  historyStorage;
   fileSearch;
   search;
   #client;
@@ -13866,6 +14030,7 @@ var CodexRuntimeProvider = class {
   #reviewWorkerOwners = /* @__PURE__ */ new Map();
   constructor(client, logger = DEFAULT_PROVIDER_LOGGER, options = {}) {
     this.#client = client;
+    this.historyStorage = createHistoryStorage(client);
     const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? resolve(homedir(), ".codex");
     this.#attachmentDirectory = join(codexHome, "codexly", "thread-attachments");
     this.#forkTaskDirectory = join(codexHome, "codexly", "fork-tasks");
@@ -14018,11 +14183,6 @@ var CodexRuntimeProvider = class {
         await this.#providerConnection.prepareModelCatalog();
         catalogRuntime = await this.#modelCatalogRuntimeFactory();
         return await this.#listModelsWithClient(catalogRuntime.client);
-      } catch {
-        this.#logger.warn(
-          { diagnosticCode: "model_catalog_refresh_failed" },
-          "Fresh model catalog unavailable; falling back to the primary Codex CLI catalog"
-        );
       } finally {
         if (catalogRuntime !== null) {
           await catalogRuntime.close().catch(() => {
@@ -14070,6 +14230,9 @@ var CodexRuntimeProvider = class {
   listInstalledSkills(projects, forceReload) {
     return listCodexInstalledSkills(this.#client, projects, forceReload);
   }
+  reconcileOfficialPlugins() {
+    return reconcileCodexPlugins(this.#client);
+  }
   listOfficialPlugins(projects, forceRefetch) {
     return listCodexOfficialPlugins(this.#client, projects, forceRefetch);
   }