@evident-ai/cli 3.4.1-dev.b1bf8c5 → 3.4.1-dev.b45408b

package/dist/index.js

@@ -722,6 +722,14 @@ function toReportedWindow(window) {
   if (!window) return null;
   return { utilization: window.utilization, resets_at: window.resetsAt };
 }
+function toReportedOwner(snapshot) {
+  if (!snapshot.owner) return null;
+  return {
+    email: snapshot.owner.email,
+    organization_name: snapshot.owner.organizationName,
+    rate_limit_tier: snapshot.owner.rateLimitTier
+  };
+}
 async function reportClaudeUsage(agentId, authHeader, snapshot) {
   try {
     const apiUrl = getApiUrlConfig();
@@ -730,7 +738,8 @@ async function reportClaudeUsage(agentId, authHeader, snapshot) {
       headers: { Authorization: authHeader, "Content-Type": "application/json" },
       body: JSON.stringify({
         five_hour: toReportedWindow(snapshot.fiveHour),
-        seven_day: toReportedWindow(snapshot.sevenDay)
+        seven_day: toReportedWindow(snapshot.sevenDay),
+        owner: toReportedOwner(snapshot)
       }),
       signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
@@ -996,7 +1005,10 @@ import { readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var CLAUDE_PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+var CLAUDE_PROFILE_TIMEOUT_MS = 2e3;
 var KEYCHAIN_SERVICE = "Claude Code-credentials";
+var cachedOwner = null;
 var CLAUDE_CREDENTIALS_SEGMENTS = [".claude", ".credentials.json"];
 function parseClaudeCliCredentials(raw) {
   let parsed;
@@ -1070,6 +1082,47 @@ function toWindow(value) {
   }
   return { utilization: window.utilization, resetsAt };
 }
+function ownerLookupFailure(error2) {
+  const name = error2?.name;
+  return name === "TimeoutError" || name === "AbortError" ? "timed out" : "request failed";
+}
+async function getClaudeUsageOwner(accessToken) {
+  if (cachedOwner?.accessToken === accessToken) {
+    return { owner: cachedOwner.owner, ownerLookupError: null };
+  }
+  try {
+    const response = await fetch(CLAUDE_PROFILE_URL, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01"
+      },
+      signal: AbortSignal.timeout(CLAUDE_PROFILE_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return { owner: null, ownerLookupError: `HTTP ${response.status}` };
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch (error2) {
+      return { owner: null, ownerLookupError: "malformed response" };
+    }
+    const profile = body;
+    if (typeof profile.account?.email !== "string" || !profile.account.email.trim()) {
+      return { owner: null, ownerLookupError: "malformed response" };
+    }
+    const owner = {
+      email: profile.account.email,
+      organizationName: typeof profile.organization?.name === "string" && profile.organization.name.trim() ? profile.organization.name.trim() : null,
+      rateLimitTier: typeof profile.organization?.rate_limit_tier === "string" && profile.organization.rate_limit_tier.trim() ? profile.organization.rate_limit_tier.trim() : null
+    };
+    cachedOwner = { accessToken, owner };
+    return { owner, ownerLookupError: null };
+  } catch (error2) {
+    return { owner: null, ownerLookupError: ownerLookupFailure(error2) };
+  }
+}
 async function getClaudeUsage() {
   const credentials2 = readClaudeCliCredentials();
   if (!credentials2) {
@@ -1089,15 +1142,19 @@ async function getClaudeUsage() {
       Authorization: `Bearer ${credentials2.accessToken}`,
       "Content-Type": "application/json",
       "anthropic-version": "2023-06-01"
-    }
+    },
+    signal: AbortSignal.timeout(CLAUDE_PROFILE_TIMEOUT_MS)
   });
   if (!res.ok) {
     throw new ClaudeUsageError(`Claude usage request failed: HTTP ${res.status}`, "request_failed");
   }
   const body = await res.json();
+  const { owner, ownerLookupError } = await getClaudeUsageOwner(credentials2.accessToken);
   return {
     fiveHour: toWindow(body.five_hour),
-    sevenDay: toWindow(body.seven_day)
+    sevenDay: toWindow(body.seven_day),
+    owner,
+    ownerLookupError
   };
 }
 
@@ -1127,7 +1184,7 @@ async function claudeUsage() {
 
 // src/commands/run.ts
 import { homedir as homedir4 } from "os";
-import { isAbsolute as isAbsolute2, join as join6, parse, resolve as resolvePath } from "path";
+import { isAbsolute as isAbsolute2, join as join7, parse, resolve as resolvePath } from "path";
 import chalk6 from "chalk";
 
 // ../../packages/types/src/agents/index.ts
@@ -1360,6 +1417,8 @@ var SEVERITY_BY_LEVEL = {
   error: "error"
 };
 var MAX_MESSAGE_LENGTH = 500;
+var MAX_METADATA_VALUE_LENGTH = 200;
+var MAX_METADATA_ENTRIES = 20;
 var TRUNCATION_MARKER = "\u2026";
 function redact(message) {
   return message.replace(/esk_[A-Za-z0-9_-]+/g, "esk_***").replace(/ct_[A-Za-z0-9_-]+/g, "ct_***").replace(/https?:\/\/\S+/g, "<url>");
@@ -1368,6 +1427,24 @@ function truncate(message) {
   if (message.length <= MAX_MESSAGE_LENGTH) return message;
   return message.slice(0, MAX_MESSAGE_LENGTH - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
 }
+function sanitiseMetadata(metadata) {
+  if (!metadata) return {};
+  const entries = Object.entries(metadata).slice(0, MAX_METADATA_ENTRIES);
+  if (Object.keys(metadata).length > entries.length) {
+    console.error(
+      `[runner-activity-telemetry] dropped ${Object.keys(metadata).length - entries.length} metadata entries`
+    );
+  }
+  const sanitised = [];
+  for (const [key, value] of entries) {
+    if (typeof value === "string") {
+      sanitised.push([key, truncate(redact(value).slice(0, MAX_METADATA_VALUE_LENGTH))]);
+    } else if (value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+      sanitised.push([key, value]);
+    }
+  }
+  return Object.fromEntries(sanitised);
+}
 var RATE_LIMIT_WINDOW_MS = 6e4;
 var RATE_LIMIT_MAX_EVENTS = 30;
 var windowStartedAt = 0;
@@ -1406,7 +1483,7 @@ function forwardRunnerActivity(entry, context) {
     logEvent(TelemetryEventTypes.RUNNER_ACTIVITY, {
       severity: SEVERITY_BY_LEVEL[entry.level],
       message,
-      metadata: { source: "cli.run" },
+      metadata: { ...sanitiseMetadata(entry.metadata), source: "cli.run" },
       agentId: context.agentId
     });
   } catch (err) {
@@ -1416,6 +1493,150 @@ function forwardRunnerActivity(entry, context) {
   }
 }
 
+// src/lib/opencode/session-db-recovery-report.ts
+import { readFileSync as readFileSync2, unlinkSync } from "fs";
+import { join as join2 } from "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");
+}
+function drainSessionDbRecoveryReport({
+  homeDir,
+  env
+}) {
+  const path = sessionDbRecoveryReportPath(homeDir, env);
+  let content;
+  try {
+    content = readFileSync2(path, "utf8");
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return { path, records: [], skippedLines: 0, readError: null };
+    const readError = error2 instanceof Error ? error2.message : String(error2);
+    console.error(`[session-db-recovery-report] could not read ${path}: ${readError}`);
+    return { path, records: [], skippedLines: 0, readError };
+  }
+  let skippedLines = 0;
+  const records = content.split("\n").flatMap((line) => {
+    if (!line.trim()) return [];
+    try {
+      const value = JSON.parse(line);
+      if (!isSessionDbRecoveryRecord(value)) {
+        skippedLines++;
+        return [];
+      }
+      return [value];
+    } catch (error2) {
+      skippedLines++;
+      console.error(
+        `[session-db-recovery-report] skipped malformed record in ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+      return [];
+    }
+  });
+  return { path, records, skippedLines, readError: null };
+}
+function acknowledgeSessionDbRecoveryReport(path) {
+  try {
+    unlinkSync(path);
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") return;
+    console.error(
+      `[session-db-recovery-report] could not remove ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+}
+function buildSessionDbRecoveryActivity(record) {
+  const level = record.severity === "warning" ? "warn" : record.severity === "error" ? "error" : null;
+  if (!level) return null;
+  const noVerifiedPoint = record.verified_restore_point ? ` The verified restore point is ${record.verified_restore_point}.` : " No verified restore point is known.";
+  switch (record.outcome) {
+    case "fresh_session_db":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: `This runner started with a fresh session database. Earlier sessions are unavailable, and queued conversation or session references from before this start may no longer resolve.${noVerifiedPoint} Review the runner's backup configuration before relying on restored session history.`
+      };
+    case "restore_retried":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: "The initial session database restore failed; the runner will retry it. Monitor the runner backup for another restore failure."
+      };
+    case "replica_recovered":
+      if (record.reason === "quarantine")
+        return {
+          level,
+          metadata: withoutContractFields(record),
+          message: `Session database recovery quarantined ${record.quarantined_objects ?? "unknown"} objects (${record.quarantined_bytes ?? "unknown"} bytes); ${record.quarantine_failed_objects ?? "unknown"} moves failed. Review the preserved backup at ${record.quarantine_destination ?? "an unknown destination"} before deleting it.`
+        };
+      if (record.reason === "prune")
+        return {
+          level,
+          metadata: withoutContractFields(record),
+          message: "Session database recovery discarded a damaged newest backup and retried. Sessions recorded after the previous backup point may be unavailable. Review the runner backup for another restore failure."
+        };
+      if (record.reason === "clear")
+        return {
+          level,
+          metadata: withoutContractFields(record),
+          message: "Session database recovery deleted the damaged backup and prior session history is unavailable. Review the runner backup configuration before relying on restored session history."
+        };
+      return null;
+    case "history_rolled_back":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: `Session history was rolled back to verified restore point ${record.verified_restore_point ?? "unknown"}; everything after it is unavailable. Review the runner backup for another restore failure.`
+      };
+    case "restore_misconfigured":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: "This runner started with a fresh session database because it could not verify where its session history is backed up. Nothing in the backup was changed; check the runner backup configuration and permissions."
+      };
+    case "session_db_boot_refused":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: `This runner did not come online because its damaged session database could not be safely separated from its active backup or proven removed. Backed-up session history remains readable at ${record.quarantine_destination ?? "its original location or the quarantine destination named in the boot logs"}; any local session-database files that remain were left in place and nothing opened or wrote them. See the runner boot logs for SESSION-DB-LOCAL-DISCARD-FAILED details.`
+      };
+    default:
+      return null;
+  }
+}
+function withoutContractFields(record) {
+  const { v: _v, event: _event, ...metadata } = record;
+  return metadata;
+}
+var OUTCOMES = /* @__PURE__ */ new Set([
+  "replica_recovered",
+  "restore_retried",
+  "fresh_session_db",
+  "history_rolled_back",
+  "restore_misconfigured",
+  "session_db_boot_refused"
+]);
+var STAGES = /* @__PURE__ */ new Set(["restore", "verify"]);
+var SEVERITIES = /* @__PURE__ */ new Set(["warning", "error"]);
+var NUMBER_FIELDS = [
+  "litestream_exit_code",
+  "attempt",
+  "replica_objects",
+  "replica_bytes",
+  "quarantined_objects",
+  "quarantine_failed_objects",
+  "quarantined_bytes",
+  "restore_points_tried"
+];
+var STRING_OR_NULL_FIELDS = ["quarantine_destination", "verified_restore_point"];
+function isSessionDbRecoveryRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.v === 1 && record.event === "session_db_recovery" && typeof record.at === "string" && STAGES.has(record.stage) && OUTCOMES.has(record.outcome) && SEVERITIES.has(record.severity) && typeof record.reason === "string" && NUMBER_FIELDS.every((field) => record[field] === null || Number.isInteger(record[field])) && STRING_OR_NULL_FIELDS.every(
+    (field) => record[field] === null || typeof record[field] === "string"
+  );
+}
+
 // src/lib/opencode/health.ts
 async function checkOpenCodeHealth(port) {
   try {
@@ -1460,6 +1681,62 @@ function buildOpenCodeVersionWarning(version2) {
 
 // src/lib/opencode/process.ts
 import { execSync, spawn } from "child_process";
+
+// src/lib/process-stop.ts
+async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
+  if (!child.pid) {
+    return { outcome: "not-running", code: child.exitCode, signal: child.signalCode };
+  }
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return { outcome: "exited", code: child.exitCode, signal: child.signalCode };
+  }
+  return new Promise((resolve3, reject) => {
+    let forced = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      forced = true;
+      try {
+        sendKill();
+      } catch (error2) {
+        if (error2.code === "ESRCH") {
+          finish({ outcome: "exited", code: child.exitCode, signal: child.signalCode });
+        } else {
+          fail(error2);
+        }
+      }
+    }, timeoutMs);
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
+      resolve3(result);
+    };
+    const fail = (error2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
+      reject(error2);
+    };
+    const onExit = (code, signal) => {
+      finish({ outcome: forced ? "killed" : "exited", code, signal });
+    };
+    child.once("exit", onExit);
+    try {
+      sendTerm();
+    } catch (error2) {
+      if (error2.code === "ESRCH") {
+        finish({ outcome: "exited", code: child.exitCode, signal: child.signalCode });
+      } else {
+        fail(error2);
+      }
+      return;
+    }
+  });
+}
+
+// src/lib/opencode/process.ts
 var OPENCODE_PORT_RANGE = [4096, 4097, 4098, 4099, 4100];
 function getProcessCwd(pid) {
   const platform = process.platform;
@@ -1631,23 +1908,20 @@ async function startOpenCode(port) {
   });
   return child;
 }
-function stopOpenCode(opencodeProcess) {
-  if (!opencodeProcess || !opencodeProcess.pid) {
-    return;
-  }
-  try {
+function stopOpenCodeAndWait(opencodeProcess, timeoutMs) {
+  const sendSignal = (signal) => {
     if (process.platform === "win32") {
-      opencodeProcess.kill("SIGTERM");
+      opencodeProcess.kill(signal);
     } else {
-      process.kill(-opencodeProcess.pid, "SIGTERM");
-    }
-  } catch (err) {
-    if (err.code !== "ESRCH") {
-      console.warn(
-        `stopOpenCode: kill failed: ${err instanceof Error ? err.message : String(err)}`
-      );
+      process.kill(-opencodeProcess.pid, signal);
     }
-  }
+  };
+  return stopProcessAndWait(
+    opencodeProcess,
+    timeoutMs,
+    () => sendSignal("SIGTERM"),
+    () => sendSignal("SIGKILL")
+  );
 }
 
 // src/lib/opencode/install.ts
@@ -2230,7 +2504,7 @@ function isPreamblePinnedRunning(messages, userMessageId) {
   return completedOf(reply) != null && finishOf(reply) === "tool-calls";
 }
 function isB2AbandonmentConfirmed(params) {
-  return params.pinnedForMs >= params.minPinnedMs && params.descendantOngoing === false;
+  return params.pinnedForMs >= params.minPinnedMs && params.descendantOngoing === false && params.rootOngoing === false;
 }
 function isAmbiguousTerminalFinish(m) {
   if (completedOf(m) == null) return false;
@@ -2243,7 +2517,7 @@ function isAmbiguousFinishPinnedRunning(messages, userMessageId) {
   return isAmbiguousTerminalFinish(reply);
 }
 function isAmbiguousFinishResolved(params) {
-  return params.sessionOngoing === false || params.pinnedForMs >= params.maxPinnedMs;
+  return params.sessionOngoing === false || params.sessionOngoing !== true && params.pinnedForMs >= params.maxPinnedMs;
 }
 function messageError(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
@@ -2453,10 +2727,10 @@ function resolveSessionCleanupConfig(flags, env = process.env) {
 
 // src/lib/opencode/session-db-size.ts
 import { statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var LARGE_DB_THRESHOLD_BYTES = 268435456;
 function statSessionDbBytes(homeDir) {
-  const dbPath = join2(homeDir, ".local", "share", "opencode", "opencode.db");
+  const dbPath = join3(homeDir, ".local", "share", "opencode", "opencode.db");
   try {
     return statSync2(dbPath).size;
   } catch (err) {
@@ -3025,10 +3299,26 @@ function writeTunnelReadyMarker(path, agentId) {
   }
 }
 
+// src/lib/replication.ts
+import { spawn as spawn2 } from "child_process";
+function startSessionDbReplication(configPath) {
+  return spawn2("litestream", ["replicate", "-config", configPath], {
+    stdio: "inherit"
+  });
+}
+async function stopSessionDbReplication(child, timeoutMs) {
+  return stopProcessAndWait(
+    child,
+    timeoutMs,
+    () => child.kill("SIGTERM"),
+    () => child.kill("SIGKILL")
+  );
+}
+
 // src/lib/openai-usage.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "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 {
@@ -3042,7 +3332,7 @@ function isLocalCredentialProblem2(err) {
 }
 function readOpenCodeChatGptCredentials() {
   try {
-    const raw = readFileSync2(join3(homedir2(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
+    const raw = readFileSync3(join4(homedir2(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -3418,12 +3708,12 @@ function createResourceUsageCollector(homeDir) {
 import { homedir as homedir3 } from "os";
 
 // src/lib/runner-file-sync.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/lib/file-push.ts
 import { randomUUID } from "crypto";
 import { chmod, mkdir, open as open2, realpath, rename, unlink } from "fs/promises";
-import { basename, dirname as dirname3, isAbsolute, join as join4, relative, resolve as resolve2, sep } from "path";
+import { basename, dirname as dirname3, isAbsolute, join as join5, relative, resolve as resolve2, sep } from "path";
 var FILE_MODE = 384;
 var DIRECTORY_MODE = 448;
 async function writePushedFile(request) {
@@ -3456,7 +3746,7 @@ async function writePushedFile(request) {
     const { existingAncestor, missingSegments } = await resolveNearestExistingAncestor(
       dirname3(candidate)
     );
-    const realTarget = join4(existingAncestor, ...missingSegments, basename(candidate));
+    const realTarget = join5(existingAncestor, ...missingSegments, basename(candidate));
     const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget);
     if (allowedDirectory === null) {
       return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
@@ -3492,7 +3782,7 @@ function expandAndValidate(requestedPath, homeDir) {
   if (requestedPath.trim() === "" || requestedPath.includes("\0")) {
     return null;
   }
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join4(homeDir, requestedPath.slice(2)) : requestedPath;
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join5(homeDir, requestedPath.slice(2)) : requestedPath;
   if (expanded.split(/[/\\]/).includes("..")) {
     return null;
   }
@@ -3565,13 +3855,13 @@ function contains(realDirectory, realTarget) {
 async function createMissingDirectories(existingAncestor, missingSegments) {
   let current = existingAncestor;
   for (const segment of missingSegments) {
-    current = join4(current, segment);
+    current = join5(current, segment);
     await mkdir(current, { recursive: true, mode: DIRECTORY_MODE });
     await chmod(current, DIRECTORY_MODE);
   }
 }
 async function writeAtomically(realTarget, content) {
-  const temporaryPath = join4(dirname3(realTarget), `.evident-push-${randomUUID()}.tmp`);
+  const temporaryPath = join5(dirname3(realTarget), `.evident-push-${randomUUID()}.tmp`);
   let handle;
   try {
     handle = await open2(temporaryPath, "wx", FILE_MODE);
@@ -3701,12 +3991,12 @@ var NOT_APPLIED = {
   opencodeAuthApplied: false
 };
 function isClaudeCredentialPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join5(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join5(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join6(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join6(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
 }
 function isOpenCodeAuthPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join5(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join5(homeDir, ...OPENCODE_AUTH_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join6(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join6(homeDir, ...OPENCODE_AUTH_SEGMENTS);
 }
 async function applyOne(options, file) {
   const label = `${file.id.slice(0, 8)} (${file.path})`;
@@ -5519,6 +5809,7 @@ var ChannelDriver = class _ChannelDriver {
       deliveryDeadlineAnchored: false,
       b2PinnedSinceMs: 0,
       b2LastDescendantCheckMs: 0,
+      b2RootOngoingHeldLogged: false,
       b2AbandonedSignalled: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false
@@ -5613,6 +5904,7 @@ var ChannelDriver = class _ChannelDriver {
       deliveryDeadlineAnchored: false,
       b2PinnedSinceMs: 0,
       b2LastDescendantCheckMs: 0,
+      b2RootOngoingHeldLogged: false,
       b2AbandonedSignalled: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false
@@ -5966,6 +6258,7 @@ var ChannelDriver = class _ChannelDriver {
       if (snapshotReadable) {
         inFlight.b2PinnedSinceMs = 0;
         inFlight.b2LastDescendantCheckMs = 0;
+        inFlight.b2RootOngoingHeldLogged = false;
         inFlight.b2AbandonedSignalled = false;
       }
     } else {
@@ -5977,11 +6270,15 @@ var ChannelDriver = class _ChannelDriver {
       const pinnedForMs = this.now() - inFlight.b2PinnedSinceMs;
       if (pinnedForMs >= B2_ABANDONMENT_MIN_PINNED_MS && this.now() - inFlight.b2LastDescendantCheckMs >= B2_ABANDONMENT_RECHECK_MS) {
         inFlight.b2LastDescendantCheckMs = this.now();
-        const descendantOngoing = await this.isAnyDescendantSessionOngoing(sessionId);
+        const [descendantOngoing, rootOngoing] = await Promise.all([
+          this.isAnyDescendantSessionOngoing(sessionId),
+          isSessionOngoing(this.port, sessionId)
+        ]);
         if (isB2AbandonmentConfirmed({
           pinnedForMs,
           minPinnedMs: B2_ABANDONMENT_MIN_PINNED_MS,
-          descendantOngoing
+          descendantOngoing,
+          rootOngoing
         })) {
           inFlight.b2AbandonedSignalled = true;
           this.log({
@@ -5990,12 +6287,26 @@ var ChannelDriver = class _ChannelDriver {
             conversation_id: conv.id,
             message_id: id
           });
+          const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
           void this.postSignal(conv.id, id, "b2_abandoned_resolved", {
-            watched_for_ms: pinnedForMs
+            watched_for_ms: pinnedForMs,
+            finish: reply?.info?.finish ?? reply?.finish,
+            ...rootOngoing != null ? { root_ongoing: rootOngoing } : {},
+            ...descendantOngoing != null ? { descendant_ongoing: descendantOngoing } : {},
+            opencode_message_id: inFlight.opencodeMessageId
           });
           await this.settleMessageDone(sessionId, watcher, inFlight, messages);
           return;
         }
+        if (rootOngoing === true && !inFlight.b2RootOngoingHeldLogged) {
+          inFlight.b2RootOngoingHeldLogged = true;
+          this.log({
+            level: "warn",
+            message: `Message ${id.slice(0, 8)} b2-pinned for ${Math.round(pinnedForMs / 1e3)}s with root_ongoing=${rootOngoing} and descendant_ongoing=${descendantOngoing} \u2014 holding until OpenCode confirms the root is idle`,
+            conversation_id: conv.id,
+            message_id: id
+          });
+        }
       }
     }
     const ambiguousPinnedNow = activelyRunning && isAmbiguousFinishPinnedRunning(messages, inFlight.opencodeMessageId);
@@ -7738,6 +8049,7 @@ var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_
 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;
+var CHILD_STOP_TIMEOUT_MS = 1e4;
 function resolveLogLevel(options) {
   const accepted = Object.keys(LOG_LEVELS);
   const validate = (value, source) => {
@@ -7768,7 +8080,7 @@ 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("~/") ? join6(homeDir, trimmed.slice(2)) : trimmed;
+    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join7(homeDir, trimmed.slice(2)) : trimmed;
     if (!isAbsolute2(expanded)) {
       throw new Error(`--enable-file-sync-to requires an absolute directory path; got "${entry}"`);
     }
@@ -7866,7 +8178,7 @@ function logActivity(state, entry) {
   const level = entry.level ?? (entry.type === "error" ? "error" : "info");
   if (!meetsThreshold(state, level)) return;
   forwardRunnerActivity(
-    { level, message: entry.message, error: entry.error },
+    { level, message: entry.message, error: entry.error, metadata: entry.metadata },
     { agentId: state.agentId, authHeader: state.authHeader }
   );
   const fullEntry = {
@@ -7886,6 +8198,26 @@ function logActivity(state, entry) {
     }
   }
 }
+function reportSessionDbRecovery(state) {
+  try {
+    const report = drainSessionDbRecoveryReport({ homeDir: homedir4(), env: process.env });
+    for (const record of report.records) {
+      const activity = buildSessionDbRecoveryActivity(record);
+      if (!activity) throw new Error("could not map session-DB recovery record");
+      logActivity(state, {
+        type: activity.level === "error" ? "error" : "info",
+        level: activity.level,
+        ...activity.level === "error" ? { error: activity.message } : { message: activity.message },
+        metadata: activity.metadata
+      });
+    }
+    acknowledgeSessionDbRecoveryReport(report.path);
+  } catch (error2) {
+    console.error(
+      `[run] could not report session-DB recovery activity: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+}
 function displayStatus(state) {
   if (!state.interactive) return;
   const attempt = state.connection?.reconnectAttempt ?? 0;
@@ -8081,7 +8413,7 @@ async function driveChannels(state, driver) {
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
 var SESSION_DB_RECLAIM_MAX_PAGES = 2e3;
 function sessionDbPath() {
-  return join6(homedir4(), ".local", "share", "opencode", "opencode.db");
+  return join7(homedir4(), ".local", "share", "opencode", "opencode.db");
 }
 async function runSweep(state, driver, config) {
   const mode = `age=${config.maxAgeMs ?? "\u2014"} count=${config.maxCount ?? "\u2014"}`;
@@ -8323,7 +8655,17 @@ function scheduleClaudeUsageReporting(state, options) {
     setTimer: (timer) => {
       state.claudeUsageTimer = timer;
     },
-    fetchUsage: getClaudeUsage,
+    fetchUsage: async () => {
+      const usage = await getClaudeUsage();
+      if (usage.ownerLookupError) {
+        logActivity(state, {
+          type: "info",
+          level: "debug",
+          message: `Claude usage owner lookup failed: ${usage.ownerLookupError}`
+        });
+      }
+      return usage;
+    },
     report: (usage) => reportClaudeUsage(state.agentId, state.authHeader, usage),
     isLocalCredentialProblem,
     forcedOnHint: "run `claude` to sign in",
@@ -8495,15 +8837,31 @@ async function cleanup(state, opts = {}) {
   }
   if (state.opencodeProcess) {
     const opencodeProcess = state.opencodeProcess;
-    await timeShutdownPhase(state, durations, "opencode_stop", () => stopOpenCode(opencodeProcess));
+    const result = await timeShutdownPhase(
+      state,
+      durations,
+      "opencode_stop",
+      () => stopOpenCodeAndWait(opencodeProcess, CHILD_STOP_TIMEOUT_MS)
+    );
     if (state.interactive) {
-      logActivity(state, { type: "info", message: "Stopped OpenCode process" });
+      logActivity(state, { type: "info", message: `Stopped OpenCode process (${result.outcome})` });
       displayStatus(state);
     } else {
-      log2(state, "Stopped OpenCode process");
+      log2(state, `Stopped OpenCode process (${result.outcome})`);
     }
     state.opencodeProcess = null;
   }
+  if (state.litestreamProcess) {
+    const litestreamProcess = state.litestreamProcess;
+    const result = await timeShutdownPhase(
+      state,
+      durations,
+      "litestream_stop",
+      () => stopSessionDbReplication(litestreamProcess, CHILD_STOP_TIMEOUT_MS)
+    );
+    log2(state, `Stopped litestream replication (${result.outcome})`);
+    state.litestreamProcess = null;
+  }
   return durations;
 }
 async function run(options) {
@@ -8537,6 +8895,7 @@ async function run(options) {
     opencodeConnected: false,
     opencodeVersion: null,
     opencodeProcess: null,
+    litestreamProcess: null,
     connection: null,
     channelDriver: null,
     running: true,
@@ -8744,6 +9103,7 @@ async function run(options) {
     } else {
       log2(state, "Not running in a MicroVM (MICROVM_ID unset) \u2014 nothing to report", "debug");
     }
+    reportSessionDbRecovery(state);
     const { timeoutMs: opencodeStartTimeoutMs, warnings: opencodeStartTimeoutWarnings } = resolveOpenCodeStartTimeoutMs(options, process.env);
     for (const warning2 of opencodeStartTimeoutWarnings) {
       logActivity(state, { type: "info", level: "warn", message: warning2 });
@@ -8800,6 +9160,40 @@ async function run(options) {
       ocSpinner?.fail(error2.message);
       throw error2;
     }
+    if (options.litestreamConfig) {
+      const litestreamProcess = startSessionDbReplication(options.litestreamConfig);
+      state.litestreamProcess = litestreamProcess;
+      let failureHandled = false;
+      const failRunForReplication = (message) => {
+        if (failureHandled || state.shuttingDown || !state.running) return;
+        failureHandled = true;
+        state.shuttingDown = true;
+        logActivity(state, { type: "error", error: message });
+        if (state.interactive) displayStatus(state);
+        void (async () => {
+          try {
+            await cleanup(state);
+            await shutdownTelemetry();
+          } catch (error2) {
+            console.error(
+              `[run] replication failure cleanup failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+            );
+          }
+          process.exit(1);
+        })();
+      };
+      litestreamProcess.on("exit", (code, signal) => {
+        failRunForReplication(
+          `Litestream replication stopped unexpectedly (code: ${code ?? "null"}, signal: ${signal ?? "none"})`
+        );
+      });
+      litestreamProcess.on("error", (error2) => {
+        failRunForReplication(
+          `Litestream replication failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      });
+      log2(state, `Started litestream replication with config ${options.litestreamConfig}`);
+    }
     const tunnelSpinner = interactive && !state.json ? ora3("Connecting tunnel...").start() : null;
     const channelDriver = new ChannelDriver({
       agentId: state.agentId,
@@ -9060,6 +9454,9 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--tunnel-ready-file <path>",
   "Path to write once the tunnel is connected (opt-in; unused unless an operator/image sets it)"
+).option(
+  "--litestream-config <path>",
+  "Replicate the OpenCode session database with `litestream replicate` using this config file (written by the runner image). Omit to disable replication."
 ).action(
   (options) => {
     run({
@@ -9091,7 +9488,8 @@ program.command("run").description("Connect to Evident and process messages").op
       // Raw values — expansion/validation is single-sourced in run.ts's
       // resolveFileSyncDirectories.
       enableFileSyncTo: options.enableFileSyncTo,
-      tunnelReadyFile: options.tunnelReadyFile
+      tunnelReadyFile: options.tunnelReadyFile,
+      litestreamConfig: options.litestreamConfig
     });
   }
 );