@bryanhu/codexly 0.18.0 → 0.20.0

package/dist/{chunk-3PU3WPOK.js → chunk-AIACWU7L.js}

@@ -1,6 +1,6 @@
 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-M6GWGUSX.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';
@@ -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);
@@ -8706,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();
@@ -8745,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);
@@ -8771,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();
@@ -9135,6 +9422,7 @@ function createUnmaterializedTaskSnapshot(task) {
 }
 var CodexAgentProviderBase = class {
   client;
+  taskTitles;
   eventListenersIncludingEphemeral = /* @__PURE__ */ new Set();
   eventListeners = /* @__PURE__ */ new Set();
   historicalAttachments = new CodexHistoricalAttachmentStore();
@@ -9175,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({
@@ -9211,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
     ]);
@@ -9274,14 +9564,19 @@ var CodexAgentProviderBase = class {
     );
     this.runtime.projectTaskIds.add(task.id);
     this.runtime.resumedTaskIds.add(task.id);
+    this.runtime.unmaterializedTasks.set(task.id, task);
     return task;
   }
   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);
@@ -9655,6 +9950,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;
   }
@@ -9710,7 +10009,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) {
@@ -9737,7 +10038,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(
@@ -9819,7 +10123,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);
@@ -10215,12 +10521,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")
       );
@@ -10537,6 +10847,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);
@@ -10672,9 +10983,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);
       }
@@ -10768,6 +11082,274 @@ 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 = {
@@ -10788,6 +11370,48 @@ async function writeRuntimeDefaultSettings(client, settings) {
   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");
@@ -12435,52 +13059,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 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;
-}
 var CodexRuntimeProvider = class {
   personalization;
   fileSearch;
   #client;
+  #taskTitles;
   #logger;
   #gitMetadataWatch;
   #providerConnection;
@@ -12491,6 +13074,7 @@ 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")
     );
@@ -12513,6 +13097,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);
@@ -12601,6 +13186,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);
@@ -12755,7 +13341,8 @@ var CodexRuntimeProvider = class {
 function createCodexRuntimeProvider(options) {
   return new CodexRuntimeProvider(options.client, options.logger, {
     ...options.codexHome === void 0 ? {} : { codexHome: options.codexHome },
-    ...options.fetch === void 0 ? {} : { fetch: options.fetch }
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+    ...options.readTaskTitleModel === void 0 ? {} : { readTaskTitleModel: options.readTaskTitleModel }
   });
 }
 var APP_SERVER_ARGUMENTS = ["app-server", "--enable", "plugins", "--listen", "stdio://"];