@evident-ai/cli 3.5.2-dev.35de651 → 3.5.2-dev.3f3949d

package/dist/index.js

@@ -315,14 +315,14 @@ function blank() {
   console.log();
 }
 function waitForEnter(prompt = "Press Enter to continue...") {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     process.stdout.write(chalk.dim(prompt));
     const handler = () => {
       process.stdin.removeListener("data", handler);
       process.stdin.setRawMode?.(false);
       process.stdin.pause();
       console.log();
-      resolve4();
+      resolve5();
     };
     if (process.stdin.isTTY) {
       process.stdin.setRawMode?.(true);
@@ -332,7 +332,7 @@ function waitForEnter(prompt = "Press Enter to continue...") {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
 // src/commands/login.ts
@@ -410,19 +410,19 @@ async function tokenLogin() {
   );
   blank();
   process.stdout.write("Paste token: ");
-  const token = await new Promise((resolve4) => {
+  const token = await new Promise((resolve5) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve4(data.trim());
+      resolve5(data.trim());
     });
     if (process.stdin.isTTY) {
       process.stdin.once("data", (chunk) => {
         process.stdin.pause();
-        resolve4(chunk.toString().trim());
+        resolve5(chunk.toString().trim());
       });
       process.stdin.resume();
     }
@@ -1158,7 +1158,7 @@ async function claudeUsage() {
 // src/commands/run.ts
 import { chmodSync as chmodSync3, existsSync as existsSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { isAbsolute as isAbsolute3, join as join11, parse, resolve as resolvePath2 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join12, parse, resolve as resolvePath2 } from "node:path";
 import chalk7 from "chalk";
 
 // ../../packages/types/src/agents/index.ts
@@ -1322,7 +1322,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.35de651" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.3f3949d" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1810,6 +1810,263 @@ async function reclaimSessionDbSpace(input) {
   }
 }
 
+// src/lib/opencode/dependency-install-diagnostic.ts
+import { lstatSync, realpathSync } from "node:fs";
+import { basename, dirname as dirname3, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+var DEPENDENCY_INSTALL_FAILURE_MESSAGE = "background dependency install failed";
+var MAX_DISTINCT_DIAGNOSTICS = 32;
+var EFFECT = "OpenCode could not install background dependencies for this scope; its plugins and tools may be unavailable";
+function readOpenCodeLogField(line, key) {
+  const match = line.match(new RegExp(`(?:^|\\s)${key}=(?:"((?:\\\\.|[^"])*)"|(\\S+))`));
+  if (!match) return void 0;
+  if (match[1] === void 0) return match[2];
+  return match[1].replace(/\\(["\\n])/g, (_match, escaped) => {
+    return escaped === "n" ? "\n" : escaped;
+  });
+}
+function parseTrigger(line) {
+  if (readOpenCodeLogField(line, "message") !== DEPENDENCY_INSTALL_FAILURE_MESSAGE) {
+    return null;
+  }
+  const error2 = readOpenCodeLogField(line, "error");
+  if (!error2 || !/\bEACCES\b/.test(error2)) return null;
+  const errnoMatch = error2.match(/\bEACCES:\s*permission denied,\s*([a-z_]+)\s+'([^']*)'/);
+  const capturedPath = errnoMatch?.[2];
+  return {
+    dir: readOpenCodeLogField(line, "dir"),
+    op: errnoMatch?.[1],
+    path: capturedPath && isAbsolute(capturedPath) ? capturedPath : void 0
+  };
+}
+function getErrorCode(error2) {
+  if (typeof error2 === "object" && error2 !== null && "code" in error2) {
+    const code = error2.code;
+    if (typeof code === "string") return code;
+  }
+  return "UNKNOWN";
+}
+function isWithin(path, root) {
+  const candidate = resolve(path);
+  const resolvedRoot = resolve(root);
+  return candidate === resolvedRoot || candidate.startsWith(`${resolvedRoot}${sep}`);
+}
+function rootSpecs(context) {
+  return [
+    { token: "~", configured: resolve(context.homeDir) },
+    { token: "$WORKSPACE", configured: resolve(context.cwd) }
+  ];
+}
+function resolveRoots(context) {
+  const resolved = [];
+  const unresolved = [];
+  for (const spec of rootSpecs(context)) {
+    try {
+      resolved.push({ ...spec, real: realpathSync(spec.configured) });
+    } catch (_error) {
+      unresolved.push(spec);
+    }
+  }
+  return { resolved, unresolved };
+}
+function resolveNearestAncestor(failingPath, remaining, error2) {
+  let ancestor = dirname3(failingPath);
+  const suffix = [basename(failingPath), ...remaining];
+  while (ancestor) {
+    try {
+      return {
+        path: resolve(realpathSync(ancestor), ...suffix),
+        failure: { path: resolve(failingPath), error: error2 }
+      };
+    } catch (ancestorError) {
+      if (ancestor === dirname3(ancestor) || !getErrorCode(ancestorError).startsWith("E")) {
+        return null;
+      }
+      suffix.unshift(basename(ancestor));
+      ancestor = dirname3(ancestor);
+    }
+  }
+  return null;
+}
+function resolveExistingPath(absolutePath) {
+  if (!isAbsolute(absolutePath)) return null;
+  const candidate = resolve(absolutePath);
+  const remaining = [];
+  let current = candidate;
+  while (current) {
+    try {
+      const stat2 = lstatSync(current);
+      if (stat2.isSymbolicLink()) {
+        if (remaining.length === 0) {
+          return { path: join2(realpathSync(dirname3(current)), basename(current)) };
+        }
+        return { path: resolve(realpathSync(current), ...remaining) };
+      }
+      return { path: resolve(realpathSync(current), ...remaining) };
+    } catch (error2) {
+      const code = getErrorCode(error2);
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        return resolveNearestAncestor(current, remaining, error2);
+      }
+    }
+    if (current === dirname3(current)) return null;
+    remaining.unshift(basename(current));
+    current = dirname3(current);
+  }
+  return null;
+}
+function tokenise(absolutePath, roots) {
+  const pathResolution = resolveExistingPath(absolutePath);
+  if (!pathResolution) return null;
+  const root = roots.reduce((selected, candidate) => {
+    if (!isWithin(pathResolution.path, candidate.real)) return selected;
+    if (!selected || candidate.real.length > selected.real.length || candidate.real.length === selected.real.length && candidate.token === "$WORKSPACE") {
+      return candidate;
+    }
+    return selected;
+  }, null);
+  if (!root) return null;
+  const suffix = relative(root.real, pathResolution.path);
+  return {
+    value: suffix ? `${root.token}/${suffix.split(sep).join("/")}` : root.token,
+    root,
+    resolutionFailure: pathResolution.failure
+  };
+}
+function classifyScope(dir, roots) {
+  if (!dir) return "other";
+  const tokenisedDir = tokenise(dir, roots.resolved);
+  if (tokenisedDir) return tokenisedDir.root.token === "$WORKSPACE" ? "workspace" : "global";
+  for (const spec of roots.unresolved) {
+    if (isWithin(dir, spec.configured)) {
+      return spec.token === "$WORKSPACE" ? "workspace" : "global";
+    }
+  }
+  return "other";
+}
+function unresolvedRootForPath(path, unresolved) {
+  return unresolved.find((spec) => isWithin(path, spec.configured));
+}
+function statType(stat2) {
+  if (stat2.isDirectory()) return "d";
+  if (stat2.isFile()) return "f";
+  if (stat2.isSymbolicLink()) return "l";
+  return "o";
+}
+function renderStat(name, stat2) {
+  const mode = (stat2.mode & 4095).toString(8).padStart(4, "0");
+  return `${name}:${statType(stat2)}:${stat2.uid}:${stat2.gid}:${mode}`;
+}
+function renderStatError(name, error2) {
+  const code = getErrorCode(error2);
+  return `${name}:${renderErrorCode(code)}`;
+}
+function renderErrorCode(code) {
+  if (code === "ENOENT") return "missing";
+  return code.startsWith("E") ? code : `E${code}`;
+}
+function inspectChain(rootReal, rootToken, absolutePath, resolutionFailure) {
+  const target = resolve(absolutePath);
+  const relativePath = relative(rootReal, target);
+  const components = relativePath ? relativePath.split(sep) : [];
+  const entries = [];
+  let current = rootReal;
+  let status2 = "complete";
+  let finalStat;
+  for (const name of [rootToken, ...components]) {
+    if (name !== rootToken) current = join2(current, name);
+    if (resolutionFailure && resolve(current) === resolve(resolutionFailure.path)) {
+      entries.push(renderStatError(name, resolutionFailure.error));
+      status2 = "stat_failed";
+      break;
+    }
+    try {
+      const stat2 = lstatSync(current);
+      entries.push(renderStat(name, stat2));
+      finalStat = stat2;
+    } catch (error2) {
+      entries.push(renderStatError(name, error2));
+      if (getErrorCode(error2) !== "ENOENT") status2 = "stat_failed";
+      break;
+    }
+  }
+  let symlinkTarget;
+  let symlinkMeta;
+  if (finalStat?.isSymbolicLink() && entries.length === components.length + 1) {
+    try {
+      symlinkTarget = realpathSync(current);
+      try {
+        symlinkMeta = renderStat("", lstatSync(symlinkTarget)).slice(1);
+      } catch (error2) {
+        symlinkMeta = renderErrorCode(getErrorCode(error2));
+        status2 = "stat_failed";
+      }
+    } catch (error2) {
+      symlinkTarget = "<unresolved>";
+      symlinkMeta = renderErrorCode(getErrorCode(error2));
+      status2 = "stat_failed";
+    }
+  }
+  return { status: status2, chain: entries.join(","), symlinkTarget, symlinkMeta };
+}
+function buildDiagnostic(line, context) {
+  const trigger = parseTrigger(line);
+  if (!trigger) return null;
+  const roots = resolveRoots(context);
+  const scope = classifyScope(trigger.dir, roots);
+  const pathSource = trigger.path ? "error" : trigger.dir ? "dir" : "none";
+  const inspectedPath = trigger.path ?? trigger.dir;
+  const microvmId = context.microvmId?.trim() || "unknown";
+  const euid = context.euid === void 0 ? "unavailable" : String(context.euid);
+  const egid = context.egid === void 0 ? "unavailable" : String(context.egid);
+  const op = trigger.op ?? "unknown";
+  if (!inspectedPath) {
+    return {
+      event: `OPENCODE-DEPENDENCY-INSTALL-EACCES: status=no_path path_source=${pathSource} scope=${scope} microvm_id=${microvmId} op=${op} path=unknown cli_euid=${euid} cli_egid=${egid} effect="${EFFECT}" chain=unavailable`,
+      localDetail: null
+    };
+  }
+  const tokenisedPath = tokenise(inspectedPath, roots.resolved);
+  if (!tokenisedPath) {
+    const unresolvedRoot = unresolvedRootForPath(inspectedPath, roots.unresolved);
+    if (unresolvedRoot) {
+      return {
+        event: `OPENCODE-DEPENDENCY-INSTALL-EACCES: status=root_unresolved path_source=${pathSource} scope=${scope} microvm_id=${microvmId} op=${op} path=unknown cli_euid=${euid} cli_egid=${egid} effect="${EFFECT}" chain=unavailable`,
+        localDetail: null
+      };
+    }
+    return {
+      event: `OPENCODE-DEPENDENCY-INSTALL-EACCES: status=outside_roots path_source=${pathSource} scope=${scope} microvm_id=${microvmId} op=${op} path=<outside-approved-roots> cli_euid=${euid} cli_egid=${egid} effect="${EFFECT}" chain=unavailable`,
+      localDetail: `OPENCODE-DEPENDENCY-INSTALL-EACCES (local only): outside approved roots: ${inspectedPath}`
+    };
+  }
+  const inspection = inspectChain(
+    tokenisedPath.root.real,
+    tokenisedPath.root.token,
+    inspectedPath,
+    tokenisedPath.resolutionFailure
+  );
+  const optionalSymlinkFields = inspection.symlinkTarget ? ` symlink_target=${tokenise(inspection.symlinkTarget, roots.resolved)?.value ?? "<outside-approved-roots>"}` + (inspection.symlinkMeta ? ` symlink_meta=${inspection.symlinkMeta}` : "") : "";
+  return {
+    event: `OPENCODE-DEPENDENCY-INSTALL-EACCES: status=${inspection.status} path_source=${pathSource} scope=${scope} microvm_id=${microvmId} op=${op} path=${tokenisedPath.value} cli_euid=${euid} cli_egid=${egid} effect="${EFFECT}" chain=${inspection.chain}${optionalSymlinkFields}`,
+    localDetail: null
+  };
+}
+function createDependencyInstallDiagnosticReporter({
+  context,
+  emitEvent: emitEvent2,
+  emitLocal
+}) {
+  const emittedEvents = /* @__PURE__ */ new Set();
+  return (line) => {
+    const diagnostic = buildDiagnostic(line, context);
+    if (!diagnostic || emittedEvents.has(diagnostic.event)) return;
+    if (emittedEvents.size >= MAX_DISTINCT_DIAGNOSTICS) return;
+    emittedEvents.add(diagnostic.event);
+    emitEvent2(diagnostic.event);
+    if (diagnostic.localDetail) emitLocal(diagnostic.localDetail);
+  };
+}
+
 // src/lib/runner-activity-telemetry.ts
 var FORWARDED_LEVELS_BY_SOURCE = {
   "cli.run": /* @__PURE__ */ new Set(["warn", "error"]),
@@ -1841,7 +2098,17 @@ function parseOpenCodeLogLine(line) {
 }
 var MAX_LINE_BUFFER_BYTES = 16 * 1024;
 var REPEAT_SUPPRESSION_WINDOW_MS = 6e4;
-function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure) {
+function sanitiseDependencyInstallWarning(line) {
+  const withoutDirectory = line.replace(
+    /((?:^|\s)dir=)(?:"(?:\\.|[^"])*"|\/[^\s)"']+|\S+)/g,
+    "$1<path>"
+  );
+  return withoutDirectory.replace(
+    /((?:^|\s)error=)"((?:\\.|[^"])*)"/,
+    (_match, prefix, error2) => `${prefix}"${error2.replace(/'\/[^']*'/g, "'<path>'")}"`
+  );
+}
+function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure, onDependencyInstallFailure) {
   let buffer = Buffer.alloc(0);
   const repeatStates = /* @__PURE__ */ new Map();
   const forwardLine = (line, parsed, repeatsSuppressed = 0) => {
@@ -1853,7 +2120,7 @@ function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure)
     forwardRunnerActivity(
       {
         level: parsed.level,
-        error: line,
+        error: parsed.message === DEPENDENCY_INSTALL_FAILURE_MESSAGE ? sanitiseDependencyInstallWarning(line) : line,
         metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
         source: "opencode"
       },
@@ -1871,24 +2138,7 @@ function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure)
       repeatStates.delete(key);
     }
   };
-  const flushLine = (line) => {
-    const parsed = parseOpenCodeLogLine(line);
-    const isDiskFailure = isSessionStoreWriteFailure(line);
-    const cause = sessionStoreCauseToken(line);
-    if (onSessionStoreWriteFailure && (isDiskFailure || cause !== null)) {
-      try {
-        onSessionStoreWriteFailure({
-          isDiskFailure,
-          sessionId: parsed?.sessionID ?? null,
-          cause
-        });
-      } catch (err) {
-        reportTelemetryDiagnostic(
-          `Runner activity telemetry could not record session-store write failure: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    if (!parsed) return;
+  const forwardWithRepeatSuppression = (line, parsed) => {
     const now = Date.now();
     const key = parsed.message === void 0 ? void 0 : `${parsed.level}\0${parsed.message}\0${parsed.sessionID ?? ""}\0${parsed.messageID ?? ""}`;
     expireRepeatStates(now, key);
@@ -1911,6 +2161,35 @@ function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure)
     previous.parsed = parsed;
     previous.repeatsSuppressed++;
   };
+  const flushLine = (line) => {
+    const parsed = parseOpenCodeLogLine(line);
+    const isDiskFailure = isSessionStoreWriteFailure(line);
+    const cause = sessionStoreCauseToken(line);
+    if (onSessionStoreWriteFailure && (isDiskFailure || cause !== null)) {
+      try {
+        onSessionStoreWriteFailure({
+          isDiskFailure,
+          sessionId: parsed?.sessionID ?? null,
+          cause
+        });
+      } catch (err) {
+        reportTelemetryDiagnostic(
+          `Runner activity telemetry could not record session-store write failure: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    if (!parsed) return;
+    forwardWithRepeatSuppression(line, parsed);
+    if (onDependencyInstallFailure && parsed.message === DEPENDENCY_INSTALL_FAILURE_MESSAGE) {
+      try {
+        onDependencyInstallFailure(line);
+      } catch (err) {
+        reportTelemetryDiagnostic(
+          `Runner activity telemetry could not record dependency-install failure diagnostic: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  };
   const forward = ((chunk) => {
     buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8")]);
     let newlineIndex;
@@ -1950,6 +2229,23 @@ function truncate(message) {
   const remaining = MAX_MESSAGE_LENGTH - marker.length;
   const headLength = Math.ceil(remaining * 0.6);
   const tailLength = remaining - headLength;
+  const effectMatch = message.startsWith("OPENCODE-DEPENDENCY-INSTALL-EACCES:") ? message.match(/ effect="[^"]*"/) : null;
+  if (effectMatch?.index !== void 0) {
+    const effectEnd = effectMatch.index + effectMatch[0].length;
+    if (effectEnd > headLength && effectEnd < message.length) {
+      const effectLength = effectMatch[0].length;
+      const nonEffectLength = remaining - effectLength;
+      const preservedTailLength = Math.min(
+        message.length - effectEnd,
+        nonEffectLength - Math.min(effectMatch.index, Math.ceil(nonEffectLength * 0.6))
+      );
+      const preservedHeadLength = Math.min(
+        effectMatch.index,
+        nonEffectLength - preservedTailLength
+      );
+      return message.slice(0, preservedHeadLength) + marker + message.slice(effectMatch.index, effectEnd) + message.slice(message.length - preservedTailLength);
+    }
+  }
   return message.slice(0, headLength) + marker + message.slice(message.length - tailLength);
 }
 function sanitiseMetadata(metadata) {
@@ -2027,10 +2323,10 @@ function forwardRunnerActivity(entry, context) {
 
 // src/lib/opencode/session-db-recovery-report.ts
 import { readFileSync as readFileSync2, unlinkSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function sessionDbRecoveryReportPath(homeDir, env) {
   const override = env.EVIDENT_SESSION_DB_RECOVERY_REPORT?.trim();
-  return override || join2(homeDir, ".local", "state", "evident", "session-db-recovery.jsonl");
+  return override || join3(homeDir, ".local", "state", "evident", "session-db-recovery.jsonl");
 }
 function drainSessionDbRecoveryReport({
   homeDir,
@@ -2303,7 +2599,7 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
     if (health.healthy || health.authFailed) {
       return health;
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
   }
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
@@ -2314,7 +2610,7 @@ async function waitForOpenCode2Health(port, password, timeoutMs = 3e4) {
     if (health.healthy || health.authFailed) {
       return health;
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
   }
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
@@ -2904,7 +3200,7 @@ async function sendPromptAsync(port, sessionId, content, options, attachments, c
       return dispatchedUserMessageId;
     }
     if (attempt < READ_BACK_ATTEMPTS - 1) {
-      await new Promise((resolve4) => setTimeout(resolve4, READ_BACK_DELAY_MS));
+      await new Promise((resolve5) => setTimeout(resolve5, READ_BACK_DELAY_MS));
     }
   }
   return null;
@@ -3076,9 +3372,11 @@ function sumAssistantUsage(messages) {
   let cacheWriteSum = 0;
   let costSum = 0;
   let sawCost = false;
+  let toolCallCount = 0;
   let modelId = null;
   let providerId = null;
   for (const m of selected) {
+    toolCallCount += m.parts?.filter((part) => part.type === "tool").length ?? 0;
     const info = m.info;
     if (!info) continue;
     const tokens = info.tokens;
@@ -3115,7 +3413,8 @@ function sumAssistantUsage(messages) {
     usage_tokens_cache_write: cacheWriteSum,
     // NULL means OpenCode never reported a cost; it is distinct from a genuine
     // zero-cost message, which sets `sawCost` with `costSum === 0`.
-    usage_cost_usd: sawCost ? costSum : null
+    usage_cost_usd: sawCost ? costSum : null,
+    turn_tool_calls: toolCallCount
   };
 }
 function messageUsage(messages, userMessageId) {
@@ -3964,12 +4263,12 @@ async function readV2SessionErrorStream(client, options) {
 
 // src/lib/opencode/credential-import-v2.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/lib/openai-usage.ts
 import { readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 var OPENCODE_AUTH_SEGMENTS = [".local", "share", "opencode", "auth.json"];
 var OpenAiUsageError = class extends Error {
@@ -3983,7 +4282,7 @@ function isLocalCredentialProblem2(err) {
 }
 function readOpenCodeChatGptCredentials() {
   try {
-    const raw = readFileSync3(join3(homedir3(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
+    const raw = readFileSync3(join4(homedir3(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -4209,13 +4508,13 @@ var INTEGRATION_LIST_RETRY_DELAY_MS = 1e3;
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var sleep2 = (milliseconds) => new Promise((resolve4) => setTimeout(resolve4, milliseconds));
+var sleep2 = (milliseconds) => new Promise((resolve5) => setTimeout(resolve5, milliseconds));
 function emptyResult(unsupported = [], outcome = "completed") {
   return { outcome, imported: [], alreadyConnected: [], unsupported, failed: [] };
 }
 function readOpenCodeCredentials(homeDir, log3) {
   try {
-    const raw = readFileSync4(join4(homeDir, ...OPENCODE_AUTH_SEGMENTS), "utf8");
+    const raw = readFileSync4(join5(homeDir, ...OPENCODE_AUTH_SEGMENTS), "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -4417,7 +4716,7 @@ async function importOpenCodeV2Credentials({
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, resolve as resolvePath } from "node:path";
+import { dirname as dirname4, resolve as resolvePath } from "node:path";
 
 // src/lib/runner-synchroniser.ts
 import { spawn } from "node:child_process";
@@ -4427,7 +4726,7 @@ function appendError(stderr, error2) {
 ${message}`;
 }
 function runSynchroniser(args, opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let child;
     let stdout = "";
     let stderr = "";
@@ -4441,7 +4740,7 @@ function runSynchroniser(args, opts) {
       if (timer.handle) clearTimeout(timer.handle);
       if (abortListener) opts.signal?.removeEventListener("abort", abortListener);
       if (spawnListener) child.removeListener("spawn", spawnListener);
-      resolve4(result);
+      resolve5(result);
     };
     try {
       child = spawn("runner-synchroniser", args, {
@@ -4545,7 +4844,7 @@ function clearMarker(options) {
 function markNoReplicate(options, message) {
   if (options.noReplicateMarker) {
     try {
-      mkdirSync(dirname3(options.noReplicateMarker), { recursive: true });
+      mkdirSync(dirname4(options.noReplicateMarker), { recursive: true });
       writeFileSync(options.noReplicateMarker, "");
     } catch (error2) {
       options.log(
@@ -4604,7 +4903,7 @@ function parseSynchroniserEnv(stdout) {
   return values;
 }
 function runCommand(command, args, options) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let child;
     let stdout = "";
     let stderr = "";
@@ -4613,7 +4912,7 @@ function runCommand(command, args, options) {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      resolve4(result);
+      resolve5(result);
     };
     try {
       child = spawn2(command, args, {
@@ -4621,7 +4920,7 @@ function runCommand(command, args, options) {
         stdio: ["ignore", "pipe", "pipe"]
       });
     } catch (error2) {
-      resolve4({
+      resolve5({
         code: null,
         stdout,
         stderr: error2 instanceof Error ? error2.message : String(error2),
@@ -4700,7 +4999,7 @@ async function ensureLitestreamConfig(options, env) {
     return null;
   }
   try {
-    mkdirSync(dirname3(configPath), { recursive: true });
+    mkdirSync(dirname4(configPath), { recursive: true });
     writeFileSync(configPath, rendered.stdout);
   } catch (error2) {
     options.log(
@@ -4967,7 +5266,7 @@ async function restoreAndVerifySessionDb(options) {
 // src/lib/opencode/session-db-provenance.ts
 import { createRequire } from "node:module";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname5, join as join6 } from "node:path";
 var require2 = createRequire(import.meta.url);
 function readSessionDbMigrationIds(dbPath) {
   let db;
@@ -5004,7 +5303,7 @@ function readSessionDbMigrationIds(dbPath) {
 }
 function sessionDbProvenanceStatePath(homeDir, env) {
   const override = env.EVIDENT_SESSION_DB_PROVENANCE_STATE?.trim();
-  return override || join5(homeDir, ".local", "state", "evident", "session-db-provenance.json");
+  return override || join6(homeDir, ".local", "state", "evident", "session-db-provenance.json");
 }
 function loadSessionDbProvenanceState(path) {
   let value;
@@ -5033,7 +5332,7 @@ function loadSessionDbProvenanceState(path) {
 }
 function saveSessionDbProvenanceState(path, state) {
   try {
-    mkdirSync2(dirname4(path), { recursive: true });
+    mkdirSync2(dirname5(path), { recursive: true });
     writeFileSync2(path, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   } catch (error2) {
@@ -5124,7 +5423,7 @@ async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
   if (child.exitCode !== null || child.signalCode !== null) {
     return { outcome: "exited", code: child.exitCode, signal: child.signalCode };
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let forced = false;
     let settled = false;
     const timer = setTimeout(() => {
@@ -5144,7 +5443,7 @@ async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
       settled = true;
       clearTimeout(timer);
       child.removeListener("exit", onExit);
-      resolve4(result);
+      resolve5(result);
     };
     const fail = (error2) => {
       if (settled) return;
@@ -5620,7 +5919,7 @@ function selectSessionsToDelete(sessions, opts) {
   );
 }
 var DEFAULT_INTERVAL = "1h";
-function resolve(flag, envValue, fallback) {
+function resolve2(flag, envValue, fallback) {
   return flag ?? envValue ?? fallback;
 }
 function parseMaxCount(input) {
@@ -5636,9 +5935,9 @@ function parseMaxCount(input) {
 }
 function resolveSessionCleanupConfig(flags, env = process.env) {
   const warnings = [];
-  const maxAgeRaw = resolve(flags.maxAge, env.EVIDENT_SESSION_CLEANUP_MAX_AGE);
-  const maxCountRaw = resolve(flags.maxCount, env.EVIDENT_SESSION_CLEANUP_MAX_COUNT);
-  const intervalRaw = resolve(
+  const maxAgeRaw = resolve2(flags.maxAge, env.EVIDENT_SESSION_CLEANUP_MAX_AGE);
+  const maxCountRaw = resolve2(flags.maxCount, env.EVIDENT_SESSION_CLEANUP_MAX_COUNT);
+  const intervalRaw = resolve2(
     flags.interval,
     env.EVIDENT_SESSION_CLEANUP_INTERVAL,
     DEFAULT_INTERVAL
@@ -5678,10 +5977,10 @@ function resolveSessionCleanupConfig(flags, env = process.env) {
 
 // src/lib/opencode/session-db-size.ts
 import { statSync as statSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var LARGE_DB_THRESHOLD_BYTES = 268435456;
 function statSessionDbBytes(homeDir) {
-  const dbPath = join6(homeDir, ".local", "share", "opencode", "opencode.db");
+  const dbPath = join7(homeDir, ".local", "share", "opencode", "opencode.db");
   try {
     return statSync4(dbPath).size;
   } catch (err) {
@@ -5711,12 +6010,12 @@ function buildSessionStoreSizeWarning(input) {
 // src/lib/opencode/log-tail.ts
 import { statSync as statSync5 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { open as open2, stat } from "node:fs/promises";
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 function resolveOpenCodeLogPath(homeDir = homedir5(), env = process.env) {
-  const dataDir = env.XDG_DATA_HOME || join7(homeDir, ".local", "share");
-  return join7(dataDir, "opencode", "log", "opencode.log");
+  const dataDir = env.XDG_DATA_HOME || join8(homeDir, ".local", "share");
+  return join8(dataDir, "opencode", "log", "opencode.log");
 }
 function isEnoent(error2) {
   return error2?.code === "ENOENT";
@@ -5871,8 +6170,8 @@ var StreamForwarder = class {
   pauseStream(sid, stream) {
     if (!stream.paused) {
       stream.paused = true;
-      stream.pausePromise = new Promise((resolve4) => {
-        stream.resume = resolve4;
+      stream.pausePromise = new Promise((resolve5) => {
+        stream.resume = resolve5;
       });
     }
     if (stream.pauseTimer !== null) clearTimeout(stream.pauseTimer);
@@ -5939,12 +6238,12 @@ var StreamForwarder = class {
     let endBody;
     if (has_body) {
       const chunks = [];
-      bodyPromise = new Promise((resolve4) => {
+      bodyPromise = new Promise((resolve5) => {
         pushBody = (buf) => {
           chunks.push(buf);
         };
         endBody = () => {
-          resolve4(Buffer.concat(chunks));
+          resolve5(Buffer.concat(chunks));
         };
       });
     }
@@ -6115,7 +6414,7 @@ function connectTunnel(options) {
   } = options;
   const tunnelUrl = getTunnelUrlConfig();
   const url = `${tunnelUrl}/tunnel/${agentId}/connect`;
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const ws = new WebSocket2(url, {
       headers: {
         Authorization: authHeader,
@@ -6224,7 +6523,7 @@ function connectTunnel(options) {
           forwarder.setBinaryFramesSupported(message.binary_frames === true);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
-          resolve4({
+          resolve5({
             ws,
             close: () => ws.close(1e3, "CLI shutdown")
           });
@@ -6779,12 +7078,12 @@ function createSessionStoreHealth(options = {}) {
 import { homedir as homedir6 } from "node:os";
 
 // src/lib/runner-file-sync.ts
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/lib/file-push.ts
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, open as open3, realpath, rename, unlink } from "node:fs/promises";
-import { basename, dirname as dirname5, isAbsolute, join as join8, relative, resolve as resolve2, sep } from "node:path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 var FILE_MODE = 384;
 var DIRECTORY_MODE = 448;
 async function writePushedFile(request2) {
@@ -6815,9 +7114,9 @@ async function writePushedFile(request2) {
   }
   try {
     const { existingAncestor, missingSegments } = await resolveNearestExistingAncestor(
-      dirname5(candidate)
+      dirname6(candidate)
     );
-    const realTarget = join8(existingAncestor, ...missingSegments, basename(candidate));
+    const realTarget = join9(existingAncestor, ...missingSegments, basename2(candidate));
     const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget);
     if (allowedDirectory === null) {
       return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
@@ -6827,8 +7126,8 @@ async function writePushedFile(request2) {
     }
     if (missingSegments.length > 0) {
       await createMissingDirectories(existingAncestor, missingSegments);
-      const realParent = await realpath(dirname5(realTarget));
-      if (realParent !== dirname5(realTarget) || !contains(allowedDirectory, realTarget)) {
+      const realParent = await realpath(dirname6(realTarget));
+      if (realParent !== dirname6(realTarget) || !contains(allowedDirectory, realTarget)) {
         return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
           path: realTarget,
           bytes,
@@ -6853,15 +7152,15 @@ function expandAndValidate(requestedPath, homeDir) {
   if (requestedPath.trim() === "" || requestedPath.includes("\0")) {
     return null;
   }
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join8(homeDir, requestedPath.slice(2)) : requestedPath;
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join9(homeDir, requestedPath.slice(2)) : requestedPath;
   if (expanded.split(/[/\\]/).includes("..")) {
     return null;
   }
-  if (!isAbsolute(expanded)) {
+  if (!isAbsolute2(expanded)) {
     return null;
   }
-  const candidate = resolve2(expanded);
-  const name = basename(candidate);
+  const candidate = resolve3(expanded);
+  const name = basename2(candidate);
   return name === "" || name === "." || name === ".." ? null : candidate;
 }
 async function resolveNearestExistingAncestor(directory) {
@@ -6871,18 +7170,18 @@ async function resolveNearestExistingAncestor(directory) {
     try {
       return { existingAncestor: await realpath(current), missingSegments };
     } catch (err) {
-      const parent = dirname5(current);
+      const parent = dirname6(current);
       if (err.code !== "ENOENT" || parent === current) {
         throw err;
       }
-      missingSegments.unshift(basename(current));
+      missingSegments.unshift(basename2(current));
       current = parent;
     }
   }
 }
 async function findContainingAllowedDirectory(allowedDirectories, realTarget) {
   for (const directory of allowedDirectories) {
-    if (!isAbsolute(directory)) {
+    if (!isAbsolute2(directory)) {
       log("warn", "file_push_allowed_directory_skipped", { directory, reason: "not_absolute" });
       continue;
     }
@@ -6920,19 +7219,19 @@ async function realpathCreatingIfMissing(directory) {
   }
 }
 function contains(realDirectory, realTarget) {
-  const rel = relative(realDirectory, realTarget);
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+  const rel = relative2(realDirectory, realTarget);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
 }
 async function createMissingDirectories(existingAncestor, missingSegments) {
   let current = existingAncestor;
   for (const segment of missingSegments) {
-    current = join8(current, segment);
+    current = join9(current, segment);
     await mkdir(current, { recursive: true, mode: DIRECTORY_MODE });
     await chmod(current, DIRECTORY_MODE);
   }
 }
 async function writeAtomically(realTarget, content) {
-  const temporaryPath = join8(dirname5(realTarget), `.evident-push-${randomUUID()}.tmp`);
+  const temporaryPath = join9(dirname6(realTarget), `.evident-push-${randomUUID()}.tmp`);
   let handle;
   try {
     handle = await open3(temporaryPath, "wx", FILE_MODE);
@@ -7062,12 +7361,12 @@ var NOT_APPLIED = {
   opencodeAuthApplied: false
 };
 function isClaudeCredentialPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join9(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join9(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join10(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join10(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
 }
 function isOpenCodeAuthPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join9(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join9(homeDir, ...OPENCODE_AUTH_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join10(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join10(homeDir, ...OPENCODE_AUTH_SEGMENTS);
 }
 async function applyOne(options, file) {
   const label = `${file.id.slice(0, 8)} (${file.path})`;
@@ -7238,7 +7537,7 @@ var SESSION_ERROR_BUFFER_TTL_MS = SESSION_ERROR_STREAM_HEALTHY_MS;
 var MAX_BUFFERED_SESSION_ERRORS = 256;
 var SESSION_ERROR_RETENTION_TTL_MS = 6e4;
 var SESSION_STORE_UNWRITABLE_ERROR = "The runner session database could not be written, so this turn did not finish. Nothing was lost from the queue. Clear disk space and retry.";
-var SESSION_ERROR_RETAINED_DETAIL = "The runner's session database could not be written, so this turn stopped part-way. Runner-observed session error: ";
+var SESSION_ERROR_RETAINED_DETAIL = "Runner-observed OpenCode session error: ";
 var SESSION_ERROR_OBSERVED_CAUSE = "Runner-observed OpenCode session-store cause: ";
 var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
@@ -9853,7 +10152,7 @@ var ChannelDriver = class _ChannelDriver {
       if (!inFlight.done) {
         const messageErrorText = messageError(messages, inFlight.opencodeMessageId);
         const retainedReason = this.readRetainedSessionError(sessionId);
-        const retainedError = retainedReason === null ? null : `${SESSION_ERROR_RETAINED_DETAIL}${retainedReason}`;
+        const retainedError = retainedReason === null || messageErrorText !== null && messageErrorText.includes(retainedReason) ? null : `${SESSION_ERROR_RETAINED_DETAIL}${retainedReason}`;
         const observedCause = this.sessionStoreHealth?.readCause(sessionId);
         const causeError = observedCause === null || observedCause === void 0 ? null : `${SESSION_ERROR_OBSERVED_CAUSE}${observedCause}`;
         const storeError = this.sessionStoreHealth?.isUnwritable() ? SESSION_STORE_UNWRITABLE_ERROR : null;
@@ -11562,14 +11861,14 @@ var ChannelDriver = class _ChannelDriver {
     const fetchChildWithoutBlocking = async (sessionId) => {
       const pending = fetchChildMessages(sessionId);
       let timer;
-      const timeout = new Promise((resolve4) => {
+      const timeout = new Promise((resolve5) => {
         timer = setTimeout(() => {
           this.log({
             level: "warn",
             message: `Best-effort subagent session fetch for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} was slow \u2014 omitting invocation telemetry without delaying completion`,
             message_id: messageId
           });
-          resolve4(null);
+          resolve5(null);
         }, SUBAGENT_TELEMETRY_FETCH_TIMEOUT_MS);
       });
       try {
@@ -12811,7 +13110,7 @@ function commandError2(result) {
   return result.stderr.trim() || `process exited with code ${result.code ?? "null"}`;
 }
 var runCommand2 = (command, args, opts) => {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let child;
     let stdout = "";
     let stderr = "";
@@ -12821,7 +13120,7 @@ var runCommand2 = (command, args, opts) => {
       if (settled) return;
       settled = true;
       if (timer.handle) clearTimeout(timer.handle);
-      resolve4(result);
+      resolve5(result);
     };
     try {
       child = spawn5(command, args, { env: opts.env, stdio: ["ignore", "pipe", "pipe"] });
@@ -13077,7 +13376,7 @@ async function configureGitHubAccess({ env, log: log3 }) {
 // src/lib/opencode/config-overlay.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { copyFileSync, existsSync as existsSync2, statSync as statSync6 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join10, resolve as resolve3 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join11, resolve as resolve4 } from "node:path";
 function isFile(filePath) {
   return existsSync2(filePath) && statSync6(filePath).isFile();
 }
@@ -13090,8 +13389,8 @@ function applyRunnerOpenCodeConfig({
     log3("runner OpenCode config is not configured; using the baked project config", "debug");
     return;
   }
-  const source = isAbsolute2(overlayPath) ? overlayPath : resolve3(cwd, overlayPath);
-  const target = isFile(join10(cwd, "opencode.jsonc")) ? "opencode.jsonc" : "opencode.json";
+  const source = isAbsolute3(overlayPath) ? overlayPath : resolve4(cwd, overlayPath);
+  const target = isFile(join11(cwd, "opencode.jsonc")) ? "opencode.jsonc" : "opencode.json";
   if (!isFile(source)) {
     log3(
       `RUNNER-OPENCODE-CONFIG-MISSING: ${source} is not a file; headless turns will wedge on the first external-directory permission prompt (#563)`,
@@ -13099,7 +13398,7 @@ function applyRunnerOpenCodeConfig({
     );
     return;
   }
-  copyFileSync(source, join10(cwd, target));
+  copyFileSync(source, join11(cwd, target));
   try {
     execFileSync2("git", ["-C", cwd, "update-index", "--skip-worktree", target], {
       stdio: "ignore"
@@ -13108,7 +13407,7 @@ function applyRunnerOpenCodeConfig({
     const detail = error2 instanceof Error ? error2.message : String(error2);
     log3(`could not mark ${target} skip-worktree: ${detail}; it may show as a local change`, "warn");
   }
-  log3(`Applied runner OpenCode config ${source} to ${join10(cwd, target)}`);
+  log3(`Applied runner OpenCode config ${source} to ${join11(cwd, target)}`);
 }
 
 // src/lib/credential-sync.ts
@@ -13126,14 +13425,14 @@ function errorMessage2(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 function waitForSettlement(promise, timeoutMs) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     const timer = setTimeout(() => finish(false), Math.max(0, timeoutMs));
     const finish = (value) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve4(value);
+      resolve5(value);
     };
     promise.then(
       () => finish(true),
@@ -13384,8 +13683,8 @@ function resolveFileSyncDirectories(raw, homeDir) {
     if (trimmed === "") {
       throw new Error("--enable-file-sync-to requires a directory path (got an empty value)");
     }
-    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join11(homeDir, trimmed.slice(2)) : trimmed;
-    if (!isAbsolute3(expanded)) {
+    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join12(homeDir, trimmed.slice(2)) : trimmed;
+    if (!isAbsolute4(expanded)) {
       throw new Error(`--enable-file-sync-to requires an absolute directory path; got "${entry}"`);
     }
     const normalized = resolvePath2(expanded);
@@ -13485,8 +13784,7 @@ function resolveMaxActiveSessions(options, env = process.env) {
 function meetsThreshold(state, level) {
   return LOG_LEVELS[level] >= LOG_LEVELS[state.logLevel];
 }
-function log2(state, message, level = "info") {
-  if (!meetsThreshold(state, level)) return;
+function writeConsoleLog(state, message, level) {
   if (state.json) {
     console.log(
       JSON.stringify({
@@ -13495,10 +13793,18 @@ function log2(state, message, level = "info") {
         message
       })
     );
-  } else if (!state.interactive) {
-    const prefix = level === "error" ? chalk7.red("\u2717") : level === "warn" ? chalk7.yellow("!") : level === "debug" ? chalk7.dim("\xB7") : chalk7.green("\u2022");
-    console.log(`${prefix} ${message}`);
+    return;
   }
+  const prefix = level === "error" ? chalk7.red("\u2717") : level === "warn" ? chalk7.yellow("!") : level === "debug" ? chalk7.dim("\xB7") : chalk7.green("\u2022");
+  console.log(`${prefix} ${message}`);
+}
+function log2(state, message, level = "info") {
+  if (!meetsThreshold(state, level)) return;
+  if (state.json || !state.interactive) writeConsoleLog(state, message, level);
+}
+function logLocalOnly(state, message, level = "info") {
+  if (!meetsThreshold(state, level)) return;
+  writeConsoleLog(state, message, level);
 }
 function logActivity(state, entry) {
   const level = entry.level ?? (entry.type === "error" ? "error" : "info");
@@ -13800,7 +14106,7 @@ async function driveChannels(state, driver) {
         }
       }
     }
-    await new Promise((resolve4) => setTimeout(resolve4, CHANNEL_POLL_INTERVAL_MS));
+    await new Promise((resolve5) => setTimeout(resolve5, CHANNEL_POLL_INTERVAL_MS));
     const cycleMs = performance.now() - cycleStartedAtMs;
     if (idleThisCycle) idleMs += cycleMs;
     if (unreachableThisCycle) unreachableMs += cycleMs;
@@ -13835,7 +14141,7 @@ function shouldWarnForReclaimSkip(reason) {
   return major > 22 || major === 22 && (minor > 13 || minor === 13 && patch >= 0);
 }
 function sessionDbPath() {
-  return join11(homedir7(), ".local", "share", "opencode", "opencode.db");
+  return join12(homedir7(), ".local", "share", "opencode", "opencode.db");
 }
 function logSessionCleanupActivity(state, phase, entry) {
   logActivity(state, {
@@ -14515,8 +14821,8 @@ async function beginGracefulShutdown(state, trigger) {
         return true;
       }
     );
-    const timedOut = new Promise((resolve4) => {
-      timer = setTimeout(() => resolve4(false), telemetryBudgetMs);
+    const timedOut = new Promise((resolve5) => {
+      timer = setTimeout(() => resolve5(false), telemetryBudgetMs);
     });
     if (!await Promise.race([flushed, timedOut])) {
       log2(state, `Telemetry flush exceeded ${telemetryBudgetMs}ms \u2014 exiting anyway`, "warn");
@@ -14804,6 +15110,17 @@ async function run(options) {
     }
     if (githubTokenPopulated) await configureGitHubAccess(credentialContext);
     state.credentialSync?.arm();
+    const dependencyInstallDiagnosticReporter = createDependencyInstallDiagnosticReporter({
+      context: {
+        homeDir: homedir7(),
+        cwd: process.cwd(),
+        microvmId: process.env.MICROVM_ID?.trim(),
+        euid: process.getuid?.(),
+        egid: process.getgid?.()
+      },
+      emitEvent: (message) => logActivity(state, { type: "info", level: "warn", message }),
+      emitLocal: (message) => logLocalOnly(state, message, "warn")
+    });
     const openCodeActivityForwarder = createOpenCodeActivityForwarder(
       () => ({
         agentId: state.agentId,
@@ -14814,7 +15131,8 @@ async function run(options) {
         if (cause !== null && sessionId !== null) {
           state.sessionStoreHealth.observeCause(sessionId, cause);
         }
-      }
+      },
+      dependencyInstallDiagnosticReporter
     );
     const openCodeLogTail = tailOpenCodeLogFile(
       resolveOpenCodeLogPath(homedir7(), process.env),