@khalilgharbaoui/opencode-claude-code-plugin 0.36.4 → 0.37.0

package/dist/index.js

@@ -808,6 +808,13 @@ function formatSilentTurnNote(hadReasoning) {
   const what = hadReasoning ? "Claude Code finished the turn after thinking but never wrote an answer" : "Claude Code finished the turn without writing anything or calling a tool";
   return `
 ${SILENT_TURN_MARKER} ${what}, so there is no reply above. Nothing failed and nothing is pending: send the message again, or rephrase it.
+`;
+}
+var UNATTENDED_REPLAY_MARKER = "\u258C **between turns:**";
+function formatUnattendedReplayNote(dropped) {
+  const lost = dropped > 0 ? ` ${dropped} earlier line${dropped === 1 ? "" : "s"} were dropped.` : "";
+  return `${UNATTENDED_REPLAY_MARKER} The Claude Code CLI wrote this after the previous turn had already finished, so it is not an answer to the message above.${lost}
+
 `;
 }
 var UNRECOGNIZED_MODEL_STDERR_MARKER = "[claude-code:unrecognized_model]";
@@ -5464,6 +5471,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "skipping remote MCP server with no url",
   "stale scratch directory sweep failed",
   "task_batch resolving with child results missing",
+  "this opencode process is running an older plugin build than the one on disk",
   "timed out pending proxy call",
   "turn abort listener threw",
   "two different skills share a name; bridging the one the nearest root claimed",
@@ -5612,6 +5620,10 @@ var BUNDLE_DATA_ALLOWLIST = {
   toolNames: "name",
   cliFloor: "version",
   cliVersion: "version",
+  // The two halves of the stale-build WARN: what this process loaded and what
+  // is on disk now. Both are this package's own version strings.
+  loadedVersion: "version",
+  onDiskVersion: "version",
   opencode: "version",
   plugin: "version",
   version: "version",
@@ -5861,8 +5873,8 @@ function redactLogLine(raw, context) {
   if (!parsed.data || Object.keys(parsed.data).length === 0) return head;
   return `${head} ${JSON.stringify(sanitizeLogData(parsed.data, context))}`;
 }
-function readLogTail(path10, maxBytes = BUNDLE_TAIL_BYTES) {
-  const fd = openSync(path10, "r");
+function readLogTail(path11, maxBytes = BUNDLE_TAIL_BYTES) {
+  const fd = openSync(path11, "r");
   try {
     const size = fstatSync(fd).size;
     const length = Math.min(size, maxBytes);
@@ -6052,6 +6064,11 @@ async function fetchPlanUsage(cliPath, options = {}) {
   }
 }
 
+// src/stale-build.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
 // src/startup-diagnostics.ts
 import { execFile as execFile3 } from "child_process";
 import * as fs4 from "fs";
@@ -6191,6 +6208,161 @@ function logStartupDiagnostics(providers, opencodeVersion) {
   })();
 }
 
+// src/stale-build.ts
+var STALE_BUILD_MARKER = "\u258C **restart opencode:**";
+var STALE_BUILD_THROTTLE_MS = 6e4;
+var STALE_BUILD_SESSION_CAP = 64;
+function compareBuilds(loaded, onDisk) {
+  if (!onDisk) return null;
+  if (onDisk.version !== loaded.version) {
+    return {
+      kind: "version",
+      loadedVersion: loaded.version,
+      onDiskVersion: onDisk.version,
+      loadedAt: loaded.loadedAt
+    };
+  }
+  if (loaded.mtimeMs === void 0 || loaded.size === void 0) return null;
+  if (onDisk.mtimeMs === loaded.mtimeMs && onDisk.size === loaded.size) return null;
+  return {
+    kind: "rebuilt",
+    loadedVersion: loaded.version,
+    onDiskVersion: onDisk.version,
+    loadedAt: loaded.loadedAt,
+    rebuiltAt: onDisk.mtimeMs
+  };
+}
+function formatLocalMinute(ms) {
+  const when = new Date(ms);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${when.getFullYear()}-${pad(when.getMonth() + 1)}-${pad(when.getDate())} ${pad(when.getHours())}:${pad(when.getMinutes())}`;
+}
+function formatStaleBuildNote(stale) {
+  const loadedAt = formatLocalMinute(stale.loadedAt);
+  if (stale.kind === "version") {
+    return `${STALE_BUILD_MARKER} plugin ${stale.onDiskVersion} is on disk, but this opencode process still runs ${stale.loadedVersion}, loaded ${loadedAt}. opencode reads a plugin once at startup, so fixes since then are not active here: quit every opencode window and relaunch.`;
+  }
+  const rebuiltAt = stale.rebuiltAt === void 0 ? "since" : `at ${formatLocalMinute(stale.rebuiltAt)}`;
+  return `${STALE_BUILD_MARKER} this opencode process loaded plugin ${stale.loadedVersion} at ${loadedAt}, and that build was rebuilt on disk ${rebuiltAt}. opencode reads a plugin once at startup, so what you just built is not running here: quit every opencode window and relaunch.`;
+}
+function describeBuildStatus(status) {
+  const loadedAt = formatLocalMinute(status.loaded.loadedAt);
+  switch (status.verdict) {
+    case "current":
+      return `${status.loaded.version}, loaded ${loadedAt}, current`;
+    case "version":
+      return `${status.loaded.version}, loaded ${loadedAt}; on disk ${status.onDisk?.version ?? "unknown"}. Restart opencode to run it`;
+    case "rebuilt":
+      return `${status.loaded.version}, loaded ${loadedAt}; the same version was rebuilt on disk ${status.onDisk ? `at ${formatLocalMinute(status.onDisk.mtimeMs)}` : "since"}. Restart opencode to run it`;
+    case "unreadable":
+      return `${status.loaded.version}, loaded ${loadedAt}; the build on disk could not be read`;
+  }
+}
+function createStaleBuildWatch(io) {
+  const throttleMs = io.throttleMs ?? STALE_BUILD_THROTTLE_MS;
+  const warn = io.warn ?? ((data) => {
+    log.warn(
+      "this opencode process is running an older plugin build than the one on disk",
+      data
+    );
+  });
+  const claimed = /* @__PURE__ */ new Set();
+  const warned = /* @__PURE__ */ new Set();
+  let checkedAt;
+  let cached = null;
+  const read = () => {
+    let onDisk;
+    try {
+      onDisk = io.readOnDisk();
+    } catch {
+      onDisk = void 0;
+    }
+    const stale = compareBuilds(io.loaded, onDisk);
+    const verdict = !onDisk ? "unreadable" : stale ? stale.kind : "current";
+    return { loaded: io.loaded, onDisk, stale, verdict };
+  };
+  return {
+    get loaded() {
+      return io.loaded;
+    },
+    check() {
+      const now = io.now();
+      if (checkedAt !== void 0 && now - checkedAt < throttleMs) return cached;
+      checkedAt = now;
+      const status = read();
+      cached = status.stale;
+      if (status.stale && status.onDisk) {
+        const identity = `${status.stale.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
+        if (!warned.has(identity)) {
+          warned.add(identity);
+          warn({
+            kind: status.stale.kind,
+            loadedVersion: status.stale.loadedVersion,
+            onDiskVersion: status.stale.onDiskVersion,
+            path: io.loaded.entryPath
+          });
+        }
+      }
+      return cached;
+    },
+    describe() {
+      return read();
+    },
+    claimSession(sessionId) {
+      if (claimed.has(sessionId)) return false;
+      claimed.add(sessionId);
+      while (claimed.size > STALE_BUILD_SESSION_CAP) {
+        const oldest = claimed.values().next();
+        if (oldest.done) break;
+        claimed.delete(oldest.value);
+      }
+      return true;
+    },
+    claimedSessions() {
+      return [...claimed];
+    }
+  };
+}
+function defaultEntryPath() {
+  return fileURLToPath2(import.meta.url);
+}
+function readOnDiskBuild(entryPath) {
+  try {
+    const raw = fs5.readFileSync(path6.join(path6.dirname(entryPath), "..", "package.json"), "utf8");
+    const version = JSON.parse(raw).version;
+    if (typeof version !== "string" || version.length === 0) return void 0;
+    const stat = fs5.statSync(entryPath);
+    return { version, mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return void 0;
+  }
+}
+function recordLoadedBuild() {
+  const entryPath = defaultEntryPath();
+  let mtimeMs;
+  let size;
+  try {
+    const stat = fs5.statSync(entryPath);
+    mtimeMs = stat.mtimeMs;
+    size = stat.size;
+  } catch {
+  }
+  return { version: pluginVersion(), entryPath, mtimeMs, size, loadedAt: Date.now() };
+}
+var loadedAtImport = recordLoadedBuild();
+var watch;
+function staleBuildWatch() {
+  if (!watch) {
+    const loaded = loadedAtImport;
+    watch = createStaleBuildWatch({
+      loaded,
+      readOnDisk: () => readOnDiskBuild(loaded.entryPath),
+      now: () => Date.now()
+    });
+  }
+  return watch;
+}
+
 // src/doctor.ts
 var DOCTOR_COMMAND = "claude-code-doctor";
 var DOCTOR_COMMAND_DESCRIPTION = "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls. Add `usage` for plan windows, or `bundle` for a redacted log you can paste into an issue";
@@ -6262,6 +6434,7 @@ function formatDoctorReport(report) {
   lines.push("| Field | Value |");
   lines.push("|---|---|");
   lines.push(`| plugin | ${report.plugin} |`);
+  lines.push(`| plugin build | ${describeBuildStatus(report.build)} |`);
   lines.push(`| opencode | ${report.opencode} |`);
   lines.push(`| claude CLI | \`${report.claudeCli.path}\` (${report.claudeCli.version}) |`);
   lines.push(`| cwd | \`${report.cwd.resolved}\` (${report.cwd.source}) |`);
@@ -6505,6 +6678,8 @@ async function gatherDoctorReport(options) {
   }) : { status: "not-requested" };
   return {
     plugin: base.plugin,
+    // `describe`, not `check`: unthrottled, silent, and it claims no session.
+    build: staleBuildWatch().describe(),
     opencode: base.opencode,
     claudeCli: { path: cliPath, version: cli?.raw ?? "not detected" },
     cwd: base.cwd,
@@ -6571,6 +6746,7 @@ async function buildDoctorReport(options) {
     const report = await gatherDoctorReport(options);
     log.info("claude-code doctor report", {
       plugin: report.plugin,
+      verdict: report.build.verdict,
       opencode: report.opencode,
       cwd: report.cwd,
       processes: report.processes.length,
@@ -6594,7 +6770,7 @@ Could not build the report: ${message}`;
 
 // src/agent-models.ts
 import { readFile, readdir } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
 // src/models.ts
 var PROVIDER_ID = "claude-code";
@@ -7097,11 +7273,11 @@ async function readAgentMarkdownRecords(directories) {
       const name = entry.slice(0, -3);
       if (records[name]) continue;
       try {
-        const text = await readFile(path6.join(directory, entry), "utf8");
+        const text = await readFile(path7.join(directory, entry), "utf8");
         records[name] = parseAgentFrontmatter(text);
       } catch (err) {
         log.debug("failed to read agent markdown", {
-          file: path6.join(directory, entry),
+          file: path7.join(directory, entry),
           error: String(err)
         });
       }
@@ -7113,12 +7289,12 @@ function agentDirectories(home, projectDirectory) {
   const directories = [];
   if (projectDirectory) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path6.join(projectDirectory, ".opencode", name));
+      directories.push(path7.join(projectDirectory, ".opencode", name));
     }
   }
   if (home) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path6.join(home, ".config", "opencode", name));
+      directories.push(path7.join(home, ".config", "opencode", name));
     }
   }
   return directories;
@@ -7286,7 +7462,9 @@ var PLUGIN_NOTE_MARKERS = [
   SILENT_TURN_MARKER,
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
-  MODEL_FALLBACK_MARKER
+  MODEL_FALLBACK_MARKER,
+  UNATTENDED_REPLAY_MARKER,
+  STALE_BUILD_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -7673,14 +7851,14 @@ Now continuing with the current message:
 
 // src/skill-bridge.ts
 import * as crypto3 from "crypto";
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as os3 from "os";
-import * as path7 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import * as path8 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function bundledSkillsDir() {
   try {
-    const here = fileURLToPath2(import.meta.url);
-    const dir = path7.resolve(path7.dirname(here), "..", "skills");
+    const here = fileURLToPath3(import.meta.url);
+    const dir = path8.resolve(path8.dirname(here), "..", "skills");
     return dirExists2(dir) ? dir : null;
   } catch {
     return null;
@@ -7688,16 +7866,16 @@ function bundledSkillsDir() {
 }
 function dirExists2(p) {
   try {
-    return fs5.statSync(p).isDirectory();
+    return fs6.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function realPath(p) {
   try {
-    return fs5.realpathSync(p);
+    return fs6.realpathSync(p);
   } catch {
-    return path7.resolve(p);
+    return path8.resolve(p);
   }
 }
 function envEnabled(name) {
@@ -7718,10 +7896,10 @@ function declaredSkillName(source) {
   return SAFE_SKILL_NAME.test(name) ? name : null;
 }
 function readSkill(root, entry) {
-  const dir = path7.join(root, entry);
+  const dir = path8.join(root, entry);
   let source;
   try {
-    source = fs5.readFileSync(path7.join(dir, "SKILL.md"), "utf8");
+    source = fs6.readFileSync(path8.join(dir, "SKILL.md"), "utf8");
   } catch {
     return null;
   }
@@ -7739,47 +7917,47 @@ function skillRoots(cwd) {
   const roots = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path7.resolve(p);
+    const abs = path8.resolve(p);
     if (seen.has(abs)) return;
     seen.add(abs);
     if (dirExists2(abs)) roots.push(abs);
   };
   const home = os3.homedir();
-  const homeDir = home ? path7.resolve(home) : null;
-  let current = path7.resolve(cwd);
+  const homeDir = home ? path8.resolve(home) : null;
+  let current = path8.resolve(cwd);
   while (true) {
-    push(path7.join(current, ".opencode", "skills"));
+    push(path8.join(current, ".opencode", "skills"));
     if (current !== homeDir) {
-      push(path7.join(current, ".claude", "skills"));
-      push(path7.join(current, ".agents", "skills"));
+      push(path8.join(current, ".claude", "skills"));
+      push(path8.join(current, ".agents", "skills"));
     }
-    const parent = path7.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  if (homeDir) push(path7.join(homeDir, ".opencode", "skills"));
+  if (homeDir) push(path8.join(homeDir, ".opencode", "skills"));
   const envDir = process.env.OPENCODE_CONFIG_DIR;
   if (envDir) {
-    push(path7.join(envDir, "skills"));
-    push(path7.join(envDir, "skill"));
+    push(path8.join(envDir, "skills"));
+    push(path8.join(envDir, "skill"));
   }
-  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path7.join(homeDir, ".config") : null);
+  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path8.join(homeDir, ".config") : null);
   if (xdg) {
-    push(path7.join(xdg, "opencode", "skills"));
-    push(path7.join(xdg, "opencode", "skill"));
+    push(path8.join(xdg, "opencode", "skills"));
+    push(path8.join(xdg, "opencode", "skill"));
   }
   if (homeDir && !envEnabled("OPENCODE_DISABLE_EXTERNAL_SKILLS")) {
     if (!envEnabled("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")) {
-      push(path7.join(homeDir, ".claude", "skills"));
+      push(path8.join(homeDir, ".claude", "skills"));
     }
-    push(path7.join(homeDir, ".agents", "skills"));
+    push(path8.join(homeDir, ".agents", "skills"));
   }
   return roots;
 }
 function collectSkills(root, claimed, found) {
   let entries;
   try {
-    entries = fs5.readdirSync(root, { withFileTypes: true });
+    entries = fs6.readdirSync(root, { withFileTypes: true });
   } catch {
     return;
   }
@@ -7819,23 +7997,23 @@ function discoverBundledSkills() {
 }
 function claudeConfigDir(configDir) {
   const explicit = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (explicit) return path7.resolve(expandHome(explicit));
+  if (explicit) return path8.resolve(expandHome(explicit));
   const home = os3.homedir();
-  return home ? path7.resolve(home, ".claude") : null;
+  return home ? path8.resolve(home, ".claude") : null;
 }
 function installedPluginSkillRoots(configDir, cwd) {
   if (!configDir) return [];
   let parsed;
   try {
     parsed = JSON.parse(
-      fs5.readFileSync(path7.join(configDir, "plugins", "installed_plugins.json"), "utf8")
+      fs6.readFileSync(path8.join(configDir, "plugins", "installed_plugins.json"), "utf8")
     );
   } catch {
     return [];
   }
   const plugins = parsed?.plugins;
   if (!plugins || typeof plugins !== "object") return [];
-  const workspace = path7.resolve(cwd);
+  const workspace = path8.resolve(cwd);
   const roots = [];
   for (const installs of Object.values(plugins)) {
     if (!Array.isArray(installs)) continue;
@@ -7843,28 +8021,28 @@ function installedPluginSkillRoots(configDir, cwd) {
       const entry = install;
       if (typeof entry?.installPath !== "string" || !entry.installPath) continue;
       if (entry.scope !== "user" && !coversWorkspace(entry.projectPath, workspace)) continue;
-      roots.push(path7.join(entry.installPath, "skills"));
+      roots.push(path8.join(entry.installPath, "skills"));
     }
   }
   return roots;
 }
 function coversWorkspace(projectPath, workspace) {
   if (typeof projectPath !== "string" || !projectPath) return false;
-  const root = path7.resolve(projectPath);
+  const root = path8.resolve(projectPath);
   if (root === workspace) return true;
-  const rel = path7.relative(root, workspace);
-  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+  const rel = path8.relative(root, workspace);
+  return rel !== "" && !rel.startsWith("..") && !path8.isAbsolute(rel);
 }
 function discoverNativeClaudeSkills(opts) {
   const found = [];
   const scanned = /* @__PURE__ */ new Set();
   const scan = (root, scope) => {
-    const abs = path7.resolve(root);
+    const abs = path8.resolve(root);
     if (scanned.has(abs)) return;
     scanned.add(abs);
     let entries;
     try {
-      entries = fs5.readdirSync(abs, { withFileTypes: true });
+      entries = fs6.readdirSync(abs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7876,13 +8054,13 @@ function discoverNativeClaudeSkills(opts) {
     }
   };
   const configDir = claudeConfigDir(opts.configDir);
-  if (configDir) scan(path7.join(configDir, "skills"), "user");
+  if (configDir) scan(path8.join(configDir, "skills"), "user");
   const home = os3.homedir();
-  const homeDir = home ? path7.resolve(home) : null;
-  let current = path7.resolve(opts.cwd);
+  const homeDir = home ? path8.resolve(home) : null;
+  let current = path8.resolve(opts.cwd);
   while (true) {
-    if (current !== homeDir) scan(path7.join(current, ".claude", "skills"), "project");
-    const parent = path7.dirname(current);
+    if (current !== homeDir) scan(path8.join(current, ".claude", "skills"), "project");
+    const parent = path8.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -7916,10 +8094,10 @@ function dropNativelyLoadedSkills(skills, native) {
 }
 function readBundledSkillInfos() {
   return discoverBundledSkills().flatMap((skill) => {
-    const file = path7.join(skill.dir, "SKILL.md");
+    const file = path8.join(skill.dir, "SKILL.md");
     let text;
     try {
-      text = fs5.readFileSync(file, "utf8");
+      text = fs6.readFileSync(file, "utf8");
     } catch {
       return [];
     }
@@ -7943,15 +8121,15 @@ function readBundledSkillInfos() {
 }
 function linkSkill(source, target) {
   try {
-    fs5.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+    fs6.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
     return;
   } catch {
-    fs5.cpSync(source, target, { recursive: true, dereference: true });
+    fs6.cpSync(source, target, { recursive: true, dereference: true });
   }
 }
 function fileExists2(p) {
   try {
-    return fs5.statSync(p).isFile();
+    return fs6.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -7960,14 +8138,14 @@ function buildSkillPluginDir(skills) {
   if (skills.length === 0) return null;
   const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
   const hash = crypto3.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
-  const root = path7.join(pluginTmpDir(), `skills-${hash}`);
-  const manifest = path7.join(root, ".claude-plugin", "plugin.json");
+  const root = path8.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path8.join(root, ".claude-plugin", "plugin.json");
   if (fileExists2(manifest)) return root;
   try {
-    fs5.rmSync(root, { recursive: true, force: true });
-    fs5.mkdirSync(path7.join(root, ".claude-plugin"), { recursive: true });
-    fs5.mkdirSync(path7.join(root, "skills"), { recursive: true });
-    fs5.writeFileSync(
+    fs6.rmSync(root, { recursive: true, force: true });
+    fs6.mkdirSync(path8.join(root, ".claude-plugin"), { recursive: true });
+    fs6.mkdirSync(path8.join(root, "skills"), { recursive: true });
+    fs6.writeFileSync(
       manifest,
       JSON.stringify(
         {
@@ -7980,7 +8158,7 @@ function buildSkillPluginDir(skills) {
       { encoding: "utf8", mode: 384 }
     );
     for (const skill of skills) {
-      linkSkill(skill.dir, path7.join(root, "skills", skill.name));
+      linkSkill(skill.dir, path8.join(root, "skills", skill.name));
     }
   } catch (err) {
     log.warn("failed to stage opencode skill plugin dir", {
@@ -7996,7 +8174,7 @@ function registerBundledSkillPath(config) {
   if (!dir) return false;
   config.skills ??= {};
   const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path7.resolve(p) === dir)) return false;
+  if (paths.some((p) => path8.resolve(p) === dir)) return false;
   paths.push(dir);
   return true;
 }
@@ -8047,12 +8225,12 @@ import { unlink as unlink2 } from "fs/promises";
 
 // src/claude-session-bun.ts
 import * as os4 from "os";
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 import { execFileSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 function resolveClaude(cmd = "claude") {
-  if (path8.isAbsolute(cmd) && fs6.existsSync(cmd)) return cmd;
+  if (path9.isAbsolute(cmd) && fs7.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
   const isWin = os4.platform() === "win32";
@@ -8061,17 +8239,17 @@ function resolveClaude(cmd = "claude") {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs6.existsSync(p));
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs7.existsSync(p));
     if (first) return first;
   } catch {
   }
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  const resolved = path8.resolve(cwd);
+  const resolved = path9.resolve(cwd);
   let real = resolved;
   try {
-    real = fs6.realpathSync.native(resolved);
+    real = fs7.realpathSync.native(resolved);
   } catch {
   }
   return real.replace(/[^a-zA-Z0-9]/g, "-");
@@ -8156,12 +8334,12 @@ var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_t
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path8.join(os4.homedir(), ".claude");
+  if (!value) return path9.join(os4.homedir(), ".claude");
   if (value === "~") return os4.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path8.join(os4.homedir(), value.slice(2));
+    return path9.join(os4.homedir(), value.slice(2));
   }
-  return path8.resolve(value);
+  return path9.resolve(value);
 }
 var ClaudeSession = class {
   sessionId;
@@ -8179,11 +8357,11 @@ var ClaudeSession = class {
   signal;
   o;
   constructor(opts = {}) {
-    this.cwd = path8.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path9.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.signal = opts.signal;
     this.sessionId = randomUUID4();
-    this.jsonlPath = path8.join(
+    this.jsonlPath = path9.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
@@ -8306,7 +8484,7 @@ var ClaudeSession = class {
   }
   readRawLines() {
     try {
-      return fs6.readFileSync(this.jsonlPath, "utf8").split("\n");
+      return fs7.readFileSync(this.jsonlPath, "utf8").split("\n");
     } catch {
       return [];
     }
@@ -8703,13 +8881,13 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir7 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname5, join as join8 } from "path";
-function readPromptFileIfPresent(path10) {
+import { dirname as dirname6, join as join9 } from "path";
+function readPromptFileIfPresent(path11) {
   try {
-    const content = readFileSync5(path10, "utf8").trim();
+    const content = readFileSync6(path11, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -8718,9 +8896,9 @@ function readPromptFileIfPresent(path10) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join8(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join9(dir, "AGENTS.md"));
     if (content) return content;
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -8827,8 +9005,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir7(), ".config");
-  const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join9(homedir7(), ".config");
+  const globalAgents = readPromptFileIfPresent(join9(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -8839,10 +9017,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path10 = join8(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path11 = join9(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    writeFileSync4(path10, content, { encoding: "utf8", mode: 384 });
-    return path10;
+    writeFileSync4(path11, content, { encoding: "utf8", mode: 384 });
+    return path11;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -9688,6 +9866,8 @@ function createTurnState(init) {
     toolCallMap: /* @__PURE__ */ new Map(),
     skipResultForIds: /* @__PURE__ */ new Set(),
     toolCallsById: /* @__PURE__ */ new Map(),
+    toolCallEmittedIds: /* @__PURE__ */ new Set(),
+    toolCallAnsweredIds: /* @__PURE__ */ new Set(),
     resultMeta: {},
     lastCallUsage: void 0,
     resultFailure: void 0,
@@ -9704,6 +9884,23 @@ function createTurnState(init) {
   };
   return state;
 }
+function cliToolCallInputJson(state, id) {
+  for (const entry of state.toolCallMap.values()) {
+    if (entry.id === id) return entry.inputJson || "{}";
+  }
+  return "{}";
+}
+function emitCliToolCall(state, id, name, inputJson, executed) {
+  if (state.toolCallEmittedIds.has(id)) return;
+  state.toolCallEmittedIds.add(id);
+  state.controller.enqueue({
+    type: "tool-call",
+    toolCallId: id,
+    toolName: name,
+    input: inputJson,
+    providerExecuted: executed
+  });
+}
 
 // src/turn-abort.ts
 function watchTurnAbort(signal) {
@@ -10113,9 +10310,46 @@ function deliverPendingCompletions(state, force = false) {
   armStartWatchdog(state);
   return true;
 }
+var CLI_RESULT_DEFERRED_OUTPUT = "Claude Code ran this tool itself and kept its output in its own context. This step ended on a tool call opencode has to run, so the output was not available to show here.";
+function closeDeferredCliToolResults(state) {
+  const answer = (id, name, stage) => {
+    emitCliToolCall(state, id, name, cliToolCallInputJson(state, id), true);
+    state.controller.enqueue({
+      type: "tool-result",
+      toolCallId: id,
+      toolName: name,
+      result: {
+        output: CLI_RESULT_DEFERRED_OUTPUT,
+        title: name,
+        metadata: {}
+      },
+      providerExecuted: true
+    });
+    state.toolCallsById.delete(id);
+    state.toolCallAnsweredIds.add(id);
+    log.info("closing a CLI-executed tool call whose result this step cannot wait for", {
+      sessionKey: state.sessionKey,
+      toolUseId: id,
+      name,
+      stage
+    });
+  };
+  for (const [id, toolCall] of [...state.toolCallsById]) {
+    if (state.skipResultForIds.has(id)) continue;
+    answer(id, toolCall.name, "registered");
+  }
+  for (const entry of state.toolCallMap.values()) {
+    if (!entry.started || !entry.mappedName) continue;
+    if (state.skipResultForIds.has(entry.id)) continue;
+    if (state.toolCallAnsweredIds.has(entry.id)) continue;
+    if (state.toolCallEmittedIds.has(entry.id)) continue;
+    answer(entry.id, entry.mappedName, "open-block");
+  }
+}
 function finishWithToolCalls(state, calls) {
   if (state.controllerClosed) return;
   if (calls.length === 0) return;
+  closeDeferredCliToolResults(state);
   const enqueueToolCall = (toolCallId, toolName, input) => {
     state.controller.enqueue({
       type: "tool-input-start",
@@ -10321,6 +10555,26 @@ var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
   "signature_delta"
 ]);
 var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
+function adoptOpenCliToolCall(state, ctx, id) {
+  for (const entry of state.toolCallMap.values()) {
+    if (entry.id !== id || !entry.started || !entry.mappedName) continue;
+    let parsedInput = {};
+    try {
+      parsedInput = JSON.parse(entry.inputJson || "{}");
+    } catch {
+    }
+    const { input: mappedInput, executed } = mapTool(entry.name, parsedInput, {
+      webSearch: ctx.config.webSearch,
+      sessionId: getClaudeSessionId(state.sessionKey),
+      toolUseId: entry.id
+    });
+    const registration = { id: entry.id, name: entry.mappedName, input: parsedInput };
+    state.toolCallsById.set(entry.id, registration);
+    emitCliToolCall(state, entry.id, entry.mappedName, JSON.stringify(mappedInput), executed);
+    return registration;
+  }
+  return void 0;
+}
 function createLineHandler(state, ctx) {
   return (line) => {
     if (!line.trim()) return;
@@ -10449,6 +10703,7 @@ function createLineHandler(state, ctx) {
             );
             if (!skip) {
               entry.started = true;
+              entry.mappedName = mappedName;
               state.controller.enqueue({
                 type: "tool-input-start",
                 id: block2.id,
@@ -10606,20 +10861,14 @@ ${plan}
               sessionId: getClaudeSessionId(state.sessionKey),
               toolUseId: tc.id
             });
-            if (!skip) {
+            if (!skip && !state.toolCallAnsweredIds.has(tc.id)) {
               state.toolCallsById.set(tc.id, {
                 id: tc.id,
                 name: mappedName,
                 input: parsedInput
               });
               if (!executed) state.skipResultForIds.add(tc.id);
-              state.controller.enqueue({
-                type: "tool-call",
-                toolCallId: tc.id,
-                toolName: mappedName,
-                input: JSON.stringify(mappedInput),
-                providerExecuted: executed
-              });
+              emitCliToolCall(state, tc.id, mappedName, JSON.stringify(mappedInput), executed);
             }
             log.info("tool call complete", {
               name: tc.name,
@@ -10805,13 +11054,7 @@ ${plan}
                   toolName: mappedName,
                   providerExecuted: executed
                 });
-                state.controller.enqueue({
-                  type: "tool-call",
-                  toolCallId: block2.id,
-                  toolName: mappedName,
-                  input: JSON.stringify(mappedInput),
-                  providerExecuted: executed
-                });
+                emitCliToolCall(state, block2.id, mappedName, JSON.stringify(mappedInput), executed);
               }
               log.info("tool_use from assistant message", {
                 name: block2.name,
@@ -10877,7 +11120,7 @@ ${plan}
                 noteToolActivity(state);
               }
             }
-            const toolCall = state.toolCallsById.get(block2.tool_use_id);
+            const toolCall = state.toolCallsById.get(block2.tool_use_id) ?? adoptOpenCliToolCall(state, ctx, block2.tool_use_id);
             if (toolCall) {
               const isError = block2.is_error === true;
               state.controller.enqueue({
@@ -10899,6 +11142,7 @@ ${plan}
                 isError
               });
               state.toolCallsById.delete(block2.tool_use_id);
+              state.toolCallAnsweredIds.add(block2.tool_use_id);
             }
           }
         }
@@ -11829,6 +12073,11 @@ var ClaudeCodeLanguageModel = class {
       // the operator is usually not even looking at.
       childSession: !!await fetchSessionParentId(affinity)
     });
+    let staleBuild = null;
+    if (!compactionMode && mode !== "generate" && affinity !== "default") {
+      staleBuild = staleBuildWatch().check();
+      if (staleBuild && await fetchSessionParentId(affinity)) staleBuild = null;
+    }
     log.info("doStream starting", {
       cwd,
       model: effectiveModelId,
@@ -12289,6 +12538,14 @@ var ClaudeCodeLanguageModel = class {
           if (stoppedBeforeWork()) return;
           state.streamStarted = true;
           controller.enqueue({ type: "stream-start", warnings });
+          if (staleBuild && staleBuildWatch().claimSession(affinity)) {
+            controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatStaleBuildNote(staleBuild)
+            });
+            state.endTextBlock();
+          }
           if (failoverNote) {
             controller.enqueue({
               type: "text-delta",
@@ -12561,16 +12818,12 @@ var ClaudeCodeLanguageModel = class {
               });
               let partialText = false;
               {
-                if (unattended.dropped > 0) {
-                  const id = state.startTextBlock();
-                  controller.enqueue({
-                    type: "text-delta",
-                    id,
-                    delta: `> _${unattended.dropped} lines of output emitted between turns were dropped._
-
-`
-                  });
-                }
+                const replayId = state.startTextBlock();
+                controller.enqueue({
+                  type: "text-delta",
+                  id: replayId,
+                  delta: formatUnattendedReplayNote(unattended.dropped)
+                });
                 for (const line of unattended.lines) {
                   try {
                     const outer = JSON.parse(line);
@@ -12740,34 +12993,34 @@ var ClaudeCodeLanguageModel = class {
 import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname6, join as join9, resolve as resolve5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname7, join as join10, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
 var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join9(xdg, "opencode") : null,
-    join9(homedir8(), ".cache", "opencode"),
-    join9(homedir8(), "Library", "Caches", "opencode")
+    xdg ? join10(xdg, "opencode") : null,
+    join10(homedir8(), ".cache", "opencode"),
+    join10(homedir8(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir8(), ".config");
-  return join9(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join10(homedir8(), ".config");
+  return join10(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync3(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync6(cfg, "utf8"));
+    const json = JSON.parse(readFileSync7(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -12779,7 +13032,7 @@ function userIntendsToUseUnscoped() {
 }
 function ourLoadedDir() {
   try {
-    const filePath = fileURLToPath3(import.meta.url);
+    const filePath = fileURLToPath4(import.meta.url);
     return realpathSync4(resolve5(filePath, "..", ".."));
   } catch {
     return null;
@@ -12788,19 +13041,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync6(join9(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync7(join10(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join9(homedir8(), ".local", "state");
-  return join9(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join10(homedir8(), ".local", "state");
+  return join10(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync6(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync7(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -12809,7 +13062,7 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync4(dirname6(file), { recursive: true });
+    mkdirSync4(dirname7(file), { recursive: true });
     writeFileSync5(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
@@ -12845,7 +13098,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync3(cacheRoot)) return;
-  const stalePath = join9(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join10(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -12853,11 +13106,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join9(stalePath, "package.json");
+  const pkgJsonPath = join10(stalePath, "package.json");
   if (!existsSync3(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync6(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync7(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -12873,10 +13126,10 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join9(cacheRoot, "package.json");
+  const cachePkgJson = join10(cacheRoot, "package.json");
   if (!existsSync3(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync6(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync7(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync5(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -12890,7 +13143,7 @@ function cleanupOne(cacheRoot, ourDir) {
 }
 
 // src/v2-client.ts
-import path9 from "path";
+import path10 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -12919,7 +13172,7 @@ function toV1Session(info) {
   if (!info || typeof info !== "object") return void 0;
   const session = info;
   const root = session.location?.directory;
-  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path9.resolve(root, session.subpath) : root : void 0;
+  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path10.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {