@bryanhu/codexly 0.22.1 → 0.24.0

package/dist/{chunk-NUJPWN62.js → chunk-YG3QMLCD.js}

@@ -1,12 +1,12 @@
 import { createRequire } from 'node:module';
 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-ZXTTTT25.js';
+import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_IMAGE_BYTES, MAX_AGENT_TEXT_BYTES, MAX_AGENT_FILE_BYTES } from './chunk-ZXTTTT25.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 { constants, mkdtempSync, rmSync, createReadStream, mkdirSync, unlinkSync, renameSync, writeFileSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync } from 'fs';
 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 { resolve, join, basename, dirname, relative, sep, win32, posix, isAbsolute, extname } from 'path';
 import { promisify } from 'util';
 import { randomUUID, createHash } from 'crypto';
 import { Buffer as Buffer$1 } from 'buffer';
@@ -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: join7 } = __require("path");
+    var { join: join9 } = __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"] || join7(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join9(__dirname, "lib", "worker.js");
       const worker = new Worker2(toExecute, {
         ...opts.workerOpts,
         name: opts.workerOpts?.name || "thread-stream",
@@ -2499,9 +2499,9 @@ var require_thread_stream = __commonJS({
 var require_transport = __commonJS({
   "node_modules/.pnpm/pino@10.3.1/node_modules/pino/lib/transport.js"(exports, module) {
     var { createRequire: createRequire2 } = __require("module");
-    var { existsSync } = __require("fs");
+    var { existsSync: existsSync2 } = __require("fs");
     var getCallers = require_caller();
-    var { join: join7, isAbsolute: isAbsolute7, sep: sep3 } = __require("path");
+    var { join: join9, isAbsolute: isAbsolute8, sep: sep3 } = __require("path");
     var { fileURLToPath } = __require("url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
@@ -2573,7 +2573,7 @@ var require_transport = __commonJS({
           return false;
         }
       }
-      return isAbsolute7(path) && !existsSync(path);
+      return isAbsolute8(path) && !existsSync2(path);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -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"] || join7(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join9(__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"] || join7(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join9(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2691,11 +2691,11 @@ var require_transport = __commonJS({
       return buildStream(fixTarget(target), options, worker, sync, name);
       function fixTarget(origin) {
         origin = bundlerOverrides[origin] || origin;
-        if (isAbsolute7(origin) || origin.indexOf("file://") === 0) {
+        if (isAbsolute8(origin) || origin.indexOf("file://") === 0) {
           return origin;
         }
         if (origin === "pino/file") {
-          return join7(__dirname, "..", "file.js");
+          return join9(__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 join7 = ",";
+            let join9 = ",";
             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}`;
-                join7 = `,
+                join9 = `,
 ${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 += join7;
+                res += join9;
               }
               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 += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3719,7 +3719,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join7 = `,
+              join9 = `,
 ${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 = join7;
+                separator = join9;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join7;
+              separator = join9;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3780,7 +3780,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join7 = ",";
+            let join9 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3793,7 +3793,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join7 = `,
+                join9 = `,
 ${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 += join7;
+                res += join9;
               }
               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 += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3820,7 +3820,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join7 = `,
+              join9 = `,
 ${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 = join7;
+                separator = join9;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3887,20 +3887,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join8 = `,
+              const join10 = `,
 ${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 += join8;
+                res2 += join10;
               }
               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 += `${join8}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join10}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3916,16 +3916,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join7 = `,
+            const join9 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join7, maximumBreadth);
+              res += stringifyTypedArray(value, join9, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join7;
+              separator = join9;
             }
             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 = join7;
+                separator = join9;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join7;
+              separator = join9;
             }
             if (separator !== "") {
               res = `
@@ -4466,8 +4466,8 @@ var require_pino = __commonJS({
   }
 });
 var execFileAsync = promisify(execFile);
-var SUPPORTED_CODEX_VERSION = "0.154.0";
-var SUPPORTED_CODEX_VERSION_RANGE = ">=0.154.0,<0.155.0";
+var SUPPORTED_CODEX_VERSION = "0.155.1";
+var SUPPORTED_CODEX_VERSION_RANGE = ">=0.155.0,<0.156.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 !== 154 || patch === void 0 || isPrerelease) {
+  if (major !== 0 || minor !== 155 || patch === void 0 || isPrerelease) {
     throw new Error(
       `Unsupported Codex version ${version}; expected ${SUPPORTED_CODEX_VERSION_RANGE}`
     );
@@ -4664,6 +4664,7 @@ var CODEX_SPECIAL_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
   "serverRequest/resolved",
   "skills/changed",
   "thread/archived",
+  "thread/attachment/updated",
   "thread/deleted",
   "thread/name/updated",
   "thread/started",
@@ -8295,6 +8296,373 @@ var CodexHistoricalAttachmentStore = class {
     }
   }
 };
+var DATA_URL_PATTERN2 = /^data:(image\/(?:gif|jpeg|png|webp));base64,([A-Za-z0-9+/]+={0,2})$/u;
+var CodexPersistentHistoricalAttachmentStore = class {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  directory;
+  #entries = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Map();
+  #totalBytes = 0;
+  addDataUrl(taskId, input, imageIndex) {
+    const match = DATA_URL_PATTERN2.exec(input.url);
+    const mediaType = match?.[1];
+    const content = this.#decodeBase64(match?.[2]);
+    if (content === void 0 || mediaType === void 0 || detectImageMediaType(content) !== mediaType) {
+      return void 0;
+    }
+    return this.#add(
+      taskId,
+      "image",
+      mediaType,
+      normalizeAttachmentName(input.name, `\u56FE\u7247-${String(imageIndex + 1)}`),
+      content
+    );
+  }
+  addBase64Image(taskId, input, imageIndex) {
+    const content = this.#decodeBase64(input.encoded);
+    const mediaType = content === void 0 ? void 0 : detectImageMediaType(content);
+    if (content === void 0 || mediaType === void 0) return void 0;
+    return this.#add(
+      taskId,
+      "image",
+      mediaType,
+      normalizeAttachmentName(
+        input.name,
+        `\u751F\u6210\u56FE\u7247-${String(imageIndex + 1)}${imageExtensionsByMediaType[mediaType]}`
+      ),
+      content
+    );
+  }
+  addStagedImage(taskId, staged, imageIndex, inputName) {
+    if (staged.size <= 0 || staged.size > MAX_AGENT_IMAGE_BYTES) return void 0;
+    try {
+      const content = readFileSync(staged.path);
+      if (content.byteLength !== staged.size || createHash("sha256").update(content).digest("hex") !== staged.contentDigest || detectImageMediaType(content) !== staged.mediaType) {
+        return void 0;
+      }
+      const attachment = this.#add(
+        taskId,
+        "image",
+        staged.mediaType,
+        normalizeAttachmentName(
+          inputName,
+          `\u751F\u6210\u56FE\u7247-${String(imageIndex + 1)}${imageExtensionsByMediaType[staged.mediaType]}`
+        ),
+        content
+      );
+      if (attachment !== void 0) unlinkSync(staged.path);
+      return attachment;
+    } catch {
+      return void 0;
+    }
+  }
+  addLocalImage(taskId, path, imageIndex) {
+    if (!isAbsolute(path)) return void 0;
+    try {
+      const stats = statSync(path);
+      if (!stats.isFile() || stats.size <= 0 || stats.size > MAX_AGENT_IMAGE_BYTES)
+        return void 0;
+      const content = readFileSync(path);
+      const mediaType = detectImageMediaType(content);
+      if (mediaType === void 0) return void 0;
+      return this.#add(
+        taskId,
+        "image",
+        mediaType,
+        normalizeAttachmentName(basename(path), `\u56FE\u7247-${String(imageIndex + 1)}`),
+        content
+      );
+    } catch {
+      return void 0;
+    }
+  }
+  addText(taskId, input, textIndex) {
+    const content = Buffer$1.from(input.text, "utf8");
+    if (content.byteLength > MAX_AGENT_TEXT_BYTES) return void 0;
+    return this.#add(
+      taskId,
+      "text",
+      "text/plain",
+      normalizeAttachmentName(input.name, `Pasted text-${String(textIndex + 1)}.txt`),
+      content
+    );
+  }
+  addLocalFile(taskId, input) {
+    if (!isAbsolute(input.path)) return void 0;
+    try {
+      const stats = statSync(input.path);
+      if (!stats.isFile() || stats.size <= 0 || stats.size > MAX_AGENT_FILE_BYTES) return void 0;
+      return this.#add(
+        taskId,
+        "file",
+        input.mediaType,
+        normalizeAttachmentName(input.name, "Attachment"),
+        readFileSync(input.path)
+      );
+    } catch {
+      return void 0;
+    }
+  }
+  restoreTask(taskId, metadata) {
+    this.clearTask(taskId);
+    for (const record of metadata) {
+      const path = this.#blobPath(taskId, record.blobKey);
+      try {
+        const stats = statSync(path);
+        if (!stats.isFile() || stats.size !== record.attachment.size) continue;
+        this.#register({ attachment: record.attachment, blobKey: record.blobKey, path, taskId });
+      } catch {
+      }
+    }
+  }
+  pendingMetadata(taskId) {
+    return [...this.#pending.get(taskId)?.values() ?? []];
+  }
+  markPersisted(taskId, attachmentId) {
+    const pending = this.#pending.get(taskId);
+    pending?.delete(attachmentId);
+    if (pending?.size === 0) this.#pending.delete(taskId);
+  }
+  async read(taskId, attachmentId) {
+    const entry = this.#entries.get(attachmentId);
+    if (entry?.taskId !== taskId) return void 0;
+    try {
+      const content = await readFile(entry.path);
+      if (content.byteLength !== entry.attachment.size || createHash("sha256").update(content).digest("hex") !== entry.blobKey || entry.attachment.kind === "image" && detectImageMediaType(content) !== entry.attachment.mediaType) {
+        this.#forget(attachmentId);
+        rmSync(entry.path, { force: true });
+        return void 0;
+      }
+      this.#touch(entry);
+      return { ...entry.attachment, content };
+    } catch {
+      this.#forget(attachmentId);
+      return void 0;
+    }
+  }
+  clearTask(taskId) {
+    for (const [attachmentId, entry] of this.#entries) {
+      if (entry.taskId === taskId) this.#forget(attachmentId);
+    }
+    this.#pending.delete(taskId);
+  }
+  deleteTask(taskId) {
+    this.clearTask(taskId);
+    rmSync(this.#taskDirectory(taskId), { force: true, recursive: true });
+  }
+  dispose() {
+    this.#entries.clear();
+    this.#pending.clear();
+    this.#totalBytes = 0;
+  }
+  #add(taskId, kind, mediaType, name, content) {
+    const maxBytes = kind === "image" ? MAX_AGENT_IMAGE_BYTES : kind === "text" ? MAX_AGENT_TEXT_BYTES : MAX_AGENT_FILE_BYTES;
+    if (content.byteLength === 0 || content.byteLength > maxBytes) {
+      return void 0;
+    }
+    const blobKey = createHash("sha256").update(content).digest("hex");
+    const id = `history-${createHash("sha256").update(JSON.stringify([taskId, kind, mediaType, name, content.byteLength, blobKey])).digest("hex")}`;
+    const existing = this.#entries.get(id);
+    if (existing?.taskId === taskId) {
+      this.#touch(existing);
+      return existing.attachment;
+    }
+    const attachment = { id, kind, mediaType, name, size: content.byteLength };
+    const path = this.#blobPath(taskId, blobKey);
+    mkdirSync(this.#taskDirectory(taskId), { recursive: true });
+    if (!existsSync(path)) {
+      const temporaryPath = `${path}.${process.pid.toString()}.${id}.tmp`;
+      try {
+        writeFileSync(temporaryPath, content, { flag: "wx" });
+        renameSync(temporaryPath, path);
+      } catch {
+        rmSync(temporaryPath, { force: true });
+        if (!existsSync(path)) return void 0;
+      }
+    }
+    this.#ensureCapacity(attachment.size);
+    this.#register({ attachment, blobKey, path, taskId });
+    const taskPending = this.#pending.get(taskId) ?? /* @__PURE__ */ new Map();
+    taskPending.set(id, { attachment, blobKey, schemaVersion: 1 });
+    this.#pending.set(taskId, taskPending);
+    return attachment;
+  }
+  #decodeBase64(encoded) {
+    if (encoded === void 0 || encoded.length === 0) return void 0;
+    const content = Buffer$1.from(encoded, "base64");
+    return content.byteLength === 0 || content.byteLength > MAX_AGENT_IMAGE_BYTES || content.toString("base64").replace(/=+$/u, "") !== encoded.replace(/=+$/u, "") ? void 0 : content;
+  }
+  #taskDirectory(taskId) {
+    return join(this.directory, createHash("sha256").update(taskId).digest("hex"));
+  }
+  #blobPath(taskId, blobKey) {
+    return join(this.#taskDirectory(taskId), blobKey);
+  }
+  #register(entry) {
+    this.#entries.set(entry.attachment.id, entry);
+    this.#totalBytes += entry.attachment.size;
+  }
+  #touch(entry) {
+    this.#entries.delete(entry.attachment.id);
+    this.#entries.set(entry.attachment.id, entry);
+  }
+  #forget(attachmentId) {
+    const entry = this.#entries.get(attachmentId);
+    if (entry === void 0) return;
+    this.#entries.delete(attachmentId);
+    this.#totalBytes -= entry.attachment.size;
+  }
+  #ensureCapacity(incomingBytes) {
+    while (this.#entries.size >= MAX_AGENT_HISTORY_IMAGES || this.#totalBytes + incomingBytes > MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES) {
+      const oldestId = this.#entries.keys().next().value;
+      if (oldestId === void 0) return;
+      this.#forget(oldestId);
+    }
+  }
+};
+
+// packages/provider-codex/src/thread-attachment-repository.ts
+var CODEXLY_THREAD_ATTACHMENT_TYPE = "codexly.history.v1";
+var THREAD_ATTACHMENT_PAGE_SIZE = 100;
+var BLOB_KEY_PATTERN = /^[a-f0-9]{64}$/u;
+function readAttachment(value) {
+  const attachment = expectRecord(value, "Codexly thread attachment payload attachment");
+  const id = expectString(attachment["id"], "Codexly thread attachment id");
+  const kind = attachment["kind"];
+  const mediaType = expectString(attachment["mediaType"], "Codexly thread attachment mediaType");
+  const name = expectString(attachment["name"], "Codexly thread attachment name");
+  const size = attachment["size"];
+  if (kind !== "file" && kind !== "image" && kind !== "text" || id.length === 0 || id.length > 256 || mediaType.length === 0 || mediaType.length > 255 || name.length === 0 || name.length > 255 || !Number.isSafeInteger(size) || typeof size !== "number" || size <= 0 || size > MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES) {
+    throw new CodexProtocolMappingError("Codexly thread attachment metadata is invalid");
+  }
+  return { id, kind, mediaType, name, size };
+}
+function readMetadata(value, identityKey) {
+  const payload = expectRecord(value, "Codexly thread attachment payload");
+  const attachment = readAttachment(payload["attachment"]);
+  const blobKey = expectString(payload["blobKey"], "Codexly thread attachment blobKey");
+  if (payload["schemaVersion"] !== 1 || attachment.id !== identityKey || !BLOB_KEY_PATTERN.test(blobKey)) {
+    throw new CodexProtocolMappingError("Codexly thread attachment payload is invalid");
+  }
+  return { attachment, blobKey, schemaVersion: 1 };
+}
+var CodexThreadAttachmentRepository = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  #cache = /* @__PURE__ */ new Map();
+  async load(threadId) {
+    const cached = this.#cache.get(threadId);
+    if (cached !== void 0) return cached;
+    const metadata = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    for (; ; ) {
+      const response = expectRecord(
+        await this.client.request("thread/attachment/list", {
+          ...cursor === void 0 ? {} : { cursor },
+          limit: THREAD_ATTACHMENT_PAGE_SIZE,
+          threadId
+        }),
+        "thread/attachment/list response"
+      );
+      const data = response["data"];
+      if (!Array.isArray(data)) {
+        throw new CodexProtocolMappingError("thread/attachment/list data must be an array");
+      }
+      for (const value of data) {
+        const attachment = expectRecord(value, "thread/attachment/list attachment");
+        if (attachment["attachmentType"] !== CODEXLY_THREAD_ATTACHMENT_TYPE) continue;
+        const identityKey = expectString(
+          attachment["identityKey"],
+          "thread/attachment/list identityKey"
+        );
+        metadata.push(readMetadata(attachment["payload"], identityKey));
+      }
+      const nextCursor = response["nextCursor"];
+      if (nextCursor === null) break;
+      cursor = expectString(nextCursor, "thread/attachment/list nextCursor");
+      if (cursor.length === 0 || seenCursors.has(cursor)) {
+        throw new CodexProtocolMappingError("thread/attachment/list returned an invalid cursor");
+      }
+      seenCursors.add(cursor);
+    }
+    this.#cache.set(threadId, metadata);
+    return metadata;
+  }
+  async add(threadId, metadata) {
+    const response = expectRecord(
+      await this.client.request("thread/attachment/add", {
+        attachmentType: CODEXLY_THREAD_ATTACHMENT_TYPE,
+        identityKey: metadata.attachment.id,
+        payload: metadata,
+        threadId
+      }),
+      "thread/attachment/add response"
+    );
+    const nativeAttachment = expectRecord(
+      response["attachment"],
+      "thread/attachment/add attachment"
+    );
+    if (nativeAttachment["attachmentType"] !== CODEXLY_THREAD_ATTACHMENT_TYPE || nativeAttachment["identityKey"] !== metadata.attachment.id || !isRecord(nativeAttachment["payload"])) {
+      throw new CodexProtocolMappingError("thread/attachment/add returned another attachment");
+    }
+    const persisted = readMetadata(nativeAttachment["payload"], metadata.attachment.id);
+    if (JSON.stringify(persisted) !== JSON.stringify(metadata)) {
+      throw new CodexProtocolMappingError("thread/attachment/add returned conflicting metadata");
+    }
+    this.#cache.delete(threadId);
+  }
+  invalidate(threadId) {
+    this.#cache.delete(threadId);
+  }
+  clear() {
+    this.#cache.clear();
+  }
+};
+
+// packages/provider-codex/src/thread-attachment-service.ts
+var CodexThreadAttachmentService = class {
+  store;
+  #preparedTasks = /* @__PURE__ */ new Set();
+  #repository;
+  constructor(client, attachmentDirectory) {
+    this.#repository = new CodexThreadAttachmentRepository(client);
+    this.store = new CodexPersistentHistoricalAttachmentStore(attachmentDirectory);
+  }
+  async prepare(taskId) {
+    if (this.#preparedTasks.has(taskId)) return;
+    this.store.restoreTask(taskId, await this.#repository.load(taskId));
+    this.#preparedTasks.add(taskId);
+  }
+  async flush(taskId) {
+    for (const metadata of this.store.pendingMetadata(taskId)) {
+      await this.#repository.add(taskId, metadata);
+      this.store.markPersisted(taskId, metadata.attachment.id);
+    }
+  }
+  invalidate(taskId) {
+    this.#preparedTasks.delete(taskId);
+    this.#repository.invalidate(taskId);
+    this.store.clearTask(taskId);
+  }
+  forget(taskId) {
+    this.invalidate(taskId);
+  }
+  deleteTask(taskId) {
+    this.#preparedTasks.delete(taskId);
+    this.#repository.invalidate(taskId);
+    this.store.deleteTask(taskId);
+  }
+  dispose() {
+    this.#preparedTasks.clear();
+    this.#repository.clear();
+    this.store.dispose();
+  }
+};
 
 // packages/provider-codex/src/pending-request-lifecycle.ts
 var MAX_TERMINAL_PENDING_REQUESTS = 1e3;
@@ -9425,7 +9793,8 @@ var CodexAgentProviderBase = class {
   taskTitles;
   eventListenersIncludingEphemeral = /* @__PURE__ */ new Set();
   eventListeners = /* @__PURE__ */ new Set();
-  historicalAttachments = new CodexHistoricalAttachmentStore();
+  historicalAttachments;
+  threadAttachments;
   logger;
   project;
   pendingLifecycle;
@@ -9448,7 +9817,10 @@ var CodexAgentProviderBase = class {
         else this.runtime.runningTaskIds.delete(event.taskId);
       }
       this.routeEvent(event);
-      if (event.type === "task.removed") this.clearTaskRuntimeState(event.taskId);
+      if (event.type === "task.removed") {
+        if (method === "thread/deleted") this.threadAttachments?.deleteTask(event.taskId);
+        this.clearTaskRuntimeState(event.taskId);
+      }
     } catch {
       warnDroppedCodexNotification(
         this.logger,
@@ -9463,6 +9835,8 @@ var CodexAgentProviderBase = class {
   }
   constructor(client, project, options = {}) {
     this.client = client;
+    this.threadAttachments = options.attachmentDirectory === void 0 ? void 0 : new CodexThreadAttachmentService(client, options.attachmentDirectory);
+    this.historicalAttachments = this.threadAttachments?.store ?? new CodexHistoricalAttachmentStore();
     this.taskTitles = options.taskTitles;
     this.logger = options.logger ?? DEFAULT_PROVIDER_LOGGER;
     this.project = project;
@@ -9506,7 +9880,8 @@ var CodexAgentProviderBase = class {
     ]);
     this.eventListenersIncludingEphemeral.clear();
     this.eventListeners.clear();
-    this.historicalAttachments.dispose();
+    if (this.threadAttachments === void 0) this.historicalAttachments.dispose();
+    else this.threadAttachments.dispose();
     this.pendingLifecycle.clear();
     this.runtime.clear();
     this.skillsById.clear();
@@ -9526,6 +9901,7 @@ var CodexAgentProviderBase = class {
   async deleteTask(taskId) {
     this.assertKnownProjectTask(taskId);
     await deleteCodexTask(this.client, taskId);
+    this.threadAttachments?.deleteTask(taskId);
     this.clearTaskRuntimeState(taskId);
   }
   async unarchiveTask(taskId) {
@@ -10521,6 +10897,7 @@ var CodexAgentProviderTasks = class extends CodexAgentProviderTurns {
         cursor.reviewCursor
       );
       const transcriptSkillsByTurnId = await readCodexTranscriptTurnSkills(taskId);
+      await this.threadAttachments?.prepare(taskId);
       const turns = this.runtime.messageIdentities.snapshot(
         taskId,
         mapAgentTurns(
@@ -10529,6 +10906,7 @@ var CodexAgentProviderTasks = class extends CodexAgentProviderTurns {
           (input2, textIndex) => this.mapMessageText(taskId, input2, textIndex)
         ).map((turn) => attachTranscriptSkills(turn, transcriptSkillsByTurnId.get(turn.id) ?? []))
       );
+      await this.threadAttachments?.flush(taskId);
       const status = turns.some((turn) => turn.status === "running") ? "running" : mapThreadStatus(thread["status"]);
       this.runtime.skillMessages.seed(taskId, turns);
       const runningReviewTurn = turns.findLast(
@@ -10646,6 +11024,7 @@ var CodexAgentProviderTasks = class extends CodexAgentProviderTurns {
     if (!this.runtime.projectTaskIds.has(taskId)) {
       return void 0;
     }
+    await this.threadAttachments?.prepare(taskId);
     return this.historicalAttachments.read(taskId, attachmentId);
   }
   async resolvePendingRequest(input) {
@@ -10727,6 +11106,13 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
     return true;
   }
   receiveNotification(method, params) {
+    if (method === "thread/attachment/updated") {
+      const taskId = readTaskId(params);
+      if (taskId === void 0)
+        this.warnDroppedNotification("invalid_notification", method, params);
+      else this.threadAttachments?.invalidate(taskId);
+      return;
+    }
     if (this.handleProjectStateNotification(method, params)) return;
     this.handleNotification(method, params);
   }
@@ -10848,7 +11234,8 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
   }
   clearTaskRuntimeState(taskId) {
     this.taskTitles?.forget(taskId);
-    this.historicalAttachments.clearTask(taskId);
+    if (this.threadAttachments === void 0) this.historicalAttachments.clearTask(taskId);
+    else this.threadAttachments.forget(taskId);
     this.pendingLifecycle.clearTask(taskId);
     this.runtime.clearTask(taskId);
   }
@@ -12020,6 +12407,7 @@ var CodexProviderConnectionService = class {
     try {
       readProviderCapabilities(await this.#client.request("modelProvider/capabilities/read", {}));
       if (apiKey !== void 0) {
+        await this.#client.request("account/logout");
         const loginResponse = await this.#client.request("account/login/start", {
           apiKey,
           type: "apiKey"
@@ -13196,6 +13584,7 @@ var CodexRuntimeProvider = class {
   fileSearch;
   search;
   #client;
+  #attachmentDirectory;
   #taskTitles;
   #logger;
   #gitMetadataWatch;
@@ -13207,10 +13596,10 @@ var CodexRuntimeProvider = class {
   #reviewWorkerOwners = /* @__PURE__ */ new Map();
   constructor(client, logger = DEFAULT_PROVIDER_LOGGER, options = {}) {
     this.#client = client;
+    const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? resolve(homedir(), ".codex");
+    this.#attachmentDirectory = join(codexHome, "codexly", "thread-attachments");
     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")
-    );
+    const instructions = createGlobalInstructionsStore(codexHome);
     this.personalization = {
       getGlobalInstructions: instructions.read,
       saveGlobalInstructions: (input) => instructions.save(input),
@@ -13319,6 +13708,7 @@ var CodexRuntimeProvider = class {
       return current;
     }
     const rawProvider = new CodexAgentProvider(this.#client, project, {
+      attachmentDirectory: this.#attachmentDirectory,
       logger: this.#logger,
       ...this.#taskTitles === void 0 ? {} : { taskTitles: this.#taskTitles },
       subscribeRpc: false