@armadra/agent 0.7.4 → 0.7.5

package/dist/bundle/ama.cjs

@@ -41,7 +41,7 @@ var AMA_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    AMA_VERSION = true ? "0.7.4" : readPackageVersion();
+    AMA_VERSION = true ? "0.7.5" : readPackageVersion();
   }
 });
 
@@ -10284,8 +10284,9 @@ function readSessionLines(file, options = {}) {
     forEachLineSync(file, (buf, index2, last, offset) => {
       if (last) unterminated = true;
       if (isBlankLine(buf)) return;
+      let line2;
       try {
-        lines2.push(JSON.parse(buf.toString("utf8")));
+        line2 = JSON.parse(buf.toString("utf8"));
       } catch (error2) {
         if (last) {
           repairedTail = true;
@@ -10296,6 +10297,8 @@ function readSessionLines(file, options = {}) {
           cause: error2
         });
       }
+      options.onLine?.(line2, { offset, length: buf.length });
+      lines2.push(line2);
     });
   } catch (error2) {
     if (error2 instanceof AmaError) throw error2;
@@ -10304,19 +10307,20 @@ function readSessionLines(file, options = {}) {
   if (!repairedTail && unterminated && options.repair === true) {
     appendRaw(file, "\n");
   }
-  return { lines: lines2, repairedTail };
+  if (options.onLine === void 0) return { lines: lines2, repairedTail };
+  return { lines: lines2, repairedTail, bytes: (0, import_node_fs10.statSync)(file).size };
 }
 function appendRaw(file, text) {
   const fd = (0, import_node_fs10.openSync)(file, "a");
   try {
-    (0, import_node_fs10.writeSync)(fd, text);
+    return (0, import_node_fs10.writeSync)(fd, text);
   } finally {
     (0, import_node_fs10.closeSync)(fd);
   }
 }
 function appendLines(file, lines2) {
-  if (lines2.length === 0) return;
-  appendRaw(file, lines2.map((line2) => JSON.stringify(line2)).join("\n") + "\n");
+  if (lines2.length === 0) return 0;
+  return appendRaw(file, lines2.map((line2) => JSON.stringify(line2)).join("\n") + "\n");
 }
 function writeNewSessionFile(file, lines2) {
   (0, import_node_fs10.mkdirSync)((0, import_node_path13.dirname)(file), { recursive: true, mode: 448 });
@@ -10324,8 +10328,10 @@ function writeNewSessionFile(file, lines2) {
     throw new AmaError("session_exists", `session file already exists: ${file}`);
   }
   const tmp = `${file}.${process.pid}.tmp`;
-  (0, import_node_fs10.writeFileSync)(tmp, lines2.map((line2) => JSON.stringify(line2)).join("\n") + "\n", { mode: 384 });
+  const texts2 = lines2.map((line2) => JSON.stringify(line2));
+  (0, import_node_fs10.writeFileSync)(tmp, texts2.join("\n") + "\n", { mode: 384 });
   (0, import_node_fs10.renameSync)(tmp, file);
+  return texts2.map((text) => Buffer.byteLength(text));
 }
 function installExitHandler() {
   if (exitHandlerInstalled) return;
@@ -10788,12 +10794,26 @@ var init_suggest = __esm({
 
 // src/ai/json-body.ts
 function isPlain(value) {
+  plainScans.count++;
   for (let i = 0; i < value.length; i += CHECK_CHUNK) {
     const chunk = value.slice(i, i + CHECK_CHUNK);
     if (JSON.stringify(chunk).length !== chunk.length + 2) return false;
   }
   return true;
 }
+function largeString(prefix, key, text) {
+  if (text.length < LARGE_STRING_BYTES || !isShortPlain(prefix)) return prefix + text;
+  return new LargeString(prefix, key, text);
+}
+function plainLargeBytes(value) {
+  if (!isShortPlain(value.prefix)) return void 0;
+  const known = plainBytes.get(value.key);
+  if (known !== void 0 && known.length === value.text.length) return known.bytes;
+  if (!isPlain(value.text)) return void 0;
+  const bytes = Buffer.byteLength(value.text, "utf8");
+  plainBytes.set(value.key, { length: value.text.length, bytes });
+  return bytes;
+}
 function isContainer(value) {
   if (typeof value !== "object" || value === null) return false;
   if (typeof value.toJSON === "function") return false;
@@ -10803,6 +10823,7 @@ function isContainer(value) {
 }
 function collectLarge(value, marked, depth) {
   if (isLargeString(value)) return true;
+  if (value instanceof LargeString) return value.text.length >= LARGE_STRING_BYTES;
   if (depth >= MAX_DEPTH || !isContainer(value)) return false;
   let found = false;
   if (Array.isArray(value)) {
@@ -10835,6 +10856,13 @@ function writeEntry(key, value, marked, out, prefix, depth) {
     }
     return true;
   }
+  if (value instanceof LargeString && value.text.length >= LARGE_STRING_BYTES) {
+    const bytes = plainLargeBytes(value);
+    out.text(prefix);
+    if (bytes !== void 0) out.large(value.text, value.prefix, bytes);
+    else out.text(JSON.stringify(value.toJSON()));
+    return true;
+  }
   if (depth < MAX_DEPTH && isContainer(value) && marked.has(value)) {
     out.text(prefix);
     writeContainer(value, marked, out, depth);
@@ -10868,20 +10896,16 @@ function jsonParts(body) {
   const marked = /* @__PURE__ */ new Set();
   if (!collectLarge(body, marked, 0)) return void 0;
   const out = new Pieces();
-  if (isLargeString(body)) {
-    if (!isPlain(body)) return void 0;
-    out.large(body);
-  } else writeContainer(body, marked, out, 0);
+  writeEntry("", body, marked, out, "", 0);
   const parts = out.finish();
-  let length = 0;
-  for (const part of parts) length += Buffer.byteLength(part, "utf8");
-  return { parts, length };
+  return { parts, length: out.bytes };
 }
 function jsonFetchBody(body) {
   const split = jsonParts(body);
   if (split === void 0) return { body: JSON.stringify(body) };
   const { parts } = split;
   let next = 0;
+  let offset = 0;
   const stream5 = new ReadableStream({
     pull(controller) {
       const part = parts[next];
@@ -10889,8 +10913,15 @@ function jsonFetchBody(body) {
         controller.close();
         return;
       }
-      parts[next++] = "";
-      controller.enqueue(Buffer.from(part, "utf8"));
+      let end = Math.min(part.length, offset + STREAM_CHUNK_CHARS);
+      const last = part.charCodeAt(end - 1);
+      if (end < part.length && last >= 55296 && last <= 56319) end--;
+      const piece = offset === 0 && end === part.length ? part : part.slice(offset, end);
+      if (end === part.length) {
+        parts[next++] = "";
+        offset = 0;
+      } else offset = end;
+      controller.enqueue(Buffer.from(piece, "utf8"));
     },
     cancel() {
       parts.length = 0;
@@ -10898,31 +10929,55 @@ function jsonFetchBody(body) {
   });
   return { body: stream5, contentLength: split.length };
 }
-var LARGE_STRING_BYTES, CHECK_CHUNK, MAX_DEPTH, isLargeString, Pieces;
+var LARGE_STRING_BYTES, CHECK_CHUNK, isShortPlain, plainScans, LargeString, plainBytes, MAX_DEPTH, isLargeString, Pieces, STREAM_CHUNK_CHARS;
 var init_json_body = __esm({
   "src/ai/json-body.ts"() {
     "use strict";
     LARGE_STRING_BYTES = 64 * 1024;
     CHECK_CHUNK = 16 * 1024;
+    isShortPlain = (value) => JSON.stringify(value).length === value.length + 2;
+    plainScans = { count: 0 };
+    LargeString = class {
+      constructor(prefix, key, text) {
+        this.prefix = prefix;
+        this.key = key;
+        this.text = text;
+      }
+      prefix;
+      key;
+      text;
+      toJSON() {
+        return this.prefix + this.text;
+      }
+    };
+    plainBytes = /* @__PURE__ */ new WeakMap();
     MAX_DEPTH = 64;
     isLargeString = (value) => typeof value === "string" && value.length >= LARGE_STRING_BYTES;
     Pieces = class {
       parts = [];
+      /** 已推入 `parts` 的 UTF-8 字节数。 */
+      bytes = 0;
       pending = "";
       text(chunk) {
         this.pending += chunk;
       }
-      /** 大字符串原样写入（引号进相邻的小片段）。 */
-      large(value) {
-        this.parts.push(`${this.pending}"`, value);
+      /** 大字符串原样写入（引号与 `head` 进前一个小片段）；`bytes` 已知时不再数一遍。 */
+      large(value, head = "", bytes = Buffer.byteLength(value, "utf8")) {
+        const before2 = `${this.pending}"${head}`;
+        this.parts.push(before2, value);
+        this.bytes += Buffer.byteLength(before2, "utf8") + bytes;
         this.pending = '"';
       }
       finish() {
-        if (this.pending.length > 0) this.parts.push(this.pending);
+        if (this.pending.length > 0) {
+          this.parts.push(this.pending);
+          this.bytes += Buffer.byteLength(this.pending, "utf8");
+        }
         this.pending = "";
         return this.parts;
       }
     };
+    STREAM_CHUNK_CHARS = 256 * 1024;
   }
 });
 
@@ -16177,121 +16232,150 @@ var init_edit_fuzzy = __esm({
 });
 
 // src/tools/read-lines.ts
-function readHead(abs, bytes) {
-  const fd = (0, import_node_fs22.openSync)(abs, "r");
+async function readHeadAsync(abs, bytes) {
+  const handle = await (0, import_promises3.open)(abs, "r");
   try {
     const buf = Buffer.alloc(bytes);
     let got = 0;
     while (got < bytes) {
-      const n = (0, import_node_fs22.readSync)(fd, buf, got, bytes - got, null);
-      if (n === 0) break;
-      got += n;
+      const { bytesRead } = await handle.read(buf, got, bytes - got, null);
+      if (bytesRead === 0) break;
+      got += bytesRead;
     }
     return buf.subarray(0, got);
   } finally {
-    (0, import_node_fs22.closeSync)(fd);
+    await handle.close();
   }
 }
-function readLineWindow(abs, offset, limit, maxBytes, chunkBytes = CHUNK_BYTES) {
+function scanner(offset, limit, maxBytes) {
   const first = offset - 1;
-  const stop = limit === void 0 ? Infinity : first + limit;
-  const lineCap = maxBytes + LINE_SLACK;
-  const lines2 = [];
-  let truncatedBy;
-  let collected = 0;
-  let index2 = 0;
-  let parts = [];
-  let partBytes = 0;
-  let pending = false;
-  let skipLF = false;
-  let bom = false;
-  const collecting = () => truncatedBy === void 0 && index2 >= first && index2 < stop;
-  const take = (buf, from, to) => {
-    if (to <= from || partBytes >= lineCap) return;
-    const end = Math.min(to, from + lineCap - partBytes);
-    parts.push(Buffer.from(buf.subarray(from, end)));
-    partBytes += end - from;
-  };
-  const finish2 = () => {
-    if (collecting()) {
-      const line2 = (parts.length === 1 ? parts[0] : Buffer.concat(parts)).toString("utf8");
-      lines2.push(line2);
-      collected += Buffer.byteLength(line2) + 1;
-      if (collected > maxBytes) truncatedBy = "bytes";
-    }
-    if (partBytes > 0) parts = [];
-    partBytes = 0;
-    pending = false;
-    index2++;
-  };
+  return new LineScanner(first, limit === void 0 ? Infinity : first + limit, maxBytes);
+}
+async function readLineWindowAsync(abs, offset, limit, maxBytes, chunkBytes = CHUNK_BYTES) {
+  const scan = scanner(offset, limit, maxBytes);
   const size = Math.max(3, chunkBytes);
-  const fd = (0, import_node_fs22.openSync)(abs, "r");
+  const handle = await (0, import_promises3.open)(abs, "r");
   try {
     const buf = Buffer.alloc(size);
     let carry = 0;
-    let firstChunk = true;
     for (; ; ) {
-      const n = (0, import_node_fs22.readSync)(fd, buf, carry, size - carry, null);
+      const { bytesRead: n } = await handle.read(buf, carry, size - carry, null);
       const end = carry + n;
-      carry = 0;
-      if (n === 0 && end === 0) break;
-      let pos = 0;
-      if (firstChunk) {
-        if (end < 3 && n > 0) {
-          carry = end;
-          continue;
-        }
-        firstChunk = false;
-        if (end >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
-          bom = true;
-          pos = 3;
-        }
-      }
-      if (skipLF && pos < end) {
-        if (buf[pos] === LF2) pos++;
-        skipLF = false;
-      }
-      let nextLF = buf.indexOf(LF2, pos);
-      let nextCR = buf.indexOf(CR2, pos);
-      while (pos < end) {
-        if (nextLF !== -1 && nextLF < pos) nextLF = buf.indexOf(LF2, pos);
-        if (nextCR !== -1 && nextCR < pos) nextCR = buf.indexOf(CR2, pos);
-        const lf = nextLF === -1 || nextLF >= end ? end : nextLF;
-        const cr = nextCR === -1 || nextCR >= end ? end : nextCR;
-        const at = Math.min(lf, cr);
-        if (at > pos) {
-          pending = true;
-          if (collecting()) take(buf, pos, at);
-        }
-        if (at === end) break;
-        finish2();
-        pos = at + 1;
-        if (at === cr) {
-          if (pos < end) {
-            if (buf[pos] === LF2) pos++;
-          } else {
-            skipLF = true;
-          }
-        }
-      }
+      if (end === 0) break;
+      carry = scan.feed(buf, end, n === 0);
       if (n === 0) break;
     }
-    if (pending) finish2();
   } finally {
-    (0, import_node_fs22.closeSync)(fd);
+    await handle.close();
   }
-  return { lines: lines2, totalLines: index2, ...truncatedBy ? { truncatedBy } : {}, bom };
+  return scan.finish();
 }
-var import_node_fs22, STREAM_READ_THRESHOLD, CHUNK_BYTES, LINE_SLACK, LF2, CR2;
+var import_promises3, STREAM_READ_THRESHOLD, CHUNK_BYTES, LINE_SLACK, LF2, CR2, LineScanner;
 var init_read_lines = __esm({
   "src/tools/read-lines.ts"() {
     "use strict";
-    import_node_fs22 = require("node:fs");
+    import_promises3 = require("node:fs/promises");
     STREAM_READ_THRESHOLD = 1024 * 1024;
     CHUNK_BYTES = 64 * 1024;
     LINE_SLACK = 64;
     LF2 = 10;
     CR2 = 13;
+    LineScanner = class {
+      constructor(first, stop, maxBytes) {
+        this.first = first;
+        this.stop = stop;
+        this.maxBytes = maxBytes;
+        this.lineCap = maxBytes + LINE_SLACK;
+      }
+      first;
+      stop;
+      maxBytes;
+      lineCap;
+      lines = [];
+      truncatedBy;
+      collected = 0;
+      index = 0;
+      // 已完成的行数
+      parts = [];
+      partBytes = 0;
+      pending = false;
+      // 最后一个终止符之后已有字节
+      skipLF = false;
+      // 上一块以 `\r` 结尾：下一块开头的 `\n` 属于同一终止符
+      bom = false;
+      firstChunk = true;
+      /**
+       * 处理 `buf[0, end)`；`eof` 表示这是最后一块。返回调用方下次读取前应保留在 `buf` 开头的字节数
+       * （只在首块不足 3 字节、还判断不了 BOM 时非零）。
+       */
+      feed(buf, end, eof) {
+        let pos = 0;
+        if (this.firstChunk) {
+          if (end < 3 && !eof) return end;
+          this.firstChunk = false;
+          if (end >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+            this.bom = true;
+            pos = 3;
+          }
+        }
+        if (this.skipLF && pos < end) {
+          if (buf[pos] === LF2) pos++;
+          this.skipLF = false;
+        }
+        let nextLF = buf.indexOf(LF2, pos);
+        let nextCR = buf.indexOf(CR2, pos);
+        while (pos < end) {
+          if (nextLF !== -1 && nextLF < pos) nextLF = buf.indexOf(LF2, pos);
+          if (nextCR !== -1 && nextCR < pos) nextCR = buf.indexOf(CR2, pos);
+          const lf = nextLF === -1 || nextLF >= end ? end : nextLF;
+          const cr = nextCR === -1 || nextCR >= end ? end : nextCR;
+          const at = Math.min(lf, cr);
+          if (at > pos) {
+            this.pending = true;
+            if (this.collecting()) this.take(buf, pos, at);
+          }
+          if (at === end) break;
+          this.endLine();
+          pos = at + 1;
+          if (at === cr) {
+            if (pos < end) {
+              if (buf[pos] === LF2) pos++;
+            } else {
+              this.skipLF = true;
+            }
+          }
+        }
+        return 0;
+      }
+      /** 文件读完：收尾最后一行并给出结果。 */
+      finish() {
+        if (this.pending) this.endLine();
+        const { lines: lines2, truncatedBy, bom } = this;
+        return { lines: lines2, totalLines: this.index, ...truncatedBy ? { truncatedBy } : {}, bom };
+      }
+      collecting() {
+        return this.truncatedBy === void 0 && this.index >= this.first && this.index < this.stop;
+      }
+      take(buf, from, to) {
+        if (to <= from || this.partBytes >= this.lineCap) return;
+        const end = Math.min(to, from + this.lineCap - this.partBytes);
+        this.parts.push(Buffer.from(buf.subarray(from, end)));
+        this.partBytes += end - from;
+      }
+      endLine() {
+        if (this.collecting()) {
+          const { parts } = this;
+          const line2 = (parts.length === 1 ? parts[0] : Buffer.concat(parts)).toString("utf8");
+          this.lines.push(line2);
+          this.collected += Buffer.byteLength(line2) + 1;
+          if (this.collected > this.maxBytes) this.truncatedBy = "bytes";
+        }
+        if (this.partBytes > 0) this.parts = [];
+        this.partBytes = 0;
+        this.pending = false;
+        this.index++;
+      }
+    };
   }
 });
 
@@ -16363,7 +16447,7 @@ async function resizeImage(input2, target, deps = {}) {
   const mimeType = format === "jpeg" ? "image/jpeg" : "image/png";
   const long = target.size !== void 0 ? Math.max(target.size.width, target.size.height) : 0;
   const start = long > 0 ? Math.min(target.maxEdge, long) : target.maxEdge;
-  const dir = await (0, import_promises3.mkdtemp)((0, import_node_path25.join)(deps.tmpDir ?? (0, import_node_os5.tmpdir)(), "ama-resize-"));
+  const dir = await (0, import_promises4.mkdtemp)((0, import_node_path25.join)(deps.tmpDir ?? (0, import_node_os5.tmpdir)(), "ama-resize-"));
   try {
     for (const tool of resizeTools(deps.platform ?? process.platform)) {
       let edge = start;
@@ -16374,7 +16458,7 @@ async function resizeImage(input2, target, deps = {}) {
         if (result.missing === true || result.code !== 0) break;
         let buf;
         try {
-          buf = await (0, import_promises3.readFile)(output);
+          buf = await (0, import_promises4.readFile)(output);
         } catch {
           break;
         }
@@ -16390,15 +16474,15 @@ async function resizeImage(input2, target, deps = {}) {
     }
     return { ok: false, reason: "no_tool" };
   } finally {
-    await (0, import_promises3.rm)(dir, { recursive: true, force: true }).catch(() => void 0);
+    await (0, import_promises4.rm)(dir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
-var import_node_child_process3, import_promises3, import_node_os5, import_node_path25, runCommand, MAX_ATTEMPTS, SHRINK, MIN_EDGE;
+var import_node_child_process3, import_promises4, import_node_os5, import_node_path25, runCommand, MAX_ATTEMPTS, SHRINK, MIN_EDGE;
 var init_image_resize = __esm({
   "src/tools/image-resize.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
-    import_promises3 = require("node:fs/promises");
+    import_promises4 = require("node:fs/promises");
     import_node_os5 = require("node:os");
     import_node_path25 = require("node:path");
     init_image_limits();
@@ -16570,7 +16654,7 @@ function fitError(path, fit, limit, bytes, resizeOff) {
 async function loadImageFile(path, options = {}) {
   let info2;
   try {
-    info2 = await (0, import_promises4.stat)(path);
+    info2 = await (0, import_promises5.stat)(path);
   } catch {
     throw imageError(`Image not found: ${path}`, { reason: "missing", path });
   }
@@ -16586,7 +16670,7 @@ async function loadImageFile(path, options = {}) {
       sizeMb
     });
   }
-  const buf = await (0, import_promises4.readFile)(path);
+  const buf = await (0, import_promises5.readFile)(path);
   const mimeType = sniffImageMime(buf) ?? imageMimeFromPath(path);
   if (mimeType === void 0)
     throw imageError(`Unsupported image (PNG / JPEG / GIF / WebP): ${path}`, {
@@ -16603,11 +16687,11 @@ async function loadImageFile(path, options = {}) {
     ...fit.size ? { size: fit.size } : {}
   };
 }
-var import_promises4, import_node_path26, MAX_IMAGE_FILE_BYTES, IMAGE_EXTENSIONS, HINT_TEXT;
+var import_promises5, import_node_path26, MAX_IMAGE_FILE_BYTES, IMAGE_EXTENSIONS, HINT_TEXT;
 var init_image_file = __esm({
   "src/tools/image-file.ts"() {
     "use strict";
-    import_promises4 = require("node:fs/promises");
+    import_promises5 = require("node:fs/promises");
     import_node_path26 = require("node:path");
     init_errors();
     init_image_intern();
@@ -16654,7 +16738,7 @@ function numberLines(lines2, firstLine3) {
   return lines2.map((line2, i) => `${String(firstLine3 + i).padStart(6)}	${line2}`).join("\n");
 }
 async function readImage(abs, shown2, ctx, options) {
-  const buf = await (0, import_promises5.readFile)(abs);
+  const buf = await (0, import_promises6.readFile)(abs);
   const mimeType = sniffImageMime(buf) ?? imageMimeFromPath(abs) ?? "application/octet-stream";
   const size = imageSize(buf, mimeType);
   const dims = size ? `${size.width}x${size.height}, ` : "";
@@ -16685,7 +16769,7 @@ async function executeRead(input2, ctx, options = {}) {
   const shown2 = displayPath(abs, ctx.cwd);
   let info2;
   try {
-    info2 = await (0, import_promises5.stat)(abs);
+    info2 = await (0, import_promises6.stat)(abs);
   } catch {
     return error(`File not found: ${shown2}`);
   }
@@ -16698,9 +16782,9 @@ async function executeRead(input2, ctx, options = {}) {
   let totalLines;
   let selected;
   if (info2.size > (options.streamThreshold ?? STREAM_READ_THRESHOLD)) {
-    if (isBinary(readHead(abs, SNIFF_BYTES))) return error(binaryMessage(shown2));
+    if (isBinary(await readHeadAsync(abs, SNIFF_BYTES))) return error(binaryMessage(shown2));
     const want = Math.min(input2.limit ?? Infinity, DEFAULT_MAX_LINES + 1);
-    const win = readLineWindow(
+    const win = await readLineWindowAsync(
       abs,
       badOffset ? 1 : offset,
       badOffset || badLimit ? 0 : want,
@@ -16709,7 +16793,7 @@ async function executeRead(input2, ctx, options = {}) {
     totalLines = win.totalLines;
     selected = win.lines;
   } else {
-    const buf = await (0, import_promises5.readFile)(abs);
+    const buf = await (0, import_promises6.readFile)(abs);
     if (isBinary(buf)) return error(binaryMessage(shown2));
     const { text } = splitBom(buf.toString("utf8"));
     const normalized = normalizeToLF(text);
@@ -16770,11 +16854,11 @@ function createReadTool(options = {}) {
     execute: (input2, ctx) => executeRead(input2, ctx, options)
   };
 }
-var import_promises5, SNIFF_BYTES, binaryMessage;
+var import_promises6, SNIFF_BYTES, binaryMessage;
 var init_read = __esm({
   "src/tools/read.ts"() {
     "use strict";
-    import_promises5 = require("node:fs/promises");
+    import_promises6 = require("node:fs/promises");
     init_image_intern();
     init_paths2();
     init_truncate();
@@ -16943,7 +17027,7 @@ async function executeEdit(input2, ctx) {
   const shown2 = displayPath(abs, ctx.cwd);
   return withFileMutex(abs, async () => {
     try {
-      const info2 = await (0, import_promises6.stat)(abs);
+      const info2 = await (0, import_promises7.stat)(abs);
       if (!info2.isFile()) return { content: `${shown2} is not a regular file`, isError: true };
     } catch {
       return { content: `File not found: ${shown2}`, isError: true };
@@ -16951,7 +17035,7 @@ async function executeEdit(input2, ctx) {
     if (!ctx.readFiles.has(abs)) {
       return { content: `Read ${shown2} with the read tool before editing it.`, isError: true };
     }
-    const raw = await (0, import_promises6.readFile)(abs, "utf8");
+    const raw = await (0, import_promises7.readFile)(abs, "utf8");
     const { bom, text } = splitBom(raw);
     const ending = detectLineEnding(text);
     const content = normalizeToLF(text);
@@ -16964,7 +17048,7 @@ async function executeEdit(input2, ctx) {
     }
     const output = bom + restoreLineEndings(plan2.result, ending);
     await beforeWrite(ctx, abs);
-    await (0, import_promises6.writeFile)(abs, output, "utf8");
+    await (0, import_promises7.writeFile)(abs, output, "utf8");
     ctx.checkpoint?.afterWrite(abs, output);
     const details = {
       path: abs,
@@ -17014,11 +17098,11 @@ function createEditTool() {
     execute: executeEdit
   };
 }
-var import_promises6, EditError;
+var import_promises7, EditError;
 var init_edit = __esm({
   "src/tools/edit.ts"() {
     "use strict";
-    import_promises6 = require("node:fs/promises");
+    import_promises7 = require("node:fs/promises");
     init_types8();
     init_paths2();
     init_file_mutex();
@@ -17031,7 +17115,7 @@ var init_edit = __esm({
 // src/tools/write.ts
 async function exists2(path) {
   try {
-    const info2 = await (0, import_promises7.stat)(path);
+    const info2 = await (0, import_promises8.stat)(path);
     return info2.isDirectory() ? "dir" : "file";
   } catch {
     return false;
@@ -17072,12 +17156,12 @@ async function executeWrite(input2, ctx) {
           isError: true
         };
       }
-      original = await (0, import_promises7.readFile)(abs, "utf8");
+      original = await (0, import_promises8.readFile)(abs, "utf8");
       output = conformToOriginal(original, input2.content);
     }
     await beforeWrite(ctx, abs);
-    await (0, import_promises7.mkdir)((0, import_node_path27.dirname)(abs), { recursive: true });
-    await (0, import_promises7.writeFile)(abs, output, "utf8");
+    await (0, import_promises8.mkdir)((0, import_node_path27.dirname)(abs), { recursive: true });
+    await (0, import_promises8.writeFile)(abs, output, "utf8");
     ctx.checkpoint?.afterWrite(abs, output);
     ctx.markRead(abs);
     const details = {
@@ -17113,11 +17197,11 @@ function createWriteTool() {
     execute: executeWrite
   };
 }
-var import_promises7, import_node_path27;
+var import_promises8, import_node_path27;
 var init_write = __esm({
   "src/tools/write.ts"() {
     "use strict";
-    import_promises7 = require("node:fs/promises");
+    import_promises8 = require("node:fs/promises");
     import_node_path27 = require("node:path");
     init_paths2();
     init_file_mutex();
@@ -17148,7 +17232,7 @@ function gitBashCandidates(env) {
 function resolveShell(deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
-  const exists5 = deps.exists ?? import_node_fs23.existsSync;
+  const exists5 = deps.exists ?? import_node_fs22.existsSync;
   const custom = env["AMA_SHELL"]?.trim();
   if (custom) return { shell: custom, kind: shellKindOf(custom) };
   if (platform === "win32") {
@@ -17188,11 +17272,11 @@ function buildToolEnv(base4, info2) {
   set("AMA_DEPTH", String(info2.depth));
   return env;
 }
-var import_node_fs23, POWERSHELL_ARGS, INJECTED_ENV_VARS;
+var import_node_fs22, POWERSHELL_ARGS, INJECTED_ENV_VARS;
 var init_shell = __esm({
   "src/tools/shell.ts"() {
     "use strict";
-    import_node_fs23 = require("node:fs");
+    import_node_fs22 = require("node:fs");
     POWERSHELL_ARGS = ["-NoProfile", "-NonInteractive", "-Command"];
     INJECTED_ENV_VARS = [
       "AMA_SESSION_ID",
@@ -17307,11 +17391,11 @@ var init_process_tree = __esm({
 function sanitizeOutput(text) {
   return text.replace(/\r\n/g, "\n").replace(ANSI, "").replace(/\r/g, "\n").replace(CONTROL, "");
 }
-var import_node_fs24, import_node_path28, import_node_string_decoder2, ANSI, CONTROL, OutputAccumulator;
+var import_node_fs23, import_node_path28, import_node_string_decoder2, ANSI, CONTROL, OutputAccumulator;
 var init_output_accumulator = __esm({
   "src/tools/output-accumulator.ts"() {
     "use strict";
-    import_node_fs24 = require("node:fs");
+    import_node_fs23 = require("node:fs");
     import_node_path28 = require("node:path");
     import_node_string_decoder2 = require("node:string_decoder");
     init_truncate();
@@ -17353,7 +17437,7 @@ var init_output_accumulator = __esm({
           this.tailText = sliceTailBytes(this.tailText, this.maxBytes * 2);
         }
         if (this.spilledTo !== void 0) {
-          (0, import_node_fs24.appendFileSync)(this.spilledTo, text);
+          (0, import_node_fs23.appendFileSync)(this.spilledTo, text);
           return;
         }
         this.chunks.push(text);
@@ -17362,8 +17446,8 @@ var init_output_accumulator = __esm({
       }
       spill() {
         const target = this.options.spillPath();
-        (0, import_node_fs24.mkdirSync)((0, import_node_path28.dirname)(target), { recursive: true });
-        (0, import_node_fs24.writeFileSync)(target, this.chunks.join(""));
+        (0, import_node_fs23.mkdirSync)((0, import_node_path28.dirname)(target), { recursive: true });
+        (0, import_node_fs23.writeFileSync)(target, this.chunks.join(""));
         this.spilledTo = target;
         this.chunks = [];
         this.memoryBytes = 0;
@@ -17421,11 +17505,11 @@ async function disposeSessionJobs(sessionId) {
   registry2.delete(sessionId);
   await jobs.disposeAll();
 }
-var import_node_fs25, import_node_path29, BackgroundJobs, registry2;
+var import_node_fs24, import_node_path29, BackgroundJobs, registry2;
 var init_background_jobs = __esm({
   "src/tools/background-jobs.ts"() {
     "use strict";
-    import_node_fs25 = require("node:fs");
+    import_node_fs24 = require("node:fs");
     import_node_path29 = require("node:path");
     init_process_tree();
     init_truncate();
@@ -17434,13 +17518,13 @@ var init_background_jobs = __esm({
       listeners = /* @__PURE__ */ new Set();
       seq = 0;
       start(command3, options) {
-        (0, import_node_fs25.mkdirSync)((0, import_node_path29.dirname)(options.outputPath), { recursive: true });
-        const fd = (0, import_node_fs25.openSync)(options.outputPath, "a");
+        (0, import_node_fs24.mkdirSync)((0, import_node_path29.dirname)(options.outputPath), { recursive: true });
+        const fd = (0, import_node_fs24.openSync)(options.outputPath, "a");
         let child;
         try {
           child = options.spawn(fd);
         } finally {
-          (0, import_node_fs25.closeSync)(fd);
+          (0, import_node_fs24.closeSync)(fd);
         }
         const id = `bg${++this.seq}`;
         const job = {
@@ -17521,8 +17605,8 @@ var init_background_jobs = __esm({
         if (entry === void 0) return void 0;
         let text = "";
         try {
-          if ((0, import_node_fs25.statSync)(entry.job.outputPath).size > 0)
-            text = (0, import_node_fs25.readFileSync)(entry.job.outputPath, "utf8");
+          if ((0, import_node_fs24.statSync)(entry.job.outputPath).size > 0)
+            text = (0, import_node_fs24.readFileSync)(entry.job.outputPath, "utf8");
         } catch {
         }
         return { ...truncateTail(text), job: entry.job };
@@ -17568,7 +17652,7 @@ var init_background_jobs = __esm({
 });
 
 // src/sandbox/wrap.ts
-function resolveWritable(dirs, realpath4 = import_node_fs26.realpathSync) {
+function resolveWritable(dirs, realpath4 = import_node_fs25.realpathSync) {
   const out = [];
   for (const dir of dirs) {
     let real2;
@@ -17583,12 +17667,12 @@ function resolveWritable(dirs, realpath4 = import_node_fs26.realpathSync) {
 }
 function isDirectory(path) {
   try {
-    return (0, import_node_fs26.statSync)(path).isDirectory();
+    return (0, import_node_fs25.statSync)(path).isDirectory();
   } catch {
     return false;
   }
 }
-function resolveExtras(policy, missingOk, realpath4 = import_node_fs26.realpathSync, isDir4 = isDirectory) {
+function resolveExtras(policy, missingOk, realpath4 = import_node_fs25.realpathSync, isDir4 = isDirectory) {
   const readOnly = [];
   for (const path of policy.readOnly ?? []) {
     let real2;
@@ -17660,11 +17744,11 @@ function wrapCommand(status, command3, args, policy, realpath4, isDir4) {
       };
   }
 }
-var import_node_fs26, import_node_path30;
+var import_node_fs25, import_node_path30;
 var init_wrap = __esm({
   "src/sandbox/wrap.ts"() {
     "use strict";
-    import_node_fs26 = require("node:fs");
+    import_node_fs25 = require("node:fs");
     import_node_path30 = require("node:path");
     init_profile2();
   }
@@ -17827,7 +17911,7 @@ async function executeBash(input2, ctx, options = {}) {
   }
   const cwd = resolvePath(input2.cwd ?? ".", ctx.cwd);
   try {
-    if (!(await (0, import_promises8.stat)(cwd)).isDirectory())
+    if (!(await (0, import_promises9.stat)(cwd)).isDirectory())
       return fail2(`Working directory is not a directory: ${cwd}`);
   } catch {
     return fail2(`Working directory does not exist: ${cwd}`);
@@ -18077,12 +18161,12 @@ function createBashTool(options = {}) {
     execute: (input2, ctx) => executeBash(input2, ctx, options)
   };
 }
-var import_node_child_process5, import_promises8, import_node_path32, DEFAULT_BASH_TIMEOUT_MS, MAX_BASH_TIMEOUT_MS, UPDATE_THROTTLE_MS, STDIO_DRAIN_MS, DEFAULT_JOB_WAIT_MS;
+var import_node_child_process5, import_promises9, import_node_path32, DEFAULT_BASH_TIMEOUT_MS, MAX_BASH_TIMEOUT_MS, UPDATE_THROTTLE_MS, STDIO_DRAIN_MS, DEFAULT_JOB_WAIT_MS;
 var init_bash2 = __esm({
   "src/tools/bash.ts"() {
     "use strict";
     import_node_child_process5 = require("node:child_process");
-    import_promises8 = require("node:fs/promises");
+    import_promises9 = require("node:fs/promises");
     import_node_path32 = require("node:path");
     init_paths2();
     init_shell();
@@ -18109,9 +18193,9 @@ function compilePattern(input2) {
 }
 async function searchFile(abs, regex, firstOnly = false) {
   try {
-    const info2 = await (0, import_promises9.stat)(abs);
+    const info2 = await (0, import_promises10.stat)(abs);
     if (!info2.isFile() || info2.size > GREP_MAX_FILE_BYTES) return void 0;
-    const buf = await (0, import_promises9.readFile)(abs);
+    const buf = await (0, import_promises10.readFile)(abs);
     if (isBinary(buf)) return void 0;
     const lines2 = buf.toString("utf8").replace(/\r\n/g, "\n").split("\n");
     if (lines2[lines2.length - 1] === "") lines2.pop();
@@ -18172,7 +18256,7 @@ async function executeGrep(input2, ctx) {
   const root = resolvePath(input2.path ?? ".", ctx.cwd);
   let rootIsFile;
   try {
-    rootIsFile = (await (0, import_promises9.stat)(root)).isFile();
+    rootIsFile = (await (0, import_promises10.stat)(root)).isFile();
   } catch {
     return { content: `Path not found: ${displayPath(root, ctx.cwd)}`, isError: true };
   }
@@ -18277,11 +18361,11 @@ function createGrepTool() {
     execute: executeGrep
   };
 }
-var import_promises9, DEFAULT_GREP_LIMIT, GREP_MAX_FILE_BYTES, GREP_CONCURRENCY, MAX_CONTEXT;
+var import_promises10, DEFAULT_GREP_LIMIT, GREP_MAX_FILE_BYTES, GREP_CONCURRENCY, MAX_CONTEXT;
 var init_grep = __esm({
   "src/tools/grep.ts"() {
     "use strict";
-    import_promises9 = require("node:fs/promises");
+    import_promises10 = require("node:fs/promises");
     init_paths2();
     init_ignore();
     init_glob();
@@ -18298,16 +18382,16 @@ var init_grep = __esm({
 async function describe(dir, name) {
   const abs = (0, import_node_path33.join)(dir, name);
   try {
-    const info2 = await (0, import_promises10.lstat)(abs);
+    const info2 = await (0, import_promises11.lstat)(abs);
     if (info2.isSymbolicLink()) {
       let target = "?";
       try {
-        target = await (0, import_promises10.readlink)(abs);
+        target = await (0, import_promises11.readlink)(abs);
       } catch {
       }
       let pointsToDir = false;
       try {
-        pointsToDir = (await (0, import_promises10.stat)(abs)).isDirectory();
+        pointsToDir = (await (0, import_promises11.stat)(abs)).isDirectory();
       } catch {
       }
       return { name: pointsToDir ? `${name}/` : name, type: "symlink", target };
@@ -18333,9 +18417,9 @@ async function executeLs(input2, ctx) {
   const shown2 = displayPath(dir, ctx.cwd);
   let names;
   try {
-    if (!(await (0, import_promises10.stat)(dir)).isDirectory())
+    if (!(await (0, import_promises11.stat)(dir)).isDirectory())
       return { content: `${shown2} is not a directory`, isError: true };
-    names = await (0, import_promises10.readdir)(dir);
+    names = await (0, import_promises11.readdir)(dir);
   } catch {
     return { content: `Directory not found: ${shown2}`, isError: true };
   }
@@ -18370,11 +18454,11 @@ function createLsTool() {
     execute: executeLs
   };
 }
-var import_promises10, import_node_path33, DEFAULT_LS_LIMIT;
+var import_promises11, import_node_path33, DEFAULT_LS_LIMIT;
 var init_ls = __esm({
   "src/tools/ls.ts"() {
     "use strict";
-    import_promises10 = require("node:fs/promises");
+    import_promises11 = require("node:fs/promises");
     import_node_path33 = require("node:path");
     init_paths2();
     init_truncate();
@@ -18661,9 +18745,9 @@ ${tail}`, truncated: true };
 }
 function writeTaskOutput(dir, name, text) {
   try {
-    (0, import_node_fs27.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
     const file = (0, import_node_path34.join)(dir, name);
-    (0, import_node_fs27.writeFileSync)(file, text);
+    (0, import_node_fs26.writeFileSync)(file, text);
     return file;
   } catch {
     return void 0;
@@ -18700,11 +18784,11 @@ function backgroundedText(reason, afterMs) {
 function waitDetachedText(taskId) {
   return `Task ${taskId} is still running and was moved to the background by the user; do not wait again — a <task-notification> arrives when it finishes.`;
 }
-var import_node_fs27, import_node_path34, TASK_RESULT_LIMIT_BYTES, HEAD_SHARE, MAX_TURNS_NOTE, NOTIFY_HINT, TASK_NOTIFICATION_RULE;
+var import_node_fs26, import_node_path34, TASK_RESULT_LIMIT_BYTES, HEAD_SHARE, MAX_TURNS_NOTE, NOTIFY_HINT, TASK_NOTIFICATION_RULE;
 var init_result = __esm({
   "src/agents/result.ts"() {
     "use strict";
-    import_node_fs27 = require("node:fs");
+    import_node_fs26 = require("node:fs");
     import_node_path34 = require("node:path");
     TASK_RESULT_LIMIT_BYTES = 50 * 1024;
     HEAD_SHARE = 0.7;
@@ -19303,9 +19387,9 @@ function truncateResult(call, result, options, nested = false) {
   let where = "full output not saved";
   if (options.outputDir !== void 0) {
     try {
-      (0, import_node_fs28.mkdirSync)(options.outputDir, { recursive: true });
+      (0, import_node_fs27.mkdirSync)(options.outputDir, { recursive: true });
       const file = (0, import_node_path35.join)(options.outputDir, `${call.id.replace(/[^A-Za-z0-9_-]/g, "_")}.txt`);
-      (0, import_node_fs28.writeFileSync)(file, text, "utf8");
+      (0, import_node_fs27.writeFileSync)(file, text, "utf8");
       where = `full output at ${file}`;
     } catch {
     }
@@ -19520,11 +19604,11 @@ async function runSingleToolCall(call, assistant, options, signal, nested) {
   await emitEnd(call, result, emit);
   return result;
 }
-var import_node_fs28, import_node_path35, ABORTED_TOOL_TEXT, DEFAULT_MAX_TOOL_RESULT_CHARS, DEFAULT_ABORT_GRACE_MS, NESTED_MAX_RESULT_CHARS, autoDecisions, deniedCalls, batchSuffixSources;
+var import_node_fs27, import_node_path35, ABORTED_TOOL_TEXT, DEFAULT_MAX_TOOL_RESULT_CHARS, DEFAULT_ABORT_GRACE_MS, NESTED_MAX_RESULT_CHARS, autoDecisions, deniedCalls, batchSuffixSources;
 var init_tool_runner = __esm({
   "src/agent/tool-runner.ts"() {
     "use strict";
-    import_node_fs28 = require("node:fs");
+    import_node_fs27 = require("node:fs");
     import_node_path35 = require("node:path");
     init_loop_guard();
     init_schema2();
@@ -21577,9 +21661,9 @@ function materialize(candidate, outputDir) {
   if (outputDir !== void 0) {
     fullTextPath = (0, import_node_path37.join)(outputDir, `${safeFileStem(message.toolCallId)}.txt`);
     try {
-      if (!(0, import_node_fs29.existsSync)(fullTextPath)) {
-        (0, import_node_fs29.mkdirSync)(outputDir, { recursive: true });
-        (0, import_node_fs29.writeFileSync)(fullTextPath, text, "utf8");
+      if (!(0, import_node_fs28.existsSync)(fullTextPath)) {
+        (0, import_node_fs28.mkdirSync)(outputDir, { recursive: true });
+        (0, import_node_fs28.writeFileSync)(fullTextPath, text, "utf8");
       }
     } catch {
       fullTextPath = void 0;
@@ -21614,11 +21698,11 @@ function planPrune(items, options) {
   }
   return { items: plan2, savedTokens, availableTokens };
 }
-var import_node_fs29, import_node_path37, PRUNE_TRIGGER_RATIO, PRUNE_TARGET_RATIO, PRUNE_KEEP_RESULTS, PRUNE_PROTECT_TOKENS, PRUNE_PROTECT_RATIO, PRUNE_CLEAR_AT_LEAST, PRUNE_CLEAR_AT_LEAST_RATIO, PRUNE_CLEAR_AT_LEAST_CAP_RATIO, PRUNE_MIN_TOKENS, REPLACEMENT_TOKENS;
+var import_node_fs28, import_node_path37, PRUNE_TRIGGER_RATIO, PRUNE_TARGET_RATIO, PRUNE_KEEP_RESULTS, PRUNE_PROTECT_TOKENS, PRUNE_PROTECT_RATIO, PRUNE_CLEAR_AT_LEAST, PRUNE_CLEAR_AT_LEAST_RATIO, PRUNE_CLEAR_AT_LEAST_CAP_RATIO, PRUNE_MIN_TOKENS, REPLACEMENT_TOKENS;
 var init_prune_tier = __esm({
   "src/compaction/prune-tier.ts"() {
     "use strict";
-    import_node_fs29 = require("node:fs");
+    import_node_fs28 = require("node:fs");
     import_node_path37 = require("node:path");
     init_estimate();
     PRUNE_TRIGGER_RATIO = 0.7;
@@ -22075,9 +22159,9 @@ function isTaskHead(entry) {
   const data2 = entry.data;
   return data2?.context !== "fork";
 }
-function readHead2(file) {
+function readHead(file) {
   try {
-    const [header, first] = (0, import_node_fs30.readFileSync)(file, "utf8").split("\n", 2);
+    const [header, first] = (0, import_node_fs29.readFileSync)(file, "utf8").split("\n", 2);
     const parsed = JSON.parse(header ?? "{}");
     const entry = first ? JSON.parse(first) : void 0;
     return { ...parsed, task: isTaskHead(entry) };
@@ -22095,18 +22179,18 @@ function cacheKeyOf(manager) {
   let id = manager.id;
   let file = header.parentSession;
   for (let depth = 0; depth < 8 && file !== void 0; depth++) {
-    const next = readHead2(file);
+    const next = readHead(file);
     if (next.id === void 0 || next.task) break;
     id = next.id;
     file = next.parentSession;
   }
   return id;
 }
-var import_node_fs30, TASK_CUSTOM_TYPE;
+var import_node_fs29, TASK_CUSTOM_TYPE;
 var init_session_cache_key = __esm({
   "src/agent/session-cache-key.ts"() {
     "use strict";
-    import_node_fs30 = require("node:fs");
+    import_node_fs29 = require("node:fs");
     TASK_CUSTOM_TYPE = "ama.task";
   }
 });
@@ -25068,7 +25152,7 @@ function listSessionItems(dir) {
         file,
         cwd: header.cwd,
         createdAt: header.timestamp,
-        modifiedAt: (0, import_node_fs31.statSync)(file).mtime.toISOString(),
+        modifiedAt: (0, import_node_fs30.statSync)(file).mtime.toISOString(),
         messageCount
       };
       if (name !== void 0) item.name = name;
@@ -25080,11 +25164,11 @@ function listSessionItems(dir) {
   }
   return items;
 }
-var import_node_fs31, SkipFile;
+var import_node_fs30, SkipFile;
 var init_list = __esm({
   "src/session/list.ts"() {
     "use strict";
-    import_node_fs31 = require("node:fs");
+    import_node_fs30 = require("node:fs");
     init_line_reader();
     init_store();
     init_types6();
@@ -25093,6 +25177,163 @@ var init_list = __esm({
   }
 });
 
+// src/session/offload.ts
+function isImage(block) {
+  return typeof block === "object" && block !== null && block.type === "image" && typeof block.data === "string";
+}
+function contentOf(entry) {
+  if (entry.type !== "message") return void 0;
+  const content = entry.message.content;
+  return Array.isArray(content) ? content : void 0;
+}
+function hasImages(entry) {
+  return contentOf(entry)?.some(isImage) === true;
+}
+function readLineAt(file, locator) {
+  const fd = (0, import_node_fs31.openSync)(file, "r");
+  try {
+    const buf = Buffer.allocUnsafe(locator.length);
+    let read2 = 0;
+    while (read2 < locator.length) {
+      const n = (0, import_node_fs31.readSync)(fd, buf, read2, locator.length - read2, locator.offset + read2);
+      if (n === 0) throw new Error("unexpected end of file");
+      read2 += n;
+    }
+    return JSON.parse(buf.toString("utf8"));
+  } finally {
+    (0, import_node_fs31.closeSync)(fd);
+  }
+}
+function editTargets(file) {
+  const targets = /* @__PURE__ */ new Set();
+  try {
+    forEachLineSync(file, (line2) => {
+      if (lineTypeOf(line2)?.type !== "context_edit") return;
+      try {
+        const id = JSON.parse(line2.toString("utf8")).targetId;
+        if (typeof id === "string") targets.add(id);
+      } catch {
+      }
+    });
+  } catch {
+  }
+  return targets;
+}
+var import_node_fs31, placeholder, ImageOffload;
+var init_offload = __esm({
+  "src/session/offload.ts"() {
+    "use strict";
+    import_node_fs31 = require("node:fs");
+    init_image_intern();
+    init_line_reader();
+    init_projection();
+    placeholder = (block) => ({ ...block, data: "" });
+    ImageOffload = class {
+      constructor(warn2 = () => {
+      }) {
+        this.warn = warn2;
+      }
+      warn;
+      /** 含图 message 条目的行位置（只有已落盘的条目才有）。 */
+      locators = /* @__PURE__ */ new Map();
+      offloaded = /* @__PURE__ */ new Set();
+      /** 记下条目的行位置；不含图片的条目忽略。 */
+      track(entry, locator) {
+        if (hasImages(entry)) this.locators.set(entry.id, locator);
+      }
+      /** 读文件时逐行调用：记下行位置；`strip` 时就地换成占位（刚解析的对象，别处没有引用）。 */
+      load(line2, locator, strip) {
+        if (typeof line2.id !== "string" || !hasImages(line2)) return;
+        this.locators.set(line2.id, locator);
+        if (!strip) return;
+        const content = contentOf(line2);
+        content.forEach((block, i) => {
+          if (isImage(block)) content[i] = placeholder(block);
+        });
+        this.offloaded.add(line2.id);
+      }
+      isOffloaded(id) {
+        return this.offloaded.has(id);
+      }
+      /** 已卸载的条目数（测试与诊断用）。 */
+      get size() {
+        return this.offloaded.size;
+      }
+      /** 把条目里的图片换成占位；没有行位置（未落盘、不含图）或已卸载时返回 false。 */
+      offload(entry) {
+        if (entry.type !== "message" || this.offloaded.has(entry.id)) return false;
+        const content = contentOf(entry);
+        if (content === void 0 || !this.locators.has(entry.id)) return false;
+        entry.message = {
+          ...entry.message,
+          content: content.map((block) => isImage(block) ? placeholder(block) : block)
+        };
+        this.offloaded.add(entry.id);
+        return true;
+      }
+      /** 就地放回图片；读不回时返回 false（占位保留，之后不再卸载 / 回读这一条）。 */
+      hydrate(file, entry) {
+        if (!this.offloaded.has(entry.id)) return true;
+        this.offloaded.delete(entry.id);
+        const source = this.read(file, entry);
+        const content = contentOf(entry);
+        if (source === void 0 || content === void 0) return false;
+        const originals = contentOf(source) ?? [];
+        content.forEach((block, i) => {
+          const original = originals[i];
+          if (isImage(block) && block.data === "" && isImage(original)) {
+            content[i] = internImage(original);
+          }
+        });
+        return true;
+      }
+      /** 原文：已卸载的条目从文件读一份新副本（图片驻留），否则原样返回。读不回时返回占位版本。 */
+      original(file, entry) {
+        if (!this.offloaded.has(entry.id)) return entry;
+        const copy = this.read(file, entry);
+        if (copy === void 0) return entry;
+        const content = contentOf(copy) ?? [];
+        content.forEach((block, i) => {
+          if (isImage(block)) content[i] = internImage(block);
+        });
+        return copy;
+      }
+      /** 按活动分支对齐：分支上被生效编辑改写的含图条目卸载，其余已卸载的回读。 */
+      sync(file, branch, index2) {
+        const edits = collectContextEdits(branch);
+        const onBranch = /* @__PURE__ */ new Set();
+        for (const entry of branch) if (edits.has(entry.id)) onBranch.add(entry.id);
+        for (const id of [...this.offloaded]) {
+          const entry = index2.get(id);
+          if (entry !== void 0 && !onBranch.has(id)) this.hydrate(file, entry);
+        }
+        for (const id of onBranch) {
+          const entry = index2.get(id);
+          if (entry !== void 0) this.offload(entry);
+        }
+      }
+      /** 从文件读回条目（新对象）；不成功时告警、忘掉行位置并返回 undefined。 */
+      read(file, entry) {
+        const locator = this.locators.get(entry.id);
+        try {
+          if (locator === void 0) throw new Error("no line locator");
+          const line2 = readLineAt(file, locator);
+          const content = line2.id === entry.id ? contentOf(line2) : void 0;
+          if (content === void 0 || content.length !== contentOf(entry)?.length) {
+            throw new Error("line does not match the entry");
+          }
+          return line2;
+        } catch (error2) {
+          this.locators.delete(entry.id);
+          this.offloaded.delete(entry.id);
+          this.warn(`cannot read session entry ${entry.id} back from ${file}: ${String(error2)}`);
+          return void 0;
+        }
+      }
+    };
+  }
+});
+
 // src/session/manager.ts
 function newEntryId(taken) {
   for (; ; ) {
@@ -25111,6 +25352,7 @@ var init_manager = __esm({
     init_version();
     init_list();
     init_migrate();
+    init_offload();
     init_store();
     init_tree();
     init_types6();
@@ -25124,7 +25366,11 @@ var init_manager = __esm({
       storage;
       closed = false;
       now;
-      constructor(header, entries, storage, now, leafId) {
+      images;
+      warn;
+      /** 已知的会话文件字节数（新行的行首偏移）。 */
+      fileBytes = 0;
+      constructor(header, entries, storage, now, leafId, warn2, images) {
         this._header = header;
         this.id = header.id;
         this.cwd = header.cwd;
@@ -25134,6 +25380,8 @@ var init_manager = __esm({
         this.leaf = leafId === void 0 || leafId !== null && !this.index.has(leafId) ? last : leafId;
         this.storage = storage;
         this.now = now;
+        this.warn = warn2;
+        this.images = images ?? new ImageOffload(warn2);
       }
       static newHeader(cwd, options, now) {
         const header = {
@@ -25154,7 +25402,14 @@ var init_manager = __esm({
       /** `dir` 是会话文件所在目录（通常是 `sessionDirForCwd(sessionsRoot, cwd)`）。 */
       static create(dir, cwd, options = {}) {
         const now = options.now ?? (() => /* @__PURE__ */ new Date());
-        return new _SessionManager(this.newHeader(cwd, options, now()), [], { kind: "lazy", dir }, now);
+        return new _SessionManager(
+          this.newHeader(cwd, options, now()),
+          [],
+          { kind: "lazy", dir },
+          now,
+          void 0,
+          options.warn
+        );
       }
       static createForCwd(sessionsRoot, cwd, options = {}) {
         return this.create(sessionDirForCwd(sessionsRoot, cwd), cwd, options);
@@ -25162,16 +25417,29 @@ var init_manager = __esm({
       static open(file, options = {}) {
         const lock = acquireLock(file);
         try {
-          const { lines: lines2 } = readSessionLines(file, { repair: true });
+          const images = new ImageOffload(options.warn);
+          const targets = editTargets(file);
+          const { lines: lines2, bytes } = readSessionLines(file, {
+            repair: true,
+            onLine: (line2, locator) => {
+              const entry = line2;
+              images.load(entry, locator, targets.has(entry.id));
+            }
+          });
           const { header, entries, leafId } = migrateSessionLines(lines2, file);
           internSessionImages(entries);
-          return new _SessionManager(
+          const manager = new _SessionManager(
             header,
             entries,
             { kind: "file", file, lock },
             options.now ?? (() => /* @__PURE__ */ new Date()),
-            leafId
+            leafId,
+            options.warn,
+            images
           );
+          manager.fileBytes = bytes ?? 0;
+          manager.syncImages();
+          return manager;
         } catch (error2) {
           lock.release();
           throw error2;
@@ -25212,10 +25480,18 @@ var init_manager = __esm({
           parentId: this.leaf,
           timestamp: this.now().toISOString()
         };
-        if (this.storage.kind === "file") appendLines(this.storage.file, [entry]);
+        if (this.storage.kind === "file") {
+          const written = appendLines(this.storage.file, [entry]);
+          this.images.track(entry, { offset: this.fileBytes, length: written - 1 });
+          this.fileBytes += written;
+        }
         this._entries.push(entry);
         this.index.set(entry.id, entry);
         this.leaf = entry.id;
+        if (entry.type === "context_edit" && this.storage.kind === "file") {
+          const target = this.index.get(entry.targetId);
+          if (target !== void 0 && this.branch().includes(target)) this.images.offload(target);
+        }
         return entry;
       }
       setLeaf(id) {
@@ -25223,7 +25499,24 @@ var init_manager = __esm({
           throw new AmaError("invalid_arguments", `no such session entry: ${id}`);
         }
         this.leaf = id;
-        if (this.storage.kind === "file") appendLines(this.storage.file, [this.leafLine()]);
+        if (this.storage.kind === "file") {
+          this.fileBytes += appendLines(this.storage.file, [this.leafLine()]);
+        }
+        this.syncImages();
+      }
+      /** 按当前活动分支卸载 / 回读图片（只对已落盘的会话）。 */
+      syncImages() {
+        if (this.storage.kind === "file")
+          this.images.sync(this.storage.file, this.branch(), this.index);
+      }
+      /** 原文条目（已卸载的从文件回读一份副本）。 */
+      original(entry) {
+        if (this.storage.kind !== "file" || !this.images.isOffloaded(entry.id)) return entry;
+        return this.images.original(this.storage.file, entry);
+      }
+      /** 已卸载图片的条目数（测试与诊断用）。 */
+      offloadedCount() {
+        return this.images.size;
       }
       leafLine() {
         return { type: "leaf", id: this.leaf, timestamp: this.now().toISOString() };
@@ -25232,10 +25525,9 @@ var init_manager = __esm({
         return pathToRoot(this.index, leafId === void 0 ? this.leaf : leafId);
       }
       getEntries(since) {
-        if (since === void 0) return { entries: [...this._entries], leafId: this.leaf };
-        const at = this._entries.findIndex((entry) => entry.id === since);
+        const at = since === void 0 ? -1 : this._entries.findIndex((entry) => entry.id === since);
         return {
-          entries: at < 0 ? [...this._entries] : this._entries.slice(at + 1),
+          entries: this._entries.slice(at + 1).map((entry) => this.original(entry)),
           leafId: this.leaf
         };
       }
@@ -25254,7 +25546,10 @@ var init_manager = __esm({
         if (!this.index.has(entryId)) {
           throw new AmaError("invalid_arguments", `no such session entry: ${entryId}`);
         }
-        const copied = this.branch(entryId).map((entry) => structuredClone(entry));
+        const copied = this.branch(entryId).map((entry) => {
+          const original = this.original(entry);
+          return original === entry ? structuredClone(entry) : original;
+        });
         if (forkOptions.head !== void 0) {
           const head = {
             ...forkOptions.head,
@@ -25273,7 +25568,7 @@ var init_manager = __esm({
         if (this.storage.kind === "memory") storage = { kind: "memory" };
         else if (this.storage.kind === "lazy") storage = { kind: "lazy", dir: this.storage.dir };
         else storage = { kind: "lazy", dir: (0, import_node_path41.dirname)(this.storage.file) };
-        const forked = new _SessionManager(header, copied, storage, this.now);
+        const forked = new _SessionManager(header, copied, storage, this.now, void 0, this.warn);
         if (parentFile !== void 0) forked.flush();
         return forked;
       }
@@ -25287,11 +25582,18 @@ var init_manager = __esm({
         if (this.storage.kind === "file") return this.storage.file;
         const file = (0, import_node_path41.join)(this.storage.dir, sessionFileName(new Date(this._header.timestamp), this.id));
         const moved = this.leaf !== (this._entries.at(-1)?.id ?? null);
-        writeNewSessionFile(file, [
+        const lengths = writeNewSessionFile(file, [
           this._header,
           ...this._entries,
           ...moved ? [this.leafLine()] : []
         ]);
+        let offset = 0;
+        lengths.forEach((length, i) => {
+          const entry = i === 0 ? void 0 : this._entries[i - 1];
+          if (entry !== void 0) this.images.track(entry, { offset, length });
+          offset += length + 1;
+        });
+        this.fileBytes = offset;
         let lock;
         try {
           lock = acquireLock(file);
@@ -25299,6 +25601,7 @@ var init_manager = __esm({
           lock = void 0;
         }
         this.storage = { kind: "file", file, lock };
+        this.syncImages();
         return file;
       }
       isPersisted() {
@@ -29168,16 +29471,16 @@ async function putBlob(dataDir, bytes, hash = hashBytes(bytes)) {
   const target = blobPath(dataDir, hash);
   if (await exists3(target)) {
     const now = /* @__PURE__ */ new Date();
-    await (0, import_promises11.utimes)(target, now, now).catch(() => void 0);
+    await (0, import_promises12.utimes)(target, now, now).catch(() => void 0);
     return hash;
   }
-  await (0, import_promises11.mkdir)((0, import_node_path47.dirname)(target), { recursive: true, mode: 448 });
+  await (0, import_promises12.mkdir)((0, import_node_path47.dirname)(target), { recursive: true, mode: 448 });
   const tmp = `${target}.tmp-${process.pid}-${tmpCounter++}`;
   try {
-    await (0, import_promises11.writeFile)(tmp, bytes, { mode: 384 });
-    await (0, import_promises11.rename)(tmp, target);
+    await (0, import_promises12.writeFile)(tmp, bytes, { mode: 384 });
+    await (0, import_promises12.rename)(tmp, target);
   } catch (error2) {
-    await (0, import_promises11.rm)(tmp, { force: true });
+    await (0, import_promises12.rm)(tmp, { force: true });
     if (await exists3(target)) return hash;
     throw error2;
   }
@@ -29185,7 +29488,7 @@ async function putBlob(dataDir, bytes, hash = hashBytes(bytes)) {
 }
 async function readBlob(dataDir, hash) {
   try {
-    return await (0, import_promises11.readFile)(blobPath(dataDir, hash));
+    return await (0, import_promises12.readFile)(blobPath(dataDir, hash));
   } catch (error2) {
     if (isNotFound(error2)) return void 0;
     throw error2;
@@ -29193,7 +29496,7 @@ async function readBlob(dataDir, hash) {
 }
 async function realParentOf(absolutePath) {
   try {
-    return await (0, import_promises11.realpath)((0, import_node_path47.dirname)(absolutePath));
+    return await (0, import_promises12.realpath)((0, import_node_path47.dirname)(absolutePath));
   } catch (error2) {
     if (isNotFound(error2)) return void 0;
     throw error2;
@@ -29204,7 +29507,7 @@ async function recordFile(absolutePath, options) {
   const max = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
   let info2;
   try {
-    info2 = await (0, import_promises11.lstat)(absolutePath);
+    info2 = await (0, import_promises12.lstat)(absolutePath);
   } catch (error2) {
     if (!isNotFound(error2)) throw error2;
     const realParentDir2 = await realParentOf(absolutePath);
@@ -29218,7 +29521,7 @@ async function recordFile(absolutePath, options) {
   const realParentDir = await realParentOf(absolutePath);
   const base4 = { mode, size: info2.size, ...realParentDir !== void 0 ? { realParentDir } : {} };
   if (info2.size > max) return { record: { blob: null, ...base4, skipped: "too_large" }, at };
-  const bytes = await (0, import_promises11.readFile)(absolutePath);
+  const bytes = await (0, import_promises12.readFile)(absolutePath);
   if (bytes.length > max)
     return { record: { blob: null, ...base4, size: bytes.length, skipped: "too_large" }, at };
   const blob = await putBlob(options.dataDir, bytes);
@@ -29245,7 +29548,7 @@ async function listBlobs(dataDir, includeTemp = false) {
   const root = blobsDir(dataDir);
   let shards;
   try {
-    shards = await (0, import_promises11.readdir)(root);
+    shards = await (0, import_promises12.readdir)(root);
   } catch (error2) {
     if (isNotFound(error2)) return [];
     throw error2;
@@ -29255,7 +29558,7 @@ async function listBlobs(dataDir, includeTemp = false) {
     if (!/^[0-9a-f]{2}$/.test(shard)) continue;
     let names;
     try {
-      names = await (0, import_promises11.readdir)((0, import_node_path47.join)(root, shard));
+      names = await (0, import_promises12.readdir)((0, import_node_path47.join)(root, shard));
     } catch {
       continue;
     }
@@ -29264,7 +29567,7 @@ async function listBlobs(dataDir, includeTemp = false) {
       if (!isBlob && !(includeTemp && name.includes(".tmp-"))) continue;
       const path = (0, import_node_path47.join)(root, shard, name);
       try {
-        const info2 = await (0, import_promises11.stat)(path);
+        const info2 = await (0, import_promises12.stat)(path);
         if (!info2.isFile()) continue;
         out.push({
           path,
@@ -29283,19 +29586,19 @@ function isNotFound(error2) {
 }
 async function exists3(path) {
   try {
-    await (0, import_promises11.stat)(path);
+    await (0, import_promises12.stat)(path);
     return true;
   } catch {
     return false;
   }
 }
-var import_node_crypto9, import_node_fs34, import_promises11, import_node_path47, FILE_HISTORY_DIR, BLOBS_DIR, DEFAULT_MAX_FILE_BYTES, SHA256_HEX, tmpCounter;
+var import_node_crypto9, import_node_fs34, import_promises12, import_node_path47, FILE_HISTORY_DIR, BLOBS_DIR, DEFAULT_MAX_FILE_BYTES, SHA256_HEX, tmpCounter;
 var init_blobs = __esm({
   "src/checkpoints/blobs.ts"() {
     "use strict";
     import_node_crypto9 = require("node:crypto");
     import_node_fs34 = require("node:fs");
-    import_promises11 = require("node:fs/promises");
+    import_promises12 = require("node:fs/promises");
     import_node_path47 = require("node:path");
     FILE_HISTORY_DIR = "file-history";
     BLOBS_DIR = "blobs";
@@ -29311,7 +29614,7 @@ function rootsFile(dataDir) {
 }
 async function readSessionRoots(dataDir) {
   try {
-    const value = JSON.parse(await (0, import_promises12.readFile)(rootsFile(dataDir), "utf8"));
+    const value = JSON.parse(await (0, import_promises13.readFile)(rootsFile(dataDir), "utf8"));
     const roots = value?.roots;
     return Array.isArray(roots) ? roots.filter((r) => typeof r === "string") : [];
   } catch {
@@ -29323,18 +29626,18 @@ async function registerSessionRoot(dataDir, sessionsRoot) {
   const roots = await readSessionRoots(dataDir);
   if (roots.includes(root)) return;
   const dir = fileHistoryDir(dataDir);
-  await (0, import_promises12.mkdir)(dir, { recursive: true, mode: 448 });
+  await (0, import_promises13.mkdir)(dir, { recursive: true, mode: 448 });
   const tmp = `${rootsFile(dataDir)}.tmp-${process.pid}`;
-  await (0, import_promises12.writeFile)(tmp, `${JSON.stringify({ roots: [...roots, root] }, null, 2)}
+  await (0, import_promises13.writeFile)(tmp, `${JSON.stringify({ roots: [...roots, root] }, null, 2)}
 `, {
     mode: 384
   });
-  await (0, import_promises12.rename)(tmp, rootsFile(dataDir));
+  await (0, import_promises13.rename)(tmp, rootsFile(dataDir));
 }
 async function* sessionFiles(dir) {
   let entries;
   try {
-    entries = await (0, import_promises12.readdir)(dir, { withFileTypes: true });
+    entries = await (0, import_promises13.readdir)(dir, { withFileTypes: true });
   } catch (error2) {
     if (isNotFound(error2)) return;
     throw error2;
@@ -29356,7 +29659,7 @@ async function collectBlobRefs(sessionRoots) {
     for await (const file of sessionFiles(abs)) {
       let text;
       try {
-        text = await (0, import_promises12.readFile)(file, "utf8");
+        text = await (0, import_promises13.readFile)(file, "utf8");
       } catch (error2) {
         if (isNotFound(error2)) continue;
         throw error2;
@@ -29389,7 +29692,7 @@ async function gcBlobs(options) {
     if (old && unreferenced) {
       if (options.dryRun !== true) {
         try {
-          await (0, import_promises12.rm)(blob.path, { force: true });
+          await (0, import_promises13.rm)(blob.path, { force: true });
         } catch {
           continue;
         }
@@ -29414,11 +29717,11 @@ function formatBytes2(bytes) {
   }
   return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unit]}`;
 }
-var import_promises12, import_node_path48, GC_MIN_AGE_MS, ROOTS_FILE, HASH_IN_LINE;
+var import_promises13, import_node_path48, GC_MIN_AGE_MS, ROOTS_FILE, HASH_IN_LINE;
 var init_gc = __esm({
   "src/checkpoints/gc.ts"() {
     "use strict";
-    import_promises12 = require("node:fs/promises");
+    import_promises13 = require("node:fs/promises");
     import_node_path48 = require("node:path");
     init_blobs();
     init_types10();
@@ -29547,7 +29850,7 @@ var init_replay = __esm({
 // src/checkpoints/git-head.ts
 async function readText2(path) {
   try {
-    return await (0, import_promises13.readFile)(path, "utf8");
+    return await (0, import_promises14.readFile)(path, "utf8");
   } catch {
     return void 0;
   }
@@ -29557,7 +29860,7 @@ async function findGitDir(cwd) {
   for (; ; ) {
     const candidate = (0, import_node_path49.join)(dir, ".git");
     try {
-      const info2 = await (0, import_promises13.stat)(candidate);
+      const info2 = await (0, import_promises14.stat)(candidate);
       if (info2.isDirectory()) return candidate;
       if (info2.isFile()) {
         const text = await readText2(candidate) ?? "";
@@ -29605,11 +29908,11 @@ async function readGitHead(cwd) {
   const branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : void 0;
   return { head: sha, ...branch !== void 0 ? { branch } : {} };
 }
-var import_promises13, import_node_path49, SHA;
+var import_promises14, import_node_path49, SHA;
 var init_git_head = __esm({
   "src/checkpoints/git-head.ts"() {
     "use strict";
-    import_promises13 = require("node:fs/promises");
+    import_promises14 = require("node:fs/promises");
     import_node_path49 = require("node:path");
     SHA = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
   }
@@ -29629,7 +29932,7 @@ function emptyCodeResult() {
 }
 async function lstatOrUndefined(path) {
   try {
-    return await (0, import_promises14.lstat)(path);
+    return await (0, import_promises15.lstat)(path);
   } catch (error2) {
     if (isNotFound(error2)) return void 0;
     throw error2;
@@ -29718,7 +30021,7 @@ async function restoreFile(abs, record3, options) {
   await checkParent(abs, record3);
   const targetBytes = record3.blob === null ? void 0 : await (options.load ?? ((r) => readBlob(options.dataDir, r.blob)))(record3);
   if (record3.blob !== null && targetBytes === void 0) throw new Skip("backup_missing");
-  const currentBytes = info2 !== void 0 && info2.size <= options.maxDiff ? await (0, import_promises14.readFile)(abs) : void 0;
+  const currentBytes = info2 !== void 0 && info2.size <= options.maxDiff ? await (0, import_promises15.readFile)(abs) : void 0;
   const counted = info2 !== void 0 && currentBytes === void 0 ? { insertions: 0, deletions: 0 } : countLineChanges(toText(currentBytes), toText(targetBytes));
   const outcome = { deleted: record3.blob === null, conflict, ...counted };
   if (options.dryRun === true) return outcome;
@@ -29742,17 +30045,17 @@ async function removeRegular(abs, before2) {
   if (now.nlink > 1) throw new Skip("hardlink");
   if (now.dev !== before2.dev || now.ino !== before2.ino)
     throw new Error(msg().session.checkpoints.replacedDuringRestore);
-  await (0, import_promises14.unlink)(abs);
+  await (0, import_promises15.unlink)(abs);
 }
 async function writeBack(abs, bytes, record3, before2) {
   if (before2 === void 0) {
     const parent = (0, import_node_path50.dirname)(abs);
-    await (0, import_promises14.mkdir)(parent, { recursive: true });
-    if (record3.realParentDir !== void 0 && await (0, import_promises14.realpath)(parent) !== record3.realParentDir) {
+    await (0, import_promises15.mkdir)(parent, { recursive: true });
+    if (record3.realParentDir !== void 0 && await (0, import_promises15.realpath)(parent) !== record3.realParentDir) {
       throw new Skip("parent_moved");
     }
     const flags2 = import_node_fs35.constants.O_WRONLY | import_node_fs35.constants.O_CREAT | import_node_fs35.constants.O_EXCL | NOFOLLOW;
-    const handle2 = await (0, import_promises14.open)(abs, flags2, record3.mode ?? 420);
+    const handle2 = await (0, import_promises15.open)(abs, flags2, record3.mode ?? 420);
     try {
       await handle2.writeFile(bytes);
       if (record3.mode !== void 0) await handle2.chmod(record3.mode);
@@ -29763,7 +30066,7 @@ async function writeBack(abs, bytes, record3, before2) {
   }
   let handle;
   try {
-    handle = await (0, import_promises14.open)(abs, import_node_fs35.constants.O_WRONLY | NOFOLLOW);
+    handle = await (0, import_promises15.open)(abs, import_node_fs35.constants.O_WRONLY | NOFOLLOW);
   } catch (error2) {
     const code = error2.code;
     if (code === "ELOOP" || code === "EMLINK") throw new Skip("symlink");
@@ -29771,7 +30074,7 @@ async function writeBack(abs, bytes, record3, before2) {
   }
   try {
     const opened = await handle.stat();
-    const now = await (0, import_promises14.lstat)(abs);
+    const now = await (0, import_promises15.lstat)(abs);
     if (!opened.isFile() || opened.dev !== before2.dev || opened.ino !== before2.ino || now.dev !== opened.dev || now.ino !== opened.ino) {
       throw new Error(msg().session.checkpoints.replacedDuringRestore);
     }
@@ -29789,12 +30092,12 @@ async function gitHintFor(cwd, target) {
   if (current3 === void 0 || current3.head === target.git.head) return void 0;
   return { recordedHead: target.git.head, currentHead: current3.head };
 }
-var import_node_fs35, import_promises14, import_node_path50, RestoreSkip, Skip, IS_WINDOWS, NOFOLLOW;
+var import_node_fs35, import_promises15, import_node_path50, RestoreSkip, Skip, IS_WINDOWS, NOFOLLOW;
 var init_restore = __esm({
   "src/checkpoints/restore.ts"() {
     "use strict";
     import_node_fs35 = require("node:fs");
-    import_promises14 = require("node:fs/promises");
+    import_promises15 = require("node:fs/promises");
     import_node_path50 = require("node:path");
     init_edit();
     init_blobs();
@@ -29845,7 +30148,7 @@ async function shadowUsage(dataDir) {
   const usage = { repos: 0, bytes: 0 };
   let names;
   try {
-    names = await (0, import_promises15.readdir)(shadowRoot(dataDir));
+    names = await (0, import_promises16.readdir)(shadowRoot(dataDir));
   } catch {
     return usage;
   }
@@ -29861,7 +30164,7 @@ async function duBytes(dir) {
   let total = 0;
   let entries;
   try {
-    entries = await (0, import_promises15.readdir)(dir, { withFileTypes: true });
+    entries = await (0, import_promises16.readdir)(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -29870,7 +30173,7 @@ async function duBytes(dir) {
     if (entry.isDirectory()) total += await duBytes(full);
     else if (entry.isFile()) {
       try {
-        total += (await (0, import_promises15.stat)(full)).size;
+        total += (await (0, import_promises16.stat)(full)).size;
       } catch {
       }
     }
@@ -29954,7 +30257,7 @@ function excludeLine(path) {
 async function removeStaleIndexes(dir) {
   let names;
   try {
-    names = await (0, import_promises15.readdir)(dir);
+    names = await (0, import_promises16.readdir)(dir);
   } catch {
     return;
   }
@@ -29963,7 +30266,7 @@ async function removeStaleIndexes(dir) {
     if (match === null) continue;
     const pid = Number(match[1]);
     if (pid === process.pid || isAlive(pid)) continue;
-    await (0, import_promises15.rm)((0, import_node_path51.join)(dir, name), { force: true }).catch(() => void 0);
+    await (0, import_promises16.rm)((0, import_node_path51.join)(dir, name), { force: true }).catch(() => void 0);
   }
 }
 function isAlive(pid) {
@@ -29976,7 +30279,7 @@ function isAlive(pid) {
 }
 async function exists4(path) {
   try {
-    await (0, import_promises15.stat)(path);
+    await (0, import_promises16.stat)(path);
     return true;
   } catch {
     return false;
@@ -29984,18 +30287,18 @@ async function exists4(path) {
 }
 async function readSmall2(path) {
   try {
-    return (await (0, import_promises15.readFile)(path, "utf8")).trim();
+    return (await (0, import_promises16.readFile)(path, "utf8")).trim();
   } catch {
     return void 0;
   }
 }
-var import_node_child_process7, import_node_crypto10, import_promises15, import_node_os10, import_node_path51, SHADOW_DIR, SHADOW_MAX_FILES, SHADOW_MAX_SNAPSHOT_MS, GIT_TIMEOUT_MS, CONFIG_VERSION, IDENTITY, ATTRIBUTES, GitMissingError, MODE_ABSENT, MODE_SYMLINK, MODE_GITLINK, MODE_EXECUTABLE, queues2, ShadowRepo;
+var import_node_child_process7, import_node_crypto10, import_promises16, import_node_os10, import_node_path51, SHADOW_DIR, SHADOW_MAX_FILES, SHADOW_MAX_SNAPSHOT_MS, GIT_TIMEOUT_MS, CONFIG_VERSION, IDENTITY, ATTRIBUTES, GitMissingError, MODE_ABSENT, MODE_SYMLINK, MODE_GITLINK, MODE_EXECUTABLE, queues2, ShadowRepo;
 var init_shadow_git = __esm({
   "src/checkpoints/shadow-git.ts"() {
     "use strict";
     import_node_child_process7 = require("node:child_process");
     import_node_crypto10 = require("node:crypto");
-    import_promises15 = require("node:fs/promises");
+    import_promises16 = require("node:fs/promises");
     import_node_os10 = require("node:os");
     import_node_path51 = require("node:path");
     init_blobs();
@@ -30079,9 +30382,9 @@ var init_shadow_git = __esm({
       }
       async doInit() {
         const hooks = (0, import_node_path51.join)(this.dir, "ama-hooks");
-        await (0, import_promises15.mkdir)(hooks, { recursive: true, mode: 448 });
-        await (0, import_promises15.writeFile)((0, import_node_path51.join)(this.dir, "ama-empty"), "", { flag: "a", mode: 384 });
-        await (0, import_promises15.writeFile)((0, import_node_path51.join)(this.dir, "ama-cwd"), `${this.cwd}
+        await (0, import_promises16.mkdir)(hooks, { recursive: true, mode: 448 });
+        await (0, import_promises16.writeFile)((0, import_node_path51.join)(this.dir, "ama-empty"), "", { flag: "a", mode: 384 });
+        await (0, import_promises16.writeFile)((0, import_node_path51.join)(this.dir, "ama-cwd"), `${this.cwd}
 `, { mode: 384 });
         const version = await readSmall2((0, import_node_path51.join)(this.dir, "ama-config-version"));
         if (version !== CONFIG_VERSION) {
@@ -30112,9 +30415,9 @@ var init_shadow_git = __esm({
             ["user.useConfigOnly", "true"]
           ];
           for (const [key, value] of config) await this.run(["config", key, value]);
-          await (0, import_promises15.mkdir)((0, import_node_path51.join)(this.dir, "info"), { recursive: true });
-          await (0, import_promises15.writeFile)((0, import_node_path51.join)(this.dir, "info", "attributes"), ATTRIBUTES);
-          await (0, import_promises15.writeFile)((0, import_node_path51.join)(this.dir, "ama-config-version"), CONFIG_VERSION);
+          await (0, import_promises16.mkdir)((0, import_node_path51.join)(this.dir, "info"), { recursive: true });
+          await (0, import_promises16.writeFile)((0, import_node_path51.join)(this.dir, "info", "attributes"), ATTRIBUTES);
+          await (0, import_promises16.writeFile)((0, import_node_path51.join)(this.dir, "ama-config-version"), CONFIG_VERSION);
         }
         await removeStaleIndexes(this.dir);
       }
@@ -30133,8 +30436,8 @@ var init_shadow_git = __esm({
         } catch (error2) {
           if (error2 instanceof GitMissingError) throw error2;
         }
-        await (0, import_promises15.mkdir)((0, import_node_path51.join)(this.dir, "info"), { recursive: true });
-        await (0, import_promises15.writeFile)((0, import_node_path51.join)(this.dir, "info", "exclude"), `${lines2.join("\n")}
+        await (0, import_promises16.mkdir)((0, import_node_path51.join)(this.dir, "info"), { recursive: true });
+        await (0, import_promises16.writeFile)((0, import_node_path51.join)(this.dir, "info", "exclude"), `${lines2.join("\n")}
 `);
       }
       /** 把工作区收进索引并写树，返回树 id（调用前已 writeExcludes）。 */
@@ -30291,7 +30594,7 @@ async function restoreFromShadow(options) {
     changes.filter((c) => isRegularMode(c.oldMode)).map((c) => c.oldOid),
     maxBytes
   );
-  const realCwd = await (0, import_promises16.realpath)(options.cwd);
+  const realCwd = await (0, import_promises17.realpath)(options.cwd);
   const latest = latestCheckpoint(options.state);
   const result = emptyCodeResult();
   const touched = [];
@@ -30342,7 +30645,7 @@ function isRegularMode(mode) {
 async function targetRecord(change, abs, realCwd, blobs) {
   const slash = change.path.lastIndexOf("/");
   const realParentDir = slash < 0 ? realCwd : (0, import_node_path52.join)(realCwd, ...change.path.slice(0, slash).split("/"));
-  const info2 = await (0, import_promises16.lstat)(abs).catch(() => void 0);
+  const info2 = await (0, import_promises17.lstat)(abs).catch(() => void 0);
   if (change.newMode === MODE_ABSENT && info2 !== void 0) {
     return void 0;
   }
@@ -30375,11 +30678,11 @@ function merge(into, from) {
   into.insertions += from.insertions;
   into.deletions += from.deletions;
 }
-var import_promises16, import_node_path52, IS_WINDOWS2;
+var import_promises17, import_node_path52, IS_WINDOWS2;
 var init_shadow_restore = __esm({
   "src/checkpoints/shadow-restore.ts"() {
     "use strict";
-    import_promises16 = require("node:fs/promises");
+    import_promises17 = require("node:fs/promises");
     import_node_path52 = require("node:path");
     init_blobs();
     init_replay();
@@ -30394,11 +30697,11 @@ var init_shadow_restore = __esm({
 function describe2(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
-var import_promises17, MTIME_GRANULARITY_MS, CheckpointTracker;
+var import_promises18, MTIME_GRANULARITY_MS, CheckpointTracker;
 var init_tracker = __esm({
   "src/checkpoints/tracker.ts"() {
     "use strict";
-    import_promises17 = require("node:fs/promises");
+    import_promises18 = require("node:fs/promises");
     init_git_head();
     init_blobs();
     init_replay();
@@ -30510,7 +30813,7 @@ var init_tracker = __esm({
         const at = this.now();
         let info2;
         try {
-          info2 = await (0, import_promises17.lstat)(absolutePath);
+          info2 = await (0, import_promises18.lstat)(absolutePath);
         } catch (error2) {
           if (!isNotFound(error2)) throw error2;
           if (prev !== void 0 && prev.record.blob === null && prev.record.skipped === void 0)
@@ -30541,7 +30844,7 @@ var init_tracker = __esm({
             return prev;
           return { record: { blob: null, ...base4, skipped: "too_large" }, at };
         }
-        const bytes = await (0, import_promises17.readFile)(absolutePath);
+        const bytes = await (0, import_promises18.readFile)(absolutePath);
         const hash = hashBytes(bytes);
         if (p !== void 0 && p.blob === hash && p.mode === mode && p.realParentDir === realParentDir) {
           return { record: p, at };
@@ -30863,7 +31166,7 @@ function formatSkillInvocation(skill, body, args) {
 
 ${args}`;
 }
-async function expandSkillCommand(text, skills, read2 = (p) => (0, import_promises18.readFile)(p, "utf8")) {
+async function expandSkillCommand(text, skills, read2 = (p) => (0, import_promises19.readFile)(p, "utf8")) {
   const cmd = parseSkillCommand(text);
   if (!cmd) return void 0;
   const skill = skills.find((s2) => s2.name === cmd.name);
@@ -30871,11 +31174,11 @@ async function expandSkillCommand(text, skills, read2 = (p) => (0, import_promis
   const body = skillBody(await read2(skill.location));
   return { kind: "expanded", text: formatSkillInvocation(skill, body, cmd.args), skill };
 }
-var import_promises18;
+var import_promises19;
 var init_expand = __esm({
   "src/skills/expand.ts"() {
     "use strict";
-    import_promises18 = require("node:fs/promises");
+    import_promises19 = require("node:fs/promises");
     init_frontmatter2();
     init_index_prompt();
   }
@@ -30901,8 +31204,8 @@ async function discoverPromptTemplates(sources, options) {
   for (const source of sources) {
     let names;
     try {
-      if (!(await (0, import_promises19.stat)(source.dir)).isDirectory()) continue;
-      names = await (0, import_promises19.readdir)(source.dir);
+      if (!(await (0, import_promises20.stat)(source.dir)).isDirectory()) continue;
+      names = await (0, import_promises20.readdir)(source.dir);
     } catch {
       continue;
     }
@@ -30924,8 +31227,8 @@ async function discoverPromptTemplates(sources, options) {
       }
       let text;
       try {
-        if (!(await (0, import_promises19.stat)(path)).isFile()) continue;
-        text = await (0, import_promises19.readFile)(path, "utf8");
+        if (!(await (0, import_promises20.stat)(path)).isFile()) continue;
+        text = await (0, import_promises20.readFile)(path, "utf8");
       } catch {
         continue;
       }
@@ -31012,7 +31315,7 @@ function parsePromptCommand(text) {
   const rawArgs = (m[2] ?? "").trim();
   return { name: m[1], args: parseCommandArgs(rawArgs), rawArgs };
 }
-async function expandPromptCommand(text, templates, read2 = (p) => (0, import_promises19.readFile)(p, "utf8")) {
+async function expandPromptCommand(text, templates, read2 = (p) => (0, import_promises20.readFile)(p, "utf8")) {
   const cmd = parsePromptCommand(text);
   if (!cmd) return void 0;
   const template2 = templates.find((t) => t.name === cmd.name);
@@ -31020,11 +31323,11 @@ async function expandPromptCommand(text, templates, read2 = (p) => (0, import_pr
   const body = parseFrontmatter(await read2(template2.path)).body.replace(/^\n+/, "");
   return { text: expandTemplate(body, cmd.args), template: template2 };
 }
-var import_promises19, import_node_path53, TEMPLATE_NAME_RE, PLACEHOLDER;
+var import_promises20, import_node_path53, TEMPLATE_NAME_RE, PLACEHOLDER;
 var init_templates = __esm({
   "src/skills/templates.ts"() {
     "use strict";
-    import_promises19 = require("node:fs/promises");
+    import_promises20 = require("node:fs/promises");
     import_node_path53 = require("node:path");
     init_frontmatter2();
     TEMPLATE_NAME_RE = /^[a-z0-9][a-z0-9_-]*$/i;
@@ -31256,8 +31559,8 @@ function candidates(items) {
   }
   return out;
 }
-function budgetReplacement(content, placeholder = IMAGE_OMITTED_FOR_BUDGET) {
-  return content.map((block) => block.type === "text" ? block.text : placeholder).filter((text) => text !== "").join("\n");
+function budgetReplacement(content, placeholder2 = IMAGE_OMITTED_FOR_BUDGET) {
+  return content.map((block) => block.type === "text" ? block.text : placeholder2).filter((text) => text !== "").join("\n");
 }
 function base64ImageSize(block) {
   const cached = sizeCache.get(block);
@@ -31272,10 +31575,10 @@ function planImageBudget(items, budgetBytes, options = {}) {
   const all = candidates(items);
   const plan2 = [];
   const drop = (c, cause) => {
-    const placeholder = cause === "per_image" ? IMAGE_OMITTED_TOO_LARGE : IMAGE_OMITTED_FOR_BUDGET;
+    const placeholder2 = cause === "per_image" ? IMAGE_OMITTED_TOO_LARGE : IMAGE_OMITTED_FOR_BUDGET;
     plan2.push({
       targetId: c.targetId,
-      replacement: budgetReplacement(c.content, placeholder),
+      replacement: budgetReplacement(c.content, placeholder2),
       cause,
       images: c.images.length,
       bytes: c.bytes
@@ -31809,7 +32112,7 @@ var init_done_markers = __esm({
 function extractProposedPlan(text) {
   const lines2 = text.split(/\r?\n/);
   let fence2;
-  let open2;
+  let open3;
   let last;
   for (const [i, line2] of lines2.entries()) {
     const marker = FENCE.exec(line2)?.[1];
@@ -31820,10 +32123,10 @@ function extractProposedPlan(text) {
     }
     if (fence2 !== void 0) continue;
     const trimmed = line2.trim();
-    if (trimmed === PLAN_OPEN_TAG) open2 = i;
-    else if (trimmed === PLAN_CLOSE_TAG && open2 !== void 0) {
-      last = { from: open2 + 1, to: i };
-      open2 = void 0;
+    if (trimmed === PLAN_OPEN_TAG) open3 = i;
+    else if (trimmed === PLAN_CLOSE_TAG && open3 !== void 0) {
+      last = { from: open3 + 1, to: i };
+      open3 = void 0;
     }
   }
   if (last === void 0) return void 0;
@@ -37196,7 +37499,7 @@ function permissionModes(currentModeId) {
     }))
   };
 }
-function contentOf(content) {
+function contentOf2(content) {
   if (typeof content === "string") return content === "" ? [] : [{ type: "text", text: content }];
   const out = [];
   for (const block of content) {
@@ -37418,7 +37721,7 @@ var init_acp_events = __esm({
         for (const message of messages) {
           if (!("role" in message)) continue;
           if (message.role === "user") {
-            for (const block of contentOf(message.content))
+            for (const block of contentOf2(message.content))
               this.emit({ sessionUpdate: "user_message_chunk", content: block });
           } else if (message.role === "assistant") {
             for (const block of message.content) {
@@ -37825,10 +38128,11 @@ function pageSessions(items, cursor, pageSize = LIST_PAGE_SIZE) {
   const last = all[start + pageSize - 1];
   return start + pageSize < all.length && last !== void 0 ? { sessions, nextCursor: encodeCursor(last.updatedAt, last.sessionId) } : { sessions };
 }
-async function promptWhenIdle(session, job) {
+async function promptWhenIdle(session, job, onStart) {
   for (; ; ) {
     await session.waitForIdle();
     if (job.cancelRequested) return;
+    onStart?.();
     try {
       await session.prompt(job.text, job.images.length > 0 ? { images: job.images } : {});
       return;
@@ -37837,10 +38141,36 @@ async function promptWhenIdle(session, job) {
     }
   }
 }
-var LIST_PAGE_SIZE, TITLE_LIMIT, ZERO_USAGE2, PromptQueue;
+async function idleNow(session) {
+  return await Promise.race([session.waitForIdle(), Promise.resolve(BUSY)]) !== BUSY;
+}
+async function quiesce(session, control, rounds = 50) {
+  for (const task of control?.list() ?? [])
+    if (task.status === "running") await control?.stop(task.taskId).catch(() => void 0);
+  for (let i = 0; i < rounds; i++) {
+    await session.abort();
+    await new Promise((resolve41) => setImmediate(resolve41));
+    if (await idleNow(session)) return true;
+  }
+  return false;
+}
+async function disposeQuiet(runtime, session, fallback, control, retries = 3) {
+  for (let i = 0; ; i++) {
+    try {
+      await disposeSessionAlongside(runtime, session, fallback);
+      break;
+    } catch (error2) {
+      if (i >= retries || !(error2 instanceof AmaError && error2.code === "busy")) throw error2;
+      await quiesce(session, control);
+    }
+  }
+  await session.abort();
+}
+var LIST_PAGE_SIZE, TITLE_LIMIT, ZERO_USAGE2, PromptQueue, BUSY;
 var init_acp_sessions = __esm({
   "src/modes/acp/acp-sessions.ts"() {
     "use strict";
+    init_compose_session();
     init_types7();
     init_jsonrpc();
     init_errors();
@@ -37908,6 +38238,7 @@ var init_acp_sessions = __esm({
         });
       }
     };
+    BUSY = /* @__PURE__ */ Symbol("busy");
   }
 });
 
@@ -37955,6 +38286,7 @@ var init_acp_server = __esm({
     init_compose_session();
     init_compose_store();
     init_session2();
+    init_task_control();
     init_jsonrpc();
     init_types7();
     init_modes();
@@ -38052,13 +38384,14 @@ var init_acp_server = __esm({
         if (abort)
           await this.session().abort().catch(() => void 0);
         await this.queue.settled();
-        for (const session of this.sessions()) await session.waitForIdle().catch(() => void 0);
+        for (const s2 of this.sessions())
+          if (s2 instanceof AgentSessionImpl) await quiesce(s2, taskControl(s2.state.sessionId));
         const foreground = this.session();
         for (const entry of this.pool.values()) entry.unsubscribe();
         for (const session of this.sessions()) {
           if (session === foreground || !(session instanceof AgentSessionImpl)) continue;
           if (!(foreground instanceof AgentSessionImpl)) continue;
-          await disposeSessionAlongside(this.runtime, session, foreground).catch(() => void 0);
+          await disposeQuiet(this.runtime, session, foreground).catch(() => void 0);
         }
         this.pool.clear();
         this.standby = void 0;
@@ -38194,12 +38527,9 @@ var init_acp_server = __esm({
         if (entry === void 0) return {};
         this.pool.delete(id);
         this.queue.cancelQueued(id);
-        const running = this.queue.running;
-        if (running?.sessionId === id) {
-          running.cancelRequested = true;
-          await entry.session.abort().catch(() => void 0);
-          await this.queue.settled(id);
-        }
+        if (this.queue.running?.sessionId === id) this.queue.running.cancelRequested = true;
+        await quiesce(entry.session, taskControl(id));
+        await this.queue.settled(id);
         entry.unsubscribe();
         let fallback = this.session();
         if (fallback === entry.session) {
@@ -38211,7 +38541,7 @@ var init_acp_server = __esm({
           }
         }
         if (fallback instanceof AgentSessionImpl)
-          await disposeSessionAlongside(this.runtime, entry.session, fallback);
+          await disposeQuiet(this.runtime, entry.session, fallback, taskControl(id));
         return {};
       }
       async prompt(params, signal) {
@@ -38250,15 +38580,15 @@ var init_acp_server = __esm({
         const { session } = entry;
         setForegroundSession(this.runtime, session);
         if (this.runtime.permission.mode !== entry.mode) session.setPermissionMode(entry.mode);
-        const before2 = session.getStats().tokens;
+        let before2 = session.getStats().tokens;
         let failure2;
         try {
-          await promptWhenIdle(session, job);
+          await promptWhenIdle(session, job, () => void (before2 = session.getStats().tokens));
         } catch (error2) {
           failure2 = error2;
         }
-        await this.peer.flush();
         const after = session.getStats().tokens;
+        await this.peer.flush();
         const usage = {
           inputTokens: after.input - before2.input,
           outputTokens: after.output - before2.output,
@@ -38668,7 +38998,7 @@ async function bootstrap(argsIn, deps, io) {
     request = { kind: "resume", id };
   }
   const sessionRequest = request;
-  const sessionManager = await step(
+  let sessionManager = await step(
     ExitCode.Session,
     m().steps.session,
     () => deps.sessions.open(sessionRequest, { sessionDir: paths.sessionDir, cwd: paths.cwd })
@@ -38893,6 +39223,8 @@ async function bootstrap(argsIn, deps, io) {
       uiBroker: () => uiBroker,
       onSessionReplaced: (next) => {
         session = next;
+        sessionManager = next.manager ?? sessionManager;
+        assembly.sessionManager = sessionManager;
       },
       sessionStartContext: () => sessionStartContext,
       unattended,
@@ -38922,7 +39254,7 @@ async function bootstrap(argsIn, deps, io) {
         await events.emit("session_shutdown", {});
         await hooks.run("SessionEnd", { reason }).catch(() => void 0);
         await disposeHost(host, (e) => warn2(m().hostDisposeFailed(String(e))));
-        await (session ?? active).dispose();
+        await session?.dispose();
       })();
       return disposed2;
     };
@@ -38955,8 +39287,13 @@ async function bootstrap(argsIn, deps, io) {
       providers,
       model,
       thinkingLevel,
-      sessionManager,
-      session: active,
+      // [#165] 跟随当前会话（ACP 关掉启动会话后它可被回收）
+      get sessionManager() {
+        return sessionManager;
+      },
+      get session() {
+        return session;
+      },
       hooks,
       host,
       permission,
@@ -43445,18 +43782,18 @@ async function confirmContinue(options = {}) {
     });
     return index2 === 0;
   }
-  const rl = (0, import_promises20.createInterface)({ input: input2, output: options.output ?? process.stderr });
+  const rl = (0, import_promises21.createInterface)({ input: input2, output: options.output ?? process.stderr });
   try {
     return /^y(es)?$/i.test((await rl.question(m.textQuestion(question))).trim());
   } finally {
     rl.close();
   }
 }
-var import_promises20, HIDE_CURSOR2, SHOW_CURSOR2;
+var import_promises21, HIDE_CURSOR2, SHOW_CURSOR2;
 var init_choice_prompt = __esm({
   "src/cli/choice-prompt.ts"() {
     "use strict";
-    import_promises20 = require("node:readline/promises");
+    import_promises21 = require("node:readline/promises");
     init_tui2();
     init_i18n();
     HIDE_CURSOR2 = "\x1B[?25l";
@@ -44312,7 +44649,7 @@ ${error2.message}`)?.[0].toLowerCase();
 }
 function stripInto(value, removed) {
   if (Array.isArray(value)) return value.map((item) => stripInto(item, removed));
-  if (typeof value !== "object" || value === null) return value;
+  if (typeof value !== "object" || value === null || value instanceof LargeString) return value;
   const out = {};
   for (const [key, inner] of Object.entries(value)) {
     if (key === "cache_control") removed.count++;
@@ -44351,6 +44688,7 @@ var init_cache_params = __esm({
   "src/ai/apis/cache-params.ts"() {
     "use strict";
     init_http();
+    init_json_body();
     init_i18n();
     DEFAULT_BASE_URLS = {
       "anthropic-messages": "https://api.anthropic.com",
@@ -44433,7 +44771,11 @@ function convertBlocks(content) {
     } else {
       blocks.push({
         type: "image",
-        source: { type: "base64", media_type: block.mimeType, data: block.data }
+        source: {
+          type: "base64",
+          media_type: block.mimeType,
+          data: largeString("", block, block.data)
+        }
       });
     }
   }
@@ -44607,6 +44949,7 @@ var init_anthropic_request = __esm({
   "src/ai/apis/anthropic-request.ts"() {
     "use strict";
     init_context();
+    init_json_body();
     init_thinking();
     init_anthropic_compat();
     init_cache_params();
@@ -44656,7 +44999,7 @@ function validSignature(signature2) {
   return signature2 !== void 0 && signature2.length > 0 && signature2.length % 4 === 0 && BASE64.test(signature2);
 }
 function inlineData(block) {
-  return { inlineData: { mimeType: block.mimeType, data: block.data } };
+  return { inlineData: { mimeType: block.mimeType, data: largeString("", block, block.data) } };
 }
 function convertUser2(message) {
   if (typeof message.content === "string") {
@@ -44827,6 +45170,7 @@ var init_google_request = __esm({
   "src/ai/apis/google-request.ts"() {
     "use strict";
     init_context();
+    init_json_body();
     init_thinking();
     GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
     GOOGLE_COMPAT_KEYS = [
@@ -45274,7 +45618,8 @@ var init_chatgpt_backend = __esm({
 
 // src/ai/apis/openai-request.ts
 function imagePart(block) {
-  return { type: "image_url", image_url: { url: `data:${block.mimeType};base64,${block.data}` } };
+  const url = largeString(`data:${block.mimeType};base64,`, block, block.data);
+  return { type: "image_url", image_url: { url } };
 }
 function convertUser3(message) {
   if (typeof message.content === "string") {
@@ -45325,17 +45670,17 @@ function convertToolResults(model, results, compat) {
   for (const result of results) {
     const text = contentText2(result.content);
     const blocks = typeof result.content === "string" ? [] : result.content;
-    const hasImages = blocks.some((b) => b.type === "image");
+    const hasImages2 = blocks.some((b) => b.type === "image");
     const message = {
       role: "tool",
       tool_call_id: normalizeCallId(model, result.toolCallId),
       content: sanitizeText(
-        text.length > 0 ? text : hasImages ? "(see attached image)" : "(no output)"
+        text.length > 0 ? text : hasImages2 ? "(see attached image)" : "(no output)"
       )
     };
     if (compat.requiresToolResultName) message["name"] = result.toolName;
     messages.push(message);
-    if (hasImages && model.input.includes("image")) {
+    if (hasImages2 && model.input.includes("image")) {
       for (const block of blocks) if (block.type === "image") images.push(imagePart(block));
     }
   }
@@ -45527,6 +45872,7 @@ var init_openai_request = __esm({
     init_thinking();
     init_anthropic_request();
     init_cache_params();
+    init_json_body();
     init_openai_compat();
     REASONING_FIELDS = ["reasoning_content", "reasoning", "reasoning_text"];
     ASSISTANT_BRIDGE_TEXT = "Tool results received.";
@@ -45581,7 +45927,7 @@ function imagePart2(block) {
   return {
     type: "input_image",
     detail: "auto",
-    image_url: `data:${block.mimeType};base64,${block.data}`
+    image_url: largeString(`data:${block.mimeType};base64,`, block, block.data)
   };
 }
 function convertUser4(message) {
@@ -45726,6 +46072,7 @@ var init_openai_responses_request = __esm({
   "src/ai/apis/openai-responses-request.ts"() {
     "use strict";
     init_context();
+    init_json_body();
     init_thinking();
     init_cache_params();
     init_chatgpt_backend();
@@ -47647,8 +47994,8 @@ var init_registry2 = __esm({
             const id = trimmed.slice(slash + 1);
             const model = provider.models.find((m) => m.id === id);
             if (model) return { ok: true, model, provider };
-            const open2 = this.relayed.has(provider.id) || this.openTables.has(provider.id);
-            const relayed = provider.models.length === 0 || open2;
+            const open3 = this.relayed.has(provider.id) || this.openTables.has(provider.id);
+            const relayed = provider.models.length === 0 || open3;
             if (synthesize && relayed && id.length > 0) {
               const known = provider.channels?.some((c) => c.name === channel) ? channel : void 0;
               const synthesized = this.synthesize(provider, id, known);
@@ -48253,7 +48600,7 @@ function attempts(platform, file, env) {
 }
 async function isPng(file) {
   try {
-    return sniffImageMime(await (0, import_promises21.readFile)(file)) === "image/png";
+    return sniffImageMime(await (0, import_promises22.readFile)(file)) === "image/png";
   } catch {
     return false;
   }
@@ -48263,7 +48610,7 @@ async function readClipboardImage(dataDir, deps = {}) {
   const env = deps.env ?? process.env;
   const run7 = deps.run ?? runCommand;
   const dir = (0, import_node_path78.join)(dataDir, CLIPBOARD_DIR);
-  await (0, import_promises21.mkdir)(dir, { recursive: true });
+  await (0, import_promises22.mkdir)(dir, { recursive: true });
   const stamp = new Date((deps.now ?? Date.now)()).toISOString().replace(/[:.]/g, "-");
   let file = (0, import_node_path78.join)(dir, `${stamp}.png`);
   for (let n = 1; (0, import_node_fs60.existsSync)(file); n++) file = (0, import_node_path78.join)(dir, `${stamp}-${n}.png`);
@@ -48276,19 +48623,19 @@ async function readClipboardImage(dataDir, deps = {}) {
     if (result.code !== 0) continue;
     if (attempt.via === "stdout") {
       if (sniffImageMime(result.stdout) !== "image/png") continue;
-      await (0, import_promises21.writeFile)(file, result.stdout);
+      await (0, import_promises22.writeFile)(file, result.stdout);
     }
     if (await isPng(file)) return { ok: true, path: file, tool: attempt.tool };
-    await (0, import_promises21.rm)(file, { force: true });
+    await (0, import_promises22.rm)(file, { force: true });
   }
-  await (0, import_promises21.rm)(file, { force: true });
+  await (0, import_promises22.rm)(file, { force: true });
   return { ok: false, reason: anyTool ? "no_image" : "no_tool" };
 }
 async function gcClipboardImages(dataDir, options = {}) {
   const dir = (0, import_node_path78.join)(dataDir, CLIPBOARD_DIR);
   let names;
   try {
-    names = await (0, import_promises21.readdir)(dir);
+    names = await (0, import_promises22.readdir)(dir);
   } catch {
     return [];
   }
@@ -48297,21 +48644,21 @@ async function gcClipboardImages(dataDir, options = {}) {
   for (const name of names) {
     const file = (0, import_node_path78.join)(dir, name);
     try {
-      const info2 = await (0, import_promises21.stat)(file);
+      const info2 = await (0, import_promises22.stat)(file);
       if (!info2.isFile() || info2.mtimeMs >= cutoff) continue;
-      if (options.dryRun !== true) await (0, import_promises21.rm)(file, { force: true });
+      if (options.dryRun !== true) await (0, import_promises22.rm)(file, { force: true });
       removed.push(file);
     } catch {
     }
   }
   return removed;
 }
-var import_node_fs60, import_promises21, import_node_path78, CLIPBOARD_DIR, CLIPBOARD_MAX_AGE_DAYS, OSASCRIPT, POWERSHELL;
+var import_node_fs60, import_promises22, import_node_path78, CLIPBOARD_DIR, CLIPBOARD_MAX_AGE_DAYS, OSASCRIPT, POWERSHELL;
 var init_clipboard_image = __esm({
   "src/tools/clipboard-image.ts"() {
     "use strict";
     import_node_fs60 = require("node:fs");
-    import_promises21 = require("node:fs/promises");
+    import_promises22 = require("node:fs/promises");
     import_node_path78 = require("node:path");
     init_image_file();
     init_image_resize();
@@ -50456,8 +50803,8 @@ function barText(row3, width2, theme) {
     const color = colors[rank3];
     body += color === void 0 || plain ? ch2 : theme.fg(color, ch2);
   }
-  const [open2, close] = plain ? ["[", "]"] : ["▕", "▏"];
-  return theme.fg("border", open2) + body + theme.fg("border", close);
+  const [open3, close] = plain ? ["[", "]"] : ["▕", "▏"];
+  return theme.fg("border", open3) + body + theme.fg("border", close);
 }
 function labelPart(row3, ctx) {
   const g = ctx.theme.glyphs;
@@ -51115,11 +51462,11 @@ ${skill.body}`;
 }
 async function ensureFile(path, text) {
   try {
-    if (await (0, import_promises22.readFile)(path, "utf8") === text) return;
+    if (await (0, import_promises23.readFile)(path, "utf8") === text) return;
   } catch {
   }
-  await (0, import_promises22.mkdir)((0, import_node_path86.dirname)(path), { recursive: true });
-  await (0, import_promises22.writeFile)(path, text, "utf8");
+  await (0, import_promises23.mkdir)((0, import_node_path86.dirname)(path), { recursive: true });
+  await (0, import_promises23.writeFile)(path, text, "utf8");
 }
 async function withBuiltinSkills(skills, dataDir, builtins = BUILTIN_SKILLS) {
   const out = [...skills];
@@ -51148,11 +51495,11 @@ async function withBuiltinSkills(skills, dataDir, builtins = BUILTIN_SKILLS) {
   }
   return { skills: out, warnings };
 }
-var import_promises22, import_node_path86, BUILTIN_SKILLS_DIR, AMA_DOCS_BODY, BUILTIN_SKILLS;
+var import_promises23, import_node_path86, BUILTIN_SKILLS_DIR, AMA_DOCS_BODY, BUILTIN_SKILLS;
 var init_builtin3 = __esm({
   "src/skills/builtin.ts"() {
     "use strict";
-    import_promises22 = require("node:fs/promises");
+    import_promises23 = require("node:fs/promises");
     import_node_path86 = require("node:path");
     BUILTIN_SKILLS_DIR = "builtin";
     AMA_DOCS_BODY = `# ama quick reference
@@ -51263,7 +51610,7 @@ function parseSkill(text, location, scope) {
 }
 async function isDir3(path) {
   try {
-    return (await (0, import_promises23.stat)(path)).isDirectory();
+    return (await (0, import_promises24.stat)(path)).isDirectory();
   } catch {
     return false;
   }
@@ -51274,7 +51621,7 @@ async function findSkillFiles(dir, depth = 0) {
   if ((0, import_node_fs65.existsSync)(own)) return [own];
   let names;
   try {
-    names = await (0, import_promises23.readdir)(dir);
+    names = await (0, import_promises24.readdir)(dir);
   } catch {
     return [];
   }
@@ -51302,7 +51649,7 @@ async function discoverSkills(sources, options) {
     for (const file of await findSkillFiles(source.dir)) {
       let text;
       try {
-        text = await (0, import_promises23.readFile)(file, "utf8");
+        text = await (0, import_promises24.readFile)(file, "utf8");
       } catch (err) {
         result.warnings.push(`${file}: ${err.message}`);
         continue;
@@ -51323,12 +51670,12 @@ async function discoverSkills(sources, options) {
   }
   return result;
 }
-var import_node_fs65, import_promises23, import_node_path87, SKILL_FILE, SKILL_NAME_RE, MAX_SKILL_NAME, MAX_SKILL_DESCRIPTION, MAX_DEPTH3, SKIP_DIRS;
+var import_node_fs65, import_promises24, import_node_path87, SKILL_FILE, SKILL_NAME_RE, MAX_SKILL_NAME, MAX_SKILL_DESCRIPTION, MAX_DEPTH3, SKIP_DIRS;
 var init_discover2 = __esm({
   "src/skills/discover.ts"() {
     "use strict";
     import_node_fs65 = require("node:fs");
-    import_promises23 = require("node:fs/promises");
+    import_promises24 = require("node:fs/promises");
     import_node_path87 = require("node:path");
     init_frontmatter2();
     SKILL_FILE = "SKILL.md";
@@ -60456,9 +60803,9 @@ function parseLeftRight(text) {
 async function hasUpstream(cwd, branch) {
   const gitDir = await findGitDir(cwd);
   if (gitDir === void 0) return false;
-  const common = (await (0, import_promises24.readFile)((0, import_node_path95.join)(gitDir, "commondir"), "utf8").catch(() => void 0))?.trim();
+  const common = (await (0, import_promises25.readFile)((0, import_node_path95.join)(gitDir, "commondir"), "utf8").catch(() => void 0))?.trim();
   const dir = common === void 0 ? gitDir : (0, import_node_path95.isAbsolute)(common) ? common : (0, import_node_path95.resolve)(gitDir, common);
-  const text = await (0, import_promises24.readFile)((0, import_node_path95.join)(dir, "config"), "utf8").catch(() => "");
+  const text = await (0, import_promises25.readFile)((0, import_node_path95.join)(dir, "config"), "utf8").catch(() => "");
   let inBranch = false;
   for (const raw of text.split("\n")) {
     const line2 = raw.trim();
@@ -60471,7 +60818,7 @@ async function hasUpstream(cwd, branch) {
   }
   return false;
 }
-async function readHead3(cwd) {
+async function readHead2(cwd) {
   const head = await readGitHead(cwd);
   if (head !== void 0) {
     return {
@@ -60481,16 +60828,16 @@ async function readHead3(cwd) {
   }
   const gitDir = await findGitDir(cwd);
   if (gitDir === void 0) return void 0;
-  const text = await (0, import_promises24.readFile)((0, import_node_path95.join)(gitDir, "HEAD"), "utf8").catch(() => void 0);
+  const text = await (0, import_promises25.readFile)((0, import_node_path95.join)(gitDir, "HEAD"), "utf8").catch(() => void 0);
   const match = /^ref:\s*refs\/heads\/(\S+)\s*$/.exec(text ?? "");
   return match?.[1] !== void 0 ? { branch: match[1] } : void 0;
 }
-var import_node_child_process18, import_promises24, import_node_path95, GIT_NUMSTAT_INTERVAL_MS, GIT_NUMSTAT_TIMEOUT_MS, sameInfo, GitInfoWatcher;
+var import_node_child_process18, import_promises25, import_node_path95, GIT_NUMSTAT_INTERVAL_MS, GIT_NUMSTAT_TIMEOUT_MS, sameInfo, GitInfoWatcher;
 var init_info = __esm({
   "src/git/info.ts"() {
     "use strict";
     import_node_child_process18 = require("node:child_process");
-    import_promises24 = require("node:fs/promises");
+    import_promises25 = require("node:fs/promises");
     import_node_path95 = require("node:path");
     init_git_head();
     GIT_NUMSTAT_INTERVAL_MS = 1e4;
@@ -60545,7 +60892,7 @@ var init_info = __esm({
         const run7 = async () => {
           do {
             this.headAgain = false;
-            const head = await readHead3(this.cwd).catch(() => void 0);
+            const head = await readHead2(this.cwd).catch(() => void 0);
             this.update(head);
           } while (this.headAgain && !this.disposed);
           this.headReading = void 0;
@@ -62644,8 +62991,8 @@ var init_run_indicator = __esm({
       get busy() {
         return this.running || this.compacting;
       }
-      setApproval(open2) {
-        this.approval = open2;
+      setApproval(open3) {
+        this.approval = open3;
         this.sync();
       }
       /** 会话切换后清零。 */
@@ -69698,9 +70045,9 @@ async function runSessionsTrace(argv, io, deps = {}) {
     });
   }
   const outFlag = split.file ?? values.get("output");
-  const open2 = flags2.has("open");
+  const open3 = flags2.has("open");
   let outPath = outFlag === void 0 ? void 0 : (0, import_node_path84.resolve)(io.cwd, expandHome(outFlag, { env: io.env }));
-  if (outPath === void 0 && open2)
+  if (outPath === void 0 && open3)
     outPath = (0, import_node_path84.join)((0, import_node_os12.tmpdir)(), `ama-trace-${read2.header.id}.${wantsJson ? "json" : "html"}`);
   if (outPath === void 0) {
     io.stdout(text);
@@ -69708,7 +70055,7 @@ async function runSessionsTrace(argv, io, deps = {}) {
   }
   (0, import_node_fs64.writeFileSync)(outPath, text, { mode: 384 });
   io.stderr(m.wrote(outPath));
-  if (open2) {
+  if (open3) {
     try {
       await (deps.open ?? spawnOpen)(openCommand(deps.platform ?? process.platform, outPath));
     } catch (error2) {