@evident-ai/cli 3.5.2-dev.fbf25b4 → 3.5.2-dev.fdeb718

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
@@ -1293,7 +1293,11 @@ var FORWARD_FAILURE_REASON_HEADER = "X-Evident-Failure-Reason";
 function log(level, event, fields) {
   const method = level === "debug" ? "log" : level;
   try {
-    console[method]("[evident]", JSON.stringify({ level, event, ...fields }));
+    const payload = Object.fromEntries(
+      Object.entries({ level, event, ...fields }).filter(([, value]) => value !== void 0)
+    );
+    const secondArgument = globalThis.navigator?.userAgent === "Cloudflare-Workers" ? payload : JSON.stringify(payload);
+    console[method]("[evident]", secondArgument);
   } catch (err) {
     console.error(
       "[evident] log_serialize_failed",
@@ -1322,7 +1326,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.fbf25b4" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.fdeb718" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1515,9 +1519,10 @@ function redactDiagnosticText(message) {
 }
 
 // src/lib/opencode/session-db-reclaim.ts
-var SESSION_DB_RECLAIM_CHUNK_PAGES = 2e3;
+var SESSION_DB_RECLAIM_CHUNK_PAGES = 100;
 var SESSION_DB_RECLAIM_TIME_BUDGET_MS = 500;
 var SESSION_DB_RECLAIM_PAGE_CEILING = 4e4;
+var SESSION_DB_RECLAIM_BUSY_TIMEOUT_MS = 5e3;
 function errorMessage(error2) {
   if (!(error2 instanceof Error)) return String(error2);
   return error2.cause instanceof Error ? error2.cause.message : error2.message;
@@ -1642,6 +1647,7 @@ function readFreelistCount(db) {
   return db.prepare("PRAGMA freelist_count").get().freelist_count;
 }
 function readCheckpointResult(db) {
+  db.exec("PRAGMA busy_timeout=0");
   const row = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
   return { busy: row.busy !== 0, log: row.log, checkpointed: row.checkpointed };
 }
@@ -1659,7 +1665,7 @@ async function probeReclaimAvailability(input) {
   try {
     const db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
     try {
-      db.exec("PRAGMA busy_timeout=5000");
+      db.exec(`PRAGMA busy_timeout=${SESSION_DB_RECLAIM_BUSY_TIMEOUT_MS}`);
       autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
     } finally {
       db.close();
@@ -1679,7 +1685,8 @@ async function reclaimSessionDbSpace(input) {
     timeBudgetMs = SESSION_DB_RECLAIM_TIME_BUDGET_MS,
     chunkPages = SESSION_DB_RECLAIM_CHUNK_PAGES,
     now = () => performance.now(),
-    allowFullVacuum = true
+    hasLiveTurn = false,
+    hasProvenanceAnomaly = false
   } = input;
   let sqlite;
   try {
@@ -1695,17 +1702,19 @@ async function reclaimSessionDbSpace(input) {
   let db;
   try {
     db = new DatabaseSync(dbPath);
-    db.exec("PRAGMA busy_timeout=5000");
+    db.exec(`PRAGMA busy_timeout=${SESSION_DB_RECLAIM_BUSY_TIMEOUT_MS}`);
     const autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
     if (autoVacuum === 0) {
-      if (!allowFullVacuum) {
-        console.warn(
-          `[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: a session turn is live`
-        );
+      if (hasLiveTurn || hasProvenanceAnomaly) {
+        const detail = [
+          ...hasLiveTurn ? ["a session turn is live"] : [],
+          ...hasProvenanceAnomaly ? ["session-DB provenance is anomalous"] : []
+        ].join(" and ");
+        console.warn(`[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: ${detail}`);
         return {
           ok: false,
           skipped: "full-vacuum-blocked",
-          detail: "a session turn is live"
+          detail
         };
       }
       const fileBytesForGuard = statSync2(dbPath).size;
@@ -1723,7 +1732,9 @@ async function reclaimSessionDbSpace(input) {
       db.exec("VACUUM");
       const afterBytes = readLogicalBytes(db);
       const freelistAfter = readFreelistCount(db);
+      const checkpointStartedAt = now();
       const checkpoint = readCheckpointResult(db);
+      const checkpointElapsedMs = Math.max(0, now() - checkpointStartedAt);
       return {
         ok: true,
         mode: "convert",
@@ -1734,10 +1745,18 @@ async function reclaimSessionDbSpace(input) {
         pagesReclaimed: Math.max(0, freelistBefore - freelistAfter),
         stoppedBy: "freelist-drained",
         elapsedMs: Math.max(0, now() - startedAt),
+        checkpointElapsedMs,
         checkpoint
       };
     }
     if (autoVacuum === 2) {
+      if (hasLiveTurn) {
+        const detail = "a session turn is live";
+        console.warn(
+          `[reclaimSessionDbSpace] skipping incremental reclaim of ${dbPath}: ${detail}`
+        );
+        return { ok: false, skipped: "live-turn", detail };
+      }
       const beforeBytes = readLogicalBytes(db);
       const freelistBefore = readFreelistCount(db);
       const startedAt = now();
@@ -1762,7 +1781,9 @@ async function reclaimSessionDbSpace(input) {
         freelistAfter = readFreelistCount(db);
       }
       const afterBytes = readLogicalBytes(db);
+      const checkpointStartedAt = now();
       const checkpoint = readCheckpointResult(db);
+      const checkpointElapsedMs = Math.max(0, now() - checkpointStartedAt);
       return {
         ok: true,
         mode: "incremental",
@@ -1773,6 +1794,7 @@ async function reclaimSessionDbSpace(input) {
         pagesReclaimed: Math.max(0, freelistBefore - freelistAfter),
         stoppedBy,
         elapsedMs: Math.max(0, now() - startedAt),
+        checkpointElapsedMs,
         checkpoint
       };
     }
@@ -1792,6 +1814,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"]),
@@ -1823,7 +2102,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) => {
@@ -1835,7 +2124,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"
       },
@@ -1853,24 +2142,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);
@@ -1893,6 +2165,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;
@@ -1932,6 +2233,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) {
@@ -2009,10 +2327,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,
@@ -2285,7 +2603,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" };
 }
@@ -2296,7 +2614,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" };
 }
@@ -2563,7 +2881,18 @@ async function deleteSession(port, id, client) {
       { method: "DELETE" },
       { allowStatuses: ALL_HTTP_STATUSES }
     );
-    return { ok: res.status >= 200 && res.status < 300, status: res.status };
+    if (res.status >= 200 && res.status < 300) {
+      return { ok: true, status: res.status };
+    }
+    try {
+      const body = await res.text();
+      return body ? { ok: false, status: res.status, body } : { ok: false, status: res.status };
+    } catch (error2) {
+      console.error(
+        `[deleteSession] DELETE /session/${id} response body read failed for HTTP ${res.status}: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+      return { ok: false, status: res.status };
+    }
   } catch (error2) {
     console.error(
       `[deleteSession] DELETE /session/${id} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -2875,7 +3204,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;
@@ -3047,9 +3376,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;
@@ -3086,7 +3417,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) {
@@ -3190,19 +3522,32 @@ function isAbortedTerminalReply(messages, userMessageId) {
   }
   return false;
 }
+var CLAUDE_AUTH_EXPIRY_MESSAGES = Object.freeze([
+  "Claude Code credentials are unavailable or expired. Run `claude` to refresh them."
+]);
+function extractReplyErrorShape(reply) {
+  const error2 = errorOf(reply);
+  if (error2 == null || typeof error2 !== "object") {
+    return { name: null, statusCode: null };
+  }
+  const e = error2;
+  const name = typeof e.name === "string" ? e.name.slice(0, 100) : null;
+  const data = e.data;
+  const statusCode = typeof data?.statusCode === "number" && Number.isFinite(data.statusCode) ? data.statusCode : null;
+  return { name, statusCode };
+}
 function classifyReplyAuthError(reply) {
   const error2 = errorOf(reply);
   if (error2 == null || typeof error2 !== "object") return null;
   const e = error2;
   const replyProviderId = reply?.info?.providerID ?? null;
   const replyModelId = reply?.info?.modelID ?? null;
+  const data = e.data;
   if (e.name === "ProviderAuthError") {
-    const data = e.data;
     const providerId = typeof data?.providerID === "string" && data.providerID || replyProviderId;
     return { kind: "model_auth", providerId, modelId: replyModelId, reason: "missing" };
   }
   if (e.name === "APIError") {
-    const data = e.data;
     const statusCode = data?.statusCode;
     if (statusCode === 401 || statusCode === 403) {
       return {
@@ -3213,11 +3558,23 @@ function classifyReplyAuthError(reply) {
       };
     }
   }
+  const errorMessage3 = typeof data?.message === "string" ? data.message : typeof e.message === "string" ? e.message : null;
+  if (errorMessage3 !== null && CLAUDE_AUTH_EXPIRY_MESSAGES.some((knownMessage) => errorMessage3.includes(knownMessage))) {
+    return {
+      kind: "model_auth",
+      providerId: typeof data?.providerID === "string" && data.providerID || replyProviderId,
+      modelId: replyModelId,
+      reason: "rejected"
+    };
+  }
   return null;
 }
 function messageFailure(messages, userMessageId) {
   return classifyReplyAuthError(findLastAssistantReplyFor(messages, userMessageId));
 }
+function isProviderModelNotFoundError(reason) {
+  return reason.includes("Model not found:");
+}
 function findLatestSubagentAuthOutcome(messages, sinceMs) {
   if (!messages || messages.length === 0) return null;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -3426,23 +3783,49 @@ async function readSessionErrorStream(port, options, client) {
     if (reader) void reader.cancel().catch(() => void 0);
   }
 }
-async function reloadProviderCache(port, client) {
-  if (client?.version === "v2") return;
+async function disposeAndReloadProviderConfig(port, client) {
+  if (client?.version === "v2") return { outcome: "skipped_v2" };
   try {
-    const res = await requestWithClient(port, client, "/config", {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({})
-    });
+    const res = await requestWithClient(
+      port,
+      client,
+      "/config",
+      {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+      },
+      { allowStatuses: ALL_HTTP_STATUSES }
+    );
     if (!res.ok) {
       console.error(
-        `[reloadProviderCache] PATCH /config returned HTTP ${res.status} (port ${port})`
+        `[disposeAndReloadProviderConfig] PATCH /config returned HTTP ${res.status} (port ${port})`
       );
+      return { outcome: "failed", status: res.status, detail: null };
     }
+    return { outcome: "reloaded" };
   } catch (err) {
     console.error(
-      `[reloadProviderCache] PATCH /config failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+      `[disposeAndReloadProviderConfig] PATCH /config failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
     );
+    return {
+      outcome: "failed",
+      status: null,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function probeOpenCodeRequestReadiness(port, client) {
+  try {
+    const res = await requestWithClient(port, client, "/config", void 0, {
+      allowStatuses: ALL_HTTP_STATUSES
+    });
+    const body = await res.text();
+    return { ok: res.ok, status: res.status, bodyEmpty: body.trim().length === 0, detail: null };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error(`[probeOpenCodeRequestReadiness] GET /config failed (port ${port}): ${detail}`);
+    return { ok: false, status: null, bodyEmpty: null, detail };
   }
 }
 
@@ -3748,7 +4131,18 @@ async function deleteV2Session(client, sessionId) {
       { method: "DELETE" },
       { allowStatuses: Array.from({ length: 500 }, (_, index) => index + 100) }
     );
-    return { ok: response.status >= 200 && response.status < 300, status: response.status };
+    if (response.status >= 200 && response.status < 300) {
+      return { ok: true, status: response.status };
+    }
+    try {
+      const body = await response.text();
+      return body ? { ok: false, status: response.status, body } : { ok: false, status: response.status };
+    } catch (error2) {
+      console.error(
+        `[deleteV2Session] DELETE /api/session/${sessionId} response body read failed for HTTP ${response.status}: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+      return { ok: false, status: response.status };
+    }
   } catch (error2) {
     console.error(
       `[deleteV2Session] DELETE /api/session/${sessionId} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -3924,12 +4318,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 {
@@ -3943,7 +4337,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);
@@ -4169,13 +4563,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);
@@ -4377,7 +4771,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";
@@ -4387,7 +4781,7 @@ function appendError(stderr, error2) {
 ${message}`;
 }
 function runSynchroniser(args, opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let child;
     let stdout = "";
     let stderr = "";
@@ -4401,7 +4795,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, {
@@ -4505,7 +4899,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(
@@ -4564,7 +4958,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 = "";
@@ -4573,7 +4967,7 @@ function runCommand(command, args, options) {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      resolve4(result);
+      resolve5(result);
     };
     try {
       child = spawn2(command, args, {
@@ -4581,7 +4975,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),
@@ -4660,7 +5054,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(
@@ -4927,7 +5321,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;
@@ -4964,7 +5358,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;
@@ -4993,7 +5387,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) {
@@ -5084,7 +5478,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(() => {
@@ -5104,7 +5498,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;
@@ -5580,7 +5974,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) {
@@ -5596,9 +5990,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
@@ -5638,10 +6032,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) {
@@ -5671,12 +6065,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";
@@ -5831,8 +6225,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);
@@ -5899,12 +6293,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));
         };
       });
     }
@@ -6075,7 +6469,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,
@@ -6184,7 +6578,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")
           });
@@ -6739,12 +7133,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) {
@@ -6775,9 +7169,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.", {
@@ -6787,8 +7181,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,
@@ -6813,15 +7207,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) {
@@ -6831,18 +7225,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;
     }
@@ -6880,19 +7274,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);
@@ -7022,12 +7416,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})`;
@@ -7171,6 +7565,11 @@ function messageIdOf(m) {
   const infoId = m.info?.id;
   return typeof infoId === "string" ? infoId : void 0;
 }
+function composeAbandonmentNote(finish, replyShape, outcome) {
+  const base = `OpenCode ended this turn after a tool call (finish="${finish ?? "(unknown)"}") ` + (outcome === "without-answer" ? "without writing an answer, and confirmed it is no longer working on this conversation. Evident is reporting the run as failed so the failure and its reason are visible in failed runs." : "after writing only part of an answer, and confirmed it is no longer working on this conversation. Evident delivered what was written and is reporting the run as finished.");
+  if (replyShape === null) return base;
+  return `${base} ${replyShape.lastToolName === null ? "No tool call was recorded" : `The last tool call was "${replyShape.lastToolName}" with status "${replyShape.lastToolStatus ?? "(unknown)"}"`}; the reply's final part types were [${replyShape.partTypes.join(", ")}]${replyShape.droppedPartCount > 0 ? ` (${replyShape.droppedPartCount} earlier part types omitted)` : ""}.`;
+}
 function cleanImageMime(contentType) {
   if (!contentType) return null;
   const media = contentType.split(";")[0].trim().toLowerCase();
@@ -7193,7 +7592,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;
@@ -7317,12 +7716,15 @@ var ChannelDriver = class _ChannelDriver {
   /**
    * Per-conversation throttle state for the #183 recurrence warning (#1618
    * WI-4) — see `reportWedgedConversation`'s doc comment for why this exists.
-   * `firstWedgedAt` anchors `stuck_for_ms`; `lastWarnedAt` throttles both the
-   * log line and the `dispatch_wedged` signal to at most once per
-   * `wedgeWarningIntervalMs`; `consecutiveTicks` is reported in the log text
-   * so the operator sees magnitude, not repetition. Cleared the moment the
-   * conversation dispatches anything (a fresh wedge, if it recurs, is a new
-   * incident). Bounded FIFO, mirroring `supersededSessions`
+   * `firstWedgedAt` anchors `stuck_for_ms`; `warnAnchorAt` is the throttle
+   * anchor from first detection through the first warning, then from each
+   * warning onward; `consecutiveTicks` is reported in the log text so the
+   * operator sees magnitude, not repetition. Cleared the moment the
+   * conversation dispatches anything, or when it drops off the pending list
+   * (`runDrain`'s prune, the dominant real-world path — a wedge normally ends
+   * with its message completing, not a fresh dispatch on the same
+   * conversation) — either way a fresh wedge, if it recurs, is a new
+   * incident. Bounded FIFO, mirroring `supersededSessions`
    * (`MAX_WEDGED_CONVERSATIONS`).
    */
   wedgeWarnings = /* @__PURE__ */ new Map();
@@ -7552,6 +7954,7 @@ var ChannelDriver = class _ChannelDriver {
   subagentInvocationPrefetches = /* @__PURE__ */ new Map();
   /** Serialises drains so a reconnect during a drain doesn't double-process. */
   draining = false;
+  pendingProviderRegistryRepair = null;
   /**
    * Serialises runner-file syncs (#559) so the ~2s poll tick and a concurrent
    * drain ping don't download, write and ack the same file twice.
@@ -7737,8 +8140,33 @@ var ChannelDriver = class _ChannelDriver {
   async runDrain() {
     let dispatched = 0;
     try {
+      const pendingRepair = this.pendingProviderRegistryRepair;
+      if (pendingRepair && this.protectedSessionIds().size === 0) {
+        try {
+          await this.issueProviderRegistryReload(
+            pendingRepair.conversationId,
+            pendingRepair.messageId
+          );
+        } catch (err) {
+          this.log({
+            level: "error",
+            message: `Provider registry repair adoption failed for message ${pendingRepair.messageId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`,
+            conversation_id: pendingRepair.conversationId,
+            message_id: pendingRepair.messageId
+          });
+        }
+        return 0;
+      }
       this.pendingMessageIds.clear();
       const conversations = await this.getPendingConversations();
+      if (this.wedgeWarnings.size > 0) {
+        const pendingConversationIds = new Set(conversations.map(({ id }) => id));
+        for (const conversationId of this.wedgeWarnings.keys()) {
+          if (!pendingConversationIds.has(conversationId)) {
+            this.wedgeWarnings.delete(conversationId);
+          }
+        }
+      }
       if (this.recycleRequestedFlag) {
         this.stop();
       }
@@ -8275,14 +8703,13 @@ var ChannelDriver = class _ChannelDriver {
    * skip-because-already-`dispatched`, the exact signature of a message stuck
    * acknowledged-but-never-worked.
    *
-   * Unthrottled, this fired every ~6s drain tick for as long as a wedge lasted
-   * (52,843 occurrences observed in one incident) — burning the GLOBAL
-   * 30-events/60s `runner-activity-telemetry.ts` budget that was itself
-   * suppressing the diagnostics needed to debug the wedge. The `warn` log (and
-   * the `dispatch_wedged` signal once the wedge has persisted past the same
-   * interval) fire at most once per `wedgeWarningIntervalMs` per conversation,
-   * naming the consecutive-tick count so the operator sees magnitude rather
-   * than repetition.
+   * The first detection starts the clock and emits a local `debug` entry. The
+   * `warn` log and paired `dispatch_wedged` signal fire once the wedge has
+   * lasted `wedgeWarningIntervalMs`, then at most once per interval, naming the
+   * consecutive-tick count so the operator sees magnitude rather than repetition.
+   * A watcher stall that the loop-liveness watchdog recovers is expected and is
+   * already reported by its `watcher_recovered` signal, so it does not reach an
+   * operator through this warning.
    *
    * Deliberately does NOT trigger a release: WI-1's `reconcileWatchers` runs
    * unconditionally on this same tick and is already recovering anything it
@@ -8294,36 +8721,41 @@ var ChannelDriver = class _ChannelDriver {
     const existing = this.wedgeWarnings.get(conv.id);
     const firstWedgedAt = existing?.firstWedgedAt ?? now;
     const consecutiveTicks = (existing?.consecutiveTicks ?? 0) + 1;
-    const dueForWarn = !existing || now - existing.lastWarnedAt >= this.wedgeWarningIntervalMs;
-    if (!dueForWarn) {
-      this.wedgeWarnings.delete(conv.id);
-      this.wedgeWarnings.set(conv.id, {
-        firstWedgedAt,
-        lastWarnedAt: existing.lastWarnedAt,
-        consecutiveTicks
+    const warnAnchorAt = existing?.warnAnchorAt ?? now;
+    const dueForWarn = now - warnAnchorAt >= this.wedgeWarningIntervalMs;
+    if (!existing) {
+      this.log({
+        level: "debug",
+        message: `Detected a possible wedge for conversation ${conv.id.slice(0, 8)} with ${messages.length} pending message(s); it will be reported only if it outlasts the watchdog's recovery.`,
+        conversation_id: conv.id
+      });
+    }
+    let untracked = 0;
+    if (dueForWarn) {
+      const stuckForMs = now - firstWedgedAt;
+      untracked = this.countUntrackedIds(messages);
+      this.log({
+        level: "warn",
+        message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode for ${consecutiveTicks} consecutive tick(s) now (${Math.round(stuckForMs / 1e3)}s stuck). ` + (untracked > 0 ? `${untracked} of these id(s) are tracked by NO watcher \u2014 the dispatched/in-flight pairing invariant is violated for this conversation, which will NOT self-heal and needs a runner restart.` : `A watcher is tracking this work; the loop-liveness watchdog is already recovering it.`),
+        conversation_id: conv.id
       });
-      return;
     }
-    const stuckForMs = now - firstWedgedAt;
-    const untracked = this.countUntrackedIds(messages);
-    this.log({
-      level: "warn",
-      message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode for ${consecutiveTicks} consecutive tick(s) now (${stuckForMs}ms stuck). ` + (untracked > 0 ? `${untracked} of these id(s) are tracked by NO watcher \u2014 the dispatched/in-flight pairing invariant is violated for this conversation, which will NOT self-heal and needs a runner restart.` : `A watcher is tracking this work; the loop-liveness watchdog is already recovering it.`),
-      conversation_id: conv.id
-    });
     this.wedgeWarnings.delete(conv.id);
-    this.wedgeWarnings.set(conv.id, { firstWedgedAt, lastWarnedAt: now, consecutiveTicks });
+    this.wedgeWarnings.set(conv.id, {
+      firstWedgedAt,
+      warnAnchorAt: dueForWarn ? now : warnAnchorAt,
+      consecutiveTicks
+    });
     while (this.wedgeWarnings.size > MAX_WEDGED_CONVERSATIONS) {
       const oldest = this.wedgeWarnings.keys().next().value;
       if (oldest === void 0) break;
       this.wedgeWarnings.delete(oldest);
     }
-    if (stuckForMs >= this.wedgeWarningIntervalMs) {
-      void this.postSignal(conv.id, messages[0].id, "dispatch_wedged", {
-        stuck_for_ms: stuckForMs,
-        untracked
-      });
-    }
+    if (!dueForWarn) return;
+    void this.postSignal(conv.id, messages[0].id, "dispatch_wedged", {
+      stuck_for_ms: now - firstWedgedAt,
+      untracked
+    });
   }
   /**
    * How many of `messages`' ids are tracked by NO watcher's `inFlight` (#1618
@@ -9589,14 +10021,40 @@ var ChannelDriver = class _ChannelDriver {
         conversation_id: watcher.conv.id,
         message_id: inFlight.evidentMessageId
       });
-      await this.markFailed(
-        watcher.conv.id,
-        inFlight.evidentMessageId,
-        event.sessionId,
-        `OpenCode could not run this turn: ${event.reason}`
-      );
+      const isMissingProvider = isProviderModelNotFoundError(event.reason);
+      if (isMissingProvider) {
+        const dispatchedModel = inFlight.message.opencode_model;
+        const separator = dispatchedModel?.indexOf("/") ?? -1;
+        const hasProviderAndModel = dispatchedModel !== null && separator > 0 && separator < dispatchedModel.length - 1;
+        await this.markFailed(
+          watcher.conv.id,
+          inFlight.evidentMessageId,
+          event.sessionId,
+          `OpenCode could not run this turn: ${event.reason}`,
+          void 0,
+          {
+            classification: {
+              kind: "model_auth",
+              providerId: hasProviderAndModel ? dispatchedModel.slice(0, separator) : null,
+              modelId: hasProviderAndModel ? dispatchedModel.slice(separator + 1) : null,
+              reason: "missing"
+            },
+            errorShape: { name: null, statusCode: null }
+          }
+        );
+      } else {
+        await this.markFailed(
+          watcher.conv.id,
+          inFlight.evidentMessageId,
+          event.sessionId,
+          `OpenCode could not run this turn: ${event.reason}`
+        );
+      }
       inFlight.done = true;
       this.removeInFlight(watcher, inFlight.evidentMessageId);
+      if (isMissingProvider) {
+        await this.repairProviderRegistry(watcher.conv.id, inFlight.evidentMessageId);
+      }
     } catch (err) {
       if (err instanceof ChannelAuthError) {
         this.log({
@@ -9617,6 +10075,44 @@ var ChannelDriver = class _ChannelDriver {
       this.sessionErrorHandled.delete(inFlight.evidentMessageId);
     }
   }
+  async repairProviderRegistry(conversationId, messageId) {
+    if (this.isV2) {
+      void this.postSignal(conversationId, messageId, "provider_registry_reload_unsupported");
+      return;
+    }
+    const activeSessions = this.protectedSessionIds().size;
+    if (activeSessions > 0 || this.draining) {
+      this.pendingProviderRegistryRepair = { conversationId, messageId };
+      void this.postSignal(conversationId, messageId, "provider_registry_repair_deferred", {
+        active_sessions: activeSessions
+      });
+      this.log({
+        level: "warn",
+        message: `Provider registry repair deferred until a lifecycle-safe point; ${activeSessions} active session(s) protected`,
+        conversation_id: conversationId,
+        message_id: messageId
+      });
+      return;
+    }
+    await this.issueProviderRegistryReload(conversationId, messageId);
+  }
+  async issueProviderRegistryReload(conversationId, messageId) {
+    this.pendingProviderRegistryRepair = null;
+    const result = await disposeAndReloadProviderConfig(this.port, this.openCodeClient);
+    if (result.outcome === "failed") {
+      const failure = result.status === null ? `transport failure${result.detail ? `: ${result.detail}` : ""}` : `HTTP ${result.status}`;
+      this.log({
+        level: "warn",
+        message: `Provider registry reload failed (${failure})`,
+        conversation_id: conversationId,
+        message_id: messageId
+      });
+    }
+    const repairOutcome = result.outcome === "reloaded" ? "reloaded" : "reload_failed";
+    void this.postSignal(conversationId, messageId, "provider_registry_reload_issued", {
+      repair_outcome: repairOutcome
+    });
+  }
   /**
    * The per-session polling loop (WI-3). Once per tick it:
    *   1. polls `GET /session/:id/message` once and, per in-flight message,
@@ -9808,7 +10304,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;
@@ -9905,17 +10401,28 @@ var ChannelDriver = class _ChannelDriver {
       }
     } else {
       if (inFlight.b2AbandonedSignalled) {
+        const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
+        const finish = reply?.info?.finish ?? reply?.finish;
         if (inFlight.b2AbandonedWithoutAnswer) {
-          const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
           await this.settleMessageAbandonedWithoutAnswer(
             sessionId,
             watcher,
             inFlight,
             messages,
-            reply?.info?.finish ?? reply?.finish
+            finish
           );
         } else {
-          await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+          await this.settleMessageDone(
+            sessionId,
+            watcher,
+            inFlight,
+            messages,
+            composeAbandonmentNote(
+              finish,
+              describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+              "with-answer"
+            )
+          );
         }
         return;
       }
@@ -9978,7 +10485,17 @@ var ChannelDriver = class _ChannelDriver {
             ...descendantOngoing != null ? { descendant_ongoing: descendantOngoing } : {},
             opencode_message_id: inFlight.opencodeMessageId
           });
-          await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+          await this.settleMessageDone(
+            sessionId,
+            watcher,
+            inFlight,
+            messages,
+            composeAbandonmentNote(
+              finish,
+              describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+              "with-answer"
+            )
+          );
           return;
         }
         if (rootOngoing === true && !inFlight.b2RootOngoingHeldLogged) {
@@ -10178,15 +10695,11 @@ var ChannelDriver = class _ChannelDriver {
     }
   }
   /**
-   * Settle a message whose run-state has resolved `'done'` — extracted verbatim
-   * (pure refactor, no behavior change) from `serviceInFlightMessage`'s former
-   * inline `state === 'done'` branch body, so a SECOND caller (the #721
-   * b2-abandonment resolution) can reach the exact same completion behavior
-   * (delivery-deadline anchoring, title resolution, usage extraction, and
-   * `markDone`'s auth/terminal/transient-retry discipline) without duplicating it
-   * and risking the two copies silently drifting apart.
+   * Settle a message whose run-state has resolved `'done'`. Normal completion and
+   * confirmed b2 abandonment share the same delivery, usage, and terminal handling.
+   * Normal completions omit the optional terminal diagnostic.
    */
-  async settleMessageDone(sessionId, watcher, inFlight, messages) {
+  async settleMessageDone(sessionId, watcher, inFlight, messages, note) {
     const conv = watcher.conv;
     this.anchorDeliveryDeadline(inFlight);
     if (!inFlight.done) {
@@ -10213,7 +10726,8 @@ var ChannelDriver = class _ChannelDriver {
           title,
           usage,
           usageAgentName,
-          subagentInvocations
+          subagentInvocations,
+          note
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -10258,9 +10772,11 @@ var ChannelDriver = class _ChannelDriver {
   /** Report a confirmed b2 abandonment that produced no answer text. */
   async settleMessageAbandonedWithoutAnswer(sessionId, watcher, inFlight, messages, finish) {
     const conv = watcher.conv;
-    const legacyError = `OpenCode ended this turn after a tool call (finish="${finish ?? "(unknown)"}") without writing an answer, and confirmed it is no longer working on this conversation. Evident is reporting the run as failed so the failure and its reason are visible in failed runs.`;
-    const replyShape = describeAbandonedReplyShape(messages, inFlight.opencodeMessageId);
-    const error2 = replyShape === null ? legacyError : `${legacyError} ${replyShape.lastToolName === null ? "No tool call was recorded" : `The last tool call was "${replyShape.lastToolName}" with status "${replyShape.lastToolStatus ?? "(unknown)"}"`}; the reply's final part types were [${replyShape.partTypes.join(", ")}]${replyShape.droppedPartCount > 0 ? ` (${replyShape.droppedPartCount} earlier part types omitted)` : ""}.`;
+    const error2 = composeAbandonmentNote(
+      finish,
+      describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+      "without-answer"
+    );
     this.anchorDeliveryDeadline(inFlight);
     this.log({
       level: "warn",
@@ -11497,14 +12013,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 {
@@ -12064,7 +12580,7 @@ var ChannelDriver = class _ChannelDriver {
    *                                    watcher retries next tick within the
    *                                    deadline, Finding 4).
    */
-  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title, usage, usageAgentName, subagentInvocations) {
+  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title, usage, usageAgentName, subagentInvocations, error2) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
@@ -12082,7 +12598,8 @@ var ChannelDriver = class _ChannelDriver {
           ...title ? { title } : {},
           ...usage ? usage : {},
           ...usageAgentName ? { usage_agent_name: usageAgentName } : {},
-          ...subagentInvocations && subagentInvocations.length > 0 ? { subagent_invocations: subagentInvocations } : {}
+          ...subagentInvocations && subagentInvocations.length > 0 ? { subagent_invocations: subagentInvocations } : {},
+          ...error2 ? { error: error2 } : {}
         })
       }
     );
@@ -12142,11 +12659,17 @@ var ChannelDriver = class _ChannelDriver {
     if (subagentInvocations && subagentInvocations.length > 0) {
       body.subagent_invocations = subagentInvocations;
     }
-    if (failure) {
-      body.failure_kind = failure.kind;
-      body.failure_provider_id = failure.providerId;
-      body.failure_model_id = failure.modelId;
-      body.failure_reason = failure.reason;
+    if (failure && failure.errorShape.name !== null) {
+      body.failure_error_name = failure.errorShape.name;
+    }
+    if (failure && failure.errorShape.statusCode !== null) {
+      body.failure_status_code = failure.errorShape.statusCode;
+    }
+    if (failure?.classification) {
+      body.failure_kind = failure.classification.kind;
+      body.failure_provider_id = failure.classification.providerId;
+      body.failure_model_id = failure.classification.modelId;
+      body.failure_reason = failure.classification.reason;
     }
     try {
       await this.callWithRetry(
@@ -12167,27 +12690,28 @@ var ChannelDriver = class _ChannelDriver {
     this.clearSubagentInvocationCaches(messageId);
   }
   /**
-   * Classify an errored turn as a model-auth failure (#736 P1-4), for `markFailed`.
+   * Classify an errored turn and extract its bounded error shape for `markFailed`.
    *
    * `messageFailure` alone (structured OpenCode error → `model_auth`) covers
    * most cases; when it returns `null` on this ALREADY-FAILED turn, fall back
    * to the P1-2b zero-provider check — one extra loopback call to
    * `hasAnyConfiguredProvider`, only reached when the structured classifier
    * couldn't place it. Fails open (never throws): a fallback probe failure
-   * (`null`/indeterminate) leaves the classification `null`, which produces
-   * today's byte-identical PATCH body via `markFailed`'s `if (failure)` guard.
+   * (`null`/indeterminate) leaves the classification `null`; the raw error shape
+   * is still retained for diagnostics.
    */
   async classifyModelAuthFailure(messages, userMessageId) {
-    const classified = messageFailure(messages, userMessageId);
-    if (classified != null) return classified;
     const reply = findLastAssistantReplyFor(messages, userMessageId);
-    const hasProvider = await this.hasAnyConfiguredProvider();
-    return applyZeroProviderFallback(
+    const errorShape = extractReplyErrorShape(reply);
+    const classified = messageFailure(messages, userMessageId);
+    if (classified != null) return { classification: classified, errorShape };
+    const classification = applyZeroProviderFallback(
       classified,
-      hasProvider,
+      await this.hasAnyConfiguredProvider(),
       reply?.info?.providerID ?? null,
       reply?.info?.modelID ?? null
     );
+    return { classification, errorShape };
   }
   async recordSubagentModelAuthFailure(failure, conversationId, messageId) {
     const providerId = failure.providerId ?? "(unknown)";
@@ -12745,7 +13269,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 = "";
@@ -12755,7 +13279,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"] });
@@ -12810,7 +13334,9 @@ async function installRunnerSecret({
 }) {
   const arn = env.RUNNER_SECRET_ARN?.trim();
   if (!arn) {
-    log3("runner secret is not configured; continuing without GitHub and MCP credentials");
+    if (!env.GH_TOKEN) {
+      log3("runner secret is not configured; continuing without GitHub and MCP credentials");
+    }
     return false;
   }
   const result = await (commandRunner ?? runCommand2)(
@@ -13009,7 +13535,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();
 }
@@ -13022,8 +13548,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)`,
@@ -13031,7 +13557,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"
@@ -13040,7 +13566,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
@@ -13058,14 +13584,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),
@@ -13282,6 +13808,8 @@ function createCredentialSync({
 var MAX_ACTIVITY_LOG_ENTRIES = 10;
 var MAX_DISCONNECT_REASON_LENGTH = 200;
 var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_MS) || 2e3;
+var CREDENTIAL_ADOPTION_PROBE_ATTEMPTS = 3;
+var CREDENTIAL_ADOPTION_PROBE_INTERVAL_MS = 1e3;
 var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
 var SHUTDOWN_DRAIN_TIMEOUT_MS = Number(process.env.EVIDENT_SHUTDOWN_DRAIN_MS) || 25e3;
 var TELEMETRY_SHUTDOWN_TIMEOUT_MS = 5e3;
@@ -13316,8 +13844,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);
@@ -13417,8 +13945,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({
@@ -13427,10 +13954,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");
@@ -13622,6 +14157,125 @@ async function handleAuthError(state, error2) {
     return { success: false };
   }
 }
+function logCredentialAdoptionActivity(state, activity, level) {
+  const message = (() => {
+    switch (activity.outcome) {
+      case "deferred":
+        return `CREDENTIAL-ADOPTION: deferred generation ${activity.generation} with ${activity.active_sessions} active session(s)`;
+      case "reloaded_ready":
+        return `CREDENTIAL-ADOPTION: adopted generation ${activity.generation} with ${activity.active_sessions} active session(s); readiness probe succeeded after ${activity.probe_attempts} attempt(s)`;
+      case "reloaded_interrupted": {
+        const response = activity.probe_status === null ? "without an HTTP response" : `with HTTP ${activity.probe_status} and ${activity.probe_body_empty ? "an empty" : "a non-empty"} body`;
+        return `CREDENTIAL-ADOPTION: generation ${activity.generation} with ${activity.active_sessions} active session(s); replacement instance answered ${response} after ${activity.probe_attempts} probe attempt(s)`;
+      }
+      case "reload_failed":
+        return `CREDENTIAL-ADOPTION: failed to adopt generation ${activity.generation} with ${activity.active_sessions} active session(s)`;
+      case "skipped_v2":
+        return `CREDENTIAL-ADOPTION: skipped generation ${activity.generation} with ${activity.active_sessions} active session(s) on OpenCode V2`;
+    }
+  })();
+  logActivity(state, {
+    type: level === "error" ? "error" : "info",
+    level,
+    ...level === "error" ? { error: message } : { message },
+    metadata: {
+      ...activity,
+      opencode_version: state.opencodeVersion,
+      port: state.port
+    }
+  });
+}
+async function adoptCredentialGeneration(state, generation, adoption, activeSessions, deferredForMs) {
+  const reload = await disposeAndReloadProviderConfig(
+    state.port,
+    state.opencodeClient ?? void 0
+  );
+  if (reload.outcome === "failed") {
+    logCredentialAdoptionActivity(
+      state,
+      {
+        outcome: "reload_failed",
+        generation,
+        active_sessions: activeSessions,
+        adoption,
+        deferred_for_ms: deferredForMs,
+        reload_status: reload.status,
+        reload_detail: reload.detail,
+        probe_attempts: null,
+        probe_status: null,
+        probe_body_empty: null,
+        probe_detail: null
+      },
+      "error"
+    );
+    return;
+  }
+  if (reload.outcome === "skipped_v2") {
+    logCredentialAdoptionActivity(
+      state,
+      {
+        outcome: "skipped_v2",
+        generation,
+        active_sessions: activeSessions,
+        adoption,
+        deferred_for_ms: deferredForMs,
+        reload_status: null,
+        reload_detail: null,
+        probe_attempts: null,
+        probe_status: null,
+        probe_body_empty: null,
+        probe_detail: null
+      },
+      "debug"
+    );
+    return;
+  }
+  let lastProbe = null;
+  let attempts = 0;
+  for (attempts = 1; attempts <= CREDENTIAL_ADOPTION_PROBE_ATTEMPTS; attempts++) {
+    lastProbe = await probeOpenCodeRequestReadiness(state.port, state.opencodeClient ?? void 0);
+    if (lastProbe.ok) {
+      logCredentialAdoptionActivity(
+        state,
+        {
+          outcome: "reloaded_ready",
+          generation,
+          active_sessions: activeSessions,
+          adoption,
+          deferred_for_ms: deferredForMs,
+          reload_status: null,
+          reload_detail: null,
+          probe_attempts: attempts,
+          probe_status: lastProbe.status,
+          probe_body_empty: lastProbe.bodyEmpty,
+          probe_detail: lastProbe.detail
+        },
+        "warn"
+      );
+      return;
+    }
+    if (attempts < CREDENTIAL_ADOPTION_PROBE_ATTEMPTS) {
+      await new Promise((resolve5) => setTimeout(resolve5, CREDENTIAL_ADOPTION_PROBE_INTERVAL_MS));
+    }
+  }
+  logCredentialAdoptionActivity(
+    state,
+    {
+      outcome: "reloaded_interrupted",
+      generation,
+      active_sessions: activeSessions,
+      adoption,
+      deferred_for_ms: deferredForMs,
+      reload_status: null,
+      reload_detail: null,
+      probe_attempts: CREDENTIAL_ADOPTION_PROBE_ATTEMPTS,
+      probe_status: lastProbe?.status ?? null,
+      probe_body_empty: lastProbe?.bodyEmpty ?? null,
+      probe_detail: lastProbe?.detail ?? null
+    },
+    "error"
+  );
+}
 async function driveChannels(state, driver) {
   let idlePolls = 0;
   let idleMs = 0;
@@ -13631,6 +14285,15 @@ async function driveChannels(state, driver) {
   let lastSeenAppliedFiles = driver.fileSyncActivity().appliedFiles;
   let lastSeenClaudeApplies = driver.fileSyncActivity().claudeCredentialApplies;
   let lastSeenOpencodeAuthApplies = driver.fileSyncActivity().opencodeAuthApplyCount;
+  const credentialAdoption = {
+    generation: 0,
+    pendingGeneration: null,
+    pendingSinceMs: null,
+    deferredGeneration: null,
+    adoption: 0
+  };
+  const stayAwakeHolds = () => state.stayAwakeUntilMs !== null && Date.now() < state.stayAwakeUntilMs;
+  let stayAwakeSuppressionLogged = false;
   while (state.running) {
     const cycleStartedAtMs = performance.now();
     let idleThisCycle = false;
@@ -13672,12 +14335,30 @@ async function driveChannels(state, driver) {
       lastSeenOpencodeAuthApplies = opencodeAuthApplies;
       if (opencodeAuthApplied) state.openaiUsageRearm?.();
       if (claudeCredentialApplied || opencodeAuthApplied) {
-        void reloadProviderCache(state.port, state.opencodeClient ?? void 0).catch(
-          (error2) => logActivity(state, {
-            type: "error",
-            error: `OpenCode provider cache reload failed on port ${state.port}: ${error2 instanceof Error ? error2.message : String(error2)}`
-          })
-        );
+        credentialAdoption.generation++;
+        if (state.opencodeApiVersion === "v2") {
+          logCredentialAdoptionActivity(
+            state,
+            {
+              outcome: "skipped_v2",
+              generation: credentialAdoption.generation,
+              active_sessions: driver.protectedSessionIds().size,
+              adoption: null,
+              deferred_for_ms: null,
+              reload_status: null,
+              reload_detail: null,
+              probe_attempts: null,
+              probe_status: null,
+              probe_body_empty: null,
+              probe_detail: null
+            },
+            "debug"
+          );
+        } else {
+          credentialAdoption.pendingGeneration = credentialAdoption.generation;
+          credentialAdoption.pendingSinceMs = Date.now();
+          credentialAdoption.deferredGeneration = null;
+        }
       }
       if (opencodeAuthApplied && state.opencodeApiVersion === "v2") {
         void importOpenCodeV2CredentialsForState(state).catch(
@@ -13732,7 +14413,50 @@ async function driveChannels(state, driver) {
         }
       }
     }
-    await new Promise((resolve4) => setTimeout(resolve4, CHANNEL_POLL_INTERVAL_MS));
+    if (credentialAdoption.pendingGeneration !== null) {
+      const activeSessions = driver.protectedSessionIds();
+      const generation = credentialAdoption.pendingGeneration;
+      if (activeSessions.size > 0) {
+        if (credentialAdoption.deferredGeneration !== generation) {
+          credentialAdoption.deferredGeneration = generation;
+          logCredentialAdoptionActivity(
+            state,
+            {
+              outcome: "deferred",
+              generation,
+              active_sessions: activeSessions.size,
+              adoption: null,
+              deferred_for_ms: null,
+              reload_status: null,
+              reload_detail: null,
+              probe_attempts: null,
+              probe_status: null,
+              probe_body_empty: null,
+              probe_detail: null
+            },
+            "warn"
+          );
+        }
+      } else {
+        const deferredForMs = credentialAdoption.deferredGeneration === generation && credentialAdoption.pendingSinceMs !== null ? Math.max(0, Date.now() - credentialAdoption.pendingSinceMs) : null;
+        credentialAdoption.pendingGeneration = null;
+        credentialAdoption.pendingSinceMs = null;
+        credentialAdoption.adoption++;
+        void adoptCredentialGeneration(
+          state,
+          generation,
+          credentialAdoption.adoption,
+          activeSessions.size,
+          deferredForMs
+        ).catch(
+          (error2) => logActivity(state, {
+            type: "error",
+            error: `CREDENTIAL-ADOPTION: adoption failed for generation ${generation} with ${activeSessions.size} active session(s) on port ${state.port}: ${error2 instanceof Error ? error2.message : String(error2)}`
+          })
+        );
+      }
+    }
+    await new Promise((resolve5) => setTimeout(resolve5, CHANNEL_POLL_INTERVAL_MS));
     const cycleMs = performance.now() - cycleStartedAtMs;
     if (idleThisCycle) idleMs += cycleMs;
     if (unreachableThisCycle) unreachableMs += cycleMs;
@@ -13745,15 +14469,27 @@ async function driveChannels(state, driver) {
       if (state.interactive) displayStatus(state);
       break;
     }
-    if (state.idleTimeout !== null && idlePolls >= 2 && idleMs > state.idleTimeout * 1e3) {
+    if (state.idleTimeout !== null && idlePolls >= 2 && idleMs > state.idleTimeout * 1e3 && !stayAwakeHolds()) {
       logActivity(state, { type: "info", message: "Idle timeout reached" });
       if (state.interactive) displayStatus(state);
       break;
     }
+    if (state.idleTimeout !== null && idlePolls >= 2 && idleMs > state.idleTimeout * 1e3 && stayAwakeHolds()) {
+      if (!stayAwakeSuppressionLogged) {
+        stayAwakeSuppressionLogged = true;
+        logActivity(state, {
+          type: "info",
+          message: "Idle, but staying awake until the requested minimum passes"
+        });
+      }
+    }
   }
 }
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
 var SESSION_CLEANUP_MAX_DELETES_PER_SWEEP = 100;
+var SESSION_CLEANUP_MAX_ISOLATED_DELETE_FAILURES = 2;
+var SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES = 2;
+var MAX_SESSION_DELETE_BODY_LENGTH = 200;
 function shouldWarnForReclaimSkip(reason) {
   if (reason !== "sqlite-unavailable" && reason !== "disk-exhaustion") return false;
   const version2 = /^v(\d+)\.(\d+)\.(\d+)$/.exec(process.version);
@@ -13764,7 +14500,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, {
@@ -13841,8 +14577,12 @@ async function runSweep(state, driver, config) {
           protectedIds: protectedNow
         }
       );
-      const deleteCandidates = toDelete.slice(0, SESSION_CLEANUP_MAX_DELETES_PER_SWEEP);
-      remaining = toDelete.length - deleteCandidates.length;
+      const eligibleToDelete = toDelete.filter(
+        (id) => (state.sessionDeleteFailures.get(id)?.isolatedFailures ?? 0) < SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES
+      );
+      const deleteCandidates = eligibleToDelete.slice(0, SESSION_CLEANUP_MAX_DELETES_PER_SWEEP);
+      remaining = eligibleToDelete.length - deleteCandidates.length;
+      const answeredFailures = [];
       protectedNow = driver.protectedSessionIds();
       for (const id of deleteCandidates) {
         if (protectedNow.has(id)) {
@@ -13865,8 +14605,44 @@ async function runSweep(state, driver, config) {
           if (statusClass === 4) failed4xx++;
           else if (statusClass === 5) failed5xx++;
           else failedOtherStatus++;
+          answeredFailures.push({
+            id,
+            status: outcome.status,
+            ...outcome.body !== void 0 ? { body: outcome.body } : {}
+          });
+        }
+      }
+      const givenUpFailures = [];
+      if (failed > SESSION_CLEANUP_MAX_ISOLATED_DELETE_FAILURES) {
+        for (const { id } of answeredFailures) state.sessionDeleteFailures.delete(id);
+      } else {
+        for (const failure of answeredFailures) {
+          const previous = state.sessionDeleteFailures.get(failure.id);
+          const record = previous?.status === failure.status ? { status: failure.status, isolatedFailures: previous.isolatedFailures + 1 } : { status: failure.status, isolatedFailures: 1 };
+          state.sessionDeleteFailures.set(failure.id, record);
+          if (record.isolatedFailures >= SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES) {
+            givenUpFailures.push(failure);
+          }
         }
       }
+      for (const failure of givenUpFailures) {
+        const excerpt = redactDiagnosticText(failure.body ?? "(no response body)").slice(
+          0,
+          MAX_SESSION_DELETE_BODY_LENGTH
+        );
+        logSessionCleanupActivity(state, "sweep", {
+          type: "info",
+          level: "warn",
+          message: `Session cleanup: gave up on session ${failure.id} after ${SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES} isolated delete failures (status ${failure.status}): ${excerpt}`,
+          metadata: {
+            outcome: "session-delete-given-up",
+            session_id: failure.id,
+            status: failure.status,
+            body_excerpt: excerpt,
+            given_up_count: givenUpFailures.length
+          }
+        });
+      }
       const failedNote = failed > 0 ? `, failed ${failed}` : "";
       const skippedNote = skippedNewlyActive > 0 ? `, skipped ${skippedNewlyActive} newly-active` : "";
       const remainingNote = remaining > 0 ? `, remaining ${remaining}` : "";
@@ -13887,21 +14663,31 @@ async function runSweep(state, driver, config) {
       sessions_remaining: remaining,
       ...enumerationReason !== null ? { session_enumeration_reason: enumerationReason } : {}
     };
+    const protectedForReclaim = driver.protectedSessionIds();
     const reclaimResult = await reclaimSessionDbSpace({
       dbPath: sessionDbPath(),
       chunkPages: SESSION_DB_RECLAIM_CHUNK_PAGES,
       pageCeiling: SESSION_DB_RECLAIM_PAGE_CEILING,
       timeBudgetMs: SESSION_DB_RECLAIM_TIME_BUDGET_MS,
-      allowFullVacuum: protectedNow.size === 0 && !state.sessionDbProvenanceAnomaly
+      hasLiveTurn: protectedForReclaim.size > 0,
+      hasProvenanceAnomaly: state.sessionDbProvenanceAnomaly
     });
     if (reclaimResult.ok) {
       state.sessionStoreHealth.observeWritable();
       const beforeMib = (reclaimResult.beforeBytes / 1024 / 1024).toFixed(1);
       const afterMib = (reclaimResult.afterBytes / 1024 / 1024).toFixed(1);
       const checkpointNote = reclaimResult.checkpoint.busy ? ` (on-disk file truncation deferred: checkpoint busy, ${reclaimResult.checkpoint.log} WAL frames pending)` : "";
+      const loopElapsedMs = Math.max(
+        0,
+        reclaimResult.elapsedMs - reclaimResult.checkpointElapsedMs
+      );
+      const reclaimIsSlow = reclaimResult.elapsedMs >= 4 * SESSION_DB_RECLAIM_TIME_BUDGET_MS;
+      const perPageNote = reclaimResult.pagesReclaimed > 0 ? `, per-page ${(loopElapsedMs / reclaimResult.pagesReclaimed).toFixed(2)} ms/page` : "";
+      const slowReclaimNote = reclaimIsSlow ? ` (slow reclaim: total elapsed ${reclaimResult.elapsedMs} ms, checkpoint ${reclaimResult.checkpointElapsedMs} ms, loop ${loopElapsedMs} ms, budget ${SESSION_DB_RECLAIM_TIME_BUDGET_MS} ms${perPageNote})` : "";
       logSessionCleanupActivity(state, "sweep", {
         type: "info",
-        message: `Session cleanup: reclaimed session-db space (${reclaimResult.mode}): ${beforeMib} MiB -> ${afterMib} MiB (stopped by ${reclaimResult.stoppedBy}; freelist ${reclaimResult.freelistBefore} -> ${reclaimResult.freelistAfter} pages)` + checkpointNote,
+        level: reclaimIsSlow ? "warn" : "info",
+        message: `Session cleanup: reclaimed session-db space (${reclaimResult.mode}): ${beforeMib} MiB -> ${afterMib} MiB (stopped by ${reclaimResult.stoppedBy}; freelist ${reclaimResult.freelistBefore} -> ${reclaimResult.freelistAfter} pages)` + checkpointNote + slowReclaimNote,
         metadata: {
           outcome: "reclaimed",
           mode: reclaimResult.mode,
@@ -13914,6 +14700,7 @@ async function runSweep(state, driver, config) {
           freelist_after: reclaimResult.freelistAfter,
           pages_reclaimed: reclaimResult.pagesReclaimed,
           reclaim_elapsed_ms: reclaimResult.elapsedMs,
+          checkpoint_elapsed_ms: reclaimResult.checkpointElapsedMs,
           ...sessionMetadata
         }
       });
@@ -14024,10 +14811,12 @@ function scheduleUsageReporting(state, params) {
   let phase = "dormant";
   let rearmRequested = false;
   const armProbe = () => {
+    if (!state.running) return;
     phase = "probe-pending";
     params.setTimer(setTimeout(() => void tick(true), params.firstDelayMs()));
   };
   const scheduleNextTick = () => {
+    if (!state.running) return;
     if (rearmRequested) {
       rearmRequested = false;
       armProbe();
@@ -14061,6 +14850,7 @@ function scheduleUsageReporting(state, params) {
     phase = "tick-in-flight";
     try {
       const usage = await params.fetchUsage();
+      if (!state.running) return;
       const result = await params.report(usage);
       if (result.ok) {
         if (consecutiveFailures > 0) {
@@ -14199,6 +14989,7 @@ function scheduleResourceUsageReporting(state, options) {
           message: lowDiskDecision.warning
         });
       }
+      if (!state.running) return;
       const result = await reportResourceUsage(state.agentId, state.authHeader, usage);
       if (result.ok) {
         if (consecutiveFailures > 0) {
@@ -14231,7 +15022,9 @@ function scheduleResourceUsageReporting(state, options) {
         message: `Resource usage reporting failed: ${message}${failureStreakSuffix(consecutiveFailures)}`
       });
     } finally {
-      state.resourceUsageTimer = setTimeout(() => void tick(), usageReportDelayMs());
+      if (state.running) {
+        state.resourceUsageTimer = setTimeout(() => void tick(), usageReportDelayMs());
+      }
     }
   };
   state.resourceUsageTimer = setTimeout(() => void tick(), firstReportDelayMs());
@@ -14393,8 +15186,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");
@@ -14434,6 +15227,8 @@ async function run(options) {
     port: options.port ?? 4096,
     conversationFilter: options.conversation ?? null,
     idleTimeout: options.idleTimeout ?? null,
+    stayAwakeSeconds: null,
+    stayAwakeUntilMs: null,
     json: options.json ?? false,
     interactive,
     logLevel,
@@ -14457,6 +15252,7 @@ async function run(options) {
     messageCount: 0,
     lastProxiedActivityAt: null,
     sessionCleanupTimers: [],
+    sessionDeleteFailures: /* @__PURE__ */ new Map(),
     claudeUsageTimer: null,
     claudeUsageRearm: null,
     openaiUsageTimer: null,
@@ -14622,6 +15418,17 @@ async function run(options) {
     }
     spinner?.succeed(`Runner: ${validation.agent.name || state.agentId}`);
     state.agentName = validation.agent.name;
+    const requestedStayAwakeSeconds = validation.agent?.wake_stay_awake_seconds;
+    if (typeof requestedStayAwakeSeconds === "number" && Number.isFinite(requestedStayAwakeSeconds) && requestedStayAwakeSeconds > 0) {
+      state.stayAwakeSeconds = requestedStayAwakeSeconds;
+    } else if (requestedStayAwakeSeconds !== void 0 && requestedStayAwakeSeconds !== null) {
+      state.stayAwakeSeconds = null;
+      log2(
+        state,
+        `Ignoring invalid wake_stay_awake_seconds (type: ${typeof requestedStayAwakeSeconds})`,
+        "warn"
+      );
+    }
     const microvmId = process.env.MICROVM_ID?.trim();
     if (microvmId) {
       const reported = await reportMicrovmId(state.agentId, state.authHeader, microvmId);
@@ -14665,23 +15472,33 @@ async function run(options) {
         );
       }
     }
-    if (options.restoreRunnerCredentials) {
-      log2(state, "Restoring runner credentials before starting OpenCode");
-      const credentialContext = {
-        env: process.env,
-        log: (message, level = "info") => {
-          if (level === "error") {
-            logActivity(state, { type: "error", error: message });
-          } else {
-            logActivity(state, { type: "info", level, message });
-          }
+    const credentialContext = {
+      env: process.env,
+      log: (message, level = "info") => {
+        if (level === "error") {
+          logActivity(state, { type: "error", error: message });
+        } else {
+          logActivity(state, { type: "info", level, message });
         }
-      };
-      const githubTokenPopulated = await installRunnerSecret(credentialContext);
+      }
+    };
+    const githubTokenPopulated = await installRunnerSecret(credentialContext);
+    if (options.restoreRunnerCredentials) {
       await restoreCredentialStores(credentialContext);
-      if (githubTokenPopulated) await configureGitHubAccess(credentialContext);
     }
+    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,
@@ -14692,7 +15509,8 @@ async function run(options) {
         if (cause !== null && sessionId !== null) {
           state.sessionStoreHealth.observeCause(sessionId, cause);
         }
-      }
+      },
+      dependencyInstallDiagnosticReporter
     );
     const openCodeLogTail = tailOpenCodeLogFile(
       resolveOpenCodeLogPath(homedir7(), process.env),
@@ -14854,7 +15672,7 @@ async function run(options) {
             logActivity(state, { type: "info", level: "warn", message: versionWarning });
           }
         }
-        await reloadProviderCache(state.port, state.opencodeClient ?? void 0);
+        await disposeAndReloadProviderConfig(state.port, state.opencodeClient ?? void 0);
         if (state.opencodeApiVersion === "v2" && state.opencodeClient !== null) {
           await importOpenCodeV2CredentialsForState(state);
         }
@@ -15025,6 +15843,13 @@ async function run(options) {
             type: "info",
             message: connectionMessage
           });
+          if (!isReconnect && state.stayAwakeSeconds !== null && state.stayAwakeUntilMs === null) {
+            state.stayAwakeUntilMs = Date.now() + state.stayAwakeSeconds * 1e3;
+            logActivity(state, {
+              type: "info",
+              message: `Staying awake for at least ${state.stayAwakeSeconds}s as requested by the wake`
+            });
+          }
           if (options.tunnelReadyFile) {
             const marker = writeTunnelReadyMarker(options.tunnelReadyFile, agentId);
             if (marker.ok) {
@@ -15159,6 +15984,7 @@ async function run(options) {
       if (error2.message === "Unauthorized") tunnelSpinner?.fail("Unauthorized");
       throw error2;
     }
+    if (!state.running) return;
     scheduleSessionCleanup(state, channelDriver, options);
     state.claudeUsageRearm = scheduleClaudeUsageReporting(state, options);
     state.openaiUsageRearm = scheduleUsageReporting(state, {