@bryanhu/codexly 0.17.0 → 0.19.0

package/dist/{chunk-PJNYCTFC.js → chunk-YFWMYA6X.js}

@@ -1,16 +1,16 @@
 import { createRequire } from 'node:module';
-import { WorkbenchPetProviderError, PendingRequestResolutionError } from './chunk-RNTA4MFS.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_TEXT_BYTES } from './chunk-P3ZQ3QOJ.js';
+import { WorkbenchPetProviderError, PendingRequestResolutionError } from './chunk-B2673ODM.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_TEXT_BYTES } from './chunk-X5JZ3VOF.js';
 import { __commonJS, __require, __toESM } from './chunk-K6J42667.js';
 import { execFile, spawn } from 'child_process';
 import { constants, mkdtempSync, rmSync, createReadStream, mkdirSync, unlinkSync, renameSync, writeFileSync, openSync, readSync, closeSync, statSync } from 'fs';
-import { readFile, mkdir, writeFile, rename, rm, readdir, realpath, stat, access, lstat, opendir } from 'fs/promises';
+import { readFile, mkdir, writeFile, rename, rm, readdir, realpath, stat, access, open, unlink, lstat, opendir } from 'fs/promises';
 import { createRequire as createRequire$1 } from 'module';
 import { resolve, basename, dirname, join, relative, sep, win32, posix, isAbsolute, extname } from 'path';
 import { promisify } from 'util';
 import { randomUUID, createHash } from 'crypto';
 import { Buffer as Buffer$1 } from 'buffer';
-import { tmpdir, homedir } from 'os';
+import { homedir, tmpdir } from 'os';
 import { StringDecoder } from 'string_decoder';
 import { Worker } from 'worker_threads';
 
@@ -1250,7 +1250,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir2, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir3, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -1275,7 +1275,7 @@ var require_sonic_boom = __commonJS({
       this.append = append || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir2 || false;
+      this.mkdir = mkdir3 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -1983,7 +1983,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package();
     var { EventEmitter } = __require("events");
     var { Worker: Worker2 } = __require("worker_threads");
-    var { join: join6 } = __require("path");
+    var { join: join7 } = __require("path");
     var { pathToFileURL } = __require("url");
     var { wait } = require_wait();
     var {
@@ -2034,7 +2034,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join6(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join7(__dirname, "lib", "worker.js");
       const worker = new Worker2(toExecute, {
         ...opts.workerOpts,
         name: opts.workerOpts?.name || "thread-stream",
@@ -2501,7 +2501,7 @@ var require_transport = __commonJS({
     var { createRequire: createRequire2 } = __require("module");
     var { existsSync } = __require("fs");
     var getCallers = require_caller();
-    var { join: join6, isAbsolute: isAbsolute7, sep: sep3 } = __require("path");
+    var { join: join7, isAbsolute: isAbsolute7, sep: sep3 } = __require("path");
     var { fileURLToPath } = __require("url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
@@ -2654,7 +2654,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join6(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join7(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -2672,7 +2672,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join6(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join7(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2695,7 +2695,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join6(__dirname, "..", "file.js");
+          return join7(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -3670,7 +3670,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join6 = ",";
+            let join7 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -3684,7 +3684,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join6 = `,
+                join7 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3692,13 +3692,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join6;
+                res += join7;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join6}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3719,7 +3719,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join6 = `,
+              join7 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3733,13 +3733,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join6;
+                separator = join7;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join6;
+              separator = join7;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3780,7 +3780,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join6 = ",";
+            let join7 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3793,7 +3793,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join6 = `,
+                join7 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3801,13 +3801,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join6;
+                res += join7;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join6}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3820,7 +3820,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join6 = `,
+              join7 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3829,7 +3829,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join6;
+                separator = join7;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3887,20 +3887,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join7 = `,
+              const join8 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join7;
+                res2 += join8;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join8}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3916,16 +3916,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join6 = `,
+            const join7 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join6, maximumBreadth);
+              res += stringifyTypedArray(value, join7, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join6;
+              separator = join7;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -3936,13 +3936,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join6;
+                separator = join7;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join6;
+              separator = join7;
             }
             if (separator !== "") {
               res = `
@@ -4466,8 +4466,8 @@ var require_pino = __commonJS({
   }
 });
 var execFileAsync = promisify(execFile);
-var SUPPORTED_CODEX_VERSION = "0.153.4";
-var SUPPORTED_CODEX_VERSION_RANGE = ">=0.153.4,<0.154.0";
+var SUPPORTED_CODEX_VERSION = "0.154.0";
+var SUPPORTED_CODEX_VERSION_RANGE = ">=0.154.0,<0.155.0";
 var BUNDLED_CODEX_TARGETS = {
   "darwin-arm64": {
     executableName: "codex",
@@ -4609,7 +4609,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 !== 153 || patch === void 0 || patch < 4 || isPrerelease) {
+  if (major !== 0 || minor !== 154 || patch === void 0 || isPrerelease) {
     throw new Error(
       `Unsupported Codex version ${version}; expected ${SUPPORTED_CODEX_VERSION_RANGE}`
     );
@@ -5145,10 +5145,10 @@ function fieldValueMatches(field, value) {
 function mcpElicitationContentMatchesRequest(request, content) {
   if (request.mode === "unsupported") return false;
   if (request.mode === "url") return Object.keys(content).length === 0;
-  const fields = new Map(request.fields.map((field) => [field.id, field]));
+  const fields2 = new Map(request.fields.map((field) => [field.id, field]));
   const entries = Object.entries(content);
   return entries.every(([id, value]) => {
-    const field = fields.get(id);
+    const field = fields2.get(id);
     return field !== void 0 && fieldValueMatches(field, value);
   }) && request.fields.every((field) => !field.required || Object.hasOwn(content, field.id));
 }
@@ -6193,25 +6193,24 @@ function mapUserMessageContent(value, mapImage, mapText) {
   }
   return { attachments, skills, text: textParts.join("\n") };
 }
+function mergeMessageSkills(message, incoming) {
+  const skills = [...message.skills ?? []];
+  const names = new Set(skills.map((skill) => skill.name));
+  for (const skill of incoming) {
+    if (!names.has(skill.name)) {
+      names.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  return { ...message, skills, text: stripLeadingAgentSkillReferences(message.text, skills) };
+}
 function mergeExpandedSkillMessages(items) {
   const mergedItems = [];
   for (const item of items) {
-    const isSkillOnlyMessage = item.type === "message" && item.role === "user" && item.text.length === 0 && (item.skills?.length ?? 0) > 0;
+    const isSkillOnlyMessage = item.type === "message" && item.role === "user" && item.text.length === 0 && (item.attachments?.length ?? 0) === 0 && (item.skills?.length ?? 0) > 0;
     const previousItem = mergedItems.at(-1);
     if (isSkillOnlyMessage && previousItem?.type === "message" && previousItem.role === "user") {
-      const skillNames = new Set((previousItem.skills ?? []).map((skill) => skill.name));
-      const mergedSkills = [...previousItem.skills ?? []];
-      for (const skill of item.skills ?? []) {
-        if (!skillNames.has(skill.name)) {
-          skillNames.add(skill.name);
-          mergedSkills.push(skill);
-        }
-      }
-      mergedItems[mergedItems.length - 1] = {
-        ...previousItem,
-        skills: mergedSkills,
-        text: stripLeadingAgentSkillReferences(previousItem.text, mergedSkills)
-      };
+      mergedItems[mergedItems.length - 1] = mergeMessageSkills(previousItem, item.skills ?? []);
       continue;
     }
     mergedItems.push(item);
@@ -6528,10 +6527,10 @@ function normalizedTitle(thread) {
 var CODEX_PINNED_THREAD_SECTION_ID = "01984de2-8f74-7c91-a3b2-5c5e937cf318";
 function isPinnedThreadSection(value) {
   if (value === null) return false;
-  const section = expectRecord(value, "Codex thread section");
-  const sectionId = expectString(section["id"], "Codex thread section id");
-  expectString(section["name"], "Codex thread section name");
-  const appearance = section["appearance"];
+  const section2 = expectRecord(value, "Codex thread section");
+  const sectionId = expectString(section2["id"], "Codex thread section id");
+  expectString(section2["name"], "Codex thread section name");
+  const appearance = section2["appearance"];
   if (appearance !== null && (!isRecord(appearance) || appearance["icon"] !== null && typeof appearance["icon"] !== "string" || appearance["color"] !== null && typeof appearance["color"] !== "string")) {
     throw new CodexProtocolMappingError("Codex thread section appearance is invalid");
   }
@@ -7477,7 +7476,7 @@ var RpcPendingRequest = class {
 };
 
 // packages/provider-codex/src/jsonl-rpc-client.ts
-var DEFAULT_MAX_JSONL_BYTES = 64 * 1024 * 1024;
+var DEFAULT_MAX_JSONL_BYTES = 80 * 1024 * 1024;
 var DEFAULT_LARGE_FRAME_THRESHOLD_BYTES = 1 * 1024 * 1024;
 var JsonlRpcClient = class {
   #defaultTimeoutMs;
@@ -8656,6 +8655,10 @@ async function listCodexMcpServers(client, taskId) {
       const serverInfoValue = server["serverInfo"];
       const serverInfo = serverInfoValue === null || serverInfoValue === void 0 ? null : expectRecord(serverInfoValue, "mcpServerStatus/list serverInfo");
       const tools = expectRecord(server["tools"], "mcpServerStatus/list tools");
+      const toolsError = server["toolsError"];
+      if (toolsError !== null && typeof toolsError !== "string") {
+        throw new CodexProtocolMappingError("mcpServerStatus/list toolsError is invalid");
+      }
       const authStatus = mapMcpAuthStatus(server["authStatus"]);
       let displayName = name;
       if (serverInfo !== null) {
@@ -8669,10 +8672,12 @@ async function listCodexMcpServers(client, taskId) {
       if (servers.has(name)) {
         continue;
       }
+      const runtimeStatus = mapMcpRuntimeStatus(server["runtimeStatus"], authStatus);
+      const status = toolsError !== null && (runtimeStatus === "connected" || runtimeStatus === "unknown") ? "failed" : runtimeStatus;
       servers.set(name, {
         displayName,
         name,
-        status: mapMcpRuntimeStatus(server["runtimeStatus"], authStatus),
+        status,
         toolCount: Object.keys(tools).length
       });
     }
@@ -8700,8 +8705,292 @@ async function reloadCodexMcpServers(client, taskId) {
   return listCodexMcpServers(client, taskId);
 }
 
+// packages/provider-codex/src/message-identity-matching.ts
+function matchesMessageIdentity(current, incoming) {
+  if (current.role !== incoming.role) return false;
+  if (current.phase !== void 0 && incoming.phase !== void 0 && current.phase !== incoming.phase)
+    return false;
+  if (current.text.length > 0 && incoming.text.length > 0) {
+    return current.text.startsWith(incoming.text) || incoming.text.startsWith(current.text);
+  }
+  if (current.role !== "user" || current.text.length > 0 || incoming.text.length > 0) return false;
+  const attachments = current.attachments ?? [];
+  const other = incoming.attachments ?? [];
+  return attachments.length > 0 && attachments.length === other.length && attachments.every(
+    (item, index) => item.kind === "image" && other[index]?.kind === "image" && item.mediaType === other[index].mediaType && item.size === other[index].size
+  );
+}
+
+// packages/provider-codex/src/message-identity.ts
+var MAX_TURNS = 128;
+var MAX_MESSAGES = 256;
+var MAX_TEXT = 16384;
+var MAX_RETAINED_TEXT = 1048576;
+var MessageIdentityRegistry = class {
+  #turns = /* @__PURE__ */ new Map();
+  #textSize = 0;
+  #order = 0;
+  turn(taskId, turnId) {
+    const key = JSON.stringify([taskId, turnId]);
+    const value = this.#turns.get(key) ?? {
+      taskId,
+      entries: /* @__PURE__ */ new Map(),
+      running: false
+    };
+    this.#turns.delete(key);
+    this.#turns.set(key, value);
+    if (this.#turns.size > MAX_TURNS) {
+      const oldest = [...this.#turns].find(([candidateKey, turn]) => candidateKey !== key && !turn.running) ?? this.#turns.entries().next().value;
+      if (oldest !== void 0) {
+        this.release(oldest[1]);
+        this.#turns.delete(oldest[0]);
+      }
+    }
+    return value;
+  }
+  find(turn, id) {
+    return turn.entries.get(id) ?? [...turn.entries.values()].find((entry) => entry.aliases.has(id));
+  }
+  remember(turn, item, live, snapshot) {
+    let entry = this.find(turn, item.id);
+    if (entry === void 0) {
+      if (turn.entries.size >= MAX_MESSAGES) return void 0;
+      entry = {
+        message: { id: item.id, type: "message", role: item.role, text: "" },
+        aliases: /* @__PURE__ */ new Set(),
+        live: false,
+        snapshot: false,
+        comparable: true,
+        order: this.#order++
+      };
+      turn.entries.set(item.id, entry);
+    }
+    this.#textSize -= entry.message.text.length;
+    entry.comparable = item.text.length <= MAX_TEXT && this.#textSize + item.text.length <= MAX_RETAINED_TEXT;
+    const phase = item.phase ?? entry.message.phase;
+    entry.message = {
+      id: entry.message.id,
+      type: "message",
+      role: item.role,
+      text: entry.comparable ? item.text : "",
+      ...phase === void 0 ? {} : { phase },
+      ...item.attachments === void 0 ? {} : { attachments: item.attachments }
+    };
+    this.#textSize += entry.message.text.length;
+    entry.live ||= live;
+    entry.snapshot ||= snapshot;
+    return entry;
+  }
+  alias(entry, id) {
+    if (entry.message.id === id || entry.aliases.has(id)) return true;
+    if (entry.aliases.size >= 256) return false;
+    entry.aliases.add(id);
+    return true;
+  }
+  render(item, entry) {
+    return {
+      ...item,
+      id: entry.message.id,
+      ...entry.aliases.size === 0 ? {} : { identityAliases: [...entry.aliases] }
+    };
+  }
+  snapshot(taskId, turns) {
+    return turns.map((turn) => {
+      const messages = turn.items.filter(
+        (item) => item.type === "message"
+      );
+      if (messages.length === 0) return turn;
+      const state = this.turn(taskId, turn.id);
+      state.running = turn.status === "running";
+      const matches = /* @__PURE__ */ new Map();
+      const used = /* @__PURE__ */ new Set();
+      for (const item of messages) {
+        const known = this.find(state, item.id);
+        if (known !== void 0) {
+          matches.set(item.id, known);
+          used.add(known);
+        }
+      }
+      const candidates = /* @__PURE__ */ new Map();
+      const counts = /* @__PURE__ */ new Map();
+      for (const item of messages) {
+        if (matches.has(item.id)) continue;
+        const options = [...state.entries.values()].filter(
+          (entry) => entry.live && entry.comparable && !used.has(entry) && matchesMessageIdentity(entry.message, item)
+        );
+        candidates.set(item.id, options);
+        for (const entry of options) counts.set(entry, (counts.get(entry) ?? 0) + 1);
+      }
+      for (const [id, options] of candidates) {
+        const entry = options.length === 1 ? options[0] : void 0;
+        if (entry !== void 0 && counts.get(entry) === 1 && this.alias(entry, id))
+          matches.set(id, entry);
+      }
+      return {
+        ...turn,
+        items: turn.items.map((item) => {
+          if (item.type !== "message") return item;
+          const entry = matches.get(item.id);
+          const normalized = entry === void 0 ? item : this.render(item, entry);
+          this.remember(state, normalized, false, true);
+          return normalized;
+        })
+      };
+    });
+  }
+  event(event) {
+    if (event.type === "turn.started" || event.type === "turn.completed") {
+      const items = event.payload.turn.items.map(
+        (item) => item.type === "message" ? this.completed(event.taskId, event.turnId, item, event.payload.turn.items) : item
+      );
+      this.turn(event.taskId, event.turnId).running = event.type === "turn.started";
+      return { ...event, payload: { ...event.payload, turn: { ...event.payload.turn, items } } };
+    }
+    if (event.type === "item.started" || event.type === "item.completed") {
+      if (event.payload.item.type !== "message") return event;
+      const item = this.completed(event.taskId, event.turnId, event.payload.item);
+      return { ...event, itemId: item.id, payload: { item } };
+    }
+    if (event.type !== "message.delta") return event;
+    const state = this.turn(event.taskId, event.turnId);
+    state.running = true;
+    const entry = this.find(state, event.itemId);
+    const id = entry?.message.id ?? event.itemId;
+    if (entry?.comparable !== false)
+      this.remember(
+        state,
+        {
+          id,
+          type: "message",
+          role: "assistant",
+          text: (entry?.message.text ?? "") + event.payload.delta
+        },
+        true,
+        false
+      );
+    return id === event.itemId ? event : { ...event, itemId: id };
+  }
+  completed(taskId, turnId, item, batch = [item]) {
+    const state = this.turn(taskId, turnId);
+    let entry = this.find(state, item.id);
+    if (entry?.snapshot !== true) {
+      const candidates = [...state.entries.values()].filter(
+        (candidate2) => candidate2 !== entry && candidate2.snapshot && !candidate2.live && candidate2.comparable && matchesMessageIdentity(candidate2.message, item) && // 批量终态也要求反向唯一；其他消息已占用或同样匹配时禁止贪心归并。
+        !batch.some(
+          (other) => other.type === "message" && other.id !== item.id && (this.find(state, other.id) === candidate2 || matchesMessageIdentity(candidate2.message, other))
+        )
+      );
+      const candidate = candidates.length === 1 ? candidates[0] : void 0;
+      if (candidate !== void 0) {
+        const keep = entry !== void 0 && entry.order < candidate.order ? entry : candidate;
+        const remove = keep === entry ? candidate : entry;
+        const aliases = /* @__PURE__ */ new Set([
+          ...keep.aliases,
+          item.id,
+          ...remove === void 0 ? [] : [remove.message.id, ...remove.aliases]
+        ]);
+        aliases.delete(keep.message.id);
+        if (aliases.size <= 256) {
+          keep.aliases = aliases;
+          keep.snapshot = true;
+          if (remove !== void 0) {
+            state.entries.delete(remove.message.id);
+            this.#textSize -= remove.message.text.length;
+          }
+          entry = keep;
+        }
+      }
+    }
+    const normalized = entry === void 0 ? item : this.render(item, entry);
+    this.remember(state, normalized, true, false);
+    return normalized;
+  }
+  release(turn) {
+    for (const entry of turn.entries.values()) this.#textSize -= entry.message.text.length;
+  }
+  clearTask(taskId) {
+    for (const [key, turn] of this.#turns)
+      if (turn.taskId === taskId) {
+        this.release(turn);
+        this.#turns.delete(key);
+      }
+  }
+  clear() {
+    this.#turns.clear();
+    this.#textSize = 0;
+  }
+};
+
+// packages/provider-codex/src/realtime-skill-messages.ts
+var RealtimeSkillMessages = class {
+  #tails = /* @__PURE__ */ new Map();
+  #size = 0;
+  key(taskId, turnId) {
+    return JSON.stringify([taskId, turnId]);
+  }
+  remove(key) {
+    this.#size -= this.#tails.get(key)?.size ?? 0;
+    this.#tails.delete(key);
+  }
+  remember(taskId, turnId, item) {
+    const key = this.key(taskId, turnId);
+    this.remove(key);
+    let retained = item?.type === "message" && item.role === "user" ? item : void 0;
+    let size = retained === void 0 ? 0 : JSON.stringify(retained).length;
+    if (size > 65536) {
+      retained = void 0;
+      size = 0;
+    }
+    this.#tails.set(key, { taskId, item: retained, size });
+    this.#size += size;
+    while (this.#tails.size > 128 || this.#size > 1048576) {
+      const oldest = this.#tails.keys().next().value;
+      if (oldest === void 0) break;
+      this.remove(oldest);
+    }
+  }
+  seed(taskId, turns) {
+    for (const turn of turns) {
+      if (turn.status === "running" && !this.#tails.has(this.key(taskId, turn.id)))
+        this.remember(taskId, turn.id, turn.items.at(-1));
+    }
+  }
+  event(event) {
+    if (event.type === "turn.started") {
+      this.remember(event.taskId, event.turnId, event.payload.turn.items.at(-1));
+      return event;
+    }
+    if (event.type === "turn.completed") {
+      this.remove(this.key(event.taskId, event.turnId));
+      return event;
+    }
+    if (event.type === "message.delta") {
+      this.remember(event.taskId, event.turnId, void 0);
+      return event;
+    }
+    if (event.type !== "item.started" && event.type !== "item.completed") return event;
+    const incoming = event.payload.item;
+    const previous = this.#tails.get(this.key(event.taskId, event.turnId))?.item;
+    const [first, second] = previous === void 0 ? [incoming] : mergeExpandedSkillMessages([previous, incoming]);
+    let item = second ?? first ?? incoming;
+    if (second !== void 0 && previous?.type === "message" && incoming.type === "message" && previous.id === incoming.id && incoming.role === "user" && previous.skills !== void 0)
+      item = mergeMessageSkills(incoming, previous.skills);
+    this.remember(event.taskId, event.turnId, item);
+    return item === incoming ? event : { ...event, itemId: item.id, payload: { item } };
+  }
+  clearTask(taskId) {
+    for (const [key, tail] of this.#tails) if (tail.taskId === taskId) this.remove(key);
+  }
+  clear() {
+    this.#tails.clear();
+    this.#size = 0;
+  }
+};
+
 // packages/provider-codex/src/task-runtime-state.ts
 var TaskRuntimeState = class {
+  messageIdentities = new MessageIdentityRegistry();
+  skillMessages = new RealtimeSkillMessages();
   activeReviewTargets = /* @__PURE__ */ new Map();
   activeReviewTurnIds = /* @__PURE__ */ new Map();
   activeReviewWorkerTaskIds = /* @__PURE__ */ new Set();
@@ -8739,6 +9028,8 @@ var TaskRuntimeState = class {
     return this.runningTaskIds.has(taskId) || this.pendingTaskReads.has(taskId) || this.resumePromises.has(taskId) || (this.pendingTaskServerRequests.get(taskId)?.length ?? 0) > 0 || hasPendingRequest;
   }
   clearTask(taskId) {
+    this.messageIdentities.clearTask(taskId);
+    this.skillMessages.clearTask(taskId);
     this.activeReviewTargets.delete(taskId);
     this.activeReviewTurnIds.delete(taskId);
     this.activeReviewWorkerTaskIds.delete(taskId);
@@ -8765,6 +9056,8 @@ var TaskRuntimeState = class {
     this.unmaterializedTasks.delete(taskId);
   }
   clear() {
+    this.messageIdentities.clear();
+    this.skillMessages.clear();
     this.activeReviewTargets.clear();
     this.activeReviewTurnIds.clear();
     this.activeReviewWorkerTaskIds.clear();
@@ -9129,6 +9422,7 @@ function createUnmaterializedTaskSnapshot(task) {
 }
 var CodexAgentProviderBase = class {
   client;
+  taskTitles;
   eventListenersIncludingEphemeral = /* @__PURE__ */ new Set();
   eventListeners = /* @__PURE__ */ new Set();
   historicalAttachments = new CodexHistoricalAttachmentStore();
@@ -9169,6 +9463,7 @@ var CodexAgentProviderBase = class {
   }
   constructor(client, project, options = {}) {
     this.client = client;
+    this.taskTitles = options.taskTitles;
     this.logger = options.logger ?? DEFAULT_PROVIDER_LOGGER;
     this.project = project;
     this.pendingLifecycle = new PendingRequestLifecycle({
@@ -9205,6 +9500,7 @@ var CodexAgentProviderBase = class {
     });
   }
   async releaseProject() {
+    await this.taskTitles?.releaseProject(this.project.id);
     await releaseCodexProjectThreads(this.client, this.logger, this.project.id, [
       ...this.runtime.projectTaskIds
     ]);
@@ -9272,10 +9568,14 @@ var CodexAgentProviderBase = class {
   }
   async renameTask(taskId, title) {
     this.assertKnownProjectTask(taskId);
-    expectRecord(
-      await this.client.request("thread/name/set", { name: title, threadId: taskId }),
-      "thread/name/set response"
-    );
+    const rename3 = async () => {
+      expectRecord(
+        await this.client.request("thread/name/set", { name: title, threadId: taskId }),
+        "thread/name/set response"
+      );
+    };
+    if (this.taskTitles === void 0) await rename3();
+    else await this.taskTitles.mutate(taskId, rename3);
   }
   async pinTask(taskId, pinned) {
     this.assertKnownProjectTask(taskId);
@@ -9446,12 +9746,19 @@ var CodexAgentProviderQueue = class extends CodexAgentProviderBase {
       }
       return { name: skill.name, path: skill.path, type: "skill" };
     });
-    const images = input.images.map((image) => {
-      if (image.path.length === 0) {
-        throw new CodexProtocolMappingError("Provider image path must not be empty");
-      }
-      return { detail: image.detail, path: image.path, type: "localImage" };
-    });
+    const images = await Promise.all(
+      input.images.map(async (image) => {
+        if (image.path.length === 0) {
+          throw new CodexProtocolMappingError("Provider image path must not be empty");
+        }
+        const content = await readFile(image.path);
+        return {
+          detail: image.detail,
+          type: "image",
+          url: `data:${image.mediaType};base64,${content.toString("base64")}`
+        };
+      })
+    );
     const files = input.files.map(createCodexFileTextInput);
     const textAttachments = input.textAttachments.map((attachment) => ({
       text: attachment.text,
@@ -9642,6 +9949,10 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
       this.runtime.ephemeralTaskIds.add(task.id);
     } else {
       this.runtime.unmaterializedTasks.set(task.id, task);
+      const thread = expectRecord(response["thread"], "thread/start thread");
+      if (typeof thread["name"] !== "string" || !thread["name"].trim()) {
+        this.taskTitles?.register(task.id, this.project, expectString(thread["cwd"], "thread cwd"));
+      }
     }
     return task;
   }
@@ -9697,7 +10008,9 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
           }, 3e4);
           timeout.unref();
         });
-        return await Promise.race([startedTurn, timeoutTurn]);
+        const turn2 = await Promise.race([startedTurn, timeoutTurn]);
+        this.taskTitles?.start(taskId, input);
+        return turn2;
       } finally {
         this.eventListeners.delete(listener);
         if (timeout !== void 0) {
@@ -9724,7 +10037,10 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
     if (turn.status === "running") {
       this.runtime.runningTaskIds.add(taskId);
     }
-    return turn;
+    const normalized = this.runtime.messageIdentities.snapshot(taskId, [turn])[0] ?? turn;
+    this.runtime.skillMessages.seed(taskId, [normalized]);
+    this.taskTitles?.start(taskId, input);
+    return normalized;
   }
   async readGoalResponse(taskId) {
     const response = expectRecord(
@@ -9806,7 +10122,9 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
       this.runtime.activeReviewWorkerTaskIds.delete(taskId);
       this.runtime.reviewWorkerOutputTaskIds.delete(taskId);
     }
-    return turn;
+    const normalized = this.runtime.messageIdentities.snapshot(taskId, [turn])[0] ?? turn;
+    this.runtime.skillMessages.seed(taskId, [normalized]);
+    return normalized;
   }
   async interruptTurn(taskId, turnId) {
     this.assertKnownProjectTask(taskId);
@@ -10202,12 +10520,16 @@ var CodexAgentProviderTasks = class extends CodexAgentProviderTurns {
         cursor.reviewCursor
       );
       const transcriptSkillsByTurnId = await readCodexTranscriptTurnSkills(taskId);
-      const turns = mapAgentTurns(
-        reviewPage.turns,
-        (part, imageIndex) => this.mapMessageImage(taskId, part, imageIndex),
-        (input2, textIndex) => this.mapMessageText(taskId, input2, textIndex)
-      ).map((turn) => attachTranscriptSkills(turn, transcriptSkillsByTurnId.get(turn.id) ?? []));
+      const turns = this.runtime.messageIdentities.snapshot(
+        taskId,
+        mapAgentTurns(
+          reviewPage.turns,
+          (part, imageIndex) => this.mapMessageImage(taskId, part, imageIndex),
+          (input2, textIndex) => this.mapMessageText(taskId, input2, textIndex)
+        ).map((turn) => attachTranscriptSkills(turn, transcriptSkillsByTurnId.get(turn.id) ?? []))
+      );
       const status = turns.some((turn) => turn.status === "running") ? "running" : mapThreadStatus(thread["status"]);
+      this.runtime.skillMessages.seed(taskId, turns);
       const runningReviewTurn = turns.findLast(
         (turn) => turn.status === "running" && turn.items.some((item) => item.type === "review")
       );
@@ -10524,6 +10846,7 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
     return this.runtime.hasLifecycleObligations(taskId, this.pendingLifecycle.hasForTask(taskId));
   }
   clearTaskRuntimeState(taskId) {
+    this.taskTitles?.forget(taskId);
     this.historicalAttachments.clearTask(taskId);
     this.pendingLifecycle.clearTask(taskId);
     this.runtime.clearTask(taskId);
@@ -10659,9 +10982,12 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
     }
   }
   publishEvent(event) {
+    const normalizedEvent = this.runtime.messageIdentities.event(
+      this.runtime.skillMessages.event(event)
+    );
     const notify = (listener) => {
       try {
-        listener(event);
+        listener(normalizedEvent);
       } catch {
         warnEventListenerFailure(this.logger, this.project.id, event);
       }
@@ -10755,6 +11081,456 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
 };
 var CodexAgentProvider = class extends CodexAgentProviderEvents {
 };
+function taskTitlePrompt(text) {
+  let bounded = "";
+  let count = 0;
+  for (const character of text.trim()) {
+    if (count++ === 1024) break;
+    bounded += character;
+  }
+  return `\u603B\u7ED3\u4EE5\u4E0B\u7528\u6237\u8BF7\u6C42\uFF0C\u751F\u6210\u6700\u591A 36 \u4E2A\u5B57\u7B26\u7684\u5355\u884C\u4EFB\u52A1\u6807\u9898\u3002\u4F7F\u7528\u7528\u6237\u7684\u8BED\u8A00\uFF0C\u4EE5\u52A8\u8BCD\u5F00\u5934\uFF0C\u4FDD\u7559\u4EE3\u7801\u540D\u79F0\uFF1B\u4E0D\u8981\u7167\u6284\u957F\u53E5\uFF0C\u4E0D\u52A0\u5F15\u53F7\u3001Markdown \u6216\u672B\u5C3E\u6807\u70B9\uFF0C\u4E0D\u56DE\u7B54\u6216\u6267\u884C\u8BF7\u6C42\u3002
+
+\u7528\u6237\u8BF7\u6C42\uFF1A
+${bounded}`;
+}
+function parseTaskTitle(output) {
+  if (Buffer$1.byteLength(output, "utf8") > 8192) throw new Error("Task title output exceeds limit");
+  const value = expectRecord(JSON.parse(output), "task title output");
+  const title = Array.from(
+    expectString(value["title"], "task title").trim().replace(/^["'`“”‘’]+|["'`“”‘’]+$/gu, "").split(/\s+/u).join(" ").replace(/[.?!。？！]+$/u, "").trim()
+  ).slice(0, 36).join("");
+  if (!title) throw new Error("Task title is empty");
+  return title;
+}
+function isolatedConfig(effective) {
+  const config = {
+    "tools.update_plan.enabled": true,
+    web_search: "disabled",
+    "skills.include_instructions": false,
+    "orchestrator.skills.enabled": false,
+    "tools.experimental_request_user_input.enabled": false,
+    "token_budget.use_history_notes_extension": false
+  };
+  for (const feature of [
+    "apps",
+    "code_mode",
+    "code_mode_only",
+    "context_management",
+    "current_time_reminder",
+    "deferred_executor",
+    "enable_fanout",
+    "goals",
+    "hooks",
+    "image_generation",
+    "memories",
+    "multi_agent",
+    "multi_agent_v2",
+    "plugins",
+    "request_permissions_tool",
+    "shell_snapshot",
+    "shell_tool",
+    "standalone_web_search",
+    "token_budget",
+    "tool_suggest",
+    "unified_exec",
+    "view_image"
+  ])
+    config[`features.${feature}`] = false;
+  config["mcp_servers"] = Object.fromEntries(
+    Object.keys(
+      effective["mcp_servers"] === void 0 ? {} : expectRecord(effective["mcp_servers"], "MCP servers")
+    ).map((name) => [name, { enabled: false }])
+  );
+  return config;
+}
+async function generateTaskTitle(client, subscribe, cwd, model, prompt, signal) {
+  signal.throwIfAborted();
+  const effective = expectRecord(
+    await client.request("config/read", { cwd, includeLayers: false }),
+    "config/read response"
+  );
+  signal.throwIfAborted();
+  const response = expectRecord(
+    await client.request("thread/start", {
+      approvalPolicy: "never",
+      config: isolatedConfig(expectRecord(effective["config"], "config/read config")),
+      cwd,
+      developerInstructions: "Generate only the requested structured task title. Do not call tools or execute the supplied request.",
+      ephemeral: true,
+      historyMode: "paginated",
+      model,
+      runtimeWorkspaceRoots: [],
+      sandbox: "read-only",
+      threadSource: "system",
+      environments: [],
+      dynamicTools: [],
+      selectedCapabilityRoots: []
+    }),
+    "thread/start response"
+  );
+  const threadId = expectString(
+    expectRecord(response["thread"], "title thread")["id"],
+    "title thread id"
+  );
+  let turnId;
+  let unsubscribe;
+  let timeout;
+  let abort;
+  let succeeded = false;
+  try {
+    signal.throwIfAborted();
+    let output = "";
+    let outputTurnId;
+    const completed = new Promise((resolve7, reject) => {
+      abort = () => {
+        reject(new Error("Task title generation cancelled"));
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      timeout = setTimeout(() => {
+        reject(new Error("Task title generation timed out"));
+      }, 6e4);
+      timeout.unref();
+      unsubscribe = subscribe(({ method, params }) => {
+        try {
+          if (params === null || typeof params !== "object" || !("threadId" in params) || params.threadId !== threadId)
+            return;
+          const record = expectRecord(params, "title notification");
+          if (method === "item/completed") {
+            const item = expectRecord(record["item"], "title item");
+            if (item["type"] === "agentMessage" && item["phase"] !== "commentary") {
+              output = expectString(item["text"], "title message");
+              if (Buffer$1.byteLength(output, "utf8") > 8192)
+                throw new Error("Task title output exceeds limit");
+              outputTurnId = expectString(record["turnId"], "title message turn");
+            }
+          } else if (method === "turn/completed") {
+            const turn = expectRecord(record["turn"], "title turn");
+            if (turn["status"] !== "completed") throw new Error("Task title turn failed");
+            const id = expectString(turn["id"], "title turn id");
+            if (outputTurnId !== id) throw new Error("Task title output is missing");
+            resolve7({ id, output });
+          } else if (method === "error" && record["willRetry"] !== true) {
+            throw new Error("Task title provider failed");
+          }
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error("Invalid task title notification"));
+        }
+      });
+    });
+    void completed.catch(() => void 0);
+    const started = expectRecord(
+      await client.request("turn/start", {
+        threadId,
+        input: [{ type: "text", text: prompt, text_elements: [] }],
+        outputSchema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["title"],
+          properties: { title: { type: "string", minLength: 1, maxLength: 36 } }
+        }
+      }),
+      "turn/start response"
+    );
+    turnId = expectString(
+      expectRecord(started["turn"], "started title turn")["id"],
+      "started title turn id"
+    );
+    const result = await completed;
+    signal.throwIfAborted();
+    if (result.id !== turnId) throw new Error("Task title turn identity mismatch");
+    const title = parseTaskTitle(result.output);
+    succeeded = true;
+    return title;
+  } finally {
+    if (timeout !== void 0) clearTimeout(timeout);
+    if (abort !== void 0) signal.removeEventListener("abort", abort);
+    unsubscribe?.();
+    if (!succeeded && turnId !== void 0) {
+      await client.request("turn/interrupt", { threadId, turnId }).catch(() => void 0);
+    }
+    await client.request("thread/unsubscribe", { threadId }).catch(() => void 0);
+  }
+}
+
+// packages/provider-codex/src/task-titles.ts
+var CodexTaskTitles = class {
+  constructor(client, readModel, logger) {
+    this.client = client;
+    this.readModel = readModel;
+    this.logger = logger;
+  }
+  client;
+  readModel;
+  logger;
+  #pending = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Map();
+  #mutations = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Set();
+  receiveNotification(notification) {
+    for (const listener of this.#listeners) listener(notification);
+  }
+  register(taskId, project, cwd) {
+    this.#pending.set(taskId, { project, cwd });
+  }
+  start(taskId, input) {
+    const pending = this.#pending.get(taskId);
+    if (pending === 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() };
+    this.#active.set(taskId, active);
+    active.done = Promise.resolve().then(async () => {
+      const model = await this.readModel();
+      controller.signal.throwIfAborted();
+      const title = await generateTaskTitle(
+        this.client,
+        (listener) => {
+          this.#listeners.add(listener);
+          return () => {
+            this.#listeners.delete(listener);
+          };
+        },
+        pending.cwd,
+        model,
+        prompt,
+        controller.signal
+      );
+      await this.mutate(taskId, async () => {
+        controller.signal.throwIfAborted();
+        const response = expectRecord(
+          await this.client.request("thread/read", {
+            threadId: taskId,
+            includeTurns: false
+          }),
+          "thread/read response"
+        );
+        const thread = expectRecord(response["thread"], "task title thread");
+        const projectId = pending.project.kind === "temporary" ? null : pending.project.id;
+        if (thread["id"] !== taskId || thread["projectId"] !== projectId) {
+          throw new Error("Task title ownership mismatch");
+        }
+        if (typeof thread["name"] === "string" && thread["name"].trim()) return;
+        controller.signal.throwIfAborted();
+        await this.client.request("thread/name/set", { threadId: taskId, name: title });
+      });
+    }).catch(() => {
+      if (!controller.signal.aborted) {
+        this.logger.warn(
+          { diagnosticCode: "task_title_generation_failed" },
+          "Automatic task title unavailable"
+        );
+      }
+    }).finally(() => {
+      if (this.#active.get(taskId) === active) this.#active.delete(taskId);
+    });
+  }
+  async mutate(taskId, action) {
+    const previous = this.#mutations.get(taskId) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(action);
+    this.#mutations.set(taskId, current);
+    try {
+      return await current;
+    } finally {
+      if (this.#mutations.get(taskId) === current) this.#mutations.delete(taskId);
+    }
+  }
+  forget(taskId) {
+    this.#pending.delete(taskId);
+    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);
+    }
+    const active = [...this.#active.values()].filter((entry) => entry.project.id === projectId);
+    for (const entry of active) entry.controller.abort();
+    await Promise.all(active.map((entry) => entry.done));
+  }
+};
+
+// packages/provider-codex/src/runtime-default-settings.ts
+var fields = {
+  approvalPolicy: "approval_policy",
+  approvalsReviewer: "approvals_reviewer",
+  model: "model",
+  reasoningEffort: "model_reasoning_effort",
+  sandboxMode: "sandbox_mode",
+  fastMode: "service_tier"
+};
+async function writeRuntimeDefaultSettings(client, settings) {
+  const edits = Object.keys(fields).filter((key) => settings[key] !== void 0).map((key) => ({
+    keyPath: fields[key],
+    // default 显式关闭快速档位；不删除键，避免重新继承模型的默认档位。
+    value: key === "fastMode" ? settings.fastMode ? "priority" : "default" : settings[key],
+    mergeStrategy: "replace"
+  }));
+  if (edits.length === 0) return;
+  await client.request("config/batchWrite", { edits, reloadUserConfig: true });
+}
+function optionalNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalApprovalPolicy(value) {
+  if (value === "on-request" || value === "never") {
+    return value;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (Object.keys(record).length !== 1 || !("granular" in record)) {
+    return void 0;
+  }
+  const granular = record["granular"];
+  if (typeof granular !== "object" || granular === null || Array.isArray(granular)) {
+    return void 0;
+  }
+  const fields2 = granular;
+  const knownFields = /* @__PURE__ */ new Set([
+    "mcp_elicitations",
+    "request_permissions",
+    "rules",
+    "sandbox_approval",
+    "skill_approval"
+  ]);
+  if (Object.keys(fields2).some((key) => !knownFields.has(key)) || typeof fields2["mcp_elicitations"] !== "boolean" || typeof fields2["rules"] !== "boolean" || typeof fields2["sandbox_approval"] !== "boolean" || fields2["request_permissions"] !== void 0 && typeof fields2["request_permissions"] !== "boolean" || fields2["skill_approval"] !== void 0 && typeof fields2["skill_approval"] !== "boolean") {
+    return void 0;
+  }
+  return {
+    granular: {
+      mcp_elicitations: fields2["mcp_elicitations"],
+      request_permissions: fields2["request_permissions"] ?? false,
+      rules: fields2["rules"],
+      sandbox_approval: fields2["sandbox_approval"],
+      skill_approval: fields2["skill_approval"] ?? false
+    }
+  };
+}
+function optionalSandboxMode(value) {
+  return value === "read-only" || value === "workspace-write" || value === "danger-full-access" ? value : void 0;
+}
+async function readOptional(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+function createGlobalInstructionsStore(home) {
+  let pending = Promise.resolve();
+  const read = async () => ({
+    content: await readOptional(join(home, "AGENTS.md")),
+    path: join(home, "AGENTS.md"),
+    overrideActive: (await readOptional(join(home, "AGENTS.override.md"))).trim().length > 0
+  });
+  return {
+    read,
+    save(input) {
+      const result = pending.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"), {
+            code: "GLOBAL_INSTRUCTIONS_CHANGED"
+          });
+        }
+        await mkdir(home, { recursive: true });
+        let target = path;
+        try {
+          target = await realpath(path);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        const temporary = join(dirname(target), `.AGENTS-${randomUUID()}.tmp`);
+        const file = await open(temporary, "wx", 384);
+        try {
+          try {
+            await file.chmod((await stat(target)).mode);
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+          await file.writeFile(input.content, "utf8");
+          await file.sync();
+          await file.close();
+          if (await readOptional(path) !== input.expectedContent)
+            throw Object.assign(new Error("Global instructions changed; reload before saving"), {
+              code: "GLOBAL_INSTRUCTIONS_CHANGED"
+            });
+          await rename(temporary, target);
+        } finally {
+          await file.close();
+          await unlink(temporary).catch((error) => {
+            if (error.code !== "ENOENT") throw error;
+          });
+        }
+        return read();
+      });
+      pending = result.then(
+        () => void 0,
+        () => void 0
+      );
+      return result;
+    }
+  };
+}
+
+// packages/provider-codex/src/personalization.ts
+async function readConfig(client) {
+  const response = expectRecord(
+    await client.request("config/read", { includeLayers: false }),
+    "config/read response"
+  );
+  return expectRecord(response["config"], "config/read config");
+}
+function section(config, key) {
+  return config[key] === void 0 ? {} : expectRecord(config[key], key);
+}
+var edit = (keyPath, value) => ({ keyPath, value, mergeStrategy: "replace" });
+async function readMemorySettings(client) {
+  const config = await readConfig(client);
+  const features = section(config, "features");
+  const memories = section(config, "memories");
+  return {
+    enabled: features["memories"] === true && memories["generate_memories"] !== false && memories["use_memories"] !== false,
+    allowExternalContext: !(memories["disable_on_external_context"] ?? memories["no_memories_if_mcp_or_web_search"] ?? false)
+  };
+}
+async function updateMemorySettings(client, update) {
+  const edits = [];
+  if (update.enabled !== void 0)
+    for (const key of ["features.memories", "memories.generate_memories", "memories.use_memories"])
+      edits.push(edit(key, update.enabled));
+  if (update.allowExternalContext !== void 0) {
+    edits.push(edit("memories.no_memories_if_mcp_or_web_search", null));
+    edits.push(edit("memories.disable_on_external_context", !update.allowExternalContext));
+  }
+  if (edits.length) await client.request("config/batchWrite", { edits, reloadUserConfig: true });
+  return readMemorySettings(client);
+}
+async function resetMemories(client) {
+  await client.request("memory/reset", null);
+}
+async function readAgentPreferences(client) {
+  const config = await readConfig(client);
+  const verbosity = config["model_verbosity"];
+  const search = config["web_search"];
+  return {
+    webSearch: search === "disabled" || search === "live" ? search : "cached",
+    modelVerbosity: verbosity === "low" || verbosity === "medium" || verbosity === "high" ? verbosity : null
+  };
+}
+async function updateAgentPreferences(client, settings) {
+  await client.request("config/batchWrite", {
+    edits: [
+      edit("web_search", settings.webSearch),
+      edit("model_verbosity", settings.modelVerbosity)
+    ],
+    reloadUserConfig: true
+  });
+  return readAgentPreferences(client);
+}
 
 // packages/provider-codex/src/custom-model-catalog.ts
 var DEFAULT_REASONING_EFFORTS = [
@@ -11084,7 +11860,7 @@ function mapAccount(value) {
   }
   return null;
 }
-function readConfig(response) {
+function readConfig2(response) {
   if (!isRecord7(response) || !isRecord7(response["config"])) {
     throw new CodexProviderConnectionError("Codex returned an invalid config response");
   }
@@ -11131,7 +11907,7 @@ var CodexProviderConnectionService = class {
     this.#modelResponseMaxBytes = options.modelResponseMaxBytes ?? DEFAULT_MODEL_RESPONSE_MAX_BYTES;
     this.#nativeState = new CodexNativeStateSnapshot({
       account: async () => readAccountResponse(await client.request("account/read", { refreshToken: false })),
-      config: async () => readConfig(await client.request("config/read", { includeLayers: false }))
+      config: async () => readConfig2(await client.request("config/read", { includeLayers: false }))
     });
   }
   receiveNotification(method, params) {
@@ -11201,6 +11977,9 @@ var CodexProviderConnectionService = class {
   async readConfig() {
     return this.#nativeState.readConfig();
   }
+  invalidateConfig() {
+    this.#nativeState.clear();
+  }
   async configureCustom(input, persistedModels) {
     const baseUrl = normalizeBaseUrl(input.baseUrl);
     const apiKey = input.apiKey;
@@ -11226,7 +12005,7 @@ var CodexProviderConnectionService = class {
       this.#client.request("config/read", { includeLayers: false }),
       this.#client.request("account/read", { refreshToken: false })
     ]);
-    const previousConfig = readConfig(configResponse);
+    const previousConfig = readConfig2(configResponse);
     const previousAccountState = readAccountResponse(accountResponse);
     const configUpdate = createCustomProviderConfigUpdate(
       previousConfig,
@@ -12279,51 +13058,11 @@ async function setCodexMcpServerEnabled(client, name, enabled) {
 }
 
 // packages/provider-codex/src/runtime-provider.ts
-function optionalNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function optionalApprovalPolicy(value) {
-  if (value === "on-request" || value === "never") {
-    return value;
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return void 0;
-  }
-  const record = value;
-  if (Object.keys(record).length !== 1 || !("granular" in record)) {
-    return void 0;
-  }
-  const granular = record["granular"];
-  if (typeof granular !== "object" || granular === null || Array.isArray(granular)) {
-    return void 0;
-  }
-  const fields = granular;
-  const knownFields = /* @__PURE__ */ new Set([
-    "mcp_elicitations",
-    "request_permissions",
-    "rules",
-    "sandbox_approval",
-    "skill_approval"
-  ]);
-  if (Object.keys(fields).some((key) => !knownFields.has(key)) || typeof fields["mcp_elicitations"] !== "boolean" || typeof fields["rules"] !== "boolean" || typeof fields["sandbox_approval"] !== "boolean" || fields["request_permissions"] !== void 0 && typeof fields["request_permissions"] !== "boolean" || fields["skill_approval"] !== void 0 && typeof fields["skill_approval"] !== "boolean") {
-    return void 0;
-  }
-  return {
-    granular: {
-      mcp_elicitations: fields["mcp_elicitations"],
-      request_permissions: fields["request_permissions"] ?? false,
-      rules: fields["rules"],
-      sandbox_approval: fields["sandbox_approval"],
-      skill_approval: fields["skill_approval"] ?? false
-    }
-  };
-}
-function optionalSandboxMode(value) {
-  return value === "read-only" || value === "workspace-write" || value === "danger-full-access" ? value : void 0;
-}
 var CodexRuntimeProvider = class {
+  personalization;
   fileSearch;
   #client;
+  #taskTitles;
   #logger;
   #gitMetadataWatch;
   #providerConnection;
@@ -12334,6 +13073,19 @@ var CodexRuntimeProvider = class {
   #reviewWorkerOwners = /* @__PURE__ */ new Map();
   constructor(client, logger = DEFAULT_PROVIDER_LOGGER, options = {}) {
     this.#client = client;
+    this.#taskTitles = options.readTaskTitleModel === void 0 ? void 0 : new CodexTaskTitles(client, options.readTaskTitleModel, logger);
+    const instructions = createGlobalInstructionsStore(
+      options.codexHome ?? process.env["CODEX_HOME"] ?? resolve(homedir(), ".codex")
+    );
+    this.personalization = {
+      getGlobalInstructions: instructions.read,
+      saveGlobalInstructions: (input) => instructions.save(input),
+      getMemorySettings: () => readMemorySettings(client),
+      updateMemorySettings: (input) => updateMemorySettings(client, input),
+      resetMemories: () => resetMemories(client),
+      getAgentPreferences: () => readAgentPreferences(client),
+      updateAgentPreferences: (input) => updateAgentPreferences(client, input)
+    };
     this.#logger = logger;
     this.#providerConnection = new CodexProviderConnectionService(client, options);
     this.fileSearch = new CodexFuzzyFileSearchService(client);
@@ -12344,6 +13096,7 @@ var CodexRuntimeProvider = class {
       }
     });
     client.onNotification((notification) => {
+      this.#taskTitles?.receiveNotification(notification);
       this.#gitMetadataWatch.receiveNotification(notification.method, notification.params);
       if (notification.method === "fs/changed") return;
       this.fileSearch.receiveNotification(notification.method, notification.params);
@@ -12432,6 +13185,7 @@ var CodexRuntimeProvider = class {
     }
     const rawProvider = new CodexAgentProvider(this.#client, project, {
       logger: this.#logger,
+      ...this.#taskTitles === void 0 ? {} : { taskTitles: this.#taskTitles },
       subscribeRpc: false
     });
     const provider = new CodexRuntimeProjectProvider(this, rawProvider, project);
@@ -12515,6 +13269,7 @@ var CodexRuntimeProvider = class {
     const sandboxMode = optionalSandboxMode(config["sandbox_mode"]);
     return {
       ...approvalDefaults,
+      fastMode: config["service_tier"] === "priority" || config["service_tier"] === "fast",
       ...model === void 0 ? {} : { model },
       ...reasoningEffort === void 0 ? {} : { reasoningEffort },
       ...sandboxMode === void 0 ? {} : { sandboxMode }
@@ -12523,6 +13278,10 @@ var CodexRuntimeProvider = class {
   readProviderConnection() {
     return this.#providerConnection.readStatus();
   }
+  async updateDefaultSettings(settings) {
+    await writeRuntimeDefaultSettings(this.#client, settings);
+    this.#providerConnection.invalidateConfig();
+  }
   async releaseProject(projectId, expectedProvider) {
     const projectProvider = this.#projectProviders.get(projectId);
     if (expectedProvider !== void 0 && projectProvider !== expectedProvider) {
@@ -12580,7 +13339,9 @@ var CodexRuntimeProvider = class {
 };
 function createCodexRuntimeProvider(options) {
   return new CodexRuntimeProvider(options.client, options.logger, {
-    ...options.fetch === void 0 ? {} : { fetch: options.fetch }
+    ...options.codexHome === void 0 ? {} : { codexHome: options.codexHome },
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+    ...options.readTaskTitleModel === void 0 ? {} : { readTaskTitleModel: options.readTaskTitleModel }
   });
 }
 var APP_SERVER_ARGUMENTS = ["app-server", "--enable", "plugins", "--listen", "stdio://"];