@khalilgharbaoui/opencode-claude-code-plugin 0.36.5 → 0.37.1

package/dist/index.js

@@ -149,6 +149,7 @@ import path from "path";
 import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
+import { isMainThread } from "worker_threads";
 var LEVEL_RANK = {
   debug: 0,
   info: 1,
@@ -241,15 +242,110 @@ function fmt(level, msg, data) {
 function shouldEmit(level) {
   return LEVEL_RANK[level] >= LEVEL_RANK[activeConfig.level];
 }
-function shouldTui(level) {
+var tuiHostOverride;
+function isTuiHost() {
+  return tuiHostOverride ?? !isMainThread;
+}
+var MAX_BUFFERED_SINK_ENTRIES = 50;
+var MAX_TOASTED_MESSAGES = 200;
+var toastBurstLimit = 3;
+var toastBurstWindowMs = 2e3;
+var activeSink = null;
+var bufferedEntries = [];
+var droppedBeforeSink = 0;
+var toastedMessages = /* @__PURE__ */ new Set();
+var burstWindowStart = 0;
+var burstCount = 0;
+var burstSuppressed = 0;
+var burstSummaryTimer = null;
+function setLogSink(sink) {
+  activeSink = sink;
+  if (!sink) return;
+  const pending = bufferedEntries;
+  const dropped = droppedBeforeSink;
+  bufferedEntries = [];
+  droppedBeforeSink = 0;
+  for (const entry of pending) deliverToSink(entry);
+  if (dropped > 0) {
+    const message = `${dropped} earlier log line(s) were dropped before opencode's log channel was available`;
+    deliverToSink({
+      level: "warn",
+      message,
+      line: fmt("WARN", message)
+    });
+  }
+}
+function routeToSink(entry) {
+  if (!activeSink) {
+    if (bufferedEntries.length >= MAX_BUFFERED_SINK_ENTRIES) {
+      droppedBeforeSink += 1;
+      return;
+    }
+    bufferedEntries.push(entry);
+    return;
+  }
+  deliverToSink(entry);
+}
+function deliverToSink(entry) {
+  const sink = activeSink;
+  if (!sink) return;
+  try {
+    sink.log(entry);
+  } catch {
+  }
+  if (entry.level !== "warn" && entry.level !== "error") return;
+  if (toastedMessages.has(entry.message)) return;
+  if (toastedMessages.size < MAX_TOASTED_MESSAGES) toastedMessages.add(entry.message);
+  if (!allowToastNow()) return;
+  sendToast(sink, entry);
+}
+function sendToast(sink, entry) {
+  try {
+    sink.toast(entry);
+  } catch {
+  }
+}
+function allowToastNow() {
+  const now = Date.now();
+  if (now - burstWindowStart >= toastBurstWindowMs) {
+    burstWindowStart = now;
+    burstCount = 0;
+  }
+  if (burstCount < toastBurstLimit) {
+    burstCount += 1;
+    return true;
+  }
+  burstSuppressed += 1;
+  armBurstSummary();
+  return false;
+}
+function armBurstSummary() {
+  if (burstSummaryTimer) return;
+  burstSummaryTimer = setTimeout(() => {
+    burstSummaryTimer = null;
+    const suppressed = burstSuppressed;
+    burstSuppressed = 0;
+    if (suppressed <= 0) return;
+    const sink = activeSink;
+    if (!sink) return;
+    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in opencode's log`;
+    sendToast(sink, { level: "warn", message, line: fmt("WARN", message) });
+  }, toastBurstWindowMs);
+  burstSummaryTimer.unref?.();
+}
+function shouldSurface(level) {
   if (level === "warn" || level === "error") return true;
   return activeConfig.mode === "debug";
 }
 function emit(level, msg, data) {
   if (!shouldEmit(level)) return;
   const line = fmt(level.toUpperCase(), msg, data);
-  if (shouldTui(level)) {
-    console.error(line);
+  if (shouldSurface(level)) {
+    if (isTuiHost()) {
+      routeToSink({ level, message: msg, data, line });
+    } else {
+      console.error(line);
+    }
   }
   writeToFile(line);
 }
@@ -5471,6 +5567,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",
@@ -5619,6 +5716,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",
@@ -5868,8 +5969,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);
@@ -6059,6 +6160,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";
@@ -6198,6 +6304,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";
@@ -6269,6 +6530,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}) |`);
@@ -6512,6 +6774,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,
@@ -6578,6 +6842,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,
@@ -6601,7 +6866,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";
@@ -7104,11 +7369,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)
         });
       }
@@ -7120,12 +7385,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;
@@ -7294,7 +7559,8 @@ var PLUGIN_NOTE_MARKERS = [
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
   MODEL_FALLBACK_MARKER,
-  UNATTENDED_REPLAY_MARKER
+  UNATTENDED_REPLAY_MARKER,
+  STALE_BUILD_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -7681,14 +7947,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;
@@ -7696,16 +7962,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) {
@@ -7726,10 +7992,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;
   }
@@ -7747,47 +8013,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;
   }
@@ -7827,23 +8093,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;
@@ -7851,28 +8117,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;
     }
@@ -7884,13 +8150,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;
   }
@@ -7924,10 +8190,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 [];
     }
@@ -7951,15 +8217,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;
   }
@@ -7968,14 +8234,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(
         {
@@ -7988,7 +8254,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", {
@@ -8004,7 +8270,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;
 }
@@ -8055,12 +8321,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";
@@ -8069,17 +8335,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, "-");
@@ -8164,12 +8430,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;
@@ -8187,11 +8453,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),
@@ -8314,7 +8580,7 @@ var ClaudeSession = class {
   }
   readRawLines() {
     try {
-      return fs6.readFileSync(this.jsonlPath, "utf8").split("\n");
+      return fs7.readFileSync(this.jsonlPath, "utf8").split("\n");
     } catch {
       return [];
     }
@@ -8711,13 +8977,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;
@@ -8726,9 +8992,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;
   }
@@ -8835,8 +9101,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);
@@ -8847,10 +9113,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;
@@ -11903,6 +12169,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,
@@ -12363,6 +12634,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",
@@ -12810,34 +13089,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(
@@ -12849,7 +13128,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;
@@ -12858,19 +13137,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;
@@ -12879,7 +13158,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",
@@ -12915,7 +13194,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 {
@@ -12923,11 +13202,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;
   }
@@ -12943,10 +13222,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");
@@ -12959,8 +13238,74 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
+// src/tui-log-sink.ts
+var LOG_SERVICE_NAME = "opencode-claude-code";
+var TOAST_TITLE = "claude-code";
+var TOAST_DURATION_MS = 1e4;
+var MAX_TOAST_CHARS = 240;
+var APP_LOG_LEVEL = {
+  debug: "debug",
+  info: "info",
+  notice: "info",
+  warn: "warn",
+  error: "error"
+};
+function toastMessage(message) {
+  const flat = message.replace(/\s+/g, " ").trim();
+  if (flat.length <= MAX_TOAST_CHARS) return flat;
+  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
+}
+function appLogBody(entry) {
+  return {
+    service: LOG_SERVICE_NAME,
+    level: APP_LOG_LEVEL[entry.level],
+    message: entry.message,
+    ...entry.data && Object.keys(entry.data).length > 0 ? { extra: entry.data } : {}
+  };
+}
+function toastBody(entry) {
+  return {
+    title: TOAST_TITLE,
+    message: toastMessage(entry.message),
+    variant: entry.level === "error" ? "error" : "warning",
+    duration: TOAST_DURATION_MS
+  };
+}
+function fireAndForget(call) {
+  try {
+    const result = call();
+    if (result && typeof result.catch === "function") {
+      void result.catch(() => void 0);
+    }
+  } catch {
+  }
+}
+function createOpencodeLogSink(client) {
+  if (!client || typeof client !== "object") return null;
+  const sdk = client;
+  const canLog = typeof sdk.app?.log === "function";
+  const canToast = typeof sdk.tui?.showToast === "function";
+  if (!canLog && !canToast) return null;
+  return {
+    log(entry) {
+      if (!canLog) return;
+      fireAndForget(() => sdk.app.log({ body: appLogBody(entry) }));
+    },
+    toast(entry) {
+      if (!canToast) return;
+      fireAndForget(() => sdk.tui.showToast({ body: toastBody(entry) }));
+    }
+  };
+}
+function registerOpencodeLogSink(client) {
+  const sink = createOpencodeLogSink(client);
+  if (!sink) return false;
+  setLogSink(sink);
+  return true;
+}
+
 // 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 [];
@@ -12989,7 +13334,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) {
@@ -13783,7 +14128,9 @@ var server = async (input) => {
   ensureProcessExitCleanup();
   const opencodeVersion = pickOpencodeVersion(input);
   if (input && typeof input === "object" && "client" in input) {
-    setOpencodeClient(input.client);
+    const client = input.client;
+    setOpencodeClient(client);
+    registerOpencodeLogSink(client);
   }
   setOpencodeProjectDirectory(pickOpencodeDirectory(input));
   return {