laohuang 0.9.1 → 0.9.2

package/dist/bin.js

@@ -7369,8 +7369,8 @@ var require_dist = __commonJS({
 });
 
 // src/main.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname13, join as join17 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname13, join as join20 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../packages/session/session-context/dist/conversation-history.js
@@ -7415,13 +7415,14 @@ var DefaultTokenEstimator = class {
     };
   }
   estimateMessage(message) {
+    const attachmentTokens = message.role === "user" || message.role === "tool-result" ? (message.attachments ?? []).reduce((sum, block, index) => sum + (block.type === "image" && !message.omittedImageIndexes?.includes(index) ? 85 + 170 * Math.ceil(block.ref.width / 512) * Math.ceil(block.ref.height / 512) : 32), 0) : 0;
     if (message.role === "system" && message.toolDefinitions !== void 0)
       return 0;
     if (message.role === "system" || message.role === "user") {
-      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content);
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
     }
     if (message.role === "tool-result") {
-      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content);
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
     }
     return MESSAGE_OVERHEAD + message.content.reduce((total, block) => {
       if (block.type === "text" || block.type === "reasoning") {
@@ -7489,7 +7490,7 @@ var ContextUsage = class {
   }
   /** Histories are append-only and ordered; process each committed entry once. */
   append(entry) {
-    if (entry.entryType === "compaction") {
+    if (entry.entryType === "compaction" || entry.entryType === "image_offload") {
       this.#tokens = null;
       return;
     }
@@ -7549,14 +7550,14 @@ var ConversationHistory = class _ConversationHistory {
   }
   static fromReplay(replay, journal) {
     const history = new _ConversationHistory(replay.items.filter((item) => item.kind === "entry"), journal);
-    for (const open4 of replay.openToolCalls) {
+    for (const open6 of replay.openToolCalls) {
       const entry = history.appendToolResults({
         requestId: "recovered",
         recovered: true,
         messages: [{
           role: "tool-result",
-          toolCallId: open4.toolCallId,
-          toolName: open4.toolName,
+          toolCallId: open6.toolCallId,
+          toolName: open6.toolName,
           content: JSON.stringify({
             ok: false,
             status: "interrupted",
@@ -7569,7 +7570,7 @@ var ConversationHistory = class _ConversationHistory {
         recordType: "error",
         payload: {
           type: "interrupted_tool_call",
-          toolCallId: open4.toolCallId,
+          toolCallId: open6.toolCallId,
           repairedEntryId: entry?.id ?? null
         }
       });
@@ -7661,6 +7662,12 @@ var ConversationHistory = class _ConversationHistory {
   entries() {
     return [...this.#entries];
   }
+  offloadImages(keys2) {
+    if (keys2.length === 0)
+      return;
+    this.append({ entryType: "image_offload", payload: { keys: [...keys2] } });
+    this.#journal.flush();
+  }
   get contextTokens() {
     return this.#contextUsage.tokens;
   }
@@ -7728,6 +7735,14 @@ function clampReasoningEffort(supported, requested) {
   }
   return "off";
 }
+function projectImageOffloads(message, keys2) {
+  if (message.role !== "user" && message.role !== "tool-result" || !message.attachments?.length)
+    return message;
+  const omittedImageIndexes = message.attachments.flatMap((block, index) => block.type === "image" && keys2.has(`${message.attachmentKey}:${index}`) ? [index] : []);
+  if (!omittedImageIndexes.length)
+    return message;
+  return { ...message, omittedImageIndexes };
+}
 var ModelError = class extends ModelStreamError {
   kind;
   constructor(message, options) {
@@ -7813,6 +7828,7 @@ var ModelRuntime = class {
     const maxAttempts = validateMaxAttempts(request.maxAttempts ?? 3);
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
       const adapterRequest = {
+        ...request.imageContext === void 0 ? {} : { imageContext: request.imageContext },
         provider: request.provider,
         model: request.model,
         ...request.baseUrl === void 0 ? {} : { baseUrl: request.baseUrl },
@@ -7921,7 +7937,7 @@ async function defaultSleep(delayMs, cancelToken) {
     throw new ModelStreamCancelled(cancelToken?.reason || "cancelled");
   }
   if (cancelToken === null) {
-    await new Promise((resolve14) => setTimeout(resolve14, delayMs));
+    await new Promise((resolve15) => setTimeout(resolve15, delayMs));
   }
 }
 function errorMessage(error) {
@@ -7970,8 +7986,9 @@ ${activeCompaction.payload.summary}
       }
     }
     validateToolPairs(selected);
+    const offloaded = new Set(sorted.flatMap((entry) => entry.entryType === "image_offload" ? entry.payload.keys : []));
     return {
-      messages: selected.map((item) => item.message),
+      messages: selected.map((item) => projectImageOffloads(item.message, offloaded)),
       sourceEntryIds: selected.map((item) => item.entryId),
       activeCompactionId: activeCompaction?.id ?? null
     };
@@ -8084,12 +8101,15 @@ function selectCompactionPlan(input) {
   if (retained.length === 0 && units.length > 0) {
     retained.push(units.at(-1));
   }
-  const retainedFirst = retained[0]?.entries[0]?.seq ?? Number.MAX_SAFE_INTEGER;
+  const currentTurn = input.protectedFromSeq ?? [...input.entries].reverse().find((entry) => entry.entryType === "user_message")?.seq ?? 0;
+  const hasCurrentImages = input.entries.some((entry) => entry.seq >= currentTurn && "message" in entry.payload && "attachments" in entry.payload.message && entry.payload.message.attachments?.some((block) => block.type === "image"));
+  const retainedFirst = Math.min(retained[0]?.entries[0]?.seq ?? Number.MAX_SAFE_INTEGER, hasCurrentImages ? currentTurn : Number.MAX_SAFE_INTEGER);
+  const retainedUnits = units.filter((unit) => unit.entries[0].seq >= retainedFirst);
   const summarized = units.filter((unit) => unit.entries[0].seq < retainedFirst);
   return {
     summarizedEntries: summarized.flatMap((unit) => unit.entries),
-    retainedEntries: retained.flatMap((unit) => unit.entries),
-    retainedFromSeq: retained[0]?.entries[0]?.seq ?? 1
+    retainedEntries: retainedUnits.flatMap((unit) => unit.entries),
+    retainedFromSeq: retainedUnits[0]?.entries[0]?.seq ?? 1
   };
 }
 function serializeConversation(entries) {
@@ -8111,6 +8131,10 @@ function serializeConversation(entries) {
     } else if (entry.entryType === "user_message" || entry.entryType === "skill_context" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
       lines2.push(`[${entry.payload.message.role}] ${entry.payload.message.content}`);
     }
+    if ("message" in entry.payload && "attachments" in entry.payload.message) {
+      for (const block of entry.payload.message.attachments ?? [])
+        lines2.push(`[attachment metadata only; not visual interpretation] ${JSON.stringify(block)}`);
+    }
     lines2.push("</entry>");
   }
   lines2.push("</conversation>");
@@ -8123,7 +8147,7 @@ function semanticUnits(entries) {
     const entry = entries[index];
     if (groupedDefinitions.has(entry.id))
       continue;
-    if (entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
+    if (entry.entryType === "image_offload" || entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
       continue;
     }
     if (entry.entryType === "assistant_message") {
@@ -8208,6 +8232,7 @@ var ContextGovernor = class {
   async compact(input) {
     const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
     const plan = selectCompactionPlan({
+      protectedFromSeq: input.protectedFromSeq,
       entries: input.entries,
       // A search preflight reserves the pending call/result/definition unit.
       // Keep the latest completed unit and summarize older units to make room.
@@ -8282,6 +8307,66 @@ function calculateModelBudget(input) {
   return { hardInputLimit, safetyTokens, autoTrigger, retainTokens };
 }
 
+// ../../packages/attachment/attachment/dist/errors.js
+var AttachmentError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "AttachmentError";
+    this.code = code;
+  }
+};
+
+// ../../packages/attachment/attachment/dist/types.js
+var DEFAULT_IMAGE_LIMITS = Object.freeze({
+  maxBytes: 20 * 1024 ** 2,
+  maxImages: 20,
+  maxBatchBytes: 200 * 1024 ** 2,
+  maxPixels: 64e6,
+  maxDimension: 8192
+});
+var RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function assertAttachmentContent(value) {
+  if (!value || typeof value !== "object")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment content");
+  const block = value;
+  if (block.type !== "image" && block.type !== "file")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment kind");
+  assertFileRef(block.ref);
+  if (block.type === "image") {
+    const ref = block.ref;
+    if (!["image/png", "image/jpeg", "image/webp", "image/gif"].includes(String(ref.mimeType)) || !Number.isSafeInteger(ref.width) || Number(ref.width) < 1 || !Number.isSafeInteger(ref.height) || Number(ref.height) < 1 || typeof ref.animated !== "boolean") {
+      throw new AttachmentError("INVALID_REFERENCE", "Invalid image reference");
+    }
+    if (block.view !== void 0)
+      assertImageView(block.view);
+  }
+}
+function assertFileRef(value) {
+  const ref = value;
+  if (!ref || typeof ref !== "object" || typeof ref.id !== "string" || !/^sha256:[a-f0-9]{64}$/.test(ref.id) || !Number.isSafeInteger(ref.bytes) || Number(ref.bytes) < 0 || typeof ref.name !== "string") {
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment reference");
+  }
+}
+function assertImageView(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid image view");
+  const view = value;
+  if (view.fullResolution !== void 0 && typeof view.fullResolution !== "boolean")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid fullResolution");
+  if (view.region !== void 0) {
+    const r = view.region;
+    if (!r || typeof r !== "object" || !["x", "y", "width", "height"].every((k) => Number.isSafeInteger(r[k])) || Number(r.x) < 0 || Number(r.y) < 0 || Number(r.width) < 1 || Number(r.height) < 1) {
+      throw new AttachmentError("INVALID_REFERENCE", "Invalid crop region");
+    }
+  }
+}
+
+// ../../packages/attachment/attachment/dist/attachment-store.js
+var AttachmentStore = class {
+};
+
 // ../../packages/session/session-store/dist/session-metadata.js
 function normalizeSessionTitle(input) {
   if (new RegExp("\\p{Cc}|\\u2028|\\u2029", "u").test(input)) {
@@ -8312,6 +8397,7 @@ function sessionTitleAt(items, throughSeq = Infinity) {
 
 // ../../packages/session/session-store/dist/schema.js
 var ENTRY_TYPES = /* @__PURE__ */ new Set([
+  "image_offload",
   "skill_context",
   "tool_definitions",
   "tool_catalog",
@@ -8420,7 +8506,21 @@ function parseSessionItem(value, expectedSessionId) {
     if (!ENTRY_TYPES.has(entryType)) {
       throw new SessionSchemaError("invalid session entry type");
     }
-    objectOf(input["payload"], "entry payload");
+    const entryPayload = objectOf(input["payload"], "entry payload");
+    if (entryType === "image_offload" && (!Array.isArray(entryPayload.keys) || entryPayload.keys.some((key) => typeof key !== "string"))) {
+      throw new SessionSchemaError("invalid image offload keys");
+    }
+    if (entryPayload.message !== void 0) {
+      const message = objectOf(entryPayload.message, "message");
+      if (message.attachments !== void 0) {
+        if (message.role !== "user" && message.role !== "tool-result" || !Array.isArray(message.attachments))
+          throw new SessionSchemaError("invalid message attachments");
+        for (const attachment of message.attachments)
+          assertAttachmentContent(attachment);
+        if (typeof message.attachmentKey !== "string" || !message.attachmentKey)
+          throw new SessionSchemaError("missing attachment occurrence key");
+      }
+    }
     if (entryType === "skill_context") {
       const payload = objectOf(input["payload"], "skill payload");
       const message = objectOf(payload["message"], "skill message");
@@ -8516,35 +8616,9 @@ function requirePositiveInteger(input, key) {
   return value;
 }
 
-// ../../packages/session/session-store/dist/session-paths.js
-import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, realpathSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-function canonicalProjectRoot(projectRoot) {
-  try {
-    return realpathSync.native(projectRoot);
-  } catch {
-    return resolve(projectRoot);
-  }
-}
-function projectKeyForRoot(projectRoot) {
-  const canonical = canonicalProjectRoot(projectRoot);
-  const digest = createHash2("sha256").update(canonical).digest("hex").slice(0, 12);
-  return `${sanitizePathPart(basename(canonical) || "project")}-${digest}`;
-}
-function ensureSessionDirectory(sessionsRoot, projectKey) {
-  const directory = join(sessionsRoot, projectKey);
-  mkdirSync(directory, { recursive: true, mode: 448 });
-  return directory;
-}
-function sessionPathForHeader(sessionsRoot, projectKey, createdAt, sessionId) {
-  const safeCreatedAt = createdAt.replaceAll(":", "").replaceAll(".", "");
-  return join(ensureSessionDirectory(sessionsRoot, projectKey), `${safeCreatedAt}_${sessionId}.jsonl`);
-}
-function sanitizePathPart(value) {
-  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return sanitized || "project";
-}
+// ../../packages/session/session-store/dist/attachment-references.js
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 
 // ../../packages/session/session-store/dist/session-reader.js
 import { readFileSync } from "node:fs";
@@ -8636,6 +8710,78 @@ function findOpenToolCalls(items) {
   return [...calls.values()];
 }
 
+// ../../packages/session/session-store/dist/attachment-references.js
+function attachmentReferences(entries) {
+  const result = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.entryType === "compaction" || entry.entryType === "image_offload")
+      continue;
+    if (!("message" in entry.payload) || !entry.payload.message || typeof entry.payload.message !== "object")
+      throw new Error("Incomplete session message during attachment scan");
+    const message = entry.payload.message;
+    if (!("attachments" in message))
+      continue;
+    for (const block of message.attachments ?? []) {
+      assertAttachmentContent(block);
+      result.add(block.ref.id);
+    }
+  }
+  return result;
+}
+function scanAttachmentReferences(sessionsRoot) {
+  const result = /* @__PURE__ */ new Set();
+  const visit = (directory) => {
+    for (const file of readdirSync(directory, { withFileTypes: true })) {
+      const path5 = join(directory, file.name);
+      if (file.isSymbolicLink())
+        throw new Error(`Cannot scan symbolic session path: ${path5}`);
+      if (file.isDirectory())
+        visit(path5);
+      else if (file.name.endsWith(".jsonl")) {
+        if (!lstatSync(path5).isFile())
+          throw new Error(`Invalid session file: ${path5}`);
+        const replay = readSessionFile(path5);
+        if (replay.ignoredTornTail)
+          throw new Error(`Incomplete session journal: ${path5}`);
+        for (const id of attachmentReferences(replay.items.filter((item) => item.kind === "entry")))
+          result.add(id);
+      }
+    }
+  };
+  visit(sessionsRoot);
+  return result;
+}
+
+// ../../packages/session/session-store/dist/session-paths.js
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync, realpathSync } from "node:fs";
+import { basename, join as join2, resolve } from "node:path";
+function canonicalProjectRoot(projectRoot) {
+  try {
+    return realpathSync.native(projectRoot);
+  } catch {
+    return resolve(projectRoot);
+  }
+}
+function projectKeyForRoot(projectRoot) {
+  const canonical = canonicalProjectRoot(projectRoot);
+  const digest = createHash2("sha256").update(canonical).digest("hex").slice(0, 12);
+  return `${sanitizePathPart(basename(canonical) || "project")}-${digest}`;
+}
+function ensureSessionDirectory(sessionsRoot, projectKey) {
+  const directory = join2(sessionsRoot, projectKey);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  return directory;
+}
+function sessionPathForHeader(sessionsRoot, projectKey, createdAt, sessionId) {
+  const safeCreatedAt = createdAt.replaceAll(":", "").replaceAll(".", "");
+  return join2(ensureSessionDirectory(sessionsRoot, projectKey), `${safeCreatedAt}_${sessionId}.jsonl`);
+}
+function sanitizePathPart(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "project";
+}
+
 // ../../packages/session/session-store/dist/session-journal.js
 import { closeSync, existsSync, fsyncSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -8646,6 +8792,7 @@ var SessionJournalLockError = class extends Error {
   }
 };
 var FileSessionJournal = class {
+  attachments;
   header;
   path;
   #fd;
@@ -8653,6 +8800,7 @@ var FileSessionJournal = class {
   #nextSeq;
   #closed = false;
   constructor(input) {
+    this.attachments = input.attachments;
     this.header = input.header;
     this.path = input.path;
     this.#nextSeq = input.nextSeq;
@@ -8670,7 +8818,21 @@ var FileSessionJournal = class {
       entryType: input.entryType,
       payload: input.payload
     };
-    this.writeItem(entry);
+    const message = "message" in entry.payload ? entry.payload.message : void 0;
+    const attachments = message && "attachments" in message ? message.attachments : void 0;
+    if (attachments?.length) {
+      for (const attachment of attachments)
+        assertAttachmentContent(attachment);
+      if (!this.attachments)
+        throw new Error("Attachment persistence requires an attachment store");
+      if (!("attachmentKey" in message) || !message.attachmentKey)
+        throw new Error("Attachment message requires an occurrence key");
+      this.attachments.commit(attachments.map((block) => block.ref), () => {
+        this.writeItem(entry);
+        this.flush();
+      });
+    } else
+      this.writeItem(entry);
     if (entry.entryType === "compaction") {
       this.flush();
     }
@@ -8736,14 +8898,15 @@ function createSessionJournal(options) {
     if (!existing) {
       writeLine(fd, header);
       fsyncSync(fd);
-      return new FileSessionJournal({ header, path: path5, nextSeq: 1, fd });
+      return new FileSessionJournal({ header, path: path5, nextSeq: 1, fd, attachments: options.attachments });
     }
     const replay = readSessionFile(path5);
     return new FileSessionJournal({
       header: replay.header,
       path: path5,
       nextSeq: replay.lastSeq + 1,
-      fd
+      fd,
+      attachments: options.attachments
     });
   } catch (error) {
     releaseLock(lockPath);
@@ -8819,8 +8982,8 @@ function required(value, label) {
 }
 
 // ../../packages/session/session-store/dist/session-manager.js
-import { existsSync as existsSync2, readdirSync, statSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
 
 // ../../packages/session/session-store/dist/session-tree.js
 function buildSessionTree(sessions) {
@@ -8848,14 +9011,17 @@ function buildSessionTree(sessions) {
 
 // ../../packages/session/session-store/dist/session-manager.js
 var SessionManager = class {
+  #attachments;
   #sessionsRoot;
   #appVersion;
   constructor(options) {
+    this.#attachments = options.attachments;
     this.#sessionsRoot = options.sessionsRoot;
     this.#appVersion = options.appVersion;
   }
   create(options) {
     const journal = createSessionJournal({
+      attachments: this.#attachments,
       sessionsRoot: this.#sessionsRoot,
       projectRoot: options.projectRoot,
       initialCwd: options.initialCwd,
@@ -8884,6 +9050,7 @@ var SessionManager = class {
     }
     const replay = readSessionFile(summary.path);
     const journal = createSessionJournal({
+      attachments: this.#attachments,
       sessionsRoot: this.#sessionsRoot,
       header: replay.header,
       path: summary.path
@@ -8911,6 +9078,7 @@ var SessionManager = class {
       throw new Error("fork target must be a user_message entry");
     }
     const child = createSessionJournal({
+      attachments: this.#attachments,
       sessionsRoot: this.#sessionsRoot,
       projectRoot: parent.header.projectRoot,
       initialCwd: parent.header.initialCwd,
@@ -8941,6 +9109,7 @@ var SessionManager = class {
     const parent = this.parentReplay(options.parentSessionId);
     const lastEntry = [...parent.items].reverse().find((item) => item.kind === "entry");
     const child = createSessionJournal({
+      attachments: this.#attachments,
       sessionsRoot: this.#sessionsRoot,
       projectRoot: parent.header.projectRoot,
       initialCwd: parent.header.initialCwd,
@@ -8974,8 +9143,8 @@ var SessionManager = class {
     }
     const paths = [];
     const visit = (directory) => {
-      for (const entry of readdirSync(directory)) {
-        const absolute = join2(directory, entry);
+      for (const entry of readdirSync2(directory)) {
+        const absolute = join3(directory, entry);
         const stat6 = statSync(absolute);
         if (stat6.isDirectory()) {
           visit(absolute);
@@ -9331,14 +9500,14 @@ function toolsOf(request) {
   }
   return request.tools.map(toolOf);
 }
-function toPiContext(request) {
+function toPiContext(request, attachments) {
   const systems = request.messages.filter((message) => message.role === "system" && message.toolDefinitions === void 0);
   if (systems.length > 1) {
     throw new ModelError("model history contains more than one system message", {
       kind: "protocol"
     });
   }
-  const messages = request.messages.filter((message) => message.role !== "system").map((message) => toPiMessage(message, request.provider, request.model));
+  const messages = request.messages.filter((message) => message.role !== "system").map((message) => toPiMessage(message, request.provider, request.model, attachments?.get(message)));
   const tools = toolsOf(request);
   return {
     ...systems[0] === void 0 ? {} : { systemPrompt: systems[0].content },
@@ -9346,9 +9515,12 @@ function toPiContext(request) {
     ...tools === void 0 ? {} : { tools }
   };
 }
-function toPiMessage(message, provider2, model2) {
+function toPiMessage(message, provider2, model2, attachments) {
+  if ((message.role === "user" || message.role === "tool-result") && message.attachments?.length && attachments === void 0) {
+    throw new ModelError("Attachments must be prepared before serializing model context", { kind: "protocol" });
+  }
   if (message.role === "user") {
-    return { role: "user", content: message.content, timestamp: 0 };
+    return { role: "user", content: attachments?.length ? [{ type: "text", text: message.content }, ...attachments] : message.content, timestamp: 0 };
   }
   if (message.role === "assistant") {
     return toPiAssistant(message, { provider: provider2, model: model2 });
@@ -9357,7 +9529,7 @@ function toPiMessage(message, provider2, model2) {
     role: "toolResult",
     toolCallId: message.toolCallId,
     toolName: message.toolName,
-    content: [{ type: "text", text: message.content || "(no output)" }],
+    content: [{ type: "text", text: message.content || "(no output)" }, ...attachments ?? []],
     isError: message.isError,
     timestamp: 0
   };
@@ -9543,13 +9715,88 @@ function ensureActive(request, hadDelta) {
   }
 }
 
+// ../../packages/llm/llm-pi-ai/dist/images.js
+function defaultImagePolicy(model2) {
+  const anthropic = model2.api === "anthropic-messages";
+  const google = model2.api === "google-generative-ai" || model2.api === "google-vertex";
+  return {
+    target: {
+      maxPixels: anthropic ? 115e4 : google ? 4194304 : 2097152,
+      maxDimension: anthropic ? 1568 : 2048,
+      maxBytes: 4 * 1024 ** 2,
+      formats: ["image/png", "image/jpeg", "image/webp"]
+    },
+    maxImages: 20,
+    maxTotalBytes: (google ? 12 : 16) * 1024 ** 2
+  };
+}
+async function prepareRequestImages(request, model2, options) {
+  const offloaded = request.imageContext?.offloaded ?? /* @__PURE__ */ new Set();
+  const blocks = /* @__PURE__ */ new Map();
+  const images = [];
+  const policy = (options?.policy ?? defaultImagePolicy)(model2);
+  if (![policy.maxImages, policy.maxTotalBytes].every((n) => Number.isSafeInteger(n) && n > 0))
+    throw new ModelError("Invalid image request budget", { kind: "protocol" });
+  for (const message of request.messages) {
+    if (message.role !== "user" && message.role !== "tool-result")
+      continue;
+    const output = [];
+    blocks.set(message, output);
+    for (const [index, block] of (message.attachments ?? []).entries()) {
+      assertAttachmentContent(block);
+      if (block.type === "file") {
+        output.push({ type: "text", text: `Attached file ${JSON.stringify(block.ref.name)} (${block.ref.id}, ${block.ref.bytes} bytes). File bytes have not been read or parsed.` });
+        continue;
+      }
+      const key = `${message.attachmentKey}:${index}`;
+      if (offloaded.has(key) || message.omittedImageIndexes?.includes(index)) {
+        output.push({ type: "text", text: `[Image ${block.ref.id} omitted from context; use read_image to inspect it again.]` });
+        continue;
+      }
+      if (!model2.input.includes("image"))
+        throw new ModelError(`Model ${model2.provider}/${model2.id} does not declare image input`, { kind: "protocol" });
+      const store = options?.store();
+      if (!store)
+        throw new ModelError("Image request requires an attachment store", { kind: "protocol" });
+      const prepared = await store.prepareImage(block.ref, { ...policy.target, ...block.view }, request.cancelToken?.signal);
+      const content = { type: "image", data: Buffer.from(prepared.data).toString("base64"), mimeType: prepared.mimeType };
+      const note = { type: "text", text: `Image ${block.ref.id}: ${prepared.note}` };
+      output.push(note, content);
+      images.push({ key, owner: message, content, note, bytes: prepared.data.byteLength });
+    }
+  }
+  let count = images.length;
+  let bytes = images.reduce((sum, image) => sum + image.bytes, 0);
+  const evicted = [];
+  for (const image of images) {
+    if (count <= policy.maxImages && bytes <= policy.maxTotalBytes)
+      break;
+    if (!request.imageContext || request.imageContext.protectedKeys.has(image.key) || !("attachmentKey" in image.owner) || !image.owner.attachmentKey)
+      continue;
+    const output = blocks.get(image.owner);
+    output.splice(output.indexOf(image.content), 1);
+    image.note.text = `[Image omitted from context to meet request budget; original remains stored. Use read_image to inspect it again.]`;
+    evicted.push(image.key);
+    count--;
+    bytes -= image.bytes;
+  }
+  if (count > policy.maxImages || bytes > policy.maxTotalBytes)
+    throw new ModelError("Current-turn images exceed the request image budget; reduce the number or crop the images", { kind: "protocol" });
+  request.cancelToken?.signal.throwIfAborted();
+  if (evicted.length)
+    request.imageContext.persistOffload(evicted);
+  return blocks;
+}
+
 // ../../packages/llm/llm-pi-ai/dist/adapter.js
 var PiAiAdapter = class {
+  attachments;
   name = "pi-ai";
   models;
   eligibleProviderIds;
   constructor(options, models) {
     this.eligibleProviderIds = options.eligibleProviderIds;
+    this.attachments = options.attachments;
     this.models = models;
   }
   async runAttempt(request) {
@@ -9564,9 +9811,6 @@ var PiAiAdapter = class {
       throw new ModelError(`unknown model route: ${request.provider}/${request.model}`, { kind: "protocol" });
     }
     this.checkActive(request);
-    if (request.onRequestOpened?.() === false) {
-      throw new ModelStreamCancelled("model request was cancelled before opening");
-    }
     const requestModel = request.baseUrl === void 0 ? model2 : { ...model2, baseUrl: request.baseUrl };
     const options = {
       ...request.cancelToken === void 0 ? {} : { signal: request.cancelToken.signal },
@@ -9577,16 +9821,26 @@ var PiAiAdapter = class {
       maxRetries: 0
     };
     try {
-      const stream = this.models.streamSimple(requestModel, toPiContext(request), options);
+      const images = await prepareRequestImages(request, model2, this.attachments).catch((error) => {
+        this.checkActive(request);
+        if (error instanceof ModelError)
+          throw error;
+        throw new ModelError(errorMessage2(error), { kind: "protocol", cause: error });
+      });
+      this.checkActive(request);
+      if (request.onRequestOpened?.() === false)
+        throw new ModelStreamCancelled("model request was cancelled before opening");
+      const stream = this.models.streamSimple(requestModel, toPiContext(request, images), options);
       const result = await consumePiEvents(stream, request, request.onEvent);
       this.checkActive(request);
       return result;
     } catch (error) {
+      this.checkActive(request);
       if (error instanceof ModelError || error instanceof ModelStreamCancelled) {
         throw error;
       }
       throw new ModelError(errorMessage2(error), {
-        kind: piModelErrorKind(error),
+        kind: error instanceof AttachmentError ? "protocol" : piModelErrorKind(error),
         cause: error
       });
     }
@@ -17855,6 +18109,7 @@ async function createPiAiPlatform(options) {
   for (const id of custom.providerIds)
     verified.delete(id);
   return new PiAiPlatform(models, {
+    attachments: options.attachments,
     excludedProviderIds: options.excludedProviderIds,
     verifiedProviderIds: verified,
     reload: async () => {
@@ -17881,7 +18136,7 @@ var PiAiPlatform = class {
     this.models = models;
     this.eligibleIds = new Set(eligibleProviderIds(models, options.excludedProviderIds));
     this.verifiedProviderIds = options.verifiedProviderIds;
-    this.adapter = new PiAiAdapter({ eligibleProviderIds: this.eligibleIds }, models);
+    this.adapter = new PiAiAdapter({ eligibleProviderIds: this.eligibleIds, attachments: options.attachments }, models);
     this.catalog = new PiAiCatalog(this.models, this.eligibleIds, this.verifiedProviderIds, async () => {
       await options.reload?.();
       this.eligibleIds.clear();
@@ -18086,7 +18341,7 @@ function errorMessage3(error) {
 // ../../packages/storage/local-config/dist/config.js
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
-import { basename as basename2, dirname, join as join3 } from "node:path";
+import { basename as basename2, dirname, join as join4 } from "node:path";
 
 // ../../packages/fs/local-paths/dist/index.js
 import { execFileSync } from "node:child_process";
@@ -18184,8 +18439,8 @@ function defaultConfigPath(environ = process.env) {
     return normalizeLocalPath(explicit, { env: environ });
   }
   const configHome = environ["XDG_CONFIG_HOME"];
-  const root = configHome ? normalizeLocalPath(configHome, { env: environ }) : join3(getHomeDirectory({ env: environ }), ".config");
-  return join3(root, "laohuang", "config.json");
+  const root = configHome ? normalizeLocalPath(configHome, { env: environ }) : join4(getHomeDirectory({ env: environ }), ".config");
+  return join4(root, "laohuang", "config.json");
 }
 var ConfigManager = class {
   path;
@@ -18287,7 +18542,7 @@ var ConfigManager = class {
     const parent = dirname(this.path);
     mkdirSync2(parent, { recursive: true, mode: 448 });
     const content = JSON.stringify(document, null, 2) + "\n";
-    const temporary = join3(parent, `.${basename2(this.path)}.${process.pid}.${randomUUID3()}.tmp`);
+    const temporary = join4(parent, `.${basename2(this.path)}.${process.pid}.${randomUUID3()}.tmp`);
     writeFileSync(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync(temporary, 384);
     renameSync(temporary, this.path);
@@ -18363,7 +18618,7 @@ var CustomModelsStore = class {
 // ../../packages/storage/local-config/dist/credentials.js
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename3, dirname as dirname2, join as join4 } from "node:path";
+import { basename as basename3, dirname as dirname2, join as join5 } from "node:path";
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -18527,7 +18782,7 @@ var CredentialStore = class {
       version: 2,
       providers: document.providers
     }, null, 2) + "\n";
-    const temporary = join4(parent, `.${basename3(this.path)}.${process.pid}.${randomUUID4()}.tmp`);
+    const temporary = join5(parent, `.${basename3(this.path)}.${process.pid}.${randomUUID4()}.tmp`);
     writeFileSync2(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync2(temporary, 384);
     renameSync2(temporary, this.path);
@@ -18544,7 +18799,7 @@ function normalizeStoredCredential(credential) {
 // ../../packages/storage/local-config/dist/model-catalog-store.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { chmodSync as chmodSync3, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename4, dirname as dirname3, join as join5 } from "node:path";
+import { basename as basename4, dirname as dirname3, join as join6 } from "node:path";
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -18608,7 +18863,7 @@ var ModelCatalogStore = class {
       chmodSync3(parent, 448);
     }
     const content = JSON.stringify(document, null, 2) + "\n";
-    const temporary = join5(parent, `.${basename4(this.path)}.${process.pid}.${randomUUID5()}.tmp`);
+    const temporary = join6(parent, `.${basename4(this.path)}.${process.pid}.${randomUUID5()}.tmp`);
     writeFileSync3(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync3(temporary, 384);
     renameSync3(temporary, this.path);
@@ -18652,7 +18907,7 @@ function normalizeEntry(providerId, entry) {
 // ../../packages/storage/local-config/dist/mcp-config.js
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
-import { basename as basename5, dirname as dirname4, join as join6 } from "node:path";
+import { basename as basename5, dirname as dirname4, join as join7 } from "node:path";
 var McpConfigStore = class {
   path;
   constructor(path5) {
@@ -18684,7 +18939,7 @@ var McpConfigStore = class {
       throw new Error("MCP storage requires JSON data");
     const parent = dirname4(this.path);
     await mkdir(parent, { recursive: true, mode: 448 });
-    const temporary = join6(parent, `.${basename5(this.path)}.${randomUUID6()}.tmp`);
+    const temporary = join7(parent, `.${basename5(this.path)}.${randomUUID6()}.tmp`);
     try {
       await writeFile(temporary, `${content}
 `, { mode: 384, flag: "wx" });
@@ -18703,7 +18958,7 @@ var McpConfigStore = class {
 // ../../packages/storage/local-config/dist/mcp-credentials.js
 import { createHash as createHash3 } from "node:crypto";
 import { unlink as unlink2 } from "node:fs/promises";
-import { join as join7, resolve as resolve2 } from "node:path";
+import { join as join8, resolve as resolve2 } from "node:path";
 var operations = /* @__PURE__ */ new Map();
 var McpCredentialFileStore = class {
   directory;
@@ -18711,7 +18966,7 @@ var McpCredentialFileStore = class {
     this.directory = resolve2(directory);
   }
   path(key) {
-    return join7(this.directory, `${createHash3("sha256").update(key).digest("hex")}.json`);
+    return join8(this.directory, `${createHash3("sha256").update(key).digest("hex")}.json`);
   }
   async read(key) {
     const path5 = this.path(key);
@@ -18800,8 +19055,8 @@ var CancelToken = class {
         continue;
       }
     }
-    for (const resolve14 of this.#waiters) {
-      resolve14();
+    for (const resolve15 of this.#waiters) {
+      resolve15();
     }
     this.#waiters.clear();
     return true;
@@ -18814,20 +19069,20 @@ var CancelToken = class {
     if (this.#cancelled) {
       return Promise.resolve(true);
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       let timer;
       const onCancel = () => {
         if (timer !== void 0) {
           clearTimeout(timer);
         }
         this.#waiters.delete(onCancel);
-        resolve14(true);
+        resolve15(true);
       };
       this.#waiters.add(onCancel);
       if (timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.#waiters.delete(onCancel);
-          resolve14(false);
+          resolve15(false);
         }, timeoutMs);
       }
     });
@@ -19423,8 +19678,8 @@ var SubscriberMailbox = class _SubscriberMailbox {
     const deadline = timeoutMs === void 0 ? void 0 : Date.now() + timeoutMs;
     while (this.unfinished > 0) {
       if (deadline === void 0) {
-        await new Promise((resolve14) => {
-          this.flushWaiters.push(resolve14);
+        await new Promise((resolve15) => {
+          this.flushWaiters.push(resolve15);
         });
         continue;
       }
@@ -19432,12 +19687,12 @@ var SubscriberMailbox = class _SubscriberMailbox {
       if (remaining <= 0) {
         return false;
       }
-      const waiter = new Promise((resolve14) => {
-        this.flushWaiters.push(resolve14);
+      const waiter = new Promise((resolve15) => {
+        this.flushWaiters.push(resolve15);
       });
       let timer;
-      const timeout = new Promise((resolve14) => {
-        timer = setTimeout(resolve14, remaining);
+      const timeout = new Promise((resolve15) => {
+        timer = setTimeout(resolve15, remaining);
       });
       await Promise.race([waiter, timeout]);
       clearTimeout(timer);
@@ -19466,22 +19721,22 @@ var SubscriberMailbox = class _SubscriberMailbox {
   wake() {
     const waiters = this.wakeWaiters;
     this.wakeWaiters = [];
-    for (const resolve14 of waiters) {
-      resolve14();
+    for (const resolve15 of waiters) {
+      resolve15();
     }
   }
   notifyFlushWaiters() {
     const waiters = this.flushWaiters;
     this.flushWaiters = [];
-    for (const resolve14 of waiters) {
-      resolve14();
+    for (const resolve15 of waiters) {
+      resolve15();
     }
   }
   async run() {
     for (; ; ) {
       while (this.items.length === 0 && !this.closed) {
-        await new Promise((resolve14) => {
-          this.wakeWaiters.push(resolve14);
+        await new Promise((resolve15) => {
+          this.wakeWaiters.push(resolve15);
         });
       }
       if (this.items.length === 0 && this.closed) {
@@ -19629,8 +19884,8 @@ var EventBus = class {
     if (this.closed) {
       return Promise.reject(new EventBusClosedError());
     }
-    return new Promise((resolve14, reject) => {
-      const waiter = { resolve: resolve14, reject };
+    return new Promise((resolve15, reject) => {
+      const waiter = { resolve: resolve15, reject };
       if (timeoutMs !== void 0) {
         waiter.timer = setTimeout(() => {
           const index = this.bufferWaiters.indexOf(waiter);
@@ -19729,7 +19984,7 @@ function makeCancelIntent(reason, source) {
 
 // ../../packages/context/project-instructions/dist/project-instructions.js
 import { createHash as createHash4 } from "node:crypto";
-import { closeSync as closeSync2, existsSync as existsSync7, fstatSync, lstatSync, openSync as openSync2, readSync, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync7, fstatSync, lstatSync as lstatSync2, openSync as openSync2, readSync, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
 import path from "node:path";
 var INSTRUCTION_FILENAMES = [
   "AGENTS.md",
@@ -19913,7 +20168,7 @@ function scopeChain(root, cwd) {
 function readInstructionFile(rootReal, candidate, options) {
   let stats;
   try {
-    stats = lstatSync(candidate);
+    stats = lstatSync2(candidate);
   } catch {
     return null;
   }
@@ -21496,20 +21751,20 @@ var AgentSession = class {
     if (timeoutMs !== void 0 && timeoutMs <= 0) {
       return Promise.resolve(false);
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       let timer;
       const onIdle = () => {
         if (timer !== void 0) {
           clearTimeout(timer);
         }
         this.#idleWaiters.delete(onIdle);
-        resolve14(true);
+        resolve15(true);
       };
       this.#idleWaiters.add(onIdle);
       if (timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.#idleWaiters.delete(onIdle);
-          resolve14(false);
+          resolve15(false);
         }, timeoutMs);
         timer.unref();
       }
@@ -21823,8 +22078,8 @@ var AgentSession = class {
     if (value) {
       const waiters = [...this.#idleWaiters];
       this.#idleWaiters.clear();
-      for (const resolve14 of waiters) {
-        resolve14();
+      for (const resolve15 of waiters) {
+        resolve15();
       }
     }
   }
@@ -22054,13 +22309,13 @@ function inputTimeout(kind, env = process.env) {
 async function drainTerminalInput(input, maxMs = 1e3, idleMs = 50) {
   if (!input?.off)
     return;
-  await new Promise((resolve14) => {
+  await new Promise((resolve15) => {
     let idle;
     const finish = () => {
       clearTimeout(idle);
       clearTimeout(deadline);
       input.off?.("data", onData);
-      resolve14();
+      resolve15();
     };
     const onData = () => {
       clearTimeout(idle);
@@ -22608,7 +22863,7 @@ var BoundedTerminalWriter = class _BoundedTerminalWriter {
 // ../../packages/terminal/tui/dist/tui/render-diagnostics.js
 import { mkdtempSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var RenderWidthError = class extends Error {
   expected;
   actual;
@@ -22626,8 +22881,8 @@ function recordRenderFailure(error) {
   if (!(error instanceof RenderWidthError))
     return error;
   try {
-    const directory = mkdtempSync(join8(tmpdir(), "laohuang-tui-error-"));
-    const path5 = join8(directory, "render.json");
+    const directory = mkdtempSync(join9(tmpdir(), "laohuang-tui-error-"));
+    const path5 = join9(directory, "render.json");
     writeFileSync4(path5, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       source: error.source,
@@ -26843,19 +27098,19 @@ var ViewHost = class {
     this.#overlays = overlays;
   }
   openSelection(request) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const component = this.#selectionComponent(request);
-      this.#open({ id: request.id, component, resolve: resolve14 }, "selector", request.floating);
+      this.#open({ id: request.id, component, resolve: resolve15 }, "selector", request.floating);
     });
   }
   openPrompt(request) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const component = new AuthDialog({
         request,
         onSubmit: (value) => this.#close(request.id, value),
         onCancel: () => this.#close(request.id, null)
       });
-      this.#open({ id: request.id, component, resolve: resolve14 }, "modal", request.floating);
+      this.#open({ id: request.id, component, resolve: resolve15 }, "modal", request.floating);
     });
   }
   handleInput(event) {
@@ -27379,8 +27634,8 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
       try {
         input?.resume?.();
         if (!this.#exitRequested) {
-          await new Promise((resolve14) => {
-            this.#exitResolve = resolve14;
+          await new Promise((resolve15) => {
+            this.#exitResolve = resolve15;
           });
         }
       } finally {
@@ -27747,18 +28002,18 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
     if (this.#closed || !this.#running) {
       return Promise.resolve(null);
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       if (type === "open_selection") {
         this.#work.push({
           type,
           request,
-          resolve: resolve14
+          resolve: resolve15
         });
       } else {
         this.#work.push({
           type,
           request,
-          resolve: resolve14
+          resolve: resolve15
         });
       }
       this.#scheduleWakeup();
@@ -29086,8 +29341,8 @@ async function executeEdit(args, execution, resolvePath, io) {
 async function withFileMutationLock(key, fn) {
   const previous = mutationLocks.get(key) ?? Promise.resolve();
   let release;
-  const current = new Promise((resolve14) => {
-    release = resolve14;
+  const current = new Promise((resolve15) => {
+    release = resolve15;
   });
   const tail2 = previous.then(() => current);
   mutationLocks.set(key, tail2);
@@ -29170,6 +29425,98 @@ function editsArgument(args) {
   });
 }
 
+// ../../packages/fs/tool-fs/dist/read-image.js
+import { open } from "node:fs/promises";
+import { basename as basename6 } from "node:path";
+function createReadImageTool(options) {
+  return {
+    spec: {
+      name: "read_image",
+      description: "View a PNG, JPEG, WebP or GIF image. Use path to read a local image file. Use attachment_id only to re-read an image attachment reference already returned in the current session; do not guess IDs. Provide exactly one of path or attachment_id. Optional crop coordinates use the oriented original pixels. Animations show only their first frame. full_resolution prevents downscaling and may exceed model limits.",
+      parameters: { type: "object", properties: {
+        path: {
+          type: "string",
+          description: "Local image file path. Absolute paths are accepted; relative paths resolve against the default working directory, and ~/ expands to the user's home directory. Use this for local files. Provide exactly one of path or attachment_id."
+        },
+        attachment_id: {
+          type: "string",
+          description: "Exact image attachment ID (sha256:...) already returned in the current session. Use only to re-read an existing session attachment, not to locate a local file. Do not guess IDs. Images not referenced by the current session are rejected. Provide exactly one of path or attachment_id."
+        },
+        region: {
+          type: "object",
+          description: "Optional rectangle in original-image pixels after orientation correction, with the origin at the top-left. Omit to view the whole image. Use a crop to inspect details that are unclear in a downscaled view. Out-of-bounds regions are rejected, not clipped. The crop may still be downscaled unless full_resolution is true.",
+          properties: {
+            x: { type: "integer", minimum: 0, description: "Zero-based left edge in the oriented original image, in pixels." },
+            y: { type: "integer", minimum: 0, description: "Zero-based top edge in the oriented original image, in pixels." },
+            width: { type: "integer", minimum: 1, description: "Crop width in original-image pixels; must be positive." },
+            height: { type: "integer", minimum: 1, description: "Crop height in original-image pixels; must be positive." }
+          },
+          required: ["x", "y", "width", "height"],
+          additionalProperties: false
+        },
+        full_resolution: {
+          type: "boolean",
+          description: "Defaults to false: the whole image or crop may be downscaled to fit model request limits. Set true to preserve its pixel dimensions; orientation correction and re-encoding may still occur. If model limits cannot be met, request preparation fails instead of silently downscaling. Use a smaller region in that case."
+        }
+      }, additionalProperties: false },
+      promptGuidelines: ["Use read_image for visual image inspection. Use read for text. Image crop coordinates refer to the oriented original; follow the returned coordinate mapping."]
+    },
+    async execute(args, execution) {
+      if (typeof args.path === "string" === (typeof args.attachment_id === "string"))
+        throw new Error("Supply exactly one of path or attachment_id");
+      const view = { ...args.region === void 0 ? {} : { region: args.region }, ...args.full_resolution === void 0 ? {} : { fullResolution: args.full_resolution } };
+      assertImageView(view);
+      const release = options.store.protect();
+      try {
+        let ref;
+        let target;
+        if (typeof args.path === "string") {
+          target = resolveLocalPath(args.path, options.projectRoot, options.pathOptions);
+          const handle = await open(target, "r");
+          let bytes;
+          try {
+            const stat6 = await handle.stat();
+            if (!stat6.isFile() || stat6.size > options.store.imageLimits.maxBytes)
+              throw new AttachmentError("LIMIT_EXCEEDED", "Image must be a regular file within the source byte limit");
+            const chunks = [];
+            let total = 0;
+            while (true) {
+              execution.signal?.throwIfAborted();
+              const buffer = Buffer.allocUnsafe(64 * 1024);
+              const { bytesRead } = await handle.read(buffer);
+              if (!bytesRead)
+                break;
+              total += bytesRead;
+              if (total > options.store.imageLimits.maxBytes)
+                throw new AttachmentError("LIMIT_EXCEEDED", "Image exceeds source byte limit");
+              chunks.push(buffer.subarray(0, bytesRead));
+            }
+            bytes = Buffer.concat(chunks);
+          } finally {
+            await handle.close();
+          }
+          ref = (await options.store.saveImages([{ data: bytes, name: basename6(target) }], execution.signal))[0];
+        } else {
+          const found = options.resolveReference(String(args.attachment_id));
+          if (!found)
+            throw new AttachmentError("ACCESS_DENIED", "Image is not referenced by the current session");
+          ref = found;
+          for await (const _chunk of options.store.readFile(ref, execution.signal)) {
+          }
+        }
+        if (view.region && (view.region.x + view.region.width > ref.width || view.region.y + view.region.height > ref.height))
+          throw new AttachmentError("LIMIT_EXCEEDED", "Crop is outside the oriented image");
+        if (execution.isCancelled())
+          return cancelledResult(execution);
+        const result = { ok: true, content: `Image ${ref.id}, oriented original ${ref.width}x${ref.height}.`, attachmentContent: [{ type: "image", ref, view }] };
+        return target ? withTouchedPath(result, target) : result;
+      } finally {
+        release();
+      }
+    }
+  };
+}
+
 // ../../packages/shell/tool-bash/dist/tool-bash.js
 import { promises as fs2 } from "node:fs";
 import { realpathSync as realpathSync4 } from "node:fs";
@@ -29239,9 +29586,9 @@ function resolveBashPath(options = {}) {
 }
 
 // ../../packages/shell/bash-local/dist/bash-output.js
-import { mkdir as mkdir2, mkdtemp, open, readdir, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, mkdtemp, open as open2, readdir, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { join as join9, resolve as resolve3 } from "node:path";
+import { join as join10, resolve as resolve3 } from "node:path";
 var BASH_OUTPUT_MAX_BYTES = 50 * 1024;
 var BASH_OUTPUT_MAX_LINES = 2e3;
 var OUTPUT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -29291,7 +29638,7 @@ var BashOutput = class {
       if (!Number.isSafeInteger(limit) || limit < 1)
         throw new RangeError("Bash output limits must be positive integers");
     }
-    this.#directory = resolve3(options.outputDirectory ?? join9(homedir3(), ".laohuang", "tool-output"));
+    this.#directory = resolve3(options.outputDirectory ?? join10(homedir3(), ".laohuang", "tool-output"));
   }
   append(stream, text3) {
     const next = this.#pending.then(() => this.#append(stream, text3));
@@ -29328,13 +29675,13 @@ var BashOutput = class {
     try {
       await mkdir2(this.#directory, { recursive: true, mode: 448 });
       await this.#removeExpired();
-      this.#archiveDirectory = await mkdtemp(join9(this.#directory, "bash-"));
+      this.#archiveDirectory = await mkdtemp(join10(this.#directory, "bash-"));
       const files = {
-        stdout: join9(this.#archiveDirectory, "stdout.log"),
-        stderr: join9(this.#archiveDirectory, "stderr.log")
+        stdout: join10(this.#archiveDirectory, "stdout.log"),
+        stderr: join10(this.#archiveDirectory, "stderr.log")
       };
       for (const stream of ["stdout", "stderr"])
-        this.#handles[stream] = await open(files[stream], "wx", 384);
+        this.#handles[stream] = await open2(files[stream], "wx", 384);
       this.files = files;
     } catch (error) {
       this.fileError = `Cannot save Bash output: ${String(error)}`;
@@ -29370,7 +29717,7 @@ var BashOutput = class {
     }
     if (this.#archiveDirectory !== null) {
       try {
-        await writeFile2(join9(this.#archiveDirectory, "completed"), "", { mode: 384 });
+        await writeFile2(join10(this.#archiveDirectory, "completed"), "", { mode: 384 });
       } catch {
       }
     }
@@ -29379,9 +29726,9 @@ var BashOutput = class {
     for (const entry of await readdir(this.#directory, { withFileTypes: true })) {
       if (!entry.isDirectory() || !entry.name.startsWith("bash-"))
         continue;
-      const directory = join9(this.#directory, entry.name);
+      const directory = join10(this.#directory, entry.name);
       try {
-        if (Date.now() - (await stat(join9(directory, "completed"))).mtimeMs > OUTPUT_RETENTION_MS) {
+        if (Date.now() - (await stat(join10(directory, "completed"))).mtimeMs > OUTPUT_RETENTION_MS) {
           await rm(directory, { recursive: true, force: true });
         }
       } catch {
@@ -29563,7 +29910,7 @@ var TerminalSanitizer = class {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function errnoCode(error) {
   return error?.code;
@@ -29574,7 +29921,7 @@ async function terminateProcessTree(child, graceMs = TERMINATION_GRACE_MS) {
     return;
   if (process.platform === "win32") {
     const taskkill = win323.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe");
-    await new Promise((resolve14, reject) => {
+    await new Promise((resolve15, reject) => {
       execFile(taskkill, ["/F", "/T", "/PID", String(pid)], {
         windowsHide: true,
         timeout: TASKKILL_TIMEOUT_MS,
@@ -29583,7 +29930,7 @@ async function terminateProcessTree(child, graceMs = TERMINATION_GRACE_MS) {
         if (error)
           reject(new Error(`taskkill failed: ${error.message}`));
         else
-          resolve14();
+          resolve15();
       });
     });
     return;
@@ -29686,9 +30033,9 @@ async function runBash(command, options) {
     });
     return await finish(result2);
   }
-  const spawnError = await new Promise((resolve14) => {
-    child.once("spawn", () => resolve14(null));
-    child.once("error", (error) => resolve14(error));
+  const spawnError = await new Promise((resolve15) => {
+    child.once("spawn", () => resolve15(null));
+    child.once("error", (error) => resolve15(error));
   });
   if (spawnError) {
     const result2 = new BashResult({
@@ -29765,8 +30112,8 @@ async function runBash(command, options) {
   const stdoutDone = readPipe("stdout", child.stdout);
   const stderrDone = readPipe("stderr", child.stderr);
   let resolveExit;
-  const exitInfo = new Promise((resolve14) => {
-    resolveExit = resolve14;
+  const exitInfo = new Promise((resolve15) => {
+    resolveExit = resolve15;
   });
   const onExit = (code2, signal2) => {
     exited = true;
@@ -31723,6 +32070,7 @@ var SessionController = class {
   constructor(options) {
     this.#sessionsRoot = options.sessionsRoot;
     this.#manager = new SessionManager({
+      attachments: options.attachments,
       sessionsRoot: options.sessionsRoot,
       appVersion: options.appVersion
     });
@@ -32352,6 +32700,7 @@ function errorMessage10(error) {
 }
 
 // ../../packages/core/agent-runtime/dist/core/history-committer.js
+import { randomUUID as randomUUID11 } from "node:crypto";
 var HistoryCommitter = class {
   messages;
   context;
@@ -32366,7 +32715,10 @@ var HistoryCommitter = class {
     this.conversationHistory = options.conversationHistory ?? null;
   }
   commitInput(content) {
-    const message = typeof content === "string" ? { role: "user", content } : content;
+    const message = typeof content === "string" ? { role: "user", content } : {
+      ...content,
+      ...content.attachments?.length ? { attachmentKey: content.attachmentKey ?? randomUUID11() } : {}
+    };
     const commitInput = this.context?.commitInput;
     if (typeof commitInput === "function") {
       return this.commitContextMessage((append, rollback) => commitInput.call(this.context, append, rollback), message);
@@ -32385,7 +32737,10 @@ var HistoryCommitter = class {
     if (content === "") {
       return true;
     }
-    const message = prepared ?? { role: "user", content };
+    const message = prepared ? {
+      ...prepared,
+      ...prepared.attachments?.length ? { attachmentKey: prepared.attachmentKey ?? randomUUID11() } : {}
+    } : { role: "user", content };
     const commitPending = this.context?.commitPending;
     if (typeof commitPending === "function") {
       return this.commitContextMessage((append, rollback) => commitPending.call(this.context, batch, append, rollback), message);
@@ -32434,21 +32789,23 @@ var HistoryCommitter = class {
       if (call === void 0 || result === void 0) {
         continue;
       }
+      const { attachmentContent: attachments, ...textResult } = result;
       const message = {
         role: "tool-result",
         toolCallId: call.id,
         toolName: call.name,
-        content: JSON.stringify(result),
+        content: JSON.stringify(textResult),
+        ...attachments?.length ? { attachments, attachmentKey: randomUUID11() } : {},
         isError: result.ok !== true
       };
       messages.push(message);
-      this.messages.push(message);
     }
     this.conversationHistory?.appendToolResults({
       requestId: "tool-results",
       messages,
       recovered: false
     });
+    this.messages.push(...messages);
   }
   commitReminder(content) {
     this.raiseIfCancelled();
@@ -32942,7 +33299,32 @@ function resultText(result) {
 function createSessionRuntime(options) {
   let route = { ...options.route };
   let selectedModel = modelInfo2(options.catalog, route);
-  const modelRuntime = new ModelRuntime(options.modelAdapter);
+  let attachmentTurnStart;
+  const adapter = {
+    name: options.modelAdapter.name,
+    runAttempt: (request) => {
+      const history = options.sessionController.history;
+      const entries = history?.entries() ?? [];
+      const boundary = attachmentTurnStart ?? [...entries].reverse().find((entry) => entry.entryType === "user_message")?.seq ?? 0;
+      const protectedKeys = /* @__PURE__ */ new Set();
+      for (const entry of entries) {
+        if (entry.seq < boundary || !("message" in entry.payload)) continue;
+        const message = entry.payload.message;
+        if (!("attachments" in message)) continue;
+        for (const [index] of (message.attachments ?? []).entries()) protectedKeys.add(`${message.attachmentKey}:${index}`);
+      }
+      return options.modelAdapter.runAttempt({ ...request, imageContext: {
+        offloaded: new Set(entries.flatMap((entry) => entry.entryType === "image_offload" ? entry.payload.keys : [])),
+        protectedKeys,
+        persistOffload: (keys2) => {
+          if (!history) throw new Error("Cannot persist image offload without an active session");
+          history.offloadImages(keys2);
+        }
+      } });
+    }
+  };
+  const modelRuntime = new ModelRuntime(adapter);
+  let releaseAttachments;
   const activeConversationHistory = {
     appendSkillContext: (input) => activeHistory(options.sessionController).appendSkillContext(input),
     appendToolDefinitions: (input) => activeHistory(options.sessionController).appendToolDefinitions(input),
@@ -32977,20 +33359,30 @@ function createSessionRuntime(options) {
     }
   });
   const agent = new CodingAgent({
-    resources: options.skills ? {
+    resources: {
       prepareInput: async (input, signal, inputs) => {
+        attachmentTurnStart ??= (options.sessionController.history?.entries().at(-1)?.seq ?? 0) + 1;
+        releaseAttachments ??= options.attachments?.protect();
         try {
-          return await options.skills.prepareInput(input, signal, inputs);
+          return await options.skills?.prepareInput(input, signal, inputs) ?? { role: "user", content: input };
         } catch (error) {
           if (!signal?.aborted) options.skillInputFailed?.(inputs?.join("\n\n") ?? input, error);
           throw error;
         }
       },
-      prepareContext: (messages, signal) => options.skills.prepareContext(messages, signal),
-      committed: (messages) => options.skills.committed(messages),
-      finishTurn: () => options.skills.finishTurn()
-    } : void 0,
-    modelAdapter: options.modelAdapter,
+      prepareContext: (messages, signal) => options.skills?.prepareContext(messages, signal) ?? Promise.resolve([]),
+      committed: (messages) => options.skills?.committed(messages),
+      finishTurn: () => {
+        try {
+          options.skills?.finishTurn();
+        } finally {
+          releaseAttachments?.();
+          releaseAttachments = void 0;
+          attachmentTurnStart = void 0;
+        }
+      }
+    },
+    modelAdapter: adapter,
     model: route.model,
     tools: options.tools,
     prepareTools: options.prepareTools,
@@ -33010,6 +33402,7 @@ function createSessionRuntime(options) {
         const entries = history.entries();
         const pendingAssistant = pendingToolCall ? [...entries].reverse().find((entry) => entry.entryType === "assistant_message") : void 0;
         const prepared = await createGovernor(history).prepare({
+          protectedFromSeq: attachmentTurnStart,
           entries: entries.filter((entry) => entry !== pendingAssistant),
           currentProvider: route.provider,
           currentModel: route.model,
@@ -33177,8 +33570,8 @@ function defaultContextPolicy() {
 }
 
 // src/create-mcp-runtime.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
-import { dirname as dirname6, join as join11, resolve as resolve6 } from "node:path";
+import { randomUUID as randomUUID13 } from "node:crypto";
+import { dirname as dirname6, join as join12, resolve as resolve6 } from "node:path";
 
 // ../../packages/core/mcp/dist/config.js
 import { resolve as resolve4 } from "node:path";
@@ -33354,14 +33747,14 @@ function createMcpClient(config, version, changed) {
 function waitWithSignal(work, signal) {
   if (signal === void 0)
     return work;
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     const abort = () => {
       signal.removeEventListener("abort", abort);
       reject(signal.reason);
     };
     work.then((value) => {
       signal.removeEventListener("abort", abort);
-      resolve14(value);
+      resolve15(value);
     }, (error) => {
       signal.removeEventListener("abort", abort);
       reject(error);
@@ -33447,9 +33840,9 @@ function privateRedirectFetch(base, privateHeaders) {
 import { createHash as createHash6 } from "node:crypto";
 
 // ../../packages/core/mcp/dist/output.js
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function bounded(result, limit) {
   if (Buffer.byteLength(JSON.stringify(result), "utf8") <= limit)
     return result;
@@ -33510,13 +33903,13 @@ async function adaptMcpResult(result, options) {
   if (!oversized && media.length === 0)
     return preview;
   try {
-    const directory = join10(options.artifactRoot, randomUUID11());
+    const directory = join11(options.artifactRoot, randomUUID12());
     await mkdir3(directory, { recursive: true, mode: 448 });
-    const path5 = join10(directory, "result.json");
+    const path5 = join11(directory, "result.json");
     await writeFile3(path5, JSON.stringify(business), { mode: 384, flag: "wx" });
     const attachments = [];
     for (const [index, item] of media.entries()) {
-      const path6 = join10(directory, `attachment-${index}.bin`);
+      const path6 = join11(directory, `attachment-${index}.bin`);
       const decoded = Buffer.from(item.data, "base64");
       if (decoded.toString("base64").replace(/=+$/, "") !== item.data.replace(/=+$/, ""))
         throw new Error("Invalid base64 attachment");
@@ -33921,8 +34314,8 @@ async function createOAuthCallback(options) {
   let accept;
   let reject;
   let settled = false;
-  const response = new Promise((resolve14, fail) => {
-    accept = resolve14;
+  const response = new Promise((resolve15, fail) => {
+    accept = resolve15;
     reject = fail;
   });
   void response.catch(() => {
@@ -33952,9 +34345,9 @@ async function createOAuthCallback(options) {
     reply.writeHead(200, { "Content-Type": "text/plain", "Cache-Control": "no-store" }).end("Authorization received. Return to laohuang.");
     accept(url.searchParams);
   });
-  await new Promise((resolve14, fail) => {
+  await new Promise((resolve15, fail) => {
     server.once("error", fail);
-    server.listen(0, "127.0.0.1", resolve14);
+    server.listen(0, "127.0.0.1", resolve15);
   });
   const address = server.address();
   if (address === null || typeof address === "string")
@@ -33969,8 +34362,8 @@ async function createOAuthCallback(options) {
       settled = true;
       reject(new Error("OAuth authorization cancelled"));
     }
-    closing = new Promise((resolve14) => {
-      server.close(() => resolve14());
+    closing = new Promise((resolve15) => {
+      server.close(() => resolve15());
       server.closeAllConnections();
     });
     return closing;
@@ -34493,7 +34886,7 @@ var ConnectionManager = class {
 // src/create-mcp-runtime.ts
 async function createMcpRuntime(options) {
   const directory = dirname6(resolve6(options.configPath));
-  const paths = [.../* @__PURE__ */ new Set([join11(directory, "mcp.json"), resolve6(options.projectRoot, ".laohuang/mcp.json")])];
+  const paths = [.../* @__PURE__ */ new Set([join12(directory, "mcp.json"), resolve6(options.projectRoot, ".laohuang/mcp.json")])];
   const readSources = async (reload) => {
     const sources = [];
     let invalid2 = false;
@@ -34523,8 +34916,8 @@ ${url}`, tone: "info" });
     projectRoot: options.projectRoot,
     version: options.version,
     env: options.env,
-    credentials: new McpCredentialFileStore(join11(directory, "mcp-credentials")),
-    artifactRoot: join11(directory, "mcp-artifacts", randomUUID12()),
+    credentials: new McpCredentialFileStore(join12(directory, "mcp-credentials")),
+    artifactRoot: join12(directory, "mcp-artifacts", randomUUID13()),
     onAuthorization: ({ serverId, url }) => showAuthorization(serverId, url),
     onLoginState: (active) => {
       if (active) process.on("SIGINT", cancel);
@@ -34760,10 +35153,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path5) {
     let entry;
-    const basename9 = this._isDirent ? dirent.name : dirent;
+    const basename10 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename9));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
+      const fullPath = presolve(pjoin(path5, basename10));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename10 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -34834,7 +35227,7 @@ function readdirp(root, options = {}) {
 
 // ../../packages/fs/file-watcher/node_modules/chokidar/esm/handler.js
 import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open as open2, stat as stat3, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import { open as open3, stat as stat3, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
 var STR_DATA = "data";
@@ -35218,7 +35611,7 @@ var setFsWatchListener = (path5, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path5, "r");
+          const fd = await open3(path5, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -35302,9 +35695,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path5);
-    const basename9 = sysPath.basename(path5);
+    const basename10 = sysPath.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename9);
+    parent.add(basename10);
     const absolutePath = sysPath.resolve(path5);
     const options = {
       persistent: opts.persistent
@@ -35314,7 +35707,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -35337,10 +35730,10 @@ var NodeFsHandler = class {
       return;
     }
     const dirname14 = sysPath.dirname(file);
-    const basename9 = sysPath.basename(file);
+    const basename10 = sysPath.basename(file);
     const parent = this.fsw._getWatchedDir(dirname14);
     let prevStats = stats;
-    if (parent.has(basename9))
+    if (parent.has(basename10))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
@@ -35365,9 +35758,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname14, basename9);
+          this.fsw._remove(dirname14, basename10);
         }
-      } else if (parent.has(basename9)) {
+      } else if (parent.has(basename10)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -35461,7 +35854,7 @@ var NodeFsHandler = class {
         this._addToNodeFs(path5, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -35470,7 +35863,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve14(void 0);
+        resolve15(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -36550,8 +36943,8 @@ var Handle = class {
   constructor(task, release) {
     this.task = task;
     this.release = release;
-    this.ready = new Promise((resolve14, reject) => {
-      this.resolveReady = resolve14;
+    this.ready = new Promise((resolve15, reject) => {
+      this.resolveReady = resolve15;
       this.rejectReady = reject;
     });
     void this.ready.catch(() => {
@@ -36862,7 +37255,7 @@ var SkillRegistry = class {
 
 // ../../packages/skill/skill-filesystem/dist/index.js
 import { lstat as lstat3, readFile as readFile3, readlink, readdir as readdir4, realpath as realpath2 } from "node:fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute3, join as join14, parse as parse2, relative as relative4, resolve as resolve11, sep as sep2 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute3, join as join15, parse as parse2, relative as relative4, resolve as resolve11, sep as sep2 } from "node:path";
 
 // ../../packages/skill/skill-filesystem/dist/parser.js
 var import_yaml = __toESM(require_dist(), 1);
@@ -36893,11 +37286,11 @@ function parseSkill(text3) {
 // ../../packages/skill/skill-filesystem/dist/index.js
 function skillRoots(projectRoot, home, extras) {
   return [
-    { path: join14(projectRoot, ".laohuang/skills"), priority: 100 },
-    { path: join14(projectRoot, ".agents/skills"), priority: 200 },
+    { path: join15(projectRoot, ".laohuang/skills"), priority: 100 },
+    { path: join15(projectRoot, ".agents/skills"), priority: 200 },
     ...extras.map((path5, index) => ({ path: path5, priority: 300 + index / (extras.length + 1) })),
-    { path: join14(home, ".laohuang/skills"), priority: 400 },
-    { path: join14(home, ".agents/skills"), priority: 500 }
+    { path: join15(home, ".laohuang/skills"), priority: 400 },
+    { path: join15(home, ".agents/skills"), priority: 500 }
   ];
 }
 function parseSkillDirs(value, configPath, home) {
@@ -37068,7 +37461,7 @@ var FileSystemSkillProvider = class {
         let current = root;
         let followed = false;
         for (let index = 0; index < parts.length; index++) {
-          current = join14(current, parts[index]);
+          current = join15(current, parts[index]);
           let stat6;
           try {
             stat6 = await lstat3(current);
@@ -37140,13 +37533,13 @@ var FileSystemSkillProvider = class {
       }
       children.sort((a, b) => compareSkillPaths(a.name, b.name));
       if (children.some((child) => child.name === "SKILL.md")) {
-        await file(join14(path5, "SKILL.md"));
+        await file(join15(path5, "SKILL.md"));
         return;
       }
       for (const child of children) {
         if (child.name.startsWith(".") || child.name === "node_modules")
           continue;
-        const childPath = join14(path5, child.name);
+        const childPath = join15(path5, child.name);
         if (child.isDirectory())
           await walk(childPath, false);
         else if (child.isSymbolicLink()) {
@@ -37231,7 +37624,7 @@ var FileSystemSkillProvider = class {
 };
 
 // ../../packages/skill/tool-skill/dist/index.js
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function parseSkillCommand(input) {
   const match = /^\s*\/skill:([^\s]+)(?:[ \t]|\r?\n)?([\s\S]*)$/.exec(input);
   return match ? { name: match[1], arguments: match[2] } : null;
@@ -37281,7 +37674,7 @@ var SkillSession = class {
       const skill = await this.registry.load(args["name"], context.signal);
       if (context.isCancelled() || this.closed)
         throw new Error("Skill load cancelled");
-      const key = randomUUID13();
+      const key = randomUUID14();
       this.pending.set(key, { session: this.state, skill });
       return { ok: true, content: render(skill), skillReceipt: key, skill: metadata(skill) };
     }
@@ -37304,7 +37697,7 @@ var SkillSession = class {
     signal?.throwIfAborted();
     if (this.closed)
       throw new Error("Skill session is closed");
-    const key = randomUUID13();
+    const key = randomUUID14();
     this.pending.set(key, { session: this.state, skill });
     return {
       role: "user",
@@ -37495,6 +37888,500 @@ async function createSkillRuntime(options) {
   };
 }
 
+// src/create-attachment-runtime.ts
+import { mkdirSync as mkdirSync6 } from "node:fs";
+
+// ../../packages/attachment/attachment-local/dist/local-attachment-store.js
+import { createHash as createHash10, randomUUID as randomUUID16 } from "node:crypto";
+import { chmodSync as chmodSync4, existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync3, rmSync } from "node:fs";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename2, unlink as unlink4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join17, resolve as resolve13 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import sharp2 from "sharp";
+
+// ../../packages/attachment/attachment-local/dist/object-store.js
+import { createHash as createHash9, randomUUID as randomUUID15 } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { mkdir as mkdir4, open as open4, link, unlink as unlink3, chmod } from "node:fs/promises";
+import { join as join16 } from "node:path";
+async function syncDirectory(path5) {
+  if (process.platform === "win32")
+    return;
+  const handle = await open4(path5, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function writeObject(root, source, name, signal) {
+  const temporary = join16(root, "tmp", randomUUID15());
+  const handle = await open4(temporary, "wx", 384);
+  const hash = createHash9("sha256");
+  let bytes = 0;
+  try {
+    for await (const input of source) {
+      signal?.throwIfAborted();
+      const chunk = Buffer.from(input);
+      bytes += chunk.byteLength;
+      if (!Number.isSafeInteger(bytes))
+        throw new AttachmentError("LIMIT_EXCEEDED", "File is too large");
+      hash.update(chunk);
+      await handle.writeFile(chunk);
+    }
+    signal?.throwIfAborted();
+    await handle.sync();
+    const ref = {
+      id: `sha256:${hash.digest("hex")}`,
+      bytes,
+      name: name.split(/[\\/]/).at(-1).replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 255)
+    };
+    const directory = join16(root, "objects", ref.id.slice(7, 9));
+    await mkdir4(directory, { recursive: true, mode: 448 });
+    await syncDirectory(join16(root, "objects"));
+    const target = join16(directory, ref.id.slice(7));
+    try {
+      await link(temporary, target);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+        throw error;
+      for await (const _chunk of readObject(root, ref, signal)) {
+      }
+    }
+    await chmod(target, 384);
+    await syncDirectory(directory);
+    return ref;
+  } finally {
+    await handle.close();
+    await unlink3(temporary);
+  }
+}
+async function* readObject(root, ref, signal) {
+  assertFileRef(ref);
+  signal?.throwIfAborted();
+  let handle;
+  try {
+    handle = await open4(join16(root, "objects", ref.id.slice(7, 9), ref.id.slice(7)), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    throw new AttachmentError(error instanceof Error && "code" in error && error.code === "ENOENT" ? "NOT_FOUND" : "IO", `Cannot read attachment ${ref.id}`, { cause: error });
+  }
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.size !== ref.bytes)
+      throw new AttachmentError("CORRUPT", `Attachment size mismatch: ${ref.id}`);
+    const hash = createHash9("sha256");
+    let bytes = 0;
+    while (true) {
+      signal?.throwIfAborted();
+      const chunk = Buffer.allocUnsafe(64 * 1024);
+      const { bytesRead } = await handle.read(chunk);
+      if (bytesRead === 0)
+        break;
+      const part = chunk.subarray(0, bytesRead);
+      bytes += bytesRead;
+      hash.update(part);
+      yield part;
+    }
+    if (bytes !== ref.bytes || `sha256:${hash.digest("hex")}` !== ref.id)
+      throw new AttachmentError("CORRUPT", `Attachment digest mismatch: ${ref.id}`);
+  } finally {
+    await handle.close();
+  }
+}
+
+// ../../packages/attachment/attachment-local/dist/image.js
+import sharp from "sharp";
+var MIME = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif" };
+async function inspectImage(input, limits) {
+  if (input.data.byteLength === 0 || input.data.byteLength > limits.maxBytes)
+    throw new AttachmentError("LIMIT_EXCEEDED", "Image source byte limit exceeded or empty image");
+  try {
+    const decoder = sharp(input.data, { failOn: "warning", limitInputPixels: limits.maxPixels });
+    const meta = await decoder.metadata();
+    if (!meta.format || !(meta.format in MIME))
+      throw new AttachmentError("INVALID_IMAGE", "Only PNG, JPEG, WebP and GIF are accepted");
+    const mimeType = MIME[meta.format];
+    if (input.mimeType !== void 0 && input.mimeType !== mimeType)
+      throw new AttachmentError("INVALID_IMAGE", "Image MIME does not match its bytes");
+    const rotated = (meta.orientation ?? 1) >= 5;
+    const width = rotated ? meta.height : meta.width;
+    const height = rotated ? meta.width : meta.height;
+    if (width * height > limits.maxPixels || Math.max(width, height) > limits.maxDimension)
+      throw new AttachmentError("LIMIT_EXCEEDED", "Image pixel or dimension limit exceeded");
+    await decoder.stats();
+    return { mimeType, width, height, animated: (meta.pages ?? 1) > 1 };
+  } catch (error) {
+    if (error instanceof AttachmentError)
+      throw error;
+    throw new AttachmentError("INVALID_IMAGE", "Image cannot be decoded safely", { cause: error });
+  }
+}
+function validateTarget(target) {
+  assertImageView(target);
+  if (![target.maxBytes, target.maxPixels, target.maxDimension].every((n) => Number.isSafeInteger(n) && n > 0) || target.formats.length === 0 || target.formats.some((f) => !["image/png", "image/jpeg", "image/webp"].includes(f))) {
+    throw new AttachmentError("LIMIT_EXCEEDED", "Invalid image request limits");
+  }
+}
+async function renderImage(data, ref, target, variantId, signal) {
+  validateTarget(target);
+  const region = target.region;
+  if (region && (region.x + region.width > ref.width || region.y + region.height > ref.height))
+    throw new AttachmentError("LIMIT_EXCEEDED", "Crop is outside the oriented original image");
+  const sourceWidth = region?.width ?? ref.width;
+  const sourceHeight = region?.height ?? ref.height;
+  let scale = Math.min(1, Math.sqrt(target.maxPixels / (sourceWidth * sourceHeight)), target.maxDimension / Math.max(sourceWidth, sourceHeight));
+  if (target.fullResolution && scale < 1)
+    throw new AttachmentError("LIMIT_EXCEEDED", "Native resolution exceeds image pixel limits; use a crop or allow resizing");
+  const base = sharp(data, { failOn: "warning", limitInputPixels: ref.width * ref.height }).rotate().toColourspace("srgb");
+  if (region)
+    base.extract({ left: region.x, top: region.y, width: region.width, height: region.height });
+  const alpha = (await base.metadata()).hasAlpha;
+  const formats2 = target.formats.filter((f) => !alpha || f !== "image/jpeg");
+  if (formats2.length === 0)
+    throw new AttachmentError("LIMIT_EXCEEDED", "Request formats cannot preserve image transparency");
+  let previous = "";
+  while (true) {
+    signal?.throwIfAborted();
+    const width = Math.max(1, Math.floor(sourceWidth * scale));
+    const height = Math.max(1, Math.floor(sourceHeight * scale));
+    if (width * height > target.maxPixels) {
+      scale *= 0.75;
+      continue;
+    }
+    const dimensions = `${width}x${height}`;
+    if (dimensions === previous)
+      break;
+    previous = dimensions;
+    for (const mimeType of formats2) {
+      for (const quality of mimeType === "image/png" ? [100] : [85, 75, 60]) {
+        signal?.throwIfAborted();
+        const pipeline = base.clone().resize(width, height, { fit: "fill", withoutEnlargement: true });
+        const encoded = mimeType === "image/png" ? pipeline.png() : mimeType === "image/webp" ? pipeline.webp({ quality }) : pipeline.jpeg({ quality });
+        const { data: output, info } = await encoded.toBuffer({ resolveWithObject: true });
+        if (output.length <= target.maxBytes) {
+          signal?.throwIfAborted();
+          return {
+            data: output,
+            mimeType,
+            width: info.width,
+            height: info.height,
+            variantId,
+            note: `Original oriented size ${ref.width}x${ref.height}; sent ${info.width}x${info.height}.` + (region ? ` Crop origin (${region.x},${region.y}), source region ${region.width}x${region.height}; scale coordinates to that region then add the origin.` : " Scale coordinates to the original size.") + (ref.animated ? " Animation: only the first frame is shown." : "")
+          };
+        }
+      }
+    }
+    if (target.fullResolution || width === 1 && height === 1)
+      break;
+    scale *= 0.75;
+  }
+  throw new AttachmentError("LIMIT_EXCEEDED", "Image cannot fit the request byte limit without violating the requested view");
+}
+
+// ../../packages/attachment/attachment-local/dist/local-attachment-store.js
+var LocalAttachmentStore = class extends AttachmentStore {
+  root;
+  imageLimits;
+  db;
+  now;
+  concurrency;
+  active = 0;
+  waiting = [];
+  operations = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(options) {
+    super();
+    this.root = resolve13(options.root);
+    this.now = options.now ?? Date.now;
+    this.imageLimits = Object.freeze({ ...DEFAULT_IMAGE_LIMITS, ...options.imageLimits });
+    this.concurrency = options.compressionConcurrency ?? 2;
+    if (![...Object.values(this.imageLimits), this.concurrency].every((n) => Number.isSafeInteger(n) && n > 0) || this.concurrency > 8)
+      throw new AttachmentError("LIMIT_EXCEEDED", "Invalid attachment configuration");
+    for (const path5 of [this.root, join17(this.root, "objects"), join17(this.root, "tmp"), join17(this.root, "variants")]) {
+      mkdirSync5(path5, { recursive: true, mode: 448 });
+    }
+    this.db = new DatabaseSync(join17(this.root, "metadata.sqlite"));
+    chmodSync4(join17(this.root, "metadata.sqlite"), 384);
+    this.db.exec(`PRAGMA busy_timeout=5000; PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL;
+      CREATE TABLE IF NOT EXISTS objects(id TEXT PRIMARY KEY, created INTEGER NOT NULL, unreferenced INTEGER, referenced INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS operations(id TEXT PRIMARY KEY, pid INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value INTEGER NOT NULL);`);
+  }
+  transaction(action) {
+    if (this.closed)
+      throw new AttachmentError("CLOSED", "Attachment store is closed");
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = action();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  protect() {
+    const id = randomUUID16();
+    this.transaction(() => this.db.prepare("INSERT INTO operations VALUES (?, ?)").run(id, process.pid));
+    this.operations.add(id);
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      if (!this.closed)
+        this.db.prepare("DELETE FROM operations WHERE id=?").run(id);
+      this.operations.delete(id);
+    };
+  }
+  async limited(task) {
+    if (this.active >= this.concurrency)
+      await new Promise((resolve15) => this.waiting.push(resolve15));
+    else
+      this.active++;
+    try {
+      return await task();
+    } finally {
+      const next = this.waiting.shift();
+      if (next)
+        next();
+      else
+        this.active--;
+    }
+  }
+  async saveFile(source, name, signal) {
+    const release = this.protect();
+    try {
+      const ref = await writeObject(this.root, source, name, signal);
+      this.transaction(() => this.db.prepare("INSERT OR IGNORE INTO objects VALUES (?, ?, ?, 0)").run(ref.id, this.now(), this.now()));
+      return ref;
+    } finally {
+      release();
+    }
+  }
+  async *readFile(ref, signal) {
+    const release = this.protect();
+    try {
+      yield* readObject(this.root, ref, signal);
+    } finally {
+      release();
+    }
+  }
+  async saveImages(inputs, signal) {
+    const release = this.protect();
+    try {
+      if (inputs.length > this.imageLimits.maxImages || inputs.reduce((sum, input) => sum + input.data.byteLength, 0) > this.imageLimits.maxBatchBytes)
+        throw new AttachmentError("LIMIT_EXCEEDED", "Image batch exceeds count or byte limits");
+      const owned = inputs.map((input) => ({ ...input, data: Buffer.from(input.data) }));
+      const inspected = [];
+      for (const input of owned) {
+        signal?.throwIfAborted();
+        inspected.push(await this.limited(() => inspectImage(input, this.imageLimits)));
+      }
+      const refs = [];
+      for (const [index, input] of owned.entries()) {
+        const ref = await this.saveFile((async function* () {
+          yield input.data;
+        })(), input.name, signal);
+        refs.push({ ...ref, ...inspected[index] });
+      }
+      return refs;
+    } finally {
+      release();
+    }
+  }
+  async prepareImage(ref, target, signal) {
+    assertAttachmentContent({ type: "image", ref });
+    validateTarget(target);
+    const release = this.protect();
+    try {
+      if (ref.bytes > this.imageLimits.maxBytes)
+        throw new AttachmentError("LIMIT_EXCEEDED", "Stored image exceeds configured source limit");
+      const chunks = [];
+      for await (const chunk of this.readFile(ref, signal))
+        chunks.push(chunk);
+      const data = Buffer.concat(chunks);
+      return await this.limited(async () => {
+        const actual = await inspectImage({ data, name: ref.name, mimeType: ref.mimeType }, this.imageLimits);
+        if (actual.width !== ref.width || actual.height !== ref.height || actual.animated !== ref.animated)
+          throw new AttachmentError("CORRUPT", "Image reference metadata mismatch");
+        const variantId = createHash10("sha256").update(JSON.stringify({
+          version: 1,
+          id: ref.id,
+          pixels: target.maxPixels,
+          dimension: target.maxDimension,
+          bytes: target.maxBytes,
+          formats: target.formats,
+          region: target.region ?? null,
+          full: target.fullResolution ?? false
+        })).digest("hex");
+        const directory = join17(this.root, "variants", ref.id.slice(7));
+        const path5 = join17(directory, variantId + ".json");
+        try {
+          const raw = JSON.parse(await readFile5(path5, { encoding: "utf8", signal }));
+          const cached = raw;
+          if (cached.variantId === variantId && typeof cached.data === "string" && typeof cached.digest === "string" && typeof cached.note === "string") {
+            const bytes = Buffer.from(cached.data, "base64");
+            if (bytes.length <= target.maxBytes && createHash10("sha256").update(bytes).digest("hex") === cached.digest) {
+              const decoder = sharp2(bytes, { failOn: "warning", limitInputPixels: target.maxPixels });
+              const meta = await decoder.metadata();
+              if (meta.width === cached.width && meta.height === cached.height && Math.max(meta.width, meta.height) <= target.maxDimension && meta.width * meta.height <= target.maxPixels && cached.mimeType === `image/${meta.format}` && target.formats.includes(cached.mimeType)) {
+                await decoder.stats();
+                signal?.throwIfAborted();
+                return { data: bytes, width: meta.width, height: meta.height, mimeType: cached.mimeType, variantId, note: cached.note };
+              }
+            }
+          }
+        } catch (error) {
+          signal?.throwIfAborted();
+        }
+        const result = await renderImage(data, ref, target, variantId, signal);
+        await mkdir5(directory, { recursive: true, mode: 448 });
+        const temporary = join17(this.root, "tmp", randomUUID16());
+        try {
+          await writeFile4(temporary, JSON.stringify({ ...result, data: Buffer.from(result.data).toString("base64"), digest: createHash10("sha256").update(result.data).digest("hex") }), { flag: "wx", mode: 384 });
+          await rename2(temporary, path5);
+        } finally {
+          await unlink4(temporary).catch((error) => {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+              throw error;
+          });
+        }
+        return result;
+      });
+    } finally {
+      release();
+    }
+  }
+  commit(refs, write) {
+    return this.transaction(() => {
+      for (const ref of refs) {
+        assertFileRef(ref);
+        const path5 = join17(this.root, "objects", ref.id.slice(7, 9), ref.id.slice(7));
+        if (!existsSync8(path5))
+          throw new AttachmentError("NOT_FOUND", `Attachment missing before commit: ${ref.id}`);
+        const info = lstatSync3(path5);
+        if (!info.isFile() || info.size !== ref.bytes)
+          throw new AttachmentError("CORRUPT", "Attachment changed before commit");
+        this.db.prepare("INSERT OR IGNORE INTO objects VALUES (?, ?, NULL, 1)").run(ref.id, this.now());
+        this.db.prepare("UPDATE objects SET referenced=1, unreferenced=NULL WHERE id=?").run(ref.id);
+      }
+      const result = write();
+      if (result instanceof Promise)
+        throw new TypeError("Attachment commit callback must be synchronous");
+      return result;
+    });
+  }
+  collectGarbage(references, force = false) {
+    return this.transaction(() => {
+      const now = this.now();
+      const last = this.db.prepare("SELECT value FROM settings WHERE key='lastCleanup'").get();
+      if (!force && last && now - last.value < CLEANUP_INTERVAL_MS)
+        return { deleted: [], skipped: true };
+      const operations2 = this.db.prepare("SELECT id,pid FROM operations").all();
+      for (const operation of operations2) {
+        let alive = true;
+        try {
+          process.kill(operation.pid, 0);
+        } catch (error) {
+          if (error instanceof Error && "code" in error && error.code === "ESRCH")
+            alive = false;
+        }
+        if (alive)
+          return { deleted: [], skipped: true };
+        this.db.prepare("DELETE FROM operations WHERE id=?").run(operation.id);
+      }
+      const retained = references();
+      for (const prefix of readdirSync3(join17(this.root, "objects"))) {
+        if (!/^[a-f0-9]{2}$/.test(prefix))
+          continue;
+        for (const hash of readdirSync3(join17(this.root, "objects", prefix))) {
+          if (!/^[a-f0-9]{64}$/.test(hash) || !hash.startsWith(prefix))
+            continue;
+          const info = lstatSync3(join17(this.root, "objects", prefix, hash));
+          if (!info.isFile())
+            throw new AttachmentError("CORRUPT", "Unexpected attachment object type");
+          this.db.prepare("INSERT OR IGNORE INTO objects VALUES (?, ?, ?, 0)").run(`sha256:${hash}`, info.mtimeMs, info.mtimeMs);
+        }
+      }
+      const rows = this.db.prepare("SELECT * FROM objects").all();
+      const deleted = [];
+      for (const row of rows) {
+        if (retained.has(row.id)) {
+          this.db.prepare("UPDATE objects SET referenced=1, unreferenced=NULL WHERE id=?").run(row.id);
+          continue;
+        }
+        if (row.unreferenced === null) {
+          this.db.prepare("UPDATE objects SET unreferenced=? WHERE id=?").run(now, row.id);
+          continue;
+        }
+        if (now - row.unreferenced < RETENTION_MS)
+          continue;
+        rmSync(join17(this.root, "variants", row.id.slice(7)), { recursive: true, force: true });
+        rmSync(join17(this.root, "objects", row.id.slice(7, 9), row.id.slice(7)), { force: true });
+        this.db.prepare("DELETE FROM objects WHERE id=?").run(row.id);
+        deleted.push(row.id);
+      }
+      for (const file of readdirSync3(join17(this.root, "tmp"))) {
+        if (/^[a-f0-9-]{36}$/.test(file))
+          rmSync(join17(this.root, "tmp", file), { force: true });
+      }
+      this.db.prepare("INSERT OR REPLACE INTO settings VALUES ('lastCleanup', ?)").run(now);
+      return { deleted, skipped: false };
+    });
+  }
+  get nextCollectionAt() {
+    if (this.closed)
+      throw new AttachmentError("CLOSED", "Attachment store is closed");
+    const row = this.db.prepare("SELECT value FROM settings WHERE key='lastCleanup'").get();
+    return row ? row.value + CLEANUP_INTERVAL_MS : 0;
+  }
+  close() {
+    if (this.closed)
+      return;
+    if (this.active || this.waiting.length || this.operations.size)
+      throw new AttachmentError("IO", "Cannot close while attachment operations are active");
+    for (const id of this.operations)
+      this.db.prepare("DELETE FROM operations WHERE id=?").run(id);
+    this.operations.clear();
+    this.db.close();
+    this.closed = true;
+  }
+};
+
+// src/create-attachment-runtime.ts
+function createAttachmentRuntime(options) {
+  mkdirSync6(options.sessionsRoot, { recursive: true, mode: 448 });
+  const store = new LocalAttachmentStore(options);
+  const now = options.now ?? Date.now;
+  let closed = false;
+  let timer;
+  const collect = (force = false) => store.collectGarbage(
+    () => scanAttachmentReferences(options.sessionsRoot),
+    force
+  );
+  const run = () => {
+    if (closed) return;
+    try {
+      collect();
+    } catch (error) {
+      options.onError(error);
+    } finally {
+      if (!closed) timer = setTimeout(run, CLEANUP_INTERVAL_MS).unref();
+    }
+  };
+  timer = setTimeout(run, Math.max(0, store.nextCollectionAt - now())).unref();
+  return {
+    store,
+    collect,
+    close() {
+      clearTimeout(timer);
+      store.close();
+      closed = true;
+    }
+  };
+}
+
 // src/stdin-prompts.ts
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 var StdinPrompts = class {
@@ -37513,7 +38400,7 @@ var StdinPrompts = class {
     if (input.readableEnded || input.destroyed) throw new PromptEofError();
     this.#active = true;
     const raw = Boolean(secret && input.isTTY && input.setRawMode);
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const decoder = new StringDecoder2("utf8");
       let answer = "";
       let settled = false;
@@ -37539,7 +38426,7 @@ var StdinPrompts = class {
           error ??= outputError;
         }
         if (error !== void 0) reject(error);
-        else resolve14(answer);
+        else resolve15(answer);
       };
       const onData = (data) => {
         try {
@@ -37782,8 +38669,8 @@ function startCoordinator(session, commandHandler, presenter, suggestCommand) {
   const done = (async () => {
     for (; ; ) {
       if (queue.length === 0) {
-        await new Promise((resolve14) => {
-          wake = resolve14;
+        await new Promise((resolve15) => {
+          wake = resolve15;
         });
         wake = null;
       }
@@ -37829,14 +38716,14 @@ function startCoordinator(session, commandHandler, presenter, suggestCommand) {
   };
 }
 function delay(ms) {
-  return new Promise((resolve14) => {
-    setTimeout(resolve14, ms);
+  return new Promise((resolve15) => {
+    setTimeout(resolve15, ms);
   });
 }
 async function settlesWithin(promise, ms) {
   let timer;
-  const timeout = new Promise((resolve14) => {
-    timer = setTimeout(() => resolve14(false), ms);
+  const timeout = new Promise((resolve15) => {
+    timer = setTimeout(() => resolve15(false), ms);
   });
   const settled = promise.then(
     () => true,
@@ -38005,13 +38892,13 @@ async function runTerminalUi(ui, driver, onSubmit) {
 
 // src/update-installation.ts
 import { spawn as spawn2 } from "node:child_process";
-import { lstat as lstat4, readFile as readFile6, realpath as realpath4 } from "node:fs/promises";
-import { basename as basename8, delimiter, dirname as dirname12, isAbsolute as isAbsolute4, join as join16, relative as relative5, resolve as resolve13, sep as sep3, win32 as win324 } from "node:path";
+import { lstat as lstat4, readFile as readFile7, realpath as realpath4 } from "node:fs/promises";
+import { basename as basename9, delimiter, dirname as dirname12, isAbsolute as isAbsolute4, join as join19, relative as relative5, resolve as resolve14, sep as sep3, win32 as win324 } from "node:path";
 
 // src/update.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
-import { open as open3, readFile as readFile5, realpath as realpath3, unlink as unlink3 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { randomUUID as randomUUID17 } from "node:crypto";
+import { open as open5, readFile as readFile6, realpath as realpath3, unlink as unlink5 } from "node:fs/promises";
+import { join as join18 } from "node:path";
 function compareStableVersions(left, right) {
   const parse3 = (value) => {
     if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) || value.includes("\n")) {
@@ -38031,13 +38918,13 @@ function updateDiagnostic(value) {
   return String(value instanceof Error ? value.message : value).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/https?:\/\/[^\s]+/gi, "[registry URL]").replace(/npm_[a-zA-Z0-9]+/g, "[redacted]").replace(/bearer\s+[^\s"']+/gi, "[redacted]").replace(/["']?(?:_authToken|_auth|password|token|authorization)["']?\s*[=:]\s*["']?[^\s"',;}]+/gi, "[redacted]").slice(0, 600);
 }
 var defaultLockIO = {
-  acquire: (path5) => open3(path5, "wx", 384),
-  read: (path5) => readFile5(path5, "utf8"),
-  remove: (path5) => unlink3(path5)
+  acquire: (path5) => open5(path5, "wx", 384),
+  read: (path5) => readFile6(path5, "utf8"),
+  remove: (path5) => unlink5(path5)
 };
 async function installedVersion(installation) {
   if (await realpath3(installation.packageRoot) !== installation.packageRoot) throw new Error("Installation target changed");
-  const value = JSON.parse(await readFile5(join15(installation.packageRoot, "package.json"), "utf8"));
+  const value = JSON.parse(await readFile6(join18(installation.packageRoot, "package.json"), "utf8"));
   if (typeof value !== "object" || value === null || !("name" in value) || value.name !== "laohuang" || !("version" in value) || typeof value.version !== "string") {
     throw new Error("Installed laohuang package is missing or invalid");
   }
@@ -38045,7 +38932,7 @@ async function installedVersion(installation) {
   return value.version;
 }
 async function runUpdate({ installation, output, signal, lockIO = defaultLockIO }) {
-  const token = randomUUID14();
+  const token = randomUUID17();
   let ownsLock = false;
   let installing = false;
   const cancelled = () => {
@@ -38128,7 +39015,7 @@ function object(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 async function json(path5) {
-  return object(JSON.parse(await readFile6(path5, "utf8")));
+  return object(JSON.parse(await readFile7(path5, "utf8")));
 }
 async function exists(path5) {
   try {
@@ -38237,17 +39124,17 @@ function createNpmRunner(cliPath, environ, options = {}) {
   };
 }
 async function npmCandidates(environ) {
-  const paths = [environ.npm_execpath, join16(dirname12(process.execPath), "node_modules/npm/bin/npm-cli.js"), join16(dirname12(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js")];
+  const paths = [environ.npm_execpath, join19(dirname12(process.execPath), "node_modules/npm/bin/npm-cli.js"), join19(dirname12(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js")];
   for (const directory of (environ.PATH ?? environ.Path ?? "").split(delimiter).filter(Boolean)) {
-    paths.push(join16(directory, "npm"), join16(directory, "node_modules/npm/bin/npm-cli.js"));
+    paths.push(join19(directory, "npm"), join19(directory, "node_modules/npm/bin/npm-cli.js"));
   }
   const result = /* @__PURE__ */ new Set();
   for (const path5 of paths) {
     if (!path5) continue;
     try {
       const actual = await realpath4(path5);
-      if (basename8(actual) !== "npm-cli.js") continue;
-      const manifest = await json(join16(dirname12(actual), "../package.json"));
+      if (basename9(actual) !== "npm-cli.js") continue;
+      const manifest = await json(join19(dirname12(actual), "../package.json"));
       if (manifest.name === "npm") result.add(actual);
     } catch {
     }
@@ -38264,8 +39151,8 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
   let packageRoot = dirname12(entry);
   let manifest = {};
   while (true) {
-    if (await exists(join16(packageRoot, "package.json"))) {
-      manifest = await json(join16(packageRoot, "package.json"));
+    if (await exists(join19(packageRoot, "package.json"))) {
+      manifest = await json(join19(packageRoot, "package.json"));
       break;
     }
     const parent = dirname12(packageRoot);
@@ -38275,8 +39162,8 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
   if (manifest.name !== "laohuang" || typeof manifest.version !== "string") throw new Error("Entry does not belong to laohuang");
   compareStableVersions(manifest.version, manifest.version);
   const bin = typeof manifest.bin === "string" ? manifest.bin : object(manifest.bin).laohuang;
-  if (typeof bin !== "string" || await realpath4(resolve13(packageRoot, bin)) !== entry) throw new Error("Entry does not match the installed laohuang executable");
-  if (basename8(dirname12(packageRoot)) !== "node_modules" || packageRoot.split(sep3).some((part) => ["_npx", ".pnpm", ".yarn"].includes(part))) throw new Error("Update requires a direct npm installation; source, linked, cache and other package-manager installations are unsupported");
+  if (typeof bin !== "string" || await realpath4(resolve14(packageRoot, bin)) !== entry) throw new Error("Entry does not match the installed laohuang executable");
+  if (basename9(dirname12(packageRoot)) !== "node_modules" || packageRoot.split(sep3).some((part) => ["_npx", ".pnpm", ".yarn"].includes(part))) throw new Error("Update requires a direct npm installation; source, linked, cache and other package-manager installations are unsupported");
   const candidates = options.cliPaths ?? await npmCandidates(environ);
   const runner = options.createRunner ?? createNpmRunner;
   if (candidates.length === 0) throw new Error("Cannot locate npm-cli.js");
@@ -38294,7 +39181,7 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
       if (checked.code !== 0 || await realpath4(checked.stdout.trim()) !== dirname12(packageRoot)) continue;
       globals.push({ packageRoot, installedVersion: manifest.version, npm: {
         run: (args, runOptions) => npm.run(args[0] === "view" ? [...args, "--global", "--prefix", prefix] : args, runOptions)
-      }, workingDirectory: prefix, installArgs: ["--global", "--prefix", prefix], lockPath: join16(dirname12(packageRoot), ".laohuang-update.lock") });
+      }, workingDirectory: prefix, installArgs: ["--global", "--prefix", prefix], lockPath: join19(dirname12(packageRoot), ".laohuang-update.lock") });
     } catch {
       options.signal?.throwIfAborted();
     }
@@ -38306,12 +39193,12 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
   const owners = [];
   for (let root = dirname12(dirname12(packageRoot)); ; root = dirname12(root)) {
     options.signal?.throwIfAborted();
-    const lockPath = join16(root, "package-lock.json");
+    const lockPath = join19(root, "package-lock.json");
     if (await exists(lockPath)) {
       for (const other of ["pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb", "npm-shrinkwrap.json"]) {
-        if (await exists(join16(root, other))) throw new Error("Ambiguous or unsupported package manager ownership");
+        if (await exists(join19(root, other))) throw new Error("Ambiguous or unsupported package manager ownership");
       }
-      const rootManifest = await json(join16(root, "package.json"));
+      const rootManifest = await json(join19(root, "package.json"));
       if (typeof rootManifest.packageManager === "string" && !rootManifest.packageManager.startsWith("npm@")) throw new Error("Installation belongs to another package manager");
       const lock = await json(lockPath);
       const packages = object(lock.packages);
@@ -38330,27 +39217,27 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
         if (!Array.isArray(workspaces)) throw new Error("npm returned invalid workspace metadata");
         for (const value of workspaces) {
           const workspace = object(value);
-          if (typeof workspace.location !== "string" || typeof workspace.realpath !== "string" || !inside2(root, resolve13(root, workspace.location))) throw new Error("npm returned invalid workspace ownership");
-          if (await realpath4(resolve13(root, workspace.location)) !== workspace.realpath) throw new Error("npm workspace target changed");
+          if (typeof workspace.location !== "string" || typeof workspace.realpath !== "string" || !inside2(root, resolve14(root, workspace.location))) throw new Error("npm returned invalid workspace ownership");
+          if (await realpath4(resolve14(root, workspace.location)) !== workspace.realpath) throw new Error("npm workspace target changed");
           workspacePaths.add(workspace.location);
         }
       }
       for (const [key, metadata2] of Object.entries(packages)) {
-        if (key.includes("node_modules") || !inside2(root, resolve13(root, key))) continue;
+        if (key.includes("node_modules") || !inside2(root, resolve14(root, key))) continue;
         if (key !== "") {
           if (!workspacePaths.has(key)) continue;
           if (!Object.values(packages).some((value) => object(value).link === true && object(value).resolved === key)) continue;
         }
-        const owner = await realpath4(resolve13(root, key));
+        const owner = await realpath4(resolve14(root, key));
         if (!inside2(root, owner)) continue;
-        const declaration = await json(join16(owner, "package.json"));
+        const declaration = await json(join19(owner, "package.json"));
         for (const bucket of ["dependencies", "devDependencies", "optionalDependencies"]) {
           const range = object(declaration[bucket]).laohuang;
           if (typeof range !== "string") continue;
           let resolvedPackage;
           for (let directory = owner; inside2(root, directory); directory = dirname12(directory)) {
-            if (await exists(join16(directory, "node_modules/laohuang"))) {
-              resolvedPackage = await realpath4(join16(directory, "node_modules/laohuang"));
+            if (await exists(join19(directory, "node_modules/laohuang"))) {
+              resolvedPackage = await realpath4(join19(directory, "node_modules/laohuang"));
               break;
             }
             if (directory === root) break;
@@ -38367,7 +39254,7 @@ async function resolveNpmInstallation(entryPath, environ, options = {}) {
             },
             workingDirectory: root,
             installArgs: ["--global=false", "--prefix", root, "--package-lock=true", "--save=true", "--save-peer=false", "--save-dev=false", "--save-optional=false", "--save-prod=false", bucket === "devDependencies" ? "--save-dev" : bucket === "optionalDependencies" ? "--save-optional" : "--save-prod", ...bucket === "devDependencies" ? ["--include=dev"] : [], .../^[~^]/.test(range) ? ["--save-exact=false", `--save-prefix=${range[0]}`] : ["--save-exact"], ...key ? ["--workspace", key, "--include-workspace-root=false"] : ["--workspaces=false"]],
-            lockPath: join16(root, ".laohuang-update.lock")
+            lockPath: join19(root, ".laohuang-update.lock")
           });
         }
       }
@@ -38397,7 +39284,7 @@ function safeDiagnostic(value) {
 }
 function createClipboardRunner(environ, timeoutMs = 5e3) {
   const env = { ...environ };
-  return (command, args, text3) => new Promise((resolve14) => {
+  return (command, args, text3) => new Promise((resolve15) => {
     let child;
     try {
       child = spawn3(command, [...args], {
@@ -38407,7 +39294,7 @@ function createClipboardRunner(environ, timeoutMs = 5e3) {
         stdio: ["pipe", "ignore", "pipe"]
       });
     } catch (error) {
-      resolve14({ code: 1, stderr: errorMessage12(error) });
+      resolve15({ code: 1, stderr: errorMessage12(error) });
       return;
     }
     let stderr = "";
@@ -38417,7 +39304,7 @@ function createClipboardRunner(environ, timeoutMs = 5e3) {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      resolve14({ code, stderr: diagnostic });
+      resolve15({ code, stderr: diagnostic });
     };
     const stop = (diagnostic) => {
       try {
@@ -38612,17 +39499,19 @@ async function main(argv, options = {}) {
   const configPath = options.configPath ?? defaultConfigPath(environ);
   const manager = new ConfigManager(configPath);
   const credentials = new CredentialStore(
-    options.credentialsPath ?? join17(dirname13(configPath), "credentials.json")
+    options.credentialsPath ?? join20(dirname13(configPath), "credentials.json")
   );
   const modelCatalogStore = new ModelCatalogStore(
-    options.modelsPath ?? join17(dirname13(configPath), "models.json")
+    options.modelsPath ?? join20(dirname13(configPath), "models.json")
   );
   const customModels = new CustomModelsStore(
-    options.customModelsPath ?? join17(dirname13(configPath), "custom-models.json")
+    options.customModelsPath ?? join20(dirname13(configPath), "custom-models.json")
   );
   let modelPlatform;
+  let attachmentRuntime;
   try {
     modelPlatform = await createPiAiPlatform({
+      attachments: { store: () => attachmentRuntime?.store },
       credentials,
       modelCatalogStore,
       excludedProviderIds: EXCLUDED_PROVIDER_IDS,
@@ -38751,7 +39640,7 @@ async function main(argv, options = {}) {
   let shellPath;
   try {
     shellPath = manager.getShellPath();
-    if (existsSync8(configPath)) {
+    if (existsSync9(configPath)) {
       config = manager.resolve({
         environ,
         profile: args.profile,
@@ -38796,7 +39685,13 @@ async function main(argv, options = {}) {
   let terminalUi = null;
   let terminalDriver = null;
   let selectedModel = modelPlatform.catalog.getModel(config.provider, config.model);
+  attachmentRuntime = createAttachmentRuntime({
+    root: join20(getHomeDirectory({ env: environ }), ".laohuang", "attachments"),
+    sessionsRoot: defaultSessionsRoot(environ),
+    onError: (error) => writeStderr(`Attachment cleanup failed: ${errorMessage11(error)}`)
+  });
   const sessionController = new SessionController({
+    attachments: attachmentRuntime.store,
     sessionsRoot: defaultSessionsRoot(environ),
     projectRoot,
     initialCwd: process.cwd(),
@@ -38849,6 +39744,18 @@ async function main(argv, options = {}) {
       }
     });
     const toolRegistry = new ToolRegistry([
+      createReadImageTool({
+        store: attachmentRuntime.store,
+        projectRoot,
+        pathOptions: { env: environ, shellPath: () => resolveBashPath({ shellPath, env: environ }) },
+        resolveReference: (id) => {
+          for (const entry of sessionController.history?.entries() ?? []) {
+            if (!("message" in entry.payload) || !("attachments" in entry.payload.message)) continue;
+            for (const block of entry.payload.message.attachments ?? []) if (block.type === "image" && block.ref.id === id) return block.ref;
+          }
+          return void 0;
+        }
+      }),
       skillRuntime.session.tool,
       ...createFileToolDefinitions({ projectRoot, pathOptions: {
         env: environ,
@@ -38859,6 +39766,7 @@ async function main(argv, options = {}) {
     let commandDispatcher;
     let runtimeInitialized = false;
     const composedRuntime = createSessionRuntime({
+      attachments: attachmentRuntime.store,
       modelAdapter: modelPlatform.adapter,
       catalog: modelPlatform.catalog,
       route: { provider: config.provider, model: config.model, baseUrl: config.baseUrl },
@@ -39087,15 +39995,19 @@ Submit an empty line to retry, or enter a replacement.`);
         try {
           await skillRuntime?.close();
         } finally {
-          if (composedForCleanup) await composedForCleanup.close();
-          else await sessionController.close();
+          try {
+            if (composedForCleanup) await composedForCleanup.close();
+            else await sessionController.close();
+          } finally {
+            attachmentRuntime.close();
+          }
         }
       }
     }
   }
 }
 function defaultSessionsRoot(environ) {
-  return join17(getHomeDirectory({ env: environ }), ".laohuang", "sessions");
+  return join20(getHomeDirectory({ env: environ }), ".laohuang", "sessions");
 }
 async function runInitialModelSelection(options) {
   let providerName = options.providerName;