@liustack/modlens 2.5.0 → 2.6.0

package/README.md

@@ -113,7 +113,7 @@ modlens -i <image-path-or-url> [options]
 
 Reach for `-m gemini-3.1-pro-high` on dense screenshots or tricky documents. Output contract: [skills/modlens/references/output-schema.md](skills/modlens/references/output-schema.md).
 
-Two more subcommands: `modlens config <init|set|show>` manages providers and keys (details below), and `modlens recover-paste` rescues images pasted into Claude Code:
+Two more subcommands: `modlens config <init|set|show>` manages providers and keys (details below), and `modlens recover-paste` rescues images pasted into Claude Code, Pi, or OpenCode:
 
 ```bash
 modlens recover-paste                 # newest pasted image, path printed as JSON
@@ -154,11 +154,11 @@ One catch: once text-only is declared, the Codex TUI **blocks Ctrl+V image paste
 - **Drag the image file into the terminal**, or type its path. The path lands as plain text, and the modlens skill picks it up from there.
 - Attach it with `codex exec -i image.png "..."`. The skill reads the path out of the message tag.
 
-## Using it in Claude Code and Pi (gateway models)
+## Using it in Claude Code, Pi, and OpenCode (gateway models)
 
 No setup needed: drag the image file into the terminal, or type its path, and the skill takes over.
 
-Paste is trickier. If you run a text-only model behind `ANTHROPIC_BASE_URL`, Claude Code never writes pasted images to a regular temp file and has no modality switch, so a pasted image reaches the model as a pathless `[Unsupported Image]` placeholder (lenient gateways like DeepSeek's Anthropic endpoint) or breaks the request outright ([#62009](https://github.com/anthropics/claude-code/issues/62009)). But the bytes are not gone: Claude Code appends every user message, images included, to the local session transcript before the gateway ever sees it. That is what `modlens recover-paste` exploits: it pulls the most recent pasted images back out of the transcript and prints real file paths, ready for `modlens -i`. The skill runs this automatically when it spots the placeholder. Verified end to end in a real DeepSeek-gateway Claude Code session: paste an image, the model sees only the placeholder, recovers the file by session id, and answers with full image content. Transcripts are per-session files. Skills can pass the exact session via `--session` (Claude Code substitutes `${CLAUDE_SESSION_ID}` into skill text since v2.1.9); without it, recovery picks the transcript holding the newest pasted image by message timestamp, so concurrent sessions in the same project do not confuse it either way. [Pi](https://github.com/earendil-works/pi) stores sessions the same way (`~/.pi/agent/sessions/`, images as base64 in JSONL), and `recover-paste` auto-detects both harnesses, verified live against a real pi session. One honest caveat: transcript layouts are internal implementation details of those tools with no compatibility promise; if recovery ever breaks, dragging the file still works everywhere.
+Paste is trickier. If you run a text-only model behind `ANTHROPIC_BASE_URL`, Claude Code never writes pasted images to a regular temp file and has no modality switch, so a pasted image reaches the model as a pathless `[Unsupported Image]` placeholder (lenient gateways like DeepSeek's Anthropic endpoint) or breaks the request outright ([#62009](https://github.com/anthropics/claude-code/issues/62009)). But the bytes are not gone: Claude Code appends every user message, images included, to the local session transcript before the gateway ever sees it. That is what `modlens recover-paste` exploits: it pulls the most recent pasted images back out of the transcript and prints real file paths, ready for `modlens -i`. The skill runs this automatically when it spots the placeholder. Verified end to end in a real DeepSeek-gateway Claude Code session: paste an image, the model sees only the placeholder, recovers the file by session id, and answers with full image content. Transcripts are per-session files. Skills can pass the exact session via `--session` (Claude Code substitutes `${CLAUDE_SESSION_ID}` into skill text since v2.1.9); without it, recovery picks the transcript holding the newest pasted image by message timestamp, so concurrent sessions in the same project do not confuse it either way. [Pi](https://github.com/earendil-works/pi) stores sessions the same way (`~/.pi/agent/sessions/`, images as base64 in JSONL). [OpenCode](https://github.com/sst/opencode) keeps them in SQLite instead (`~/.local/share/opencode/opencode.db`, images as data URLs; reading it needs Node 22.5+ for node:sqlite). `recover-paste` auto-detects all three harnesses and picks whichever holds this project's newest pasted image, each verified against a real session. One honest caveat: transcript layouts are internal implementation details of those tools with no compatibility promise; if recovery ever breaks, dragging the file still works everywhere.
 
 ## Why a bridge instead of a multimodal model?
 

package/README.zh-CN.md

@@ -113,7 +113,7 @@ modlens -i <图片路径或 URL> [选项]
 
 截图信息密集或文档难啃，换成 `-m gemini-3.1-pro-high`。输出契约见 [skills/modlens/references/output-schema.md](skills/modlens/references/output-schema.md)。
 
-另外两个子命令：`modlens config <init|set|show>` 管 provider 和 key（下文详述），`modlens recover-paste` 抢救粘贴进 Claude Code 的图片：
+另外两个子命令：`modlens config <init|set|show>` 管 provider 和 key（下文详述），`modlens recover-paste` 抢救粘贴进 Claude Code、Pi、OpenCode 的图片：
 
 ```bash
 modlens recover-paste                 # 捞最新一张，路径以 JSON 打印
@@ -154,11 +154,11 @@ Codex 只认 Responses API，DeepSeek 官方端点原生支持。先照着[官
 - **把图片文件拖进终端**，或者手打路径。路径以纯文本形式落进消息，modlens skill 接着从这里接手。
 - 用 `codex exec -i 图片.png "..."` skill 从这里把路径抠出来。
 
-## 在 Claude Code 和 Pi 里用（网关接第三方模型）
+## 在 Claude Code、Pi、OpenCode 里用（网关接第三方模型）
 
 不用任何配置：把图片文件拖进终端，或手打路径，skill 直接接手。
 
-粘贴要多说两句。走 `ANTHROPIC_BASE_URL` 网关跑纯文本模型时，Claude Code 粘贴的图片从不写普通临时文件，也没有声明模型无视觉的开关，粘贴的图要么变成一个不带路径的 `[Unsupported Image]` 占位符到达模型（DeepSeek 的 Anthropic 兼容端点这类宽容网关），要么直接把请求搞挂（[#62009](https://github.com/anthropics/claude-code/issues/62009)）。但图片字节没有蒸发：Claude Code 在网关看到消息之前，就把每条用户消息（含图片）原样写进了本地会话记录。`modlens recover-paste` 干的就是这件事：从会话记录里把最近粘贴的图捞回来，落成真实文件路径，直接喂给 `modlens -i`。skill 看到占位符会自动跑这一步。已在真实的 DeepSeek 网关 Claude Code 会话里端到端验证：粘贴一张图，模型只看到占位符，按会话 ID 捞回文件，带着完整图片内容回答。会话记录本来就是一个会话一个文件。skill 可以通过 `--session` 传入精确会话（Claude Code 从 v2.1.9 起会把 `${CLAUDE_SESSION_ID}` 替换进 skill 文本），不传时按消息时间戳挑「持有最新粘贴图」的那份，两条路都不怕同项目并发多开。[Pi](https://github.com/earendil-works/pi) 的会话存储和它同构（`~/.pi/agent/sessions/`，图片以 base64 存 JSONL），`recover-paste` 会自动探测两家宿主，已拿真实 pi 会话验证过。一句老实话：会话记录格式是这些工具的内部实现，没有兼容承诺，哪天捞不动了，拖文件永远是保底。
+粘贴要多说两句。走 `ANTHROPIC_BASE_URL` 网关跑纯文本模型时，Claude Code 粘贴的图片从不写普通临时文件，也没有声明模型无视觉的开关，粘贴的图要么变成一个不带路径的 `[Unsupported Image]` 占位符到达模型（DeepSeek 的 Anthropic 兼容端点这类宽容网关），要么直接把请求搞挂（[#62009](https://github.com/anthropics/claude-code/issues/62009)）。但图片字节没有蒸发：Claude Code 在网关看到消息之前，就把每条用户消息（含图片）原样写进了本地会话记录。`modlens recover-paste` 干的就是这件事：从会话记录里把最近粘贴的图捞回来，落成真实文件路径，直接喂给 `modlens -i`。skill 看到占位符会自动跑这一步。已在真实的 DeepSeek 网关 Claude Code 会话里端到端验证：粘贴一张图，模型只看到占位符，按会话 ID 捞回文件，带着完整图片内容回答。会话记录本来就是一个会话一个文件。skill 可以通过 `--session` 传入精确会话（Claude Code 从 v2.1.9 起会把 `${CLAUDE_SESSION_ID}` 替换进 skill 文本），不传时按消息时间戳挑「持有最新粘贴图」的那份，两条路都不怕同项目并发多开。[Pi](https://github.com/earendil-works/pi) 的会话存储和它同构（`~/.pi/agent/sessions/`，图片以 base64 存 JSONL）。[OpenCode](https://github.com/sst/opencode) 换了个存法，图片以 data URL 塞进 SQLite（`~/.local/share/opencode/opencode.db`，读它需要 Node 22.5+ 的 node:sqlite）。`recover-paste` 会自动探测三家宿主，挑出持有本项目最新粘贴图的那家，都拿真实会话验证过。一句老实话：会话记录格式是这些工具的内部实现，没有兼容承诺，哪天捞不动了，拖文件永远是保底。
 
 ## 为什么外挂，而不是换多模态模型？
 

package/dist/main.js

@@ -5,6 +5,7 @@ import * as path from "path";
 import { spawn } from "child_process";
 import * as os from "os";
 import * as crypto from "crypto";
+import { createRequire } from "module";
 const CONFIG_DIR = path.join(os.homedir(), ".modlens");
 const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 const ENV_BINDINGS = {
@@ -850,57 +851,6 @@ const EXT_BY_MIME = {
   "image/webp": "webp",
   "image/gif": "gif"
 };
-function claudeProjectSlug(cwd) {
-  return path.resolve(cwd).replace(/[/.]/g, "-");
-}
-function piSessionSlug(cwd) {
-  const resolved = path.resolve(cwd);
-  return `--${resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-}
-const claudeAdapter = {
-  name: "claude-code",
-  sessionDir: (cwd) => path.join(os.homedir(), ".claude", "projects", claudeProjectSlug(cwd)),
-  matchesSession: (fileName, sessionId) => fileName === `${sessionId}.jsonl`,
-  extractUserImages: (line) => {
-    const message = line.message;
-    if (message?.role !== "user" || !Array.isArray(message.content)) {
-      return [];
-    }
-    const images = [];
-    for (const block of message.content) {
-      const source = block?.source;
-      if (block?.type === "image" && source?.type === "base64" && source.data) {
-        images.push({ mediaType: source.media_type ?? "image/png", data: source.data });
-      }
-    }
-    return images;
-  }
-};
-const piAdapter = {
-  name: "pi",
-  sessionDir: (cwd) => path.join(os.homedir(), ".pi", "agent", "sessions", piSessionSlug(cwd)),
-  // pi files look like 2026-08-03T14-18-04-595Z_<uuid>.jsonl
-  matchesSession: (fileName, sessionId) => fileName.endsWith(`_${sessionId}.jsonl`),
-  extractUserImages: (line) => {
-    const message = line.message;
-    if (message?.role !== "user" || !Array.isArray(message.content)) {
-      return [];
-    }
-    const images = [];
-    for (const block of message.content) {
-      const typed = block;
-      if (typed?.type === "image" && typed.data) {
-        images.push({ mediaType: typed.mimeType ?? "image/png", data: typed.data });
-      }
-    }
-    return images;
-  }
-};
-const ADAPTERS = [claudeAdapter, piAdapter];
-function lineTimestamp(line) {
-  const ts = line.timestamp;
-  return typeof ts === "string" ? ts : null;
-}
 function forEachJsonLine(filePath, visit) {
   let raw;
   try {
@@ -918,81 +868,259 @@ function forEachJsonLine(filePath, visit) {
     }
   }
 }
-function newestImageTimestamp(adapter, filePath) {
+function jsonlSource(harness, filePath, extractLine) {
+  return {
+    harness,
+    location: filePath,
+    extract: () => {
+      const images = [];
+      forEachJsonLine(filePath, (line) => {
+        images.push(...extractLine(line));
+      });
+      return images;
+    }
+  };
+}
+function newestJsonlTimestamp(filePath, extractLine) {
   let latest = null;
   forEachJsonLine(filePath, (line) => {
-    if (adapter.extractUserImages(line).length === 0) {
+    if (extractLine(line).length === 0) {
       return;
     }
-    const ts = lineTimestamp(line);
-    if (ts && (!latest || ts > latest)) {
-      latest = ts;
+    const ts = line.timestamp;
+    const ms = typeof ts === "string" ? Date.parse(ts) : NaN;
+    if (Number.isFinite(ms) && (latest === null || ms > latest)) {
+      latest = ms;
     }
   });
   return latest;
 }
-function listTranscripts(adapter, cwd) {
+function listJsonl(dir) {
   try {
-    return fs.readdirSync(adapter.sessionDir(cwd)).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(adapter.sessionDir(cwd), name));
+    return fs.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(dir, name));
   } catch {
     return [];
   }
 }
-function locateTranscript(cwd) {
-  const candidates = [];
-  for (const adapter of ADAPTERS) {
-    for (const transcript of listTranscripts(adapter, cwd)) {
-      const timestamp = newestImageTimestamp(adapter, transcript);
-      if (timestamp) {
-        candidates.push({ harness: adapter.name, transcript, timestamp });
+function jsonlAdapter(options) {
+  const { name, dirFor, matchesSession, extractLine } = options;
+  return {
+    name,
+    describe: (cwd) => dirFor(cwd),
+    findNewest: (cwd) => {
+      let best = null;
+      for (const file of listJsonl(dirFor(cwd))) {
+        const timestamp = newestJsonlTimestamp(file, extractLine);
+        if (timestamp !== null && (!best || timestamp > best.timestamp)) {
+          best = { ref: jsonlSource(name, file, extractLine), timestamp };
+        }
       }
+      return best;
+    },
+    findSession: (cwd, sessionId) => {
+      for (const file of listJsonl(dirFor(cwd))) {
+        if (matchesSession(path.basename(file), sessionId)) {
+          return jsonlSource(name, file, extractLine);
+        }
+      }
+      return null;
+    }
+  };
+}
+function claudeProjectSlug(cwd) {
+  return path.resolve(cwd).replace(/[/.]/g, "-");
+}
+function claudeExtractLine(line) {
+  const message = line.message;
+  if (message?.role !== "user" || !Array.isArray(message.content)) {
+    return [];
+  }
+  const images = [];
+  for (const block of message.content) {
+    const source = block?.source;
+    if (block?.type === "image" && source?.type === "base64" && source.data) {
+      images.push({ mediaType: source.media_type ?? "image/png", data: source.data });
+    }
+  }
+  return images;
+}
+const claudeAdapter = jsonlAdapter({
+  name: "claude-code",
+  dirFor: (cwd) => path.join(os.homedir(), ".claude", "projects", claudeProjectSlug(cwd)),
+  matchesSession: (fileName, sessionId) => fileName === `${sessionId}.jsonl`,
+  extractLine: claudeExtractLine
+});
+function piSessionSlug(cwd) {
+  const resolved = path.resolve(cwd);
+  return `--${resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+function piExtractLine(line) {
+  const message = line.message;
+  if (message?.role !== "user" || !Array.isArray(message.content)) {
+    return [];
+  }
+  const images = [];
+  for (const block of message.content) {
+    const typed = block;
+    if (typed?.type === "image" && typed.data) {
+      images.push({ mediaType: typed.mimeType ?? "image/png", data: typed.data });
     }
   }
-  if (candidates.length === 0) {
-    const dirs = ADAPTERS.map((a) => a.sessionDir(cwd)).join(" , ");
+  return images;
+}
+const piAdapter = jsonlAdapter({
+  name: "pi",
+  dirFor: (cwd) => path.join(os.homedir(), ".pi", "agent", "sessions", piSessionSlug(cwd)),
+  // pi files look like 2026-08-03T14-18-04-595Z_<uuid>.jsonl
+  matchesSession: (fileName, sessionId) => fileName.endsWith(`_${sessionId}.jsonl`),
+  extractLine: piExtractLine
+});
+function opencodeDbPath() {
+  return path.join(os.homedir(), ".local", "share", "opencode", "opencode.db");
+}
+function opencodeQuery(dbPath, cwd, sessionId) {
+  let DatabaseSync;
+  try {
+    const nodeRequire = createRequire(import.meta.url);
+    ({ DatabaseSync } = nodeRequire("node:sqlite"));
+  } catch {
     throw new Error(
-      `No pasted images found in any session transcript for this directory (looked in: ${dirs}). The user may not have pasted any, or the transcript format changed; ask for a file path instead.`
+      "Reading opencode storage needs the node:sqlite module (Node 22.5+). Upgrade Node, or pass --transcript/--session for a JSONL-based harness."
     );
   }
-  candidates.sort((a, b) => a.timestamp < b.timestamp ? 1 : -1);
-  return { harness: candidates[0].harness, transcript: candidates[0].transcript };
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    const resolved = path.resolve(cwd);
+    const sessionFilter = sessionId ? `AND (session.id = ? OR session.slug = ?)` : `AND session.directory = ?`;
+    const params = sessionId ? [sessionId, sessionId] : [resolved];
+    const rows = db.prepare(
+      `SELECT part.data AS data, part.time_created AS time_created
+                 FROM part
+                 JOIN message ON message.id = part.message_id
+                 JOIN session ON session.id = part.session_id
+                 WHERE part.data LIKE '{"type":"file"%'
+                   AND json_extract(message.data, '$.role') = 'user'
+                   ${sessionFilter}
+                 ORDER BY part.time_created ASC`
+    ).all(...params);
+    return rows;
+  } finally {
+    db.close();
+  }
 }
-function transcriptForSession(cwd, sessionId) {
-  for (const adapter of ADAPTERS) {
-    for (const transcript of listTranscripts(adapter, cwd)) {
-      if (adapter.matchesSession(path.basename(transcript), sessionId)) {
-        return { harness: adapter.name, transcript };
+function opencodeImagesFromRows(rows) {
+  const images = [];
+  for (const row of rows) {
+    try {
+      const part = JSON.parse(row.data);
+      if (part.type !== "file" || !part.mime?.startsWith("image/")) {
+        continue;
       }
+      const match = /^data:[^;]+;base64,(.+)$/.exec(part.url ?? "");
+      if (match) {
+        images.push({ mediaType: part.mime, data: match[1] });
+      }
+    } catch {
     }
   }
-  const dirs = ADAPTERS.map((a) => a.sessionDir(cwd)).join(" , ");
-  throw new Error(
-    `No transcript for session ${sessionId} under this project (looked in: ${dirs}). Check --cwd, or drop --session to auto-locate by newest pasted image.`
-  );
+  return images;
 }
-function adapterFor(transcript) {
-  if (transcript.includes(`${path.sep}.pi${path.sep}`)) {
-    return piAdapter;
+const opencodeAdapter = {
+  name: "opencode",
+  describe: () => opencodeDbPath(),
+  findNewest: (cwd) => {
+    const dbPath = opencodeDbPath();
+    if (!fs.existsSync(dbPath)) {
+      return null;
+    }
+    const rows = opencodeQuery(dbPath, cwd);
+    const images = opencodeImagesFromRows(rows);
+    if (images.length === 0) {
+      return null;
+    }
+    return {
+      ref: {
+        harness: "opencode",
+        location: dbPath,
+        extract: () => opencodeImagesFromRows(opencodeQuery(dbPath, cwd))
+      },
+      timestamp: rows[rows.length - 1].time_created
+    };
+  },
+  findSession: (cwd, sessionId) => {
+    const dbPath = opencodeDbPath();
+    if (!fs.existsSync(dbPath)) {
+      return null;
+    }
+    const rows = opencodeQuery(dbPath, cwd, sessionId);
+    if (opencodeImagesFromRows(rows).length === 0) {
+      return null;
+    }
+    return {
+      harness: "opencode",
+      location: dbPath,
+      extract: () => opencodeImagesFromRows(opencodeQuery(dbPath, cwd, sessionId))
+    };
   }
-  return claudeAdapter;
+};
+const ADAPTERS = [claudeAdapter, piAdapter, opencodeAdapter];
+function sourceForExplicitPath(filePath) {
+  if (filePath.endsWith(".db")) {
+    return {
+      harness: "opencode",
+      location: filePath,
+      extract: () => opencodeImagesFromRows(opencodeQuery(filePath, process.cwd()))
+    };
+  }
+  if (filePath.includes(`${path.sep}.pi${path.sep}`)) {
+    return jsonlSource("pi", filePath, piExtractLine);
+  }
+  return jsonlSource("claude-code", filePath, claudeExtractLine);
 }
-function extractUserImages(transcriptPath) {
-  const adapter = adapterFor(transcriptPath);
-  const images = [];
-  forEachJsonLine(transcriptPath, (line) => {
-    images.push(...adapter.extractUserImages(line));
-  });
-  return images;
+function locateSource(cwd) {
+  let best = null;
+  for (const adapter of ADAPTERS) {
+    let candidate = null;
+    try {
+      candidate = adapter.findNewest(cwd);
+    } catch {
+    }
+    if (candidate && (!best || candidate.timestamp > best.timestamp)) {
+      best = candidate;
+    }
+  }
+  if (!best) {
+    const dirs = ADAPTERS.map((a) => a.describe(cwd)).join(" , ");
+    throw new Error(
+      `No pasted images found in any session storage for this directory (looked in: ${dirs}). The user may not have pasted any, or the storage format changed; ask for a file path instead.`
+    );
+  }
+  return best.ref;
+}
+function sourceForSession(cwd, sessionId) {
+  for (const adapter of ADAPTERS) {
+    try {
+      const ref = adapter.findSession(cwd, sessionId);
+      if (ref) {
+        return ref;
+      }
+    } catch {
+    }
+  }
+  const dirs = ADAPTERS.map((a) => a.describe(cwd)).join(" , ");
+  throw new Error(
+    `No session ${sessionId} with pasted images under this project (looked in: ${dirs}). Check --cwd, or drop --session to auto-locate by newest pasted image.`
+  );
 }
 function recoverPastedImages(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const located = options.transcript ? { harness: adapterFor(options.transcript).name, transcript: options.transcript } : options.session ? transcriptForSession(cwd, options.session) : locateTranscript(cwd);
+  const source = options.transcript ? sourceForExplicitPath(options.transcript) : options.session ? sourceForSession(cwd, options.session) : locateSource(cwd);
   const count = Math.max(1, options.count ?? 1);
   const outDir = options.outDir ?? path.join(os.tmpdir(), "modlens-paste");
-  const all = extractUserImages(located.transcript);
+  const all = source.extract();
   if (all.length === 0) {
     throw new Error(
-      `No pasted images found in ${located.transcript}. The user may not have pasted any, or the transcript format changed; ask for a file path instead.`
+      `No pasted images found in ${source.location}. The user may not have pasted any, or the storage format changed; ask for a file path instead.`
     );
   }
   fs.mkdirSync(outDir, { recursive: true });
@@ -1005,10 +1133,10 @@ function recoverPastedImages(options = {}) {
     fs.writeFileSync(filePath, buffer);
     return { path: filePath, mediaType: image.mediaType, bytes: buffer.length };
   });
-  return { harness: located.harness, transcript: located.transcript, images };
+  return { harness: source.harness, transcript: source.location, images };
 }
 const program = new Command();
-program.name("modlens").description("Plug-in vision for text-only LLMs: image in, structured JSON evidence out").version("2.5.0");
+program.name("modlens").description("Plug-in vision for text-only LLMs: image in, structured JSON evidence out").version("2.6.0");
 program.command("analyze", { isDefault: true }).description("Analyze an image into structured JSON evidence (default command)").requiredOption("-i, --input <path|url>", "Input image path or https URL").option("-o, --output <path>", "Write result JSON to a file").option("-m, --model <name>", "Provider model name").option("-p, --provider <name>", `Vision provider (${listProviders().join(", ")})`).option("--prompt <text>", "Extra focus for this image").option("--timeout <ms>", "Provider timeout in milliseconds", "180000").option("--provider-bin <path>", "Provider binary path (default: agy)").option("--workdir <path>", "Working directory for the provider").action(async (options) => {
   try {
     const timeoutMs = Number.parseInt(options.timeout, 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liustack/modlens",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Plug-in vision for text-only LLMs, powered by the free Antigravity CLI",
   "type": "module",
   "bin": {

package/skills/modlens/SKILL.md

@@ -67,11 +67,11 @@ Harnesses rarely hand you a clean path. First identify which harness you are in,
 
 - Extract the `path` value from the tag and run modlens on it. Pasted images live in a temp file Codex already created; a stripped image keeps its path tag next to the placeholder. Do NOT use `recover-paste` here: it reads Claude Code session files, which do not exist for Codex.
 
-**Claude Code or Pi** (no path tag anywhere; the placeholder looks like `[Unsupported Image]` or a bare `[Image #1]`):
+**Claude Code, Pi, or OpenCode** (no path tag anywhere; the image reads as `[Unsupported Image]`, a bare `[Image #1]`, or an attachment you simply cannot see):
 
-- Neither harness writes pasted images to a regular temp file, but both log them into local session transcripts (`~/.claude/projects/` and `~/.pi/agent/sessions/`). `recover-paste` auto-detects which harness owns the newest pasted image. Run `modlens recover-paste` (add `--count <n>` for several images): it recovers the pasted image bytes and prints real file paths as JSON. Feed that path to `modlens -i`.
-- Session targeting: your session id is ${CLAUDE_SESSION_ID}. If that value reads as a UUID, pass it as `--session <uuid>` for exact targeting. If it reads as a literal placeholder, omit `--session`: the command auto-locates by scanning this project's transcripts for the newest pasted-image message, which is the session the user just pasted into, even with concurrent sessions. Run it from the project directory the conversation is happening in.
-- If recovery fails (transcript format is Claude Code internals and may change), ask the user to drag the image file into the terminal or type its path.
+- None of these harnesses writes pasted images to a regular temp file, but all of them persist user messages locally before any gateway strips them: Claude Code and Pi in session JSONL files (`~/.claude/projects/`, `~/.pi/agent/sessions/`), OpenCode in a SQLite database (`~/.local/share/opencode/opencode.db`, read via node:sqlite, needs Node 22.5+). `recover-paste` scans all three and auto-detects which harness owns the newest pasted image for this project. Run `modlens recover-paste` (add `--count <n>` for several images): it recovers the pasted image bytes and prints real file paths as JSON. Feed that path to `modlens -i`.
+- Session targeting: your session id is ${CLAUDE_SESSION_ID}. If that value reads as a UUID, pass it as `--session <uuid>` for exact targeting (on OpenCode, the session id or slug works too). If it reads as a literal placeholder, omit `--session`: the command auto-locates by scanning this project's sessions for the newest pasted-image message, which is the session the user just pasted into, even with concurrent sessions. Run it from the project directory the conversation is happening in.
+- If recovery fails (session storage is each harness's internals and may change), ask the user to drag the image file into the terminal or type its path.
 
 **Any other harness, or nothing matches** (no path tag and `recover-paste` reports no transcripts): do not guess. Ask the user for the image file path, or suggest dragging the file into the terminal.