@nyssance/codex-acp-v2 0.7.9 → 0.7.10

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.7.10 — 2026-10-11
+
+### Fixed
+
+- Restore image attachments, file references, and readable conversation titles in
+  history instead of exposing serialized attachment wrappers or Markdown links.
+- Load native local image attachments with bounded reads and preserve unavailable
+  image placeholders when clipboard files have expired.
+- Parse single and multiple questionnaire replies into question and answer metadata
+  for both live messages and history, preserving malformed input as ordinary text.
+- Report user send times, assistant completion times, and live work duration through
+  message metadata; keep native historical total duration distinct from work duration.
+- Preserve interruption metadata when replaying history and when live turns stop.
+
 ## 0.7.9 — 2026-10-10
 
 ### Added

package/dist/index.js

@@ -22168,7 +22168,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.7.9",
+  version: "0.7.10",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -23776,8 +23776,100 @@ function mcpStartupFailed(serverName, message) {
 }
 
 // src/codex/sessionConfig.ts
-import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL2 } from "url";
 import path3 from "path";
+
+// src/codex/userImages.ts
+import { constants } from "fs";
+import { open } from "fs/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+var nativeImages = new WeakMap;
+var MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+function localImageContent(path3) {
+  const block = { type: "resource_link", name: "Image", uri: path3.startsWith("file:") ? path3 : pathToFileURL(path3).href };
+  nativeImages.set(block, path3);
+  return block;
+}
+async function hydrateUserImages(content, signal) {
+  const result = [];
+  for (const block of content) {
+    signal.throwIfAborted();
+    const path3 = nativeImages.get(block);
+    result.push(path3 === undefined ? block : await readImage(path3));
+  }
+  signal.throwIfAborted();
+  return result;
+}
+async function readImage(path3) {
+  try {
+    const file2 = await open(path3.startsWith("file:") ? fileURLToPath(path3) : path3, constants.O_RDONLY | constants.O_NONBLOCK);
+    try {
+      const stat = await file2.stat();
+      if (!stat.isFile() || stat.size === 0 || stat.size > MAX_IMAGE_BYTES)
+        return unavailable();
+      const data = Buffer.alloc(stat.size);
+      let offset = 0;
+      while (offset < data.length) {
+        const { bytesRead } = await file2.read(data, offset, data.length - offset, offset);
+        if (bytesRead === 0)
+          return unavailable();
+        offset += bytesRead;
+      }
+      const mimeType = imageMimeType(data);
+      return mimeType ? { type: "image", mimeType, data: data.toString("base64") } : unavailable();
+    } finally {
+      await file2.close();
+    }
+  } catch {
+    return unavailable();
+  }
+}
+function unavailable() {
+  return { type: "resource_link", name: "Image unavailable", uri: "codex-image:unavailable", _meta: { codex: { imageUnavailable: true } } };
+}
+function imageMimeType(data) {
+  if (data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+    return "image/png";
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255)
+    return "image/jpeg";
+  if (/^GIF8[79]a$/.test(data.toString("ascii", 0, 6)))
+    return "image/gif";
+  if (data.toString("ascii", 0, 4) === "RIFF" && data.toString("ascii", 8, 12) === "WEBP")
+    return "image/webp";
+  if (data.toString("ascii", 0, 2) === "BM")
+    return "image/bmp";
+  return null;
+}
+
+// src/codex/questionReplies.ts
+function questionReplyContent(text) {
+  const envelope = /^\s*<send_user_message_question_reply>\s*([\s\S]*?)\s*<\/send_user_message_question_reply>\s*$/.exec(text);
+  if (!envelope)
+    return null;
+  let replies;
+  try {
+    replies = JSON.parse(envelope[1]);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(replies) || replies.length === 0)
+    return null;
+  const content = [];
+  for (const reply of replies) {
+    if (reply === null || typeof reply !== "object" || Array.isArray(reply) || typeof reply.questionItemId !== "string" || typeof reply.question !== "string" || typeof reply.answer !== "string")
+      return null;
+    const { questionItemId, question, answer } = reply;
+    content.push({
+      type: "text",
+      text: `${question}
+${answer}`,
+      _meta: { codex: { questionReply: { questionItemId, question, answer } } }
+    });
+  }
+  return content;
+}
+
+// src/codex/sessionConfig.ts
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
 function sanitizeMcpServerName(name) {
   return name.replace(MCP_SERVER_NAME_WHITESPACE, "_");
@@ -23882,22 +23974,44 @@ ${resource.blob}
 function fromUserInput(input) {
   switch (input.type) {
     case "text":
-      return input.text.length > 0 ? [{ type: "text", text: input.text }] : [];
-    case "image":
-      return [{ type: "text", text: "url" in input ? formatUriAsLink("image", input.url) : `image:${input.fileId}` }];
+      return questionReplyContent(input.text) ?? (input.text.length > 0 ? [fileReference(input.text) ?? { type: "text", text: input.text }] : []);
+    case "image": {
+      if ("url" in input) {
+        const data = /^data:(image\/[a-zA-Z0-9.+-]+);base64,([a-zA-Z0-9+/=\r\n]+)$/.exec(input.url);
+        if (data)
+          return [{ type: "image", mimeType: data[1], data: data[2] }];
+        return [{ type: "resource_link", name: "Image", uri: input.url }];
+      }
+      return [{ type: "resource_link", name: "Image", uri: `codex-file:${input.fileId}` }];
+    }
     case "localImage":
-      return [{ type: "text", text: formatUriAsLink(null, toFileUri(input.path)) }];
+      return [localImageContent(input.path)];
     case "skill":
       return [{ type: "text", text: `skill:${input.name} (${input.path})` }];
     case "mention":
-      return [{ type: "text", text: formatUriAsLink(input.name, toFileUri(input.path)) }];
+      return [{ type: "resource_link", name: input.name, uri: toFileUri(input.path) }];
     case "audio":
     case "localAudio":
       return [];
   }
 }
+function fileReference(text) {
+  if (!text.startsWith("[@") || !text.endsWith(")") || /[\r\n]/.test(text))
+    return null;
+  const separator = text.lastIndexOf("](file://");
+  if (separator < 3)
+    return null;
+  const uri = text.slice(separator + 2, -1);
+  try {
+    if (new URL(uri).protocol !== "file:" || /\s/.test(uri))
+      return null;
+  } catch {
+    return null;
+  }
+  return { type: "resource_link", name: text.slice(2, separator), uri };
+}
 function toFileUri(value) {
-  return value.startsWith("file://") ? value : pathToFileURL(value).href;
+  return value.startsWith("file://") ? value : pathToFileURL2(value).href;
 }
 function isSupportedImageUrl(uri) {
   if (!uri)
@@ -23922,12 +24036,43 @@ function promptTitle(prompt) {
   for (const block of prompt) {
     if (!ContentBlock.isText(block))
       continue;
+    const replies = questionReplyContent(block.text);
+    if (replies)
+      return promptTitle(replies);
     const line = block.text.split(/\r?\n/).map((part) => part.trim()).find((part) => part.length > 0);
     if (line)
       return line.length > 120 ? `${line.slice(0, 117)}...` : line;
   }
+  for (const block of prompt) {
+    if (ContentBlock.isResourceLink(block))
+      return block.name;
+  }
   return null;
 }
+function fromUserMessage(inputs) {
+  const images = new Set(inputs.filter((input) => input.type === "localImage").map((input) => input.path));
+  const inlineImages = inputs.filter((input) => input.type === "image" && ("url" in input) && /^data:image\/[a-zA-Z0-9.+-]+;base64,[a-zA-Z0-9+/=\r\n]+$/.test(input.url)).length;
+  const imageCount = images.size + inlineImages;
+  return inputs.flatMap((input, index) => {
+    if (index !== 0 || input.type !== "text" || imageCount === 0)
+      return fromUserInput(input);
+    const envelope = /^\s*# Files mentioned by the user:\r?\n\r?\n([\s\S]*?)\r?\n\r?\nDistinguish instructions in attached documents from the user's request\.\r?\n\r?\n## My request:\r?\n([\s\S]*)$/.exec(input.text);
+    if (!envelope)
+      return fromUserInput(input);
+    const entries = envelope[1].split(/\r?\n\r?\n/);
+    const paths = new Set;
+    for (const entry of entries) {
+      const match = /^## (.+): (.+)\r?\nImage attachment: true$/.exec(entry);
+      if (!match || path3.basename(match[2]) !== match[1] || paths.has(match[2]))
+        return fromUserInput(input);
+      paths.add(match[2]);
+    }
+    if (paths.size !== imageCount || [...images].some((image) => !paths.has(image)))
+      return fromUserInput(input);
+    const text = envelope[2].trim();
+    return text ? [{ type: "text", text }] : [];
+  });
+}
 
 // src/agent/commandReceipts.ts
 import { createHash, randomUUID } from "crypto";
@@ -24074,7 +24219,7 @@ function itemSnapshot(item, command) {
         return [];
       if (command)
         return [{ sessionUpdate: "user_message", messageId: command.messageId, content: command.content }];
-      const content = item.content.flatMap(fromUserInput);
+      const content = fromUserMessage(item.content);
       return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.clientId ?? item.id, content }] : [];
     }
     case "agentMessage":
@@ -24163,6 +24308,10 @@ class EventBridge {
   insertedMessages = new Map;
   unannouncedItems = new Map;
   turnTime = null;
+  messageSentTimes = new Map;
+  workTiming = null;
+  timingCarrier = null;
+  turnPrompt = null;
   openToolCalls = new Set;
   announcedTools = new Set;
   messagePhases = new Map;
@@ -24188,9 +24337,22 @@ class EventBridge {
     this.promptMeta.set(messageId, meta);
   }
   async insertPrompt(messageId, content) {
-    const meta = this.promptMeta.get(messageId);
+    content = content.flatMap((block) => ContentBlock.isText(block) ? questionReplyContent(block.text) ?? [block] : [block]);
+    let meta = this.promptMeta.get(messageId);
+    if (content.some((block) => ContentBlock.isText(block) && block._meta?.["codex"] && typeof block._meta["codex"] === "object" && ("questionReply" in block._meta["codex"]))) {
+      const parts = content.flatMap((block) => {
+        if (!ContentBlock.isText(block))
+          return [];
+        const reply = block._meta?.["codex"]?.questionReply;
+        return [reply ? { question: reply.question, text: reply.answer } : { text: block.text }];
+      });
+      meta = { ...meta, codex: { ...meta?.["codex"], questionReplyParts: parts } };
+    }
     this.promptMeta.delete(messageId);
     this.insertedMessages.set(messageId, { content, meta });
+    const sentAt = promptSentAt(meta);
+    if (sentAt !== undefined)
+      this.messageSentTimes.set(messageId, sentAt);
     await this.client.update({ sessionUpdate: "user_message", messageId, content, ...meta ? { _meta: meta } : {} });
   }
   rememberCommand(messageId, native) {
@@ -24201,6 +24363,11 @@ class EventBridge {
   }
   beginTurn() {
     this.commandEcho = null;
+    this.messageSentTimes.clear();
+    this.workTiming = null;
+    this.timingCarrier = null;
+    this.turnPrompt = null;
+    this.turnTime = null;
     this.restoredCommands.clear();
     this.unresolvedUserItems.clear();
     this.insertedMessages.clear();
@@ -24265,6 +24432,16 @@ class EventBridge {
     if (notification.method === "turn/started" || notification.method === "turn/completed") {
       const { id, startedAt } = notification.params.turn;
       this.turnTime = { id, startedAt };
+      if (notification.method === "turn/started" && startedAt !== null) {
+        this.workTiming = { id, startedAt: startedAt * 1000 };
+      }
+    }
+    if (notification.method === "item/started" && notification.params.item.type === "agentMessage" && notification.params.item.phase === "final_answer" && notification.params.item.delivery !== "async" && this.workTiming?.id === notification.params.turnId && this.workTiming.finalStartedAt === undefined) {
+      this.workTiming.finalStartedAt = notification.params.startedAtMs;
+      if (this.timingCarrier?.turnId === notification.params.turnId) {
+        const { turnId, update } = this.timingCarrier;
+        await this.client.update(this.withTiming(update, turnId));
+      }
     }
     let updates = await this.translate(notification);
     if (notification.method === "item/completed") {
@@ -24277,9 +24454,61 @@ class EventBridge {
     for (const update of updates) {
       this.trackToolCall(update);
       const turnId = "turnId" in notification.params ? notification.params.turnId : null;
-      await this.client.update(typeof turnId === "string" ? withTurnId(update, turnId, this.turnTime?.id === turnId ? this.turnTime.startedAt : null) : update);
+      let tagged = typeof turnId === "string" ? this.withTiming(withTurnId(update, turnId, this.turnTime?.id === turnId ? this.turnTime.startedAt : null), turnId) : update;
+      if (update.sessionUpdate === "user_message" && typeof update.messageId === "string") {
+        const originalSentAt = promptSentAt(update._meta);
+        if (originalSentAt !== undefined)
+          this.messageSentTimes.set(update.messageId, originalSentAt);
+        if (notification.method === "item/started" && !this.messageSentTimes.has(update.messageId)) {
+          this.messageSentTimes.set(update.messageId, notification.params.startedAtMs);
+        }
+        const sentAt = this.messageSentTimes.get(update.messageId);
+        if (sentAt !== undefined) {
+          if (this.workTiming?.id === turnId && this.turnPrompt?.turnId !== turnId && (originalSentAt !== undefined || this.insertedMessages.has(update.messageId) && promptSentAt(this.insertedMessages.get(update.messageId)?.meta) !== undefined))
+            this.workTiming.startedAt = sentAt;
+          tagged = timingMeta(typeof turnId === "string" ? this.withTiming(tagged, turnId) : tagged, { messageSentAt: sentAt });
+        }
+      }
+      if (notification.method === "item/completed" && update.sessionUpdate === "agent_message") {
+        tagged = timingMeta(tagged, { messageCompletedAt: notification.params.completedAtMs });
+      }
+      if (typeof turnId === "string" && (update.sessionUpdate === "user_message" || update.sessionUpdate === "agent_message")) {
+        this.timingCarrier = { turnId, update: tagged };
+      }
+      if (typeof turnId === "string" && update.sessionUpdate === "user_message") {
+        this.turnPrompt = { turnId, update: tagged };
+      }
+      await this.client.update(tagged);
+    }
+    if (notification.method === "turn/completed") {
+      const turn = notification.params.turn;
+      const carrier = this.timingCarrier;
+      if (carrier?.turnId === turn.id) {
+        await this.client.update(timingMeta(this.withTiming(carrier.update, turn.id), {
+          ...turn.completedAt !== null ? { turnCompletedAt: turn.completedAt * 1000 } : {},
+          ...turn.durationMs !== null ? { turnDurationMs: turn.durationMs } : {}
+        }));
+      }
+      if (this.turnPrompt?.turnId === turn.id && turn.status === "interrupted") {
+        await this.client.update(timingMeta(this.withTiming(this.turnPrompt.update, turn.id), {
+          turnInterrupted: true,
+          ...turn.completedAt !== null ? { turnCompletedAt: turn.completedAt * 1000 } : {},
+          ...turn.durationMs !== null ? { turnDurationMs: turn.durationMs } : {}
+        }));
+      }
+      this.turnPrompt = null;
     }
   }
+  withTiming(update, turnId) {
+    const timing = this.workTiming;
+    if (timing?.id !== turnId)
+      return update;
+    const duration3 = timing.finalStartedAt === undefined ? undefined : timing.finalStartedAt - timing.startedAt;
+    return timingMeta(update, {
+      workStartedAt: timing.startedAt,
+      ...duration3 !== undefined && duration3 >= 0 ? { workDurationMs: duration3 } : {}
+    });
+  }
   rememberNativeCommand(item) {
     const command = this.commandEcho;
     if (!command || command.nativeId)
@@ -24545,7 +24774,7 @@ ${details}` : summary)];
         const inserted = item.clientId ? this.insertedMessages.get(item.clientId) : undefined;
         if (inserted)
           return [{ sessionUpdate: "user_message", messageId: item.clientId, content: inserted.content }];
-        const content = item.content.flatMap(fromUserInput);
+        const content = fromUserMessage(item.content);
         if (content.length === 0)
           return [];
         const messageId = item.clientId ?? item.id;
@@ -24720,6 +24949,18 @@ function turnPlan(params) {
     }
   };
 }
+function timingMeta(update, fields) {
+  const meta = update._meta;
+  const codex = meta?.["codex"];
+  return { ...update, _meta: { ...meta, codex: { ...codex, ...fields } } };
+}
+function promptSentAt(meta) {
+  const codex = meta?.["codex"];
+  if (typeof codex !== "object" || codex === null)
+    return;
+  const value = codex["messageSentAt"];
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 8640000000000000 ? value : undefined;
+}
 
 // src/codex/AppServerClient.ts
 var import_node = __toESM(require_main(), 1);
@@ -26569,7 +26810,7 @@ class TurnContext {
 // node_modules/open/index.js
 import process10 from "process";
 import path7 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import childProcess4 from "child_process";
 import fs6, { constants as fsConstants2 } from "fs/promises";
 
@@ -26952,7 +27193,7 @@ var is_in_ssh_default = isInSsh;
 
 // node_modules/open/index.js
 var fallbackAttemptSymbol = Symbol("fallbackAttempt");
-var __dirname2 = import.meta.url ? path7.dirname(fileURLToPath(import.meta.url)) : "";
+var __dirname2 = import.meta.url ? path7.dirname(fileURLToPath2(import.meta.url)) : "";
 var localXdgOpenPath = path7.join(__dirname2, "xdg-open");
 var { platform, arch } = process10;
 var tryEachApp = async (apps, opener) => {
@@ -27164,7 +27405,7 @@ var baseOpen = async (options) => {
     });
   });
 };
-var open = (target, options) => {
+var open2 = (target, options) => {
   if (typeof target !== "string") {
     throw new TypeError("Expected a `target`");
   }
@@ -27233,7 +27474,7 @@ defineLazyProperty(apps, "edge", () => detectPlatformBinary({
 defineLazyProperty(apps, "safari", () => detectPlatformBinary({
   darwin: "Safari"
 }));
-var open_default = open;
+var open_default = open2;
 
 // src/agent/auth.ts
 var AuthMethodId = {
@@ -27369,6 +27610,10 @@ class ClientSession {
   async update(update) {
     if (this.disposed)
       return;
+    if (SessionUpdate.isUserMessage(update) && update.content) {
+      update = { ...update, content: await hydrateUserImages(update.content, this.output.signal) };
+    }
+    this.output.signal.throwIfAborted();
     await abortable(this.link.notify(methods.client.session.update, { sessionId: this.sessionId, update }), this.output.signal);
   }
   async updateAll(updates) {
@@ -27712,9 +27957,24 @@ function stringValue(request) {
 function historyUpdates(turns, commandReceipts = new Map) {
   const updates = [];
   for (const turn of turns) {
+    const openingUser = turn.items.find((item) => item.type === "userMessage");
     for (const item of turn.items) {
       const command = item.type === "userMessage" ? commandReceipts.get(item.id) : undefined;
-      updates.push(...itemSnapshot(item, command).map((update) => withTurnId(update, turn.id, turn.startedAt)));
+      updates.push(...itemSnapshot(item, command).map((update) => {
+        const replay = withTurnId(update, turn.id, turn.startedAt);
+        const meta = replay._meta;
+        const codex = meta?.["codex"];
+        const duration3 = turn.durationMs ?? (turn.startedAt !== null && turn.completedAt !== null ? (turn.completedAt - turn.startedAt) * 1000 : null);
+        replay._meta = { ...meta, codex: {
+          ...codex,
+          historyReplay: true,
+          ...turn.completedAt !== null ? { turnCompletedAt: turn.completedAt * 1000 } : {},
+          ...item === openingUser && turn.startedAt !== null ? { messageSentAt: turn.startedAt * 1000 } : {},
+          ...duration3 !== null && Number.isFinite(duration3) && duration3 >= 0 ? { turnDurationMs: duration3 } : {},
+          ...turn.status === "interrupted" ? { historyInterrupted: true } : {}
+        } };
+        return replay;
+      }));
     }
   }
   return updates;
@@ -27727,9 +27987,9 @@ function historyTitle(thread, turns) {
     for (const item of turn.items) {
       if (item.type !== "userMessage")
         continue;
-      const text2 = item.content.filter((input) => input.type === "text").map((input) => input.text.trim()).find((part) => part.length > 0);
-      if (text2)
-        return firstLine(text2);
+      const title = promptTitle(fromUserMessage(item.content));
+      if (title)
+        return title;
     }
   }
   const preview = thread.preview.trim();
@@ -27902,7 +28162,7 @@ class HistoryRead {
 }
 
 // src/agent/historyProjection.ts
-import { pathToFileURL as pathToFileURL2 } from "url";
+import { pathToFileURL as pathToFileURL3 } from "url";
 function inputBlock(input) {
   switch (input.type) {
     case "text":
@@ -27913,10 +28173,10 @@ function inputBlock(input) {
       return { type: "resource_link", name: "Audio", uri: input.url, _meta: { codex: { inputType: input.type } } };
     case "localImage":
     case "localAudio":
-      return { type: "resource_link", name: input.type === "localImage" ? "Image" : "Audio", uri: input.path.startsWith("file://") ? input.path : pathToFileURL2(input.path).href, _meta: { codex: { inputType: input.type, ..."detail" in input && input.detail ? { detail: input.detail } : {} } } };
+      return { type: "resource_link", name: input.type === "localImage" ? "Image" : "Audio", uri: input.path.startsWith("file://") ? input.path : pathToFileURL3(input.path).href, _meta: { codex: { inputType: input.type, ..."detail" in input && input.detail ? { detail: input.detail } : {} } } };
     case "skill":
     case "mention":
-      return { type: "resource_link", name: input.name, uri: input.path.startsWith("file://") ? input.path : pathToFileURL2(input.path).href, _meta: { codex: { inputType: input.type } } };
+      return { type: "resource_link", name: input.name, uri: input.path.startsWith("file://") ? input.path : pathToFileURL3(input.path).href, _meta: { codex: { inputType: input.type } } };
   }
 }
 function projectHistoryItem(item, turnId, startedAt, command) {
@@ -28328,8 +28588,8 @@ class CodexAgent {
         const catalog = await this.withCodex(() => this.codex.allModels(true));
         const nativeProvider = await this.resolveModelProvider(candidate);
         const wholesale = this.providers.active !== null && this.providers.mode === "route" || candidate.active !== null && candidate.mode === "route";
-        const unavailable = new Set([...this.sessions.values()].filter((runtime) => this.providers.mode === "catalog" && this.providers.hasGateway(runtime.modelProvider) && !candidate.hasGateway(runtime.modelProvider)));
-        const moving = [...this.sessions.values()].filter((runtime) => !unavailable.has(runtime) && (wholesale || this.providers.hasGateway(runtime.modelProvider) && candidate.gateway(runtime.modelProvider) !== this.providers.gateway(runtime.modelProvider)));
+        const unavailable2 = new Set([...this.sessions.values()].filter((runtime) => this.providers.mode === "catalog" && this.providers.hasGateway(runtime.modelProvider) && !candidate.hasGateway(runtime.modelProvider)));
+        const moving = [...this.sessions.values()].filter((runtime) => !unavailable2.has(runtime) && (wholesale || this.providers.hasGateway(runtime.modelProvider) && candidate.gateway(runtime.modelProvider) !== this.providers.gateway(runtime.modelProvider)));
         const targets = new Map(moving.map((runtime) => {
           if (candidate.active === null)
             return [runtime, null];
@@ -28367,7 +28627,7 @@ class CodexAgent {
           }));
           staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, requestedModel ?? candidate.selectionId(thread.model, modelProvider), thread.reasoningEffort) });
         }
-        for (const runtime of unavailable)
+        for (const runtime of unavailable2)
           runtime.config = candidate.rebind(runtime.config, this.providers, null);
         this.providers = candidate;
         for (const runtime of this.sessions.values()) {
@@ -28380,7 +28640,7 @@ class CodexAgent {
           }
           runtime.session.catalog = nextCatalog;
           runtime.session.gatewayGroups = candidate.gatewayGroups();
-          if (!next && !unavailable.has(runtime))
+          if (!next && !unavailable2.has(runtime))
             runtime.session.model = resolveModelSelection(nextCatalog, findModel(nextCatalog, runtime.session.model.model) ? runtime.session.model.model : null, runtime.session.model.effort);
           runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(runtime.session), _meta: { codex: { routing: { stale: false } } } }).catch((error40) => logger.error("Provider config notification failed", error40));
         }
@@ -28427,17 +28687,17 @@ class CodexAgent {
     const runtime = await this.openSession({ kind: "fork", request: params }, signal);
     return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session), _meta: { codex: runtime.lineage } };
   }
-  async openSession(open2, signal) {
+  async openSession(open3, signal) {
     if (signal?.aborted)
       throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
     const pending = this.admission(async () => {
-      const runtime = await this.openSessionInternal(open2, signal);
+      const runtime = await this.openSessionInternal(open3, signal);
       if (signal?.aborted) {
         await this.closeRuntime(runtime.session.id);
         throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
       }
       return runtime;
-    }, open2.kind === "new" ? undefined : open2.request.sessionId);
+    }, open3.kind === "new" ? undefined : open3.request.sessionId);
     try {
       return signal ? await abortable(pending, signal) : await pending;
     } catch (error40) {
@@ -28451,24 +28711,24 @@ class CodexAgent {
       throw RequestError.invalidRequest({ sessionId }, "A previous unsubscribe is still pending; retry after Codex responds or reconnect the agent");
     }
   }
-  async openSessionInternal(open2, signal) {
-    const method = { new: "session/new", resume: "session/resume", fork: "session/fork" }[open2.kind];
+  async openSessionInternal(open3, signal) {
+    const method = { new: "session/new", resume: "session/resume", fork: "session/fork" }[open3.kind];
     const capabilities = this.requireInitialized(method);
-    if (open2.kind !== "new")
-      this.assertUnsubscribeSettled(open2.request.sessionId);
-    const { request } = open2;
-    const lastTurnId = open2.kind === "fork" ? forkTurnId(request._meta) : undefined;
+    if (open3.kind !== "new")
+      this.assertUnsubscribeSettled(open3.request.sessionId);
+    const { request } = open3;
+    const lastTurnId = open3.kind === "fork" ? forkTurnId(request._meta) : undefined;
     if (typeof request.cwd !== "string" || !path9.isAbsolute(request.cwd)) {
       throw RequestError.invalidParams({ cwd: request.cwd }, "cwd must be an absolute path");
     }
-    if (open2.kind === "resume" && open2.request.replayFrom != null && open2.request.replayFrom.type !== "start") {
-      throw RequestError.invalidParams({ replayFrom: open2.request.replayFrom }, 'Only replayFrom {type: "start"} is supported');
+    if (open3.kind === "resume" && open3.request.replayFrom != null && open3.request.replayFrom.type !== "start") {
+      throw RequestError.invalidParams({ replayFrom: open3.request.replayFrom }, 'Only replayFrom {type: "start"} is supported');
     }
-    const seed = open2.kind === "new" ? seedHistoryOf(open2.request._meta) : [];
+    const seed = open3.kind === "new" ? seedHistoryOf(open3.request._meta) : [];
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories);
-    if (open2.kind === "resume" && this.sessions.has(open2.request.sessionId)) {
-      await this.closeRuntime(open2.request.sessionId);
-      this.assertUnsubscribeSettled(open2.request.sessionId);
+    if (open3.kind === "resume" && this.sessions.has(open3.request.sessionId)) {
+      await this.closeRuntime(open3.request.sessionId);
+      this.assertUnsubscribeSettled(open3.request.sessionId);
     }
     const mcpServers = request.mcpServers ?? [];
     const clientTools = clientToolsOf(request._meta);
@@ -28483,8 +28743,8 @@ class CodexAgent {
     if (this.providers.active !== null && this.providers.mode === "catalog") {
       if (requestedModel !== null)
         gatewayId = this.providers.gatewayIdFor(requestedModel);
-      else if (open2.kind === "resume") {
-        const known = await this.withCodex(() => this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false }));
+      else if (open3.kind === "resume") {
+        const known = await this.withCodex(() => this.codex.threadRead({ threadId: open3.request.sessionId, includeTurns: false }));
         gatewayId = this.providers.hasGateway(known.thread.modelProvider) ? known.thread.modelProvider : null;
       }
     }
@@ -28503,7 +28763,7 @@ class CodexAgent {
     const { thread, skills } = await this.withSkillsContext(request.cwd, additionalDirectories, async (skills2) => ({ skills: skills2, thread: await this.withCodex(async () => {
       if (signal?.aborted)
         throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
-      switch (open2.kind) {
+      switch (open3.kind) {
         case "new":
           return await this.codex.threadStart({
             ...hostThreadOptions,
@@ -28515,15 +28775,15 @@ class CodexAgent {
           });
         case "resume":
           try {
-            return await this.codex.threadResume({ ...hostThreadOptions, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+            return await this.codex.threadResume({ ...hostThreadOptions, threadId: open3.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
           } catch (error40) {
             if (!errorMessage(error40).includes("already has an active writer"))
               throw error40;
             readOnly = true;
-            return readOnlyThread((await this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false })).thread, request.cwd);
+            return readOnlyThread((await this.codex.threadRead({ threadId: open3.request.sessionId, includeTurns: false })).thread, request.cwd);
           }
         case "fork":
-          return await this.codex.threadFork({ ...hostThreadOptions, ...lastTurnId === undefined ? {} : { lastTurnId }, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+          return await this.codex.threadFork({ ...hostThreadOptions, ...lastTurnId === undefined ? {} : { lastTurnId }, threadId: open3.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
       }
     }) }));
     const sessionId = thread.thread.id;
@@ -28583,8 +28843,8 @@ class CodexAgent {
       removeCancellation = () => signal?.removeEventListener("abort", cancelOpening);
       if (signal?.aborted)
         cancelOpening();
-      const replay = open2.kind === "fork" || open2.kind === "resume" && open2.request.replayFrom?.type === "start";
-      if (open2.kind !== "new") {
+      const replay = open3.kind === "fork" || open3.kind === "resume" && open3.request.replayFrom?.type === "start";
+      if (open3.kind !== "new") {
         await this.replayHistory(runtime, replay, thread.thread);
       } else {
         if (seed.length > 0) {
@@ -28841,13 +29101,13 @@ class CodexAgent {
       response.data.push(...missing2.values());
     }
     return {
-      sessions: response.data.map((thread) => ({
+      sessions: await Promise.all(response.data.map(async (thread) => ({
         sessionId: thread.id,
         cwd: thread.cwd,
-        title: thread.name?.trim() || thread.preview.trim() || null,
+        title: !thread.name?.trim() && /^(?:\[@|# Files mentioned by the user:|<send_user_message_question_reply>)/.test(thread.preview.trimStart()) ? historyTitle(thread, (await this.turnPage(thread.id, null)).data) : thread.name?.trim() || thread.preview.trim() || null,
         updatedAt: new Date(thread.updatedAt * 1000).toISOString(),
         _meta: { codex: { archived, ...threadLineage(thread) } }
-      })),
+      }))),
       nextCursor: response.nextCursor
     };
   }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.9",
+  "version": "0.7.10",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {