@evident-ai/cli 3.5.2-dev.8d3aa06 → 3.5.2-dev.afae02b

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -1063,13 +1062,83 @@ 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 homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { isAbsolute as isAbsolute3, join as join11, parse, resolve as resolvePath2 } from "node:path";
 import chalk7 from "chalk";
 
 // ../../packages/types/src/agents/index.ts
 var MICROVM_MAX_LIFETIME_MS = 8 * 60 * 6e4;
 
+// ../../packages/types/src/opencode/index.ts
+function roleOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  if (typeof m.role === "string") return m.role;
+  const infoRole = m.info?.role;
+  return typeof infoRole === "string" ? infoRole : void 0;
+}
+function idOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  if (typeof m.id === "string") return m.id;
+  const infoId = m.info?.id;
+  return typeof infoId === "string" ? infoId : void 0;
+}
+function parentIdOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  if (typeof m.parentID === "string") return m.parentID;
+  const infoParent = m.info?.parentID;
+  return typeof infoParent === "string" ? infoParent : void 0;
+}
+function textPartsOf(m) {
+  if (!m || typeof m !== "object") return [];
+  const parts = Array.isArray(m.parts) ? m.parts : [];
+  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text ?? "").filter(Boolean);
+}
+function correlatedAssistantRun(messages, userMessageId) {
+  if (!messages || messages.length === 0) return [];
+  const byParent = messages.filter(
+    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+  );
+  if (byParent.length > 0) return byParent;
+  const userIndex = messages.findIndex((m) => idOf(m) === userMessageId);
+  if (userIndex === -1) return [];
+  const run2 = [];
+  for (let i = userIndex + 1; i < messages.length; i++) {
+    const role = roleOf(messages[i]);
+    if (role === "user") break;
+    if (role === "assistant") run2.push(messages[i]);
+  }
+  return run2;
+}
+function lastText(assistantRun) {
+  for (let i = assistantRun.length - 1; i >= 0; i--) {
+    const textParts = textPartsOf(assistantRun[i]);
+    if (textParts.length > 0) return textParts.join("\n").trim() || null;
+  }
+  return null;
+}
+function effectiveCorrelatedRun(messages, userMessageId) {
+  const run2 = correlatedAssistantRun(messages, userMessageId);
+  if (lastText(run2) !== null) return run2;
+  const userIndex = messages?.findIndex((m) => idOf(m) === userMessageId) ?? -1;
+  if (userIndex === -1) return run2;
+  let continuation;
+  for (let i = userIndex + 1; messages && i < messages.length; i++) {
+    if (roleOf(messages[i]) === "user") {
+      continuation = messages[i];
+      break;
+    }
+  }
+  const continuationId = idOf(continuation);
+  if (roleOf(continuation) === "user" && textPartsOf(continuation).join("\n").trim().toLowerCase() === "continue" && continuationId) {
+    const continuationRun = correlatedAssistantRun(messages, continuationId);
+    if (continuationRun.length > 0) return continuationRun;
+  }
+  return run2;
+}
+function extractReplyTextForMessage(messages, opencodeUserMessageId) {
+  return lastText(effectiveCorrelatedRun(messages, opencodeUserMessageId));
+}
+
 // ../../packages/types/src/telemetry/index.ts
 var TelemetryEventTypes = {
   // Agent activity events (shown in web UI activity log)
@@ -1158,7 +1227,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.8d3aa06" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.afae02b" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1172,6 +1241,23 @@ var authProvider = null;
 function setTelemetryAuthProvider(provider) {
   authProvider = provider;
 }
+var diagnosticsReporter = null;
+function setTelemetryDiagnosticsReporter(reporter) {
+  diagnosticsReporter = reporter;
+}
+function reportTelemetryDiagnostic(message) {
+  if (!diagnosticsReporter) {
+    console.error(message);
+    return;
+  }
+  try {
+    diagnosticsReporter(message);
+  } catch (error2) {
+    console.error(
+      `Telemetry diagnostics reporter failed: ${error2 instanceof Error ? error2.message : String(error2)}; original diagnostic: ${message}`
+    );
+  }
+}
 var FLUSH_FAILURE_LOG_INTERVAL_MS = 6e4;
 var lastFlushFailureLoggedAt = 0;
 var suppressedFlushFailureCount = 0;
@@ -1237,7 +1323,9 @@ async function flushEvents() {
         signal: controller.signal
       });
       if (!response.ok) {
-        console.error(`Telemetry flush failed: ${response.status}`);
+        reportTelemetryDiagnostic(
+          `Telemetry could not send events (HTTP ${response.status}); runner and OpenCode are unaffected`
+        );
       }
     } finally {
       clearTimeout(timeout);
@@ -1247,7 +1335,9 @@ async function flushEvents() {
     if (now - lastFlushFailureLoggedAt >= FLUSH_FAILURE_LOG_INTERVAL_MS) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       const suffix = suppressedFlushFailureCount > 0 ? ` (${suppressedFlushFailureCount} more suppressed in the last ${FLUSH_FAILURE_LOG_INTERVAL_MS / 1e3}s)` : "";
-      console.error(`Telemetry flush error: ${message}${suffix}`);
+      reportTelemetryDiagnostic(
+        `Telemetry flush failed: ${message}; runner and OpenCode are unaffected${suffix}`
+      );
       lastFlushFailureLoggedAt = now;
       suppressedFlushFailureCount = 0;
     } else {
@@ -1299,8 +1389,227 @@ var EventTypes = {
 };
 
 // src/lib/runner-activity-telemetry.ts
-var FORWARDED_LEVELS = /* @__PURE__ */ new Set(["warn", "error"]);
+import { homedir as homedir2 } from "node:os";
+
+// src/lib/opencode/session-db-reclaim.ts
+import { statSync as statSync2, statfsSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var SESSION_DB_RECLAIM_CHUNK_PAGES = 2e3;
+var SESSION_DB_RECLAIM_TIME_BUDGET_MS = 500;
+var SESSION_DB_RECLAIM_PAGE_CEILING = 4e4;
+function errorMessage(error2) {
+  if (!(error2 instanceof Error)) return String(error2);
+  return error2.cause instanceof Error ? error2.cause.message : error2.message;
+}
+function isSessionStoreWriteFailure(error2) {
+  const messages = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = error2;
+  while (current !== null && current !== void 0 && !visited.has(current)) {
+    visited.add(current);
+    if (typeof current === "string") {
+      messages.push(current);
+      break;
+    }
+    if (current instanceof Error) {
+      messages.push(current.name, current.message);
+      current = current.cause;
+      continue;
+    }
+    if (typeof current === "object") {
+      const record = current;
+      if (typeof record.code === "string") messages.push(record.code);
+      if (typeof record.message === "string") messages.push(record.message);
+      current = record.cause;
+      continue;
+    }
+    break;
+  }
+  return messages.some(
+    (message) => /(?:database or disk is full|disk is full|no space left on device|SQLITE_(?:FULL|IOERR)(?:\b|_))/i.test(
+      message
+    )
+  );
+}
+function insufficientSpaceReason(dbPath, requiredBytes) {
+  try {
+    const fsStats = statfsSync(dirname2(dbPath));
+    const availableBytes = fsStats.bavail * fsStats.bsize;
+    if (availableBytes < requiredBytes) {
+      return `only ${availableBytes} bytes free, need ${requiredBytes} for a second copy`;
+    }
+    return null;
+  } catch (err) {
+    return `could not check free space (${err instanceof Error ? err.message : String(err)}); refusing to guess`;
+  }
+}
+function readLogicalBytes(db) {
+  const pageCount = db.prepare("PRAGMA page_count").get().page_count;
+  const pageSize = db.prepare("PRAGMA page_size").get().page_size;
+  return pageCount * pageSize;
+}
+function readFreelistCount(db) {
+  return db.prepare("PRAGMA freelist_count").get().freelist_count;
+}
+function readCheckpointResult(db) {
+  const row = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+  return { busy: row.busy !== 0, log: row.log, checkpointed: row.checkpointed };
+}
+async function probeReclaimAvailability(input) {
+  const { dbPath, requiredBytes } = input;
+  let sqlite;
+  try {
+    sqlite = await import("node:sqlite");
+  } catch (err) {
+    const detail = `Node ${process.version}: ${errorMessage(err)}`;
+    console.warn(`[probeReclaimAvailability] node:sqlite unavailable for ${dbPath}: ` + detail);
+    return { reason: "sqlite-unavailable", detail };
+  }
+  let autoVacuum = null;
+  try {
+    const db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    try {
+      db.exec("PRAGMA busy_timeout=5000");
+      autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    console.warn(
+      `[probeReclaimAvailability] could not read auto_vacuum mode for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (autoVacuum !== 0) return null;
+  return insufficientSpaceReason(dbPath, requiredBytes) !== null ? { reason: "insufficient-disk-space" } : null;
+}
+async function reclaimSessionDbSpace(input) {
+  const {
+    dbPath,
+    pageCeiling = SESSION_DB_RECLAIM_PAGE_CEILING,
+    timeBudgetMs = SESSION_DB_RECLAIM_TIME_BUDGET_MS,
+    chunkPages = SESSION_DB_RECLAIM_CHUNK_PAGES,
+    now = () => performance.now(),
+    allowFullVacuum = true
+  } = input;
+  let sqlite;
+  try {
+    sqlite = await import("node:sqlite");
+  } catch (err) {
+    const detail = `Node ${process.version}: ${errorMessage(err)}`;
+    console.warn(
+      `[reclaimSessionDbSpace] node:sqlite unavailable (need Node >=22.5, >=22.13 unflagged) for ${dbPath}: ${detail}`
+    );
+    return { ok: false, skipped: "sqlite-unavailable", detail };
+  }
+  const { DatabaseSync } = sqlite;
+  let db;
+  try {
+    db = new DatabaseSync(dbPath);
+    db.exec("PRAGMA busy_timeout=5000");
+    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`
+        );
+        return {
+          ok: false,
+          skipped: "full-vacuum-blocked",
+          detail: "a session turn is live"
+        };
+      }
+      const fileBytesForGuard = statSync2(dbPath).size;
+      const skipReason = insufficientSpaceReason(dbPath, fileBytesForGuard);
+      if (skipReason !== null) {
+        console.warn(
+          `[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: ${skipReason}`
+        );
+        return { ok: false, skipped: "insufficient-disk-space", detail: skipReason };
+      }
+      const beforeBytes = readLogicalBytes(db);
+      const freelistBefore = readFreelistCount(db);
+      const startedAt = now();
+      db.exec("PRAGMA auto_vacuum=INCREMENTAL");
+      db.exec("VACUUM");
+      const afterBytes = readLogicalBytes(db);
+      const freelistAfter = readFreelistCount(db);
+      const checkpoint = readCheckpointResult(db);
+      return {
+        ok: true,
+        mode: "convert",
+        beforeBytes,
+        afterBytes,
+        freelistBefore,
+        freelistAfter,
+        pagesReclaimed: Math.max(0, freelistBefore - freelistAfter),
+        stoppedBy: "freelist-drained",
+        elapsedMs: Math.max(0, now() - startedAt),
+        checkpoint
+      };
+    }
+    if (autoVacuum === 2) {
+      const beforeBytes = readLogicalBytes(db);
+      const freelistBefore = readFreelistCount(db);
+      const startedAt = now();
+      const pageLimit = Math.max(0, Math.trunc(pageCeiling));
+      const chunkLimit = Math.max(1, Math.trunc(chunkPages));
+      const budget = Math.max(0, timeBudgetMs);
+      let pagesAttempted = 0;
+      let freelistAfter = freelistBefore;
+      let stoppedBy = "freelist-drained";
+      while (freelistAfter > 0) {
+        if (pagesAttempted >= pageLimit) {
+          stoppedBy = "page-ceiling";
+          break;
+        }
+        if (now() - startedAt >= budget) {
+          stoppedBy = "time-budget";
+          break;
+        }
+        const pages = Math.min(chunkLimit, pageLimit - pagesAttempted, freelistAfter);
+        db.exec(`PRAGMA incremental_vacuum(${pages})`);
+        pagesAttempted += pages;
+        freelistAfter = readFreelistCount(db);
+      }
+      const afterBytes = readLogicalBytes(db);
+      const checkpoint = readCheckpointResult(db);
+      return {
+        ok: true,
+        mode: "incremental",
+        beforeBytes,
+        afterBytes,
+        freelistBefore,
+        freelistAfter,
+        pagesReclaimed: Math.max(0, freelistBefore - freelistAfter),
+        stoppedBy,
+        elapsedMs: Math.max(0, now() - startedAt),
+        checkpoint
+      };
+    }
+    console.warn(
+      `[reclaimSessionDbSpace] ${dbPath} has auto_vacuum=${autoVacuum} (neither NONE nor INCREMENTAL); nothing to reclaim`
+    );
+    return { ok: false, skipped: "auto-vacuum-not-applicable" };
+  } catch (err) {
+    console.error(`[reclaimSessionDbSpace] reclaim failed for ${dbPath}: ` + errorMessage(err));
+    return {
+      ok: false,
+      skipped: isSessionStoreWriteFailure(err) ? "disk-exhaustion" : "reclaim-error",
+      detail: errorMessage(err)
+    };
+  } finally {
+    db?.close();
+  }
+}
+
+// src/lib/runner-activity-telemetry.ts
+var FORWARDED_LEVELS_BY_SOURCE = {
+  "cli.run": /* @__PURE__ */ new Set(["warn", "error"]),
+  opencode: /* @__PURE__ */ new Set(["warn", "error"]),
+  "cli.session-cleanup": /* @__PURE__ */ new Set(["info", "warn", "error"])
+};
 var SEVERITY_BY_LEVEL = {
+  info: "info",
   warn: "warning",
   error: "error"
 };
@@ -1310,26 +1619,85 @@ function parseOpenCodeLogLine(line) {
   if (!levelMatch) return null;
   const level = levelMatch[1].toUpperCase();
   if (level !== "WARN" && level !== "ERROR") return null;
-  const sessionMatch = normalisedLine.match(/(?:^|\s)sessionID=(\S+)/);
-  return { level: level === "WARN" ? "warn" : "error", sessionID: sessionMatch?.[1] };
+  const sessionMatch = normalisedLine.match(/(?:^|\s)(?:sessionID|session\.id)=(\S+)/);
+  const messageIDMatch = normalisedLine.match(/(?:^|\s)messageID=(\S+)/);
+  const messageMatch = normalisedLine.match(/(?:^|\s)message=(?:"((?:\\.|[^"])*)"|(\S+))/);
+  const parsed = {
+    level: level === "WARN" ? "warn" : "error",
+    sessionID: sessionMatch?.[1],
+    messageID: messageIDMatch?.[1]
+  };
+  const message = messageMatch?.[1] ?? messageMatch?.[2];
+  if (message !== void 0) parsed.message = message;
+  return parsed;
 }
 var MAX_LINE_BUFFER_BYTES = 16 * 1024;
-function createOpenCodeActivityForwarder(getContext) {
+var REPEAT_SUPPRESSION_WINDOW_MS = 6e4;
+function createOpenCodeActivityForwarder(getContext, onSessionStoreWriteFailure) {
   let buffer = Buffer.alloc(0);
-  const flushLine = (line) => {
-    const parsed = parseOpenCodeLogLine(line);
-    if (!parsed) return;
+  const repeatStates = /* @__PURE__ */ new Map();
+  const forwardLine = (line, parsed, repeatsSuppressed = 0) => {
+    const metadata = {
+      ...parsed.sessionID ? { sessionID: parsed.sessionID } : {},
+      ...parsed.messageID ? { messageID: parsed.messageID } : {},
+      ...repeatsSuppressed > 0 ? { repeats_suppressed: repeatsSuppressed } : {}
+    };
     forwardRunnerActivity(
       {
         level: parsed.level,
         error: line,
-        metadata: parsed.sessionID ? { sessionID: parsed.sessionID } : void 0,
+        metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
         source: "opencode"
       },
       getContext()
     );
   };
-  return (chunk) => {
+  const expireRepeatStates = (now, currentKey) => {
+    for (const [key, state] of repeatStates) {
+      if (key === currentKey || now - state.lastForwardedAt < REPEAT_SUPPRESSION_WINDOW_MS) {
+        continue;
+      }
+      if (state.repeatsSuppressed > 0) {
+        forwardLine(state.line, state.parsed, state.repeatsSuppressed);
+      }
+      repeatStates.delete(key);
+    }
+  };
+  const flushLine = (line) => {
+    if (onSessionStoreWriteFailure && isSessionStoreWriteFailure(line)) {
+      try {
+        onSessionStoreWriteFailure();
+      } catch (err) {
+        reportTelemetryDiagnostic(
+          `Runner activity telemetry could not record session-store write failure: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const parsed = parseOpenCodeLogLine(line);
+    if (!parsed) return;
+    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);
+    if (key === void 0) {
+      forwardLine(line, parsed);
+      return;
+    }
+    const previous = repeatStates.get(key);
+    if (!previous || now - previous.lastForwardedAt >= REPEAT_SUPPRESSION_WINDOW_MS) {
+      forwardLine(line, parsed, previous?.repeatsSuppressed ?? 0);
+      repeatStates.set(key, {
+        line,
+        parsed,
+        lastForwardedAt: now,
+        repeatsSuppressed: 0
+      });
+      return;
+    }
+    previous.line = line;
+    previous.parsed = parsed;
+    previous.repeatsSuppressed++;
+  };
+  const forward = ((chunk) => {
     buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8")]);
     let newlineIndex;
     while ((newlineIndex = buffer.indexOf(10)) !== -1) {
@@ -1340,14 +1708,44 @@ function createOpenCodeActivityForwarder(getContext) {
       flushLine(buffer.toString("utf-8"));
       buffer = Buffer.alloc(0);
     }
+  });
+  forward.flush = () => {
+    for (const state of repeatStates.values()) {
+      if (state.repeatsSuppressed > 0) {
+        forwardLine(state.line, state.parsed, state.repeatsSuppressed);
+      }
+    }
+    repeatStates.clear();
   };
+  return forward;
 }
 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(/(?<![A-Za-z0-9_-])sk-ant-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-ant-***").replace(/(?<![A-Za-z0-9_-])sk-proj-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-proj-***").replace(/(?<![A-Za-z0-9_-])sk-[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "sk-***").replace(/(?<![A-Za-z0-9_-])(gh[oprsu])_[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "$1_***").replace(/(?<![A-Za-z0-9_-])github_pat_[A-Za-z0-9_]{20,}(?![A-Za-z0-9_-])/g, "github_pat_***").replace(/https?:\/\/\S+/g, "<url>");
+function redactHomeDirectory(message) {
+  const home = homedir2();
+  if (!home || home === "/") {
+    return message;
+  }
+  const pathSegmentCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-";
+  let result = "";
+  let searchFrom = 0;
+  let homeIndex;
+  while ((homeIndex = message.indexOf(home, searchFrom)) !== -1) {
+    const homeEnd = homeIndex + home.length;
+    const previousCharacter = message[homeIndex - 1];
+    const nextCharacter = message[homeEnd];
+    const atPathBoundary = home === "/" || (!previousCharacter || !pathSegmentCharacters.includes(previousCharacter)) && (!nextCharacter || !pathSegmentCharacters.includes(nextCharacter));
+    result += message.slice(searchFrom, homeIndex);
+    result += atPathBoundary ? "~" : home;
+    searchFrom = homeEnd;
+  }
+  return result + message.slice(searchFrom);
+}
+function redactDiagnosticText(message) {
+  const redacted = message.replace(/esk_[A-Za-z0-9_-]+/g, "esk_***").replace(/ct_[A-Za-z0-9_-]+/g, "ct_***").replace(/(?<![A-Za-z0-9_-])sk-ant-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-ant-***").replace(/(?<![A-Za-z0-9_-])sk-proj-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-proj-***").replace(/(?<![A-Za-z0-9_-])sk-[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "sk-***").replace(/(?<![A-Za-z0-9_-])(gh[oprsu])_[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "$1_***").replace(/(?<![A-Za-z0-9_-])github_pat_[A-Za-z0-9_]{20,}(?![A-Za-z0-9_-])/g, "github_pat_***").replace(/https?:\/\/\S+/g, "<url>");
+  return redactHomeDirectory(redacted);
 }
 function truncate(message) {
   if (message.length <= MAX_MESSAGE_LENGTH) return message;
@@ -1357,14 +1755,17 @@ 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`
+    reportTelemetryDiagnostic(
+      `Runner activity telemetry dropped ${Object.keys(metadata).length - entries.length} metadata entries; those entries were not sent`
     );
   }
   const sanitised = [];
   for (const [key, value] of entries) {
     if (typeof value === "string") {
-      sanitised.push([key, truncate(redact(value).slice(0, MAX_METADATA_VALUE_LENGTH))]);
+      sanitised.push([
+        key,
+        truncate(redactDiagnosticText(value).slice(0, MAX_METADATA_VALUE_LENGTH))
+      ]);
     } else if (value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
       sanitised.push([key, value]);
     }
@@ -1382,8 +1783,8 @@ function admitUnderRateLimit(source, now) {
   }
   if (now - window.windowStartedAt >= RATE_LIMIT_WINDOW_MS) {
     if (window.windowDroppedCount > 0) {
-      console.error(
-        `[runner-activity-telemetry] rate cap reached: dropped ${window.windowDroppedCount} ${window.windowDroppedCount === 1 ? "entry" : "entries"} in the last ${RATE_LIMIT_WINDOW_MS / 1e3}s (cap ${RATE_LIMIT_MAX_EVENTS}/min) for source "${source}"`
+      reportTelemetryDiagnostic(
+        `Runner activity telemetry rate cap reached: dropped ${window.windowDroppedCount} ${window.windowDroppedCount === 1 ? "entry" : "entries"} in the last ${RATE_LIMIT_WINDOW_MS / 1e3}s (limit ${RATE_LIMIT_MAX_EVENTS}/min); those entries were not sent for source "${source}"`
       );
     }
     window.windowStartedAt = now;
@@ -1393,8 +1794,8 @@ function admitUnderRateLimit(source, now) {
   if (window.windowCount >= RATE_LIMIT_MAX_EVENTS) {
     window.windowDroppedCount++;
     if (window.windowDroppedCount === 1) {
-      console.error(
-        `[runner-activity-telemetry] rate cap reached (${RATE_LIMIT_MAX_EVENTS} per ${RATE_LIMIT_WINDOW_MS / 1e3}s) \u2014 dropping further entries this window for source "${source}"`
+      reportTelemetryDiagnostic(
+        `Runner activity telemetry rate cap reached (${RATE_LIMIT_MAX_EVENTS} entries per ${RATE_LIMIT_WINDOW_MS / 1e3}s limit; further entries were not sent for source "${source}"`
       );
     }
     return false;
@@ -1404,12 +1805,12 @@ function admitUnderRateLimit(source, now) {
 }
 function forwardRunnerActivity(entry, context) {
   try {
-    if (!FORWARDED_LEVELS.has(entry.level)) return;
-    if (!context.agentId || !context.authHeader) return;
     const source = entry.source ?? "cli.run";
+    if (!FORWARDED_LEVELS_BY_SOURCE[source].has(entry.level)) return;
+    if (!context.agentId || !context.authHeader) return;
     if (!admitUnderRateLimit(source, Date.now())) return;
     const rawMessage = entry.error ?? entry.message ?? "";
-    const message = truncate(redact(rawMessage));
+    const message = truncate(redactDiagnosticText(rawMessage));
     logEvent(TelemetryEventTypes.RUNNER_ACTIVITY, {
       severity: SEVERITY_BY_LEVEL[entry.level],
       message,
@@ -1417,8 +1818,8 @@ function forwardRunnerActivity(entry, context) {
       agentId: context.agentId
     });
   } catch (err) {
-    console.error(
-      `[runner-activity-telemetry] failed to forward runner activity: ${err instanceof Error ? err.message : String(err)}`
+    reportTelemetryDiagnostic(
+      `Runner activity telemetry failed to forward runner activity: ${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
@@ -1708,8 +2109,46 @@ async function waitForOpenCode2Health(port, password, timeoutMs = 3e4) {
 
 // src/lib/http-timeout.ts
 var REQUEST_TIMEOUT_MS = 6e4;
+var RequestTimeoutError = class extends Error {
+  constructor(operation, timeoutMs, elapsedMs) {
+    super(`${operation} timed out after ${elapsedMs}ms (limit ${timeoutMs}ms)`);
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+    this.elapsedMs = elapsedMs;
+    this.name = "TimeoutError";
+  }
+};
+function describeRequestOperation(input, init) {
+  const method = (init?.method ?? input.method ?? "GET").toUpperCase();
+  const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+  let path;
+  try {
+    path = new URL(rawUrl).pathname;
+  } catch (error2) {
+    if (!(error2 instanceof TypeError)) throw error2;
+    path = rawUrl.split(/[?#]/, 1)[0];
+  }
+  const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const prefixedIdentifier = /^[a-z]+_[A-Za-z0-9_-]{10,}$/;
+  const maskedPath = path.split("/").map((segment) => uuid.test(segment) || prefixedIdentifier.test(segment) ? ":id" : segment).join("/");
+  return `${method} ${maskedPath}`;
+}
 function withRequestTimeout(fetchImpl, timeoutMs) {
-  return ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+  return (async (input, init) => {
+    const startedAt = Date.now();
+    try {
+      return await fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    } catch (error2) {
+      if (error2?.name === "TimeoutError") {
+        throw new RequestTimeoutError(
+          describeRequestOperation(input, init),
+          timeoutMs,
+          Date.now() - startedAt
+        );
+      }
+      throw error2;
+    }
+  });
 }
 
 // src/lib/opencode/client.ts
@@ -1775,7 +2214,7 @@ async function getOpenCodeDirectory(port, client) {
     return null;
   }
 }
-function roleOf(m) {
+function roleOf2(m) {
   if (!m || typeof m !== "object") return void 0;
   if (typeof m.role === "string") return m.role;
   const infoRole = m.info?.role;
@@ -1789,13 +2228,13 @@ function createdOf(m) {
   if (!m || typeof m !== "object") return void 0;
   return m.info?.time?.created ?? m.time?.created;
 }
-function idOf(m) {
+function idOf2(m) {
   if (!m || typeof m !== "object") return void 0;
   if (typeof m.id === "string") return m.id;
   const infoId = m.info?.id;
   return typeof infoId === "string" ? infoId : void 0;
 }
-function parentIdOf(m) {
+function parentIdOf2(m) {
   if (!m || typeof m !== "object") return void 0;
   if (typeof m.parentID === "string") return m.parentID;
   const infoParent = m.info?.parentID;
@@ -1860,9 +2299,10 @@ async function pollSessionMessagesForRedrive(port, sessionId, client) {
 function isSessionActivelyGenerating(messages) {
   if (!messages || messages.length === 0) return false;
   const last = messages[messages.length - 1];
-  if (roleOf(last) !== "assistant") return false;
+  if (roleOf2(last) !== "assistant") return false;
   return completedOf(last) == null;
 }
+var FULL_SESSION_ENUMERATION_MAX_SESSIONS = 3200;
 function sessionLastActivityMs(session) {
   const candidates = [
     session.time?.updated,
@@ -1877,30 +2317,60 @@ function sessionLastActivityMs(session) {
   }
   return null;
 }
-async function listSessions(port, client) {
-  if (client?.version === "v2") return listV2Sessions(client);
+function sessionListPath(options) {
+  const params = new URLSearchParams();
+  if (options?.limit !== void 0) params.set("limit", String(options.limit));
+  const query = params.toString();
+  return query ? `/session?${query}` : "/session";
+}
+async function listSessionPage(port, client, options) {
+  const path = sessionListPath(options);
   try {
-    const res = await requestWithClient(port, client, "/session");
+    const res = await requestWithClient(port, client, path);
     if (!res.ok) return null;
     const body = await res.json();
     return Array.isArray(body) ? body : null;
   } catch (error2) {
     console.error(
-      `[listSessions] GET /session failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+      `[listSessionPage] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
     return null;
   }
 }
+async function listSessions(port, client, options) {
+  if (client?.version === "v2") return listV2Sessions(client);
+  return listSessionPage(port, client, options);
+}
+async function listAllSessions(port, client) {
+  if (client?.version === "v2") {
+    const sessions2 = await listV2Sessions(client);
+    return sessions2 === null ? { sessions: null, reason: "opencode-unreachable" } : { sessions: sessions2 };
+  }
+  const sessions = await listSessionPage(port, client, {
+    limit: FULL_SESSION_ENUMERATION_MAX_SESSIONS
+  });
+  if (sessions === null) return { sessions: null, reason: "opencode-unreachable" };
+  if (sessions.length >= FULL_SESSION_ENUMERATION_MAX_SESSIONS) {
+    return { sessions: null, reason: "session-enumeration-limit-bound" };
+  }
+  return { sessions };
+}
 async function deleteSession(port, id, client) {
   if (client?.version === "v2") return deleteV2Session(client, id);
   try {
-    const res = await requestWithClient(port, client, `/session/${id}`, { method: "DELETE" });
-    return res.status >= 200 && res.status < 300;
+    const res = await requestWithClient(
+      port,
+      client,
+      `/session/${id}`,
+      { method: "DELETE" },
+      { allowStatuses: ALL_HTTP_STATUSES }
+    );
+    return { ok: res.status >= 200 && res.status < 300, status: res.status };
   } catch (error2) {
     console.error(
       `[deleteSession] DELETE /session/${id} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
-    return false;
+    return { ok: false, status: "threw" };
   }
 }
 async function sessionExists(port, id, client) {
@@ -2141,7 +2611,7 @@ function messageText(m) {
 async function sendPromptAsync(port, sessionId, content, options, attachments, client) {
   const before = await getSessionMessages(port, sessionId, client);
   const knownUserIds = new Set(
-    (before ?? []).filter((m) => roleOf(m) === "user").map((m) => idOf(m)).filter((id) => typeof id === "string")
+    (before ?? []).filter((m) => roleOf2(m) === "user").map((m) => idOf2(m)).filter((id) => typeof id === "string")
   );
   const parts = [{ type: "text", text: content }];
   let pendingOutcomes = null;
@@ -2184,8 +2654,8 @@ async function sendPromptAsync(port, sessionId, content, options, attachments, c
     if (after) {
       let best = null;
       for (const m of after) {
-        if (roleOf(m) !== "user") continue;
-        const id = idOf(m);
+        if (roleOf2(m) !== "user") continue;
+        const id = idOf2(m);
         if (typeof id !== "string" || knownUserIds.has(id)) continue;
         if (messageText(m) !== content) continue;
         const created = createdOf(m) ?? 0;
@@ -2207,13 +2677,13 @@ async function sendPromptAsync(port, sessionId, content, options, attachments, c
 function findAssistantReplyAfter(messages, userMessageId) {
   if (!messages || messages.length === 0) return null;
   const byParent = messages.find(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+    (m) => roleOf2(m) === "assistant" && parentIdOf2(m) === userMessageId
   );
   if (byParent) return byParent;
-  const userIndex = messages.findIndex((m) => idOf(m) === userMessageId);
+  const userIndex = messages.findIndex((m) => idOf2(m) === userMessageId);
   if (userIndex === -1) return null;
   for (let i = userIndex + 1; i < messages.length; i++) {
-    if (roleOf(messages[i]) === "assistant") return messages[i];
+    if (roleOf2(messages[i]) === "assistant") return messages[i];
   }
   return null;
 }
@@ -2223,7 +2693,7 @@ function findLastAssistantReplyFor(messages, userMessageId) {
   let lastNonErrored = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
-    if (roleOf(m) !== "assistant" || parentIdOf(m) !== userMessageId) continue;
+    if (roleOf2(m) !== "assistant" || parentIdOf2(m) !== userMessageId) continue;
     if (lastCorrelated === null) lastCorrelated = m;
     if (errorOf(m) == null) {
       lastNonErrored = m;
@@ -2231,12 +2701,12 @@ function findLastAssistantReplyFor(messages, userMessageId) {
     }
   }
   if (lastCorrelated) return lastNonErrored ?? lastCorrelated;
-  const userIndex = messages.findIndex((m) => idOf(m) === userMessageId);
+  const userIndex = messages.findIndex((m) => idOf2(m) === userMessageId);
   if (userIndex === -1) return null;
   let last = null;
   let lastOk = null;
   for (let i = userIndex + 1; i < messages.length; i++) {
-    const role = roleOf(messages[i]);
+    const role = roleOf2(messages[i]);
     if (role === "user") break;
     if (role === "assistant") {
       last = messages[i];
@@ -2248,16 +2718,16 @@ function findLastAssistantReplyFor(messages, userMessageId) {
 function collectSubagentSessions(messages, userMessageId) {
   if (!messages || messages.length === 0) return [];
   const byParent = messages.filter(
-    (message) => roleOf(message) === "assistant" && parentIdOf(message) === userMessageId
+    (message) => roleOf2(message) === "assistant" && parentIdOf2(message) === userMessageId
   );
   const assistants = byParent.length > 0 ? byParent : [];
   if (assistants.length === 0) {
-    const userIndex = messages.findIndex((message) => idOf(message) === userMessageId);
+    const userIndex = messages.findIndex((message) => idOf2(message) === userMessageId);
     if (userIndex === -1) return [];
     for (let i = userIndex + 1; i < messages.length; i++) {
       const message = messages[i];
-      if (roleOf(message) === "user") break;
-      if (roleOf(message) === "assistant") assistants.push(message);
+      if (roleOf2(message) === "user") break;
+      if (roleOf2(message) === "assistant") assistants.push(message);
     }
   }
   const refs = [];
@@ -2297,7 +2767,7 @@ function collectTaskCalls(messages, userMessageId) {
   if (!messages || messages.length === 0) return [];
   const calls = [];
   for (const message of messages) {
-    if (roleOf(message) !== "assistant" || parentIdOf(message) !== userMessageId) continue;
+    if (roleOf2(message) !== "assistant" || parentIdOf2(message) !== userMessageId) continue;
     for (const part of message.parts ?? []) {
       if (part.tool !== "task" || !part.callID || !part.state || part.state.status === "pending") {
         continue;
@@ -2327,7 +2797,7 @@ function attributeTaskCallUsage(messages, windows) {
   for (const window of eligibleWindows) assignments.set(window.callID, []);
   const unattributed = [];
   for (const message of messages ?? []) {
-    if (roleOf(message) !== "assistant") continue;
+    if (roleOf2(message) !== "assistant") continue;
     const created = finiteNumber(createdOf(message));
     const matching = created === null ? [] : eligibleWindows.filter(
       (window) => window.timeStart <= created && (window.timeEnd === null || window.timeEnd === void 0 || created <= window.timeEnd)
@@ -2404,7 +2874,7 @@ function sumAssistantUsage(messages) {
 function messageUsage(messages, userMessageId) {
   if (!messages || messages.length === 0) return null;
   const byParentAll = messages.filter(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+    (m) => roleOf2(m) === "assistant" && parentIdOf2(m) === userMessageId
   );
   const byParentNonErrored = byParentAll.filter((m) => errorOf(m) == null);
   const byParent = byParentNonErrored.length > 0 ? byParentNonErrored : byParentAll;
@@ -2420,7 +2890,7 @@ function messageUsage(messages, userMessageId) {
 }
 function messageRunState(messages, userMessageId) {
   if (!messages || messages.length === 0) return "unknown";
-  const hasUser = messages.some((m) => idOf(m) === userMessageId);
+  const hasUser = messages.some((m) => idOf2(m) === userMessageId);
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   if (!hasUser) {
     if (!reply) return "unknown";
@@ -2512,7 +2982,7 @@ function findLatestSubagentAuthOutcome(messages, sinceMs) {
   if (!messages || messages.length === 0) return null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if (roleOf(message) !== "assistant") continue;
+    if (roleOf2(message) !== "assistant") continue;
     const created = createdOf(message);
     if (sinceMs !== null && typeof created === "number" && created < sinceMs) continue;
     const failure = classifyReplyAuthError(message);
@@ -2544,25 +3014,25 @@ function applyZeroProviderFallback(classified, hasConfiguredProvider, replyProvi
 function hasRunningAssistantExcept(messages, exceptUserMessageId) {
   if (!messages || messages.length === 0) return false;
   return messages.some(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
+    (m) => roleOf2(m) === "assistant" && parentIdOf2(m) !== exceptUserMessageId && isAssistantInFlight(m)
   );
 }
 function hasLaterSiblingTurnStarted(messages, userMessageId, siblingUserMessageIds) {
   if (!messages || messages.length === 0) return false;
-  const userIndex = messages.findIndex((message) => idOf(message) === userMessageId);
+  const userIndex = messages.findIndex((message) => idOf2(message) === userMessageId);
   if (userIndex === -1) return false;
   let hasLaterUser = false;
   let hasStartedLaterUser = false;
   for (let i = userIndex + 1; i < messages.length; i++) {
     const message = messages[i];
-    if (roleOf(message) !== "user") continue;
+    if (roleOf2(message) !== "user") continue;
     hasLaterUser = true;
-    const laterUserMessageId = idOf(message);
+    const laterUserMessageId = idOf2(message);
     if (laterUserMessageId === void 0 || !siblingUserMessageIds.has(laterUserMessageId)) {
       return false;
     }
     if (messages.some(
-      (candidate) => roleOf(candidate) === "assistant" && parentIdOf(candidate) === laterUserMessageId
+      (candidate) => roleOf2(candidate) === "assistant" && parentIdOf2(candidate) === laterUserMessageId
     )) {
       hasStartedLaterUser = true;
     }
@@ -3033,13 +3503,17 @@ async function listV2Sessions(client) {
 }
 async function deleteV2Session(client, sessionId) {
   try {
-    await client.request(`/api/session/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
-    return true;
+    const response = await client.request(
+      `/api/session/${encodeURIComponent(sessionId)}`,
+      { method: "DELETE" },
+      { allowStatuses: Array.from({ length: 500 }, (_, index) => index + 100) }
+    );
+    return { ok: response.status >= 200 && response.status < 300, status: response.status };
   } catch (error2) {
     console.error(
       `[deleteV2Session] DELETE /api/session/${sessionId} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
-    return false;
+    return { ok: false, status: "threw" };
   }
 }
 async function v2SessionExists(client, sessionId) {
@@ -3214,7 +3688,7 @@ import { join as join4 } from "node:path";
 
 // src/lib/openai-usage.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { join as join3 } from "node:path";
 var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 var OPENCODE_AUTH_SEGMENTS = [".local", "share", "opencode", "auth.json"];
@@ -3229,7 +3703,7 @@ function isLocalCredentialProblem2(err) {
 }
 function readOpenCodeChatGptCredentials() {
   try {
-    const raw = readFileSync3(join3(homedir2(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
+    const raw = readFileSync3(join3(homedir3(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -3370,16 +3844,17 @@ function hasPrimaryHeaders(headers) {
   ].some((name) => headers.has(name));
 }
 async function getOpenAiUsage(port, client) {
+  const openCodeVersion = client?.version ?? "v1";
   const credentials2 = readOpenCodeChatGptCredentials();
   if (!credentials2) {
     throw new OpenAiUsageError(
-      "No ChatGPT login found. Connect a ChatGPT account to this runner, or run `opencode auth login`.",
+      openCodeVersion === "v2" ? "OpenAI usage reporting is not available on OpenCode V2 because V2 keeps a connected ChatGPT login in a store Evident cannot read." : "No ChatGPT login found. Connect a ChatGPT account to this runner, or run `opencode auth login`.",
       "no_credentials"
     );
   }
   if (credentials2.expiresAt < Date.now()) {
     throw new OpenAiUsageError(
-      "ChatGPT credentials have expired. Run `opencode auth login` to refresh them.",
+      openCodeVersion === "v2" ? "The delivered ChatGPT login has expired. OpenCode V2 cannot be given a replacement by file; connect the account again from the runner's page in Evident." : "ChatGPT credentials have expired. Run `opencode auth login` to refresh them.",
       "credentials_expired"
     );
   }
@@ -3660,9 +4135,9 @@ async function importOpenCodeV2Credentials({
 
 // src/lib/opencode/session-db-boot.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, resolve as resolvePath } from "node:path";
+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";
 
 // src/lib/runner-synchroniser.ts
 import { spawn } from "node:child_process";
@@ -3787,7 +4262,7 @@ function clearMarker(options) {
 function markNoReplicate(options, message) {
   if (options.noReplicateMarker) {
     try {
-      mkdirSync(dirname2(options.noReplicateMarker), { recursive: true });
+      mkdirSync(dirname3(options.noReplicateMarker), { recursive: true });
       writeFileSync(options.noReplicateMarker, "");
     } catch (error2) {
       options.log(
@@ -3912,7 +4387,7 @@ async function ensureLitestreamConfig(options, env) {
     return null;
   }
   try {
-    if (statSync2(configPath).size > 0) return configPath;
+    if (statSync3(configPath).size > 0) return configPath;
   } catch (error2) {
     if (!(error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")) {
       options.log(
@@ -3942,7 +4417,7 @@ async function ensureLitestreamConfig(options, env) {
     return null;
   }
   try {
-    mkdirSync(dirname2(configPath), { recursive: true });
+    mkdirSync(dirname3(configPath), { recursive: true });
     writeFileSync(configPath, rendered.stdout);
   } catch (error2) {
     options.log(
@@ -4017,14 +4492,14 @@ async function restoreSessionDb(options, configPath, env) {
     case 0:
       return;
     case 31:
-      acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir3(), env));
+      acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir4(), env));
       options.log(
         "SESSION-DB-REPLICA-UNUSABLE: booting with a fresh opencode.db and replicating into the existing prefix this boot",
         "warn"
       );
       return;
     case 32:
-      acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir3(), env));
+      acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir4(), env));
       discardSessionDbDebris(options);
       markNoReplicate(
         options,
@@ -4103,7 +4578,7 @@ async function verifySessionDb(options, configPath, env) {
 }
 function fileExists(path) {
   try {
-    statSync2(path);
+    statSync3(path);
     return true;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") return false;
@@ -4113,7 +4588,7 @@ function fileExists(path) {
 async function restoreAndVerifySessionDb(options) {
   const env = options.env ?? process.env;
   clearMarker(options);
-  acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir3(), env));
+  acknowledgeSessionDbRecoveryReport(sessionDbRecoveryReportPath(homedir4(), env));
   const synchroniserEnv = await runSynchroniser(["env"], {
     timeoutMs: SESSION_DB_SYNCHRONISER_TIMEOUT_MS,
     env
@@ -4192,7 +4667,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 dirname3, join as join5 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 var require2 = createRequire(import.meta.url);
 function readSessionDbMigrationIds(dbPath) {
   let db;
@@ -4258,7 +4733,7 @@ function loadSessionDbProvenanceState(path) {
 }
 function saveSessionDbProvenanceState(path, state) {
   try {
-    mkdirSync2(dirname3(path), { recursive: true });
+    mkdirSync2(dirname4(path), { recursive: true });
     writeFileSync2(path, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   } catch (error2) {
@@ -4839,7 +5314,10 @@ function selectSessionsToDelete(sessions, opts) {
       toDelete.push(s.id);
     }
   }
-  return toDelete;
+  const activityById = new Map(sessions.map((session) => [session.id, session.lastActivityMs]));
+  return toDelete.sort(
+    (a, b) => (activityById.get(a) ?? -Infinity) - (activityById.get(b) ?? -Infinity)
+  );
 }
 var DEFAULT_INTERVAL = "1h";
 function resolve(flag, envValue, fallback) {
@@ -4899,13 +5377,13 @@ function resolveSessionCleanupConfig(flags, env = process.env) {
 }
 
 // src/lib/opencode/session-db-size.ts
-import { statSync as statSync3 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 var LARGE_DB_THRESHOLD_BYTES = 268435456;
 function statSessionDbBytes(homeDir) {
   const dbPath = join6(homeDir, ".local", "share", "opencode", "opencode.db");
   try {
-    return statSync3(dbPath).size;
+    return statSync4(dbPath).size;
   } catch (err) {
     const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
     if (!isMissingFile) {
@@ -4931,12 +5409,12 @@ function buildSessionStoreSizeWarning(input) {
 }
 
 // src/lib/opencode/log-tail.ts
-import { statSync as statSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { statSync as statSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import { join as join7 } from "node:path";
 import { open as open2, stat } from "node:fs/promises";
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
-function resolveOpenCodeLogPath(homeDir = homedir4(), env = process.env) {
+function resolveOpenCodeLogPath(homeDir = homedir5(), env = process.env) {
   const dataDir = env.XDG_DATA_HOME || join7(homeDir, ".local", "share");
   return join7(dataDir, "opencode", "log", "opencode.log");
 }
@@ -4954,7 +5432,7 @@ function tailOpenCodeLogFile(logPath, onChunk, opts = {}) {
   let inode = null;
   let baselineReady = true;
   try {
-    const initial = statSync4(logPath);
+    const initial = statSync5(logPath);
     offset = initial.size;
     inode = initial.ino;
   } catch (error2) {
@@ -4980,156 +5458,37 @@ function tailOpenCodeLogFile(logPath, onChunk, opts = {}) {
         offset = current.size;
         inode = current.ino;
         baselineReady = true;
-        return;
-      }
-      if (inode !== null && current.ino !== inode || current.size < offset) {
-        offset = 0;
-      }
-      inode = current.ino;
-      if (current.size === offset) return;
-      const length = current.size - offset;
-      const fh = await open2(logPath, "r");
-      try {
-        const buf = Buffer.alloc(length);
-        const { bytesRead } = await fh.read(buf, 0, length, offset);
-        offset += bytesRead;
-        if (bytesRead > 0) onChunk(buf.subarray(0, bytesRead));
-      } finally {
-        await fh.close();
-      }
-    } catch (error2) {
-      if (!isEnoent(error2)) reportFailure("poll", logPath, error2);
-    } finally {
-      polling = false;
-    }
-  };
-  const interval = setInterval(() => void poll(), pollIntervalMs);
-  void poll();
-  return {
-    stop: () => {
-      stopped = true;
-      clearInterval(interval);
-    }
-  };
-}
-
-// src/lib/opencode/session-db-reclaim.ts
-import { statSync as statSync5, statfsSync } from "node:fs";
-import { dirname as dirname4 } from "node:path";
-function errorMessage(error2) {
-  if (!(error2 instanceof Error)) return String(error2);
-  return error2.cause instanceof Error ? error2.cause.message : error2.message;
-}
-function insufficientSpaceReason(dbPath, requiredBytes) {
-  try {
-    const fsStats = statfsSync(dirname4(dbPath));
-    const availableBytes = fsStats.bavail * fsStats.bsize;
-    if (availableBytes < requiredBytes) {
-      return `only ${availableBytes} bytes free, need ${requiredBytes} for a second copy`;
-    }
-    return null;
-  } catch (err) {
-    return `could not check free space (${err instanceof Error ? err.message : String(err)}); refusing to guess`;
-  }
-}
-function readLogicalBytes(db) {
-  const pageCount = db.prepare("PRAGMA page_count").get().page_count;
-  const pageSize = db.prepare("PRAGMA page_size").get().page_size;
-  return pageCount * pageSize;
-}
-function readCheckpointResult(db) {
-  const row = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
-  return { busy: row.busy !== 0, log: row.log, checkpointed: row.checkpointed };
-}
-async function probeReclaimAvailability(input) {
-  const { dbPath, requiredBytes } = input;
-  let sqlite;
-  try {
-    sqlite = await import("node:sqlite");
-  } catch (err) {
-    const detail = `Node ${process.version}: ${errorMessage(err)}`;
-    console.warn(`[probeReclaimAvailability] node:sqlite unavailable for ${dbPath}: ` + detail);
-    return { reason: "sqlite-unavailable", detail };
-  }
-  let autoVacuum = null;
-  try {
-    const db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
-    try {
-      db.exec("PRAGMA busy_timeout=5000");
-      autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
-    } finally {
-      db.close();
-    }
-  } catch (err) {
-    console.warn(
-      `[probeReclaimAvailability] could not read auto_vacuum mode for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (autoVacuum !== 0) return null;
-  return insufficientSpaceReason(dbPath, requiredBytes) !== null ? { reason: "insufficient-disk-space" } : null;
-}
-async function reclaimSessionDbSpace(input) {
-  const { dbPath, maxPages, allowFullVacuum = true } = input;
-  let sqlite;
-  try {
-    sqlite = await import("node:sqlite");
-  } catch (err) {
-    const detail = `Node ${process.version}: ${errorMessage(err)}`;
-    console.warn(
-      `[reclaimSessionDbSpace] node:sqlite unavailable (need Node >=22.5, >=22.13 unflagged) for ${dbPath}: ${detail}`
-    );
-    return { ok: false, skipped: "sqlite-unavailable", detail };
-  }
-  const { DatabaseSync } = sqlite;
-  let db;
-  try {
-    db = new DatabaseSync(dbPath);
-    db.exec("PRAGMA busy_timeout=5000");
-    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`
-        );
-        return { ok: false, skipped: "full-vacuum-blocked" };
+        return;
       }
-      const fileBytesForGuard = statSync5(dbPath).size;
-      const skipReason = insufficientSpaceReason(dbPath, fileBytesForGuard);
-      if (skipReason !== null) {
-        console.warn(
-          `[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: ${skipReason}`
-        );
-        return { ok: false, skipped: "insufficient-disk-space" };
+      if (inode !== null && current.ino !== inode || current.size < offset) {
+        offset = 0;
       }
-      const beforeBytes = readLogicalBytes(db);
-      db.exec("PRAGMA auto_vacuum=INCREMENTAL");
-      db.exec("VACUUM");
-      const afterBytes = readLogicalBytes(db);
-      const checkpoint = readCheckpointResult(db);
-      return { ok: true, mode: "convert", beforeBytes, afterBytes, checkpoint };
+      inode = current.ino;
+      if (current.size === offset) return;
+      const length = current.size - offset;
+      const fh = await open2(logPath, "r");
+      try {
+        const buf = Buffer.alloc(length);
+        const { bytesRead } = await fh.read(buf, 0, length, offset);
+        offset += bytesRead;
+        if (bytesRead > 0) onChunk(buf.subarray(0, bytesRead));
+      } finally {
+        await fh.close();
+      }
+    } catch (error2) {
+      if (!isEnoent(error2)) reportFailure("poll", logPath, error2);
+    } finally {
+      polling = false;
     }
-    if (autoVacuum === 2) {
-      const beforeBytes = readLogicalBytes(db);
-      const bound = Math.max(0, Math.trunc(maxPages));
-      db.exec(`PRAGMA incremental_vacuum(${bound})`);
-      const afterBytes = readLogicalBytes(db);
-      const checkpoint = readCheckpointResult(db);
-      return { ok: true, mode: "incremental", beforeBytes, afterBytes, checkpoint };
+  };
+  const interval = setInterval(() => void poll(), pollIntervalMs);
+  void poll();
+  return {
+    stop: () => {
+      stopped = true;
+      clearInterval(interval);
     }
-    console.warn(
-      `[reclaimSessionDbSpace] ${dbPath} has auto_vacuum=${autoVacuum} (neither NONE nor INCREMENTAL); nothing to reclaim`
-    );
-    return { ok: false, skipped: "auto-vacuum-not-applicable" };
-  } catch (err) {
-    console.error(`[reclaimSessionDbSpace] reclaim failed for ${dbPath}: ` + errorMessage(err));
-    return {
-      ok: false,
-      skipped: "reclaim-error",
-      detail: errorMessage(err)
-    };
-  } finally {
-    db?.close();
-  }
+  };
 }
 
 // src/lib/tunnel/connection.ts
@@ -5361,6 +5720,8 @@ var StreamForwarder = class {
           if (done) break;
           const chunk = Buffer.from(value);
           for (let i = 0; i < chunk.length; i += MAX_FRAME_BYTES) {
+            await stream.pausePromise;
+            if (ac.signal.aborted) break;
             const slice = chunk.subarray(i, i + MAX_FRAME_BYTES);
             if (this.binaryFramesSupported) {
               if (this.ws.readyState === WebSocket.OPEN) {
@@ -5403,6 +5764,7 @@ function classifyUpgradeRejection(headers) {
 }
 var MAX_RECONNECT_DELAY = 3e4;
 var BASE_RECONNECT_DELAY = 500;
+var RELAY_SILENCE_TIMEOUT_MS = 9e4;
 function getReconnectDelay(attempt) {
   const exponentialDelay = BASE_RECONNECT_DELAY * Math.pow(2, attempt);
   const jitter = Math.random() * 1e3;
@@ -5474,10 +5836,27 @@ function connectTunnel(options) {
       ws.close();
       reject(new Error("Connection timeout"));
     }, 3e4);
+    let relaySilenceTimeout;
+    let relaySilenceTimedOut = false;
+    const clearRelaySilenceTimeout = () => {
+      if (relaySilenceTimeout === void 0) return;
+      clearTimeout(relaySilenceTimeout);
+      relaySilenceTimeout = void 0;
+    };
+    const armRelaySilenceTimeout = () => {
+      clearRelaySilenceTimeout();
+      relaySilenceTimeout = setTimeout(() => {
+        relaySilenceTimeout = void 0;
+        relaySilenceTimedOut = true;
+        ws.terminate();
+      }, RELAY_SILENCE_TIMEOUT_MS);
+      relaySilenceTimeout.unref?.();
+    };
     let upgradeRejection = null;
     let upgradeRejectionReason = null;
     ws.on("unexpected-response", (_req, res) => {
       clearTimeout(connectionTimeout);
+      clearRelaySilenceTimeout();
       const reason = classifyUpgradeRejection(res.headers);
       upgradeRejectionReason = reason;
       const chunks = [];
@@ -5507,6 +5886,7 @@ function connectTunnel(options) {
       onInfo?.("WebSocket connection established");
     });
     ws.on("message", (data, isBinary) => {
+      if (relaySilenceTimeout !== void 0) armRelaySilenceTimeout();
       if (isBinary) {
         try {
           const frame = decodeBinaryBodyFrame(toUint8Array(data));
@@ -5540,6 +5920,7 @@ function connectTunnel(options) {
       switch (message.type) {
         case "connected": {
           clearTimeout(connectionTimeout);
+          armRelaySilenceTimeout();
           forwarder.setBinaryFramesSupported(message.binary_frames === true);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
@@ -5564,6 +5945,7 @@ function connectTunnel(options) {
     });
     ws.on("error", (error2) => {
       clearTimeout(connectionTimeout);
+      clearRelaySilenceTimeout();
       const detail = upgradeRejection ?? describeSocketError(error2, url);
       if (upgradeRejectionReason === "do_code_updated") {
         onWarning?.("Relay redeployed \u2014 reconnecting");
@@ -5575,7 +5957,8 @@ function connectTunnel(options) {
       );
     });
     ws.on("close", (code, reason) => {
-      const reasonStr = reason.toString() || upgradeRejection || (code === 1006 ? "abnormal closure" : "No reason provided");
+      clearRelaySilenceTimeout();
+      const reasonStr = (relaySilenceTimedOut ? "no relay heartbeat for 90s \u2014 reconnecting" : void 0) || reason.toString() || upgradeRejection || (code === 1006 ? "abnormal closure" : "No reason provided");
       forwarder.abortAll();
       onDisconnected?.(code, reasonStr);
     });
@@ -5583,9 +5966,10 @@ function connectTunnel(options) {
 }
 
 // src/lib/tunnel/runner-connection.ts
-var RunnerConnection = class {
+var RunnerConnection = class _RunnerConnection {
   opts;
   sleep;
+  now;
   connection = null;
   resolvedAgentId;
   /** True while a (re)connect loop is in flight. */
@@ -5594,10 +5978,17 @@ var RunnerConnection = class {
   reconnectPromise = null;
   /** 1-based count of the current reconnect attempt streak. */
   reconnectAttempt = 0;
+  generation = 0;
+  disconnectedAtMs = null;
+  static RELAY_RECONNECT_CLOSE_REASONS = /* @__PURE__ */ new Set([
+    "No pong received",
+    "Orphaned socket"
+  ]);
   constructor(opts) {
     this.opts = opts;
     this.resolvedAgentId = opts.agentId;
     this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.now = opts.now ?? Date.now;
   }
   get agentId() {
     return this.resolvedAgentId;
@@ -5633,14 +6024,24 @@ var RunnerConnection = class {
           port: this.opts.port,
           openCodePassword: this.opts.openCodePassword,
           onConnected: (agentId) => {
+            const attempt = this.reconnectAttempt + 1;
             this.reconnectAttempt = 0;
             this.reconnecting = false;
             this.resolvedAgentId = agentId;
-            events.onConnected(agentId, isReconnect);
+            this.generation++;
+            const downtimeMs = this.disconnectedAtMs === null ? null : this.now() - this.disconnectedAtMs;
+            this.disconnectedAtMs = null;
+            events.onConnected(agentId, isReconnect, {
+              generation: this.generation,
+              attempt,
+              downtimeMs
+            });
           },
           onDisconnected: (code, reason) => {
-            events.onDisconnected(code, reason);
-            if (this.opts.isRunning() && code !== 1e3 && !this.reconnecting) {
+            this.disconnectedAtMs = this.now();
+            events.onDisconnected(code, reason, { generation: this.generation });
+            const relayRequestedReconnect = code === 1e3 && _RunnerConnection.RELAY_RECONNECT_CLOSE_REASONS.has(reason);
+            if (this.opts.isRunning() && (code !== 1e3 || relayRequestedReconnect) && !this.reconnecting) {
               this.reconnectPromise = this.connectWithRetry(true).catch((err) => {
                 events.onError?.(`Reconnection failed: ${err.message}`);
               });
@@ -5979,8 +6380,85 @@ function createResourceUsageCollector(homeDir) {
   };
 }
 
+// src/lib/resource-usage-low-disk.ts
+var RUNNER_DISK_ALERT_ENTRY_FREE_BYTES = 4 * 1024 ** 3;
+var RUNNER_DISK_ALERT_ENTRY_FREE_FRACTION = 0.25;
+var RUNNER_DISK_ALERT_VERY_LOW_FREE_BYTES = 1 * 1024 ** 3;
+var RUNNER_DISK_ALERT_CRITICAL_FREE_BYTES = 256 * 1024 ** 2;
+var RUNNER_DISK_ALERT_RECOVERY_FREE_BYTES = 6 * 1024 ** 3;
+var RUNNER_DISK_ALERT_RECOVERY_FREE_FRACTION = 0.375;
+var LOCAL_DISK_WARNING_REASSERTION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var BAND_RANK = {
+  low: 1,
+  very_low: 2,
+  critical: 3
+};
+function bandFor(freeBytes) {
+  if (freeBytes < RUNNER_DISK_ALERT_CRITICAL_FREE_BYTES) return "critical";
+  if (freeBytes < RUNNER_DISK_ALERT_VERY_LOW_FREE_BYTES) return "very_low";
+  return "low";
+}
+function formatBytes(bytes) {
+  if (bytes === null) return "unavailable";
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  const unitIndex = Math.min(Math.floor(Math.log2(Math.max(bytes, 1)) / 10), units.length - 1);
+  const value = bytes / 1024 ** unitIndex;
+  const digits = unitIndex === 0 || value >= 100 ? 0 : value >= 10 ? 1 : 2;
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+}
+function warningMessage(band, diskFreeBytes, diskTotalBytes, opencodeDbBytes) {
+  return `Low disk warning (${band} severity): ${formatBytes(diskFreeBytes)} free of ${formatBytes(diskTotalBytes)}; opencode.db is ${formatBytes(opencodeDbBytes)}. Clear space on the machine running this runner before session history or new work can no longer be saved.`;
+}
+function evaluateLowDiskWarning(input) {
+  const { diskFreeBytes, diskTotalBytes, opencodeDbBytes, nowMs, state } = input;
+  if (diskFreeBytes === null || diskTotalBytes === null || diskTotalBytes <= 0 || diskFreeBytes >= diskTotalBytes) {
+    return { warning: null, state };
+  }
+  const recovered = diskFreeBytes >= RUNNER_DISK_ALERT_RECOVERY_FREE_BYTES || diskFreeBytes >= diskTotalBytes * RUNNER_DISK_ALERT_RECOVERY_FREE_FRACTION;
+  if (recovered) {
+    return { warning: null, state: { worstBand: null, warnedAtMs: null } };
+  }
+  const low = diskFreeBytes < RUNNER_DISK_ALERT_ENTRY_FREE_BYTES && diskFreeBytes < diskTotalBytes * RUNNER_DISK_ALERT_ENTRY_FREE_FRACTION;
+  if (!low) return { warning: null, state };
+  const currentBand = bandFor(diskFreeBytes);
+  const currentRank = BAND_RANK[currentBand];
+  const previousRank = state.worstBand === null ? 0 : BAND_RANK[state.worstBand];
+  const worse = currentRank > previousRank;
+  const reassert = state.warnedAtMs !== null && nowMs - state.warnedAtMs >= LOCAL_DISK_WARNING_REASSERTION_INTERVAL_MS;
+  const nextState = {
+    worstBand: worse ? currentBand : state.worstBand ?? currentBand,
+    warnedAtMs: worse || state.warnedAtMs === null || reassert ? nowMs : state.warnedAtMs
+  };
+  return {
+    warning: worse || state.warnedAtMs === null || reassert ? warningMessage(nextState.worstBand, diskFreeBytes, diskTotalBytes, opencodeDbBytes) : null,
+    state: nextState
+  };
+}
+
+// src/lib/opencode/session-store-health.ts
+var SESSION_STORE_HEALTH_STALENESS_MS = 5 * 6e4;
+function createSessionStoreHealth(options = {}) {
+  const now = options.now ?? (() => Date.now());
+  const stalenessMs = Math.max(0, options.stalenessMs ?? SESSION_STORE_HEALTH_STALENESS_MS);
+  let lastUnwritableAt = null;
+  let lastWritableAt = null;
+  return {
+    observeUnwritable: () => {
+      lastUnwritableAt = now();
+    },
+    observeWritable: () => {
+      lastWritableAt = now();
+    },
+    isUnwritable: () => {
+      if (lastUnwritableAt === null) return false;
+      if (lastWritableAt !== null && lastWritableAt >= lastUnwritableAt) return false;
+      return now() - lastUnwritableAt < stalenessMs;
+    }
+  };
+}
+
 // src/lib/channels/driver.ts
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 
 // src/lib/runner-file-sync.ts
 import { join as join9 } from "node:path";
@@ -6437,6 +6915,7 @@ var SESSION_ERROR_BUFFER_TTL_MS = SESSION_ERROR_STREAM_HEALTHY_MS;
 var MAX_BUFFERED_SESSION_ERRORS = 256;
 var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
+var DRIVER_SESSION_ENUMERATION_LIMIT = 20;
 var DEFAULT_STUCK_QUEUED_MS = 6e4;
 var HEARTBEAT_MS = 6e4;
 var ALIVE_WITHHELD_THRESHOLD_MS = 3 * HEARTBEAT_MS;
@@ -6498,6 +6977,7 @@ var ChannelDriver = class _ChannelDriver {
   maxActiveSessions;
   watcherStallMs;
   wedgeWarningIntervalMs;
+  sessionStoreHealth;
   openCodeClient;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
@@ -6863,10 +7343,11 @@ var ChannelDriver = class _ChannelDriver {
     this.stuckQueuedMs = config.stuckQueuedMs ?? DEFAULT_STUCK_QUEUED_MS;
     this.now = config.now ?? (() => Date.now());
     this.fileSyncDirectories = config.fileSyncDirectories ?? [];
-    this.homeDir = config.homeDir ?? homedir5();
+    this.homeDir = config.homeDir ?? homedir6();
     this.maxActiveSessions = config.maxActiveSessions;
     this.watcherStallMs = config.watcherStallMs ?? WATCHER_STALL_MS;
     this.wedgeWarningIntervalMs = config.wedgeWarningIntervalMs ?? WEDGE_WARNING_INTERVAL_MS;
+    this.sessionStoreHealth = config.sessionStoreHealth;
   }
   get isV2() {
     return this.openCodeClient.version === "v2";
@@ -6882,7 +7363,9 @@ var ChannelDriver = class _ChannelDriver {
     return fetchSessionMessages(this.port, sessionId, this.openCodeClient);
   }
   async listSessions() {
-    return this.isV2 ? listV2Sessions(this.openCodeClient) : listSessions(this.port, this.openCodeClient);
+    return this.isV2 ? listV2Sessions(this.openCodeClient) : listSessions(this.port, this.openCodeClient, {
+      limit: DRIVER_SESSION_ENUMERATION_LIMIT
+    });
   }
   async sessionExists(sessionId) {
     return this.isV2 ? v2SessionExists(this.openCodeClient, sessionId) : sessionExists(this.port, sessionId, this.openCodeClient);
@@ -8336,8 +8819,10 @@ var ChannelDriver = class _ChannelDriver {
       b2LastDescendantCheckMs: 0,
       b2RootOngoingHeldLogged: false,
       b2AbandonedSignalled: false,
+      b2AbandonedWithoutAnswer: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
     const buffered = this.bufferedSessionErrors.get(sessionId);
@@ -8454,8 +8939,10 @@ var ChannelDriver = class _ChannelDriver {
       b2LastDescendantCheckMs: 0,
       b2RootOngoingHeldLogged: false,
       b2AbandonedSignalled: false,
+      b2AbandonedWithoutAnswer: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
   }
@@ -8869,6 +9356,10 @@ var ChannelDriver = class _ChannelDriver {
     if (state === "running" || state === "done" || state === "failed") {
       this.neverStartedAttempts.delete(id);
     }
+    if (inFlight.sessionStoreFailurePending) {
+      await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+      return;
+    }
     if (inFlight.neverStartedResolved) {
       if (state === "running" || state === "done" || state === "failed") {
         inFlight.neverStartedResolved = false;
@@ -9028,10 +9519,22 @@ var ChannelDriver = class _ChannelDriver {
         inFlight.b2LastDescendantCheckMs = 0;
         inFlight.b2RootOngoingHeldLogged = false;
         inFlight.b2AbandonedSignalled = false;
+        inFlight.b2AbandonedWithoutAnswer = false;
       }
     } else {
       if (inFlight.b2AbandonedSignalled) {
-        await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+        if (inFlight.b2AbandonedWithoutAnswer) {
+          const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
+          await this.settleMessageAbandonedWithoutAnswer(
+            sessionId,
+            watcher,
+            inFlight,
+            messages,
+            reply?.info?.finish ?? reply?.finish
+          );
+        } else {
+          await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+        }
         return;
       }
       if (inFlight.b2PinnedSinceMs === 0) inFlight.b2PinnedSinceMs = this.now();
@@ -9048,17 +9551,47 @@ var ChannelDriver = class _ChannelDriver {
           descendantOngoing,
           rootOngoing
         })) {
+          if (this.sessionStoreHealth?.isUnwritable()) {
+            inFlight.sessionStoreFailurePending = true;
+            void this.postSignal(conv.id, id, "b2_abandoned_resolved", {
+              watched_for_ms: pinnedForMs,
+              run_state: "failed",
+              opencode_message_id: inFlight.opencodeMessageId
+            });
+            await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+            return;
+          }
           inFlight.b2AbandonedSignalled = true;
+          const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
+          const finish = reply?.info?.finish ?? reply?.finish;
+          if (extractReplyTextForMessage(messages, inFlight.opencodeMessageId) === null) {
+            inFlight.b2AbandonedWithoutAnswer = true;
+            void this.postSignal(conv.id, id, "b2_abandoned_resolved", {
+              watched_for_ms: pinnedForMs,
+              run_state: "failed",
+              finish,
+              ...rootOngoing != null ? { root_ongoing: rootOngoing } : {},
+              ...descendantOngoing != null ? { descendant_ongoing: descendantOngoing } : {},
+              opencode_message_id: inFlight.opencodeMessageId
+            });
+            await this.settleMessageAbandonedWithoutAnswer(
+              sessionId,
+              watcher,
+              inFlight,
+              messages,
+              finish
+            );
+            return;
+          }
           this.log({
             level: "warn",
             message: `Message ${id.slice(0, 8)} b2-pinned for ${Math.round(pinnedForMs / 1e3)}s with no ongoing descendant sub-agent session (status-map confirmed) \u2014 treating the delegated/tool turn as abandoned, resolving done`,
             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,
-            finish: reply?.info?.finish ?? reply?.finish,
+            finish,
             ...rootOngoing != null ? { root_ongoing: rootOngoing } : {},
             ...descendantOngoing != null ? { descendant_ongoing: descendantOngoing } : {},
             opencode_message_id: inFlight.opencodeMessageId
@@ -9106,6 +9639,16 @@ var ChannelDriver = class _ChannelDriver {
         maxPinnedMs: AMBIGUOUS_FINISH_MAX_PINNED_MS,
         sessionOngoing: ongoing
       })) {
+        if (this.sessionStoreHealth?.isUnwritable()) {
+          inFlight.sessionStoreFailurePending = true;
+          void this.postSignal(conv.id, id, "ambiguous_finish_resolved", {
+            watched_for_ms: pinnedForMs,
+            run_state: "failed",
+            opencode_message_id: inFlight.opencodeMessageId
+          });
+          await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+          return;
+        }
         inFlight.ambiguousResolved = true;
         this.log({
           level: "warn",
@@ -9330,6 +9873,74 @@ var ChannelDriver = class _ChannelDriver {
     }
     this.removeInFlight(watcher, inFlight.evidentMessageId);
   }
+  /** Report a confirmed b2 abandonment that produced no answer text. */
+  async settleMessageAbandonedWithoutAnswer(sessionId, watcher, inFlight, messages, finish) {
+    const conv = watcher.conv;
+    const error2 = `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.`;
+    this.anchorDeliveryDeadline(inFlight);
+    this.log({
+      level: "warn",
+      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} was abandoned without an answer \u2014 ${error2}`,
+      conversation_id: conv.id,
+      message_id: inFlight.evidentMessageId
+    });
+    const usage = messageUsage(messages, inFlight.opencodeMessageId);
+    const usageAgentName = this.usageAgentName(messages ?? [], inFlight.opencodeMessageId);
+    const subagentInvocations = await this.resolveSubagentInvocations(
+      messages,
+      inFlight.opencodeMessageId,
+      inFlight.evidentMessageId
+    );
+    try {
+      await this.markFailed(
+        conv.id,
+        inFlight.evidentMessageId,
+        sessionId,
+        error2,
+        usage,
+        void 0,
+        usageAgentName,
+        subagentInvocations
+      );
+    } catch (err) {
+      if (err instanceof ChannelAuthError) throw err;
+      if (err instanceof ChannelTerminalError) {
+        this.log({
+          level: "warn",
+          message: `Failed to report abandoned no-answer message ${inFlight.evidentMessageId.slice(0, 8)} as failed (terminal HTTP ${err.status}) \u2014 leaving it for the cron safety net: ${err.message}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        this.removeInFlight(watcher, inFlight.evidentMessageId);
+        return;
+      }
+      if (this.now() >= inFlight.deadline) {
+        this.log({
+          level: "warn",
+          message: `Failed to report abandoned no-answer message ${inFlight.evidentMessageId.slice(0, 8)} as failed within the delivery window \u2014 leaving it for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        this.removeInFlight(watcher, inFlight.evidentMessageId);
+        return;
+      }
+      this.log({
+        level: "warn",
+        message: `Failed to report abandoned no-answer message ${inFlight.evidentMessageId.slice(0, 8)} as failed (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      return;
+    }
+    inFlight.done = true;
+    await this.reportSubagentAuthFailures(
+      watcher.conv.id,
+      inFlight.opencodeMessageId,
+      inFlight.evidentMessageId,
+      messages
+    );
+    this.removeInFlight(watcher, inFlight.evidentMessageId);
+  }
   /**
    * Report a queued message as failed after the never-started bound. The accepted
    * OpenCode copy is not cancelled, so the local fence remains on unsuccessful
@@ -9385,6 +9996,66 @@ var ChannelDriver = class _ChannelDriver {
     this.neverStartedAttempts.delete(inFlight.evidentMessageId);
     this.removeInFlight(watcher, inFlight.evidentMessageId);
   }
+  /**
+   * Report a turn as failed when the session database was observed unwritable.
+   * The queue row is retained as failed, while the OpenCode copy stays fenced so
+   * a later drain cannot blindly prompt the same turn again.
+   */
+  async settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight) {
+    const conv = watcher.conv;
+    const error2 = "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.";
+    this.log({
+      level: "error",
+      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} was not resolved as done: ${error2}`,
+      conversation_id: conv.id,
+      message_id: inFlight.evidentMessageId
+    });
+    this.anchorDeliveryDeadline(inFlight);
+    try {
+      await this.markFailed(conv.id, inFlight.evidentMessageId, sessionId, error2);
+    } catch (err) {
+      if (err instanceof ChannelAuthError) throw err;
+      if (err instanceof ChannelTerminalError) {
+        this.log({
+          level: "warn",
+          message: `Failed to report session-store failure for message ${inFlight.evidentMessageId.slice(0, 8)} as failed (terminal HTTP ${err.status}) \u2014 keeping its OpenCode copy fenced: ${err.message}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        this.recordReleasedOpencodeId(
+          inFlight.evidentMessageId,
+          sessionId,
+          inFlight.opencodeMessageId
+        );
+        this.removeInFlight(watcher, inFlight.evidentMessageId);
+        return;
+      }
+      if (this.now() >= inFlight.deadline) {
+        this.log({
+          level: "warn",
+          message: `Failed to report session-store failure for message ${inFlight.evidentMessageId.slice(0, 8)} as failed within the delivery window \u2014 keeping its OpenCode copy fenced: ${err instanceof Error ? err.message : String(err)}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        this.recordReleasedOpencodeId(
+          inFlight.evidentMessageId,
+          sessionId,
+          inFlight.opencodeMessageId
+        );
+        this.removeInFlight(watcher, inFlight.evidentMessageId);
+        return;
+      }
+      this.log({
+        level: "warn",
+        message: `Failed to report session-store failure for message ${inFlight.evidentMessageId.slice(0, 8)} as failed (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      return;
+    }
+    inFlight.done = true;
+    this.removeInFlight(watcher, inFlight.evidentMessageId);
+  }
   // Restart recovery: re-adopt `processing` messages (ADR-0046, WI-3/4/5)
   /**
    * Re-adopt this agent's `processing` messages on drain (ADR-0046 Decision §1).
@@ -12116,6 +12787,7 @@ function createCredentialSync({
 
 // src/commands/run.ts
 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 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;
@@ -12271,7 +12943,13 @@ 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, metadata: entry.metadata },
+    {
+      level,
+      message: entry.message,
+      error: entry.error,
+      metadata: entry.metadata,
+      ...entry.source ? { source: entry.source } : {}
+    },
     { agentId: state.agentId, authHeader: state.authHeader }
   );
   const fullEntry = {
@@ -12293,7 +12971,7 @@ function logActivity(state, entry) {
 }
 function reportSessionDbRecovery(state) {
   try {
-    const report = drainSessionDbRecoveryReport({ homeDir: homedir6(), env: process.env });
+    const report = drainSessionDbRecoveryReport({ homeDir: homedir7(), 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");
@@ -12328,7 +13006,9 @@ function displayStatus(state) {
   const opencode = state.opencodeConnected ? chalk7.green(`opencode: :${state.port}`) : chalk7.red(`opencode: :${state.port} (down)`);
   const messages = state.messageCount > 0 ? chalk7.dim(` \xB7 ${state.messageCount} processed`) : "";
   const last = state.activityLog[state.activityLog.length - 1];
-  const detail = last ? chalk7.dim(` \xB7 ${last.type === "error" ? last.error ?? "" : last.message ?? ""}`) : "";
+  const detail = last ? chalk7.dim(
+    ` \xB7 ${last.timestamp.toISOString()} ${last.type === "error" ? last.error ?? "" : last.message ?? ""}`
+  ) : "";
   const agent = state.agentName ?? state.agentId;
   console.log(
     `${chalk7.bold("Evident")} ${chalk7.dim(agent)}  ${tunnel}  ${opencode}${messages}${detail}`
@@ -12347,7 +13027,7 @@ function reportOpenCodeV2CredentialImport(state, result) {
     logActivity(state, {
       type: "info",
       level: "warn",
-      message: `OpenCode V2 saved login(s) for ${integrationIds} on this machine, but OpenCode V2 will not use them. See #2251 for importing existing logins.`
+      message: `OpenCode V2 saved login(s) for ${integrationIds} on this machine, but OpenCode V2 will not use them. Connect the provider again from the runner's page in Evident; no shell on this machine is needed.`
     });
   }
   if (result.imported.length === 0 && result.unsupported.length === 0 && result.failed.length === 0) {
@@ -12372,7 +13052,7 @@ async function importOpenCodeV2CredentialsForState(state) {
   }
   const result = await importOpenCodeV2Credentials({
     request: client.request,
-    homeDir: homedir6(),
+    homeDir: homedir7(),
     directory,
     guard: state.opencodeV2CredentialImportGuard,
     log: (message, level = "info") => logActivity(state, { type: "info", level, message })
@@ -12580,9 +13260,9 @@ async function driveChannels(state, driver) {
   }
 }
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
-var SESSION_DB_RECLAIM_MAX_PAGES = 2e4;
+var SESSION_CLEANUP_MAX_DELETES_PER_SWEEP = 100;
 function shouldWarnForReclaimSkip(reason) {
-  if (reason !== "sqlite-unavailable") return false;
+  if (reason !== "sqlite-unavailable" && reason !== "disk-exhaustion") return false;
   const version2 = /^v(\d+)\.(\d+)\.(\d+)$/.exec(process.version);
   if (!version2) return false;
   const major = Number(version2[1]);
@@ -12591,7 +13271,14 @@ function shouldWarnForReclaimSkip(reason) {
   return major > 22 || major === 22 && (minor > 13 || minor === 13 && patch >= 0);
 }
 function sessionDbPath() {
-  return join11(homedir6(), ".local", "share", "opencode", "opencode.db");
+  return join11(homedir7(), ".local", "share", "opencode", "opencode.db");
+}
+function logSessionCleanupActivity(state, phase, entry) {
+  logActivity(state, {
+    ...entry,
+    source: "cli.session-cleanup",
+    metadata: { ...entry.metadata, phase }
+  });
 }
 function logSessionDbProvenanceMismatch(state, provenance, currentVersion, preBootMigrationCount) {
   const record = {
@@ -12632,69 +13319,136 @@ function logSessionDbProvenanceMismatch(state, provenance, currentVersion, preBo
 async function runSweep(state, driver, config) {
   const mode = `age=${config.maxAgeMs ?? "\u2014"} count=${config.maxCount ?? "\u2014"}`;
   try {
-    const sessions = await listSessions(state.port, state.opencodeClient ?? void 0);
-    if (sessions === null) {
+    const enumeration = await listAllSessions(state.port, state.opencodeClient ?? void 0);
+    const sessions = enumeration.sessions;
+    const enumerationReason = sessions === null ? enumeration.reason : null;
+    if (enumerationReason !== null) {
       logActivity(state, {
         type: "info",
-        message: `Session cleanup: could not list sessions (opencode unreachable); skipping this sweep (${mode})`
+        level: "warn",
+        message: `Session cleanup: could not enumerate sessions (${enumerationReason}); skipping deletes and continuing with space reclaim (${mode})`
       });
-      return;
     }
-    const toDelete = selectSessionsToDelete(
-      sessions.map((s) => ({ id: s.id, lastActivityMs: sessionLastActivityMs(s) })),
-      {
-        maxAgeMs: config.maxAgeMs,
-        maxCount: config.maxCount,
-        nowMs: Date.now(),
-        protectedIds: driver.protectedSessionIds()
-      }
-    );
-    const protectedNow = driver.protectedSessionIds();
     let deleted = 0;
     let failed = 0;
+    let failed4xx = 0;
+    let failed5xx = 0;
+    let failedOtherStatus = 0;
+    let failedThrew = 0;
     let skippedNewlyActive = 0;
-    for (const id of toDelete) {
-      if (protectedNow.has(id)) {
-        skippedNewlyActive++;
-        logActivity(state, {
-          type: "info",
-          message: `Session cleanup: skipping ${id} \u2014 became active/bound after selection (${mode})`
-        });
-        continue;
+    let remaining = 0;
+    let protectedNow = driver.protectedSessionIds();
+    if (sessions !== null) {
+      const toDelete = selectSessionsToDelete(
+        sessions.map((s) => ({ id: s.id, lastActivityMs: sessionLastActivityMs(s) })),
+        {
+          maxAgeMs: config.maxAgeMs,
+          maxCount: config.maxCount,
+          nowMs: Date.now(),
+          protectedIds: protectedNow
+        }
+      );
+      const deleteCandidates = toDelete.slice(0, SESSION_CLEANUP_MAX_DELETES_PER_SWEEP);
+      remaining = toDelete.length - deleteCandidates.length;
+      protectedNow = driver.protectedSessionIds();
+      for (const id of deleteCandidates) {
+        if (protectedNow.has(id)) {
+          skippedNewlyActive++;
+          logActivity(state, {
+            type: "info",
+            message: `Session cleanup: skipping ${id} \u2014 became active/bound after selection (${mode})`
+          });
+          continue;
+        }
+        const outcome = await deleteSession(state.port, id, state.opencodeClient ?? void 0);
+        if (outcome.ok) {
+          deleted++;
+        } else if (outcome.status === "threw") {
+          failed++;
+          failedThrew++;
+        } else {
+          failed++;
+          const statusClass = Math.floor(outcome.status / 100);
+          if (statusClass === 4) failed4xx++;
+          else if (statusClass === 5) failed5xx++;
+          else failedOtherStatus++;
+        }
       }
-      if (await deleteSession(state.port, id, state.opencodeClient ?? void 0)) deleted++;
-      else failed++;
+      const failedNote = failed > 0 ? `, failed ${failed}` : "";
+      const skippedNote = skippedNewlyActive > 0 ? `, skipped ${skippedNewlyActive} newly-active` : "";
+      const remainingNote = remaining > 0 ? `, remaining ${remaining}` : "";
+      logActivity(state, {
+        type: "info",
+        message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote}${remainingNote} (${mode})`
+      });
     }
-    const failedNote = failed > 0 ? `, failed ${failed}` : "";
-    const skippedNote = skippedNewlyActive > 0 ? `, skipped ${skippedNewlyActive} newly-active` : "";
-    logActivity(state, {
-      type: "info",
-      message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote} (${mode})`
-    });
+    const sessionMetadata = {
+      sessions_inspected: sessions?.length ?? null,
+      sessions_deleted: deleted,
+      sessions_failed: failed,
+      sessions_failed_4xx: failed4xx,
+      sessions_failed_5xx: failed5xx,
+      sessions_failed_other: failedOtherStatus,
+      sessions_failed_threw: failedThrew,
+      sessions_skipped_active: skippedNewlyActive,
+      sessions_remaining: remaining,
+      ...enumerationReason !== null ? { session_enumeration_reason: enumerationReason } : {}
+    };
     const reclaimResult = await reclaimSessionDbSpace({
       dbPath: sessionDbPath(),
-      maxPages: SESSION_DB_RECLAIM_MAX_PAGES,
+      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
     });
     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)` : "";
-      logActivity(state, {
+      logSessionCleanupActivity(state, "sweep", {
         type: "info",
-        message: `Session cleanup: reclaimed session-db space (${reclaimResult.mode}): ${beforeMib} MiB -> ${afterMib} MiB${checkpointNote}`
+        message: `Session cleanup: reclaimed session-db space (${reclaimResult.mode}): ${beforeMib} MiB -> ${afterMib} MiB (stopped by ${reclaimResult.stoppedBy}; freelist ${reclaimResult.freelistBefore} -> ${reclaimResult.freelistAfter} pages)` + checkpointNote,
+        metadata: {
+          outcome: "reclaimed",
+          mode: reclaimResult.mode,
+          before_bytes: reclaimResult.beforeBytes,
+          after_bytes: reclaimResult.afterBytes,
+          checkpoint_busy: reclaimResult.checkpoint.busy,
+          wal_frames_pending: reclaimResult.checkpoint.log,
+          stopped_by: reclaimResult.stoppedBy,
+          freelist_before: reclaimResult.freelistBefore,
+          freelist_after: reclaimResult.freelistAfter,
+          pages_reclaimed: reclaimResult.pagesReclaimed,
+          reclaim_elapsed_ms: reclaimResult.elapsedMs,
+          ...sessionMetadata
+        }
       });
     } else {
-      logActivity(state, {
+      if (reclaimResult.skipped === "disk-exhaustion") {
+        state.sessionStoreHealth.observeUnwritable();
+      }
+      logSessionCleanupActivity(state, "sweep", {
         type: "info",
-        message: `Session cleanup: session-db space reclaim skipped (${reclaimResult.skipped})` + (reclaimResult.detail ? `: ${reclaimResult.detail}` : "")
+        level: reclaimResult.skipped === "reclaim-error" || reclaimResult.skipped === "disk-exhaustion" || reclaimResult.skipped === "insufficient-disk-space" ? "warn" : "info",
+        message: `Session cleanup: session-db space reclaim skipped (${reclaimResult.skipped})` + (reclaimResult.detail ? `: ${reclaimResult.detail}` : ""),
+        metadata: {
+          outcome: "reclaim-skipped",
+          reason: reclaimResult.skipped,
+          ...reclaimResult.detail !== void 0 ? { detail: reclaimResult.detail } : {},
+          ...sessionMetadata
+        }
       });
     }
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
-    logActivity(state, {
+    logSessionCleanupActivity(state, "sweep", {
       type: "error",
-      error: `Session cleanup sweep failed (non-fatal, ${mode}): ${message}`
+      error: `Session cleanup sweep failed (non-fatal, ${mode}): ${message}`,
+      metadata: {
+        outcome: "sweep-failed",
+        reason: "sweep-error"
+      }
     });
   }
 }
@@ -12710,14 +13464,19 @@ function scheduleSessionCleanup(state, driver, options) {
   for (const warning2 of config.warnings) {
     logActivity(state, { type: "info", level: "warn", message: `Session cleanup: ${warning2}` });
   }
-  const dbBytes = statSessionDbBytes(homedir6());
+  const dbBytes = statSessionDbBytes(homedir7());
   void (async () => {
     const reclaimAvailability = dbBytes !== null && config.enabled ? await probeReclaimAvailability({ dbPath: sessionDbPath(), requiredBytes: dbBytes }) : null;
     if (reclaimAvailability !== null) {
-      logActivity(state, {
+      logSessionCleanupActivity(state, "startup", {
         type: "info",
         level: shouldWarnForReclaimSkip(reclaimAvailability.reason) ? "warn" : "info",
-        message: `Session cleanup: reclaim preflight skipped (${reclaimAvailability.reason})` + (reclaimAvailability.detail ? `: ${reclaimAvailability.detail}` : "")
+        message: `Session cleanup: reclaim preflight skipped (${reclaimAvailability.reason})` + (reclaimAvailability.detail ? `: ${reclaimAvailability.detail}` : ""),
+        metadata: {
+          outcome: "preflight-skipped",
+          reason: reclaimAvailability.reason,
+          ...reclaimAvailability.detail !== void 0 ? { detail: reclaimAvailability.detail } : {}
+        }
       });
     }
     const sizeWarning = buildSessionStoreSizeWarning({
@@ -12734,9 +13493,15 @@ function scheduleSessionCleanup(state, driver, options) {
     );
   });
   if (!config.enabled) return;
-  logActivity(state, {
+  logSessionCleanupActivity(state, "startup", {
     type: "info",
-    message: `Session cleanup enabled (age=${config.maxAgeMs ?? "\u2014"}, count=${config.maxCount ?? "\u2014"}, interval=${config.intervalMs}ms)`
+    message: `Session cleanup enabled (age=${config.maxAgeMs ?? "\u2014"}, count=${config.maxCount ?? "\u2014"}, interval=${config.intervalMs}ms)`,
+    metadata: {
+      outcome: "armed",
+      interval_ms: config.intervalMs,
+      max_age_ms: config.maxAgeMs ?? null,
+      max_count: config.maxCount ?? null
+    }
   });
   const interval = setInterval(() => void runSweep(state, driver, config), config.intervalMs);
   const firstSweep = setTimeout(
@@ -12915,7 +13680,7 @@ function scheduleResourceUsageReporting(state, options) {
     });
     return;
   }
-  const { collect, stop } = createResourceUsageCollector(homedir6());
+  const { collect, stop } = createResourceUsageCollector(homedir7());
   state.stopResourceUsageSampling = stop;
   let consecutiveFailures = 0;
   const tick = async () => {
@@ -12928,6 +13693,19 @@ function scheduleResourceUsageReporting(state, options) {
           message: `Resource usage collection: ${warning2}`
         });
       }
+      const lowDiskDecision = evaluateLowDiskWarning({
+        ...usage,
+        nowMs: Date.now(),
+        state: state.lowDiskWarningState
+      });
+      state.lowDiskWarningState = lowDiskDecision.state;
+      if (lowDiskDecision.warning !== null) {
+        logActivity(state, {
+          type: "info",
+          level: "warn",
+          message: lowDiskDecision.warning
+        });
+      }
       const result = await reportResourceUsage(state.agentId, state.authHeader, usage);
       if (result.ok) {
         if (consecutiveFailures > 0) {
@@ -13140,7 +13918,7 @@ async function run(options) {
   let fileSyncDirectories;
   try {
     logLevel = resolveLogLevel(options);
-    fileSyncDirectories = resolveFileSyncDirectories(options.enableFileSyncTo, homedir6());
+    fileSyncDirectories = resolveFileSyncDirectories(options.enableFileSyncTo, homedir7());
     if (options.restoreSessionDb && !options.sessionDbNoReplicateMarker) {
       throw new Error(
         "--restore-session-db requires --session-db-no-replicate-marker <path>; restore failures must block Litestream replication"
@@ -13174,6 +13952,7 @@ async function run(options) {
     opencodeClient: null,
     opencodeV2CredentialImportGuard: { inFlight: false },
     sessionDbProvenanceAnomaly: false,
+    sessionStoreHealth: createSessionStoreHealth(),
     opencodeProcess: null,
     stopOpenCodeLogTail: null,
     litestreamProcess: null,
@@ -13191,10 +13970,12 @@ async function run(options) {
     openaiUsageRearm: null,
     resourceUsageTimer: null,
     stopResourceUsageSampling: null,
+    lowDiskWarningState: { worstBand: null, warnedAtMs: null },
     credentialSync: null,
     authHeader: ""
   };
   setTelemetryAuthProvider(() => ({ authHeader: state.authHeader, agentId: state.agentId }));
+  setTelemetryDiagnosticsReporter((message) => log2(state, message, "warn"));
   if (options.credentialSyncMarker) {
     state.credentialSync = createCredentialSync({
       markerPath: options.credentialSyncMarker,
@@ -13380,13 +14161,21 @@ async function run(options) {
       if (githubTokenPopulated) await configureGitHubAccess(credentialContext);
     }
     state.credentialSync?.arm();
-    state.stopOpenCodeLogTail = tailOpenCodeLogFile(
-      resolveOpenCodeLogPath(homedir6(), process.env),
-      createOpenCodeActivityForwarder(() => ({
+    const openCodeActivityForwarder = createOpenCodeActivityForwarder(
+      () => ({
         agentId: state.agentId,
         authHeader: state.authHeader
-      }))
-    ).stop;
+      }),
+      state.sessionStoreHealth.observeUnwritable
+    );
+    const openCodeLogTail = tailOpenCodeLogFile(
+      resolveOpenCodeLogPath(homedir7(), process.env),
+      openCodeActivityForwarder
+    );
+    state.stopOpenCodeLogTail = () => {
+      openCodeActivityForwarder.flush();
+      openCodeLogTail.stop();
+    };
     let sessionDbVerifyFatal = false;
     if (!options.restoreSessionDb) {
       log2(state, "Skipping session-DB restore: --restore-session-db was not passed", "debug");
@@ -13503,7 +14292,7 @@ async function run(options) {
         const provenance = checkSessionDbProvenance({
           dbPath: sessionDbPath(),
           currentVersion: state.opencodeVersion,
-          homeDir: homedir6(),
+          homeDir: homedir7(),
           env: process.env
         });
         if (provenance.anomaly) {
@@ -13670,10 +14459,11 @@ async function run(options) {
       getAuthHeader: () => state.authHeader,
       conversationFilter: state.conversationFilter,
       stuckQueuedMs: CHANNEL_STUCK_QUEUED_MS,
+      sessionStoreHealth: state.sessionStoreHealth,
       // #559: the `--enable-file-sync-to` allow-list. Empty ⇒ pending files are
       // REJECTED with `file_sync_disabled` on the ack, not silently ignored.
       fileSyncDirectories,
-      homeDir: homedir6(),
+      homeDir: homedir7(),
       maxActiveSessions,
       log: (entry) => (
         // Thread the driver's real level straight through so `debug`/`warn`
@@ -13695,12 +14485,13 @@ async function run(options) {
       openCodePassword: state.opencodePassword,
       isRunning: () => state.running,
       events: {
-        onConnected: (agentId, isReconnect) => {
+        onConnected: (agentId, isReconnect, transition) => {
           state.connected = true;
           state.agentId = agentId;
+          const connectionMessage = isReconnect ? `Tunnel reconnected (runner: ${agentId}, generation: ${transition.generation}, attempt: ${transition.attempt}, offline for ${transition.downtimeMs}ms)` : `Tunnel connected (runner: ${agentId}, generation: ${transition.generation})`;
           logActivity(state, {
             type: "info",
-            message: `Tunnel ${isReconnect ? "reconnected" : "connected"} (runner: ${agentId})`
+            message: connectionMessage
           });
           if (options.tunnelReadyFile) {
             const marker = writeTunnelReadyMarker(options.tunnelReadyFile, agentId);
@@ -13721,7 +14512,12 @@ async function run(options) {
               version: state.opencodeVersion,
               major: state.opencodeApiVersion,
               connected: state.opencodeConnected
-            })
+            }),
+            connection_generation: transition.generation,
+            ...isReconnect && transition.downtimeMs !== null ? {
+              reconnect_attempt: transition.attempt,
+              downtime_ms: transition.downtimeMs
+            } : {}
           });
           if (!isReconnect) tunnelSpinner?.succeed("Tunnel connected");
           if (state.interactive) displayStatus(state);
@@ -13743,13 +14539,18 @@ async function run(options) {
             if (state.interactive) displayStatus(state);
           });
         },
-        onDisconnected: (code, reason) => {
+        onDisconnected: (code, reason, transition) => {
           state.connected = false;
+          const safeReason = redactDiagnosticText(reason).slice(0, MAX_DISCONNECT_REASON_LENGTH);
           logActivity(state, {
             type: "info",
-            message: `Tunnel disconnected (code: ${code}, reason: ${reason})`
+            message: `Tunnel disconnected (generation: ${transition.generation}, code: ${code}, reason: ${safeReason})`
+          });
+          emitAgentDisconnected(state.agentId, {
+            code,
+            reason: safeReason,
+            connection_generation: transition.generation
           });
-          emitAgentDisconnected(state.agentId, { code, reason });
           if (state.interactive) displayStatus(state);
         },
         onError: (error2) => {
@@ -13849,7 +14650,7 @@ async function run(options) {
       },
       report: (usage) => reportOpenAiUsage(state.agentId, state.authHeader, usage),
       isLocalCredentialProblem: isLocalCredentialProblem2,
-      forcedOnHint: "connect a ChatGPT account to this runner, or run `opencode auth login`",
+      forcedOnHint: state.opencodeApiVersion === "v2" ? "OpenCode V2 keeps its connected ChatGPT login in a store Evident cannot read" : "connect a ChatGPT account to this runner, or run `opencode auth login`",
       firstDelayMs: firstReportDelayMs,
       nextDelayMs: usageReportDelayMs,
       failureLogLevel: usageReportFailureLogLevel
@@ -13892,7 +14693,7 @@ async function run(options) {
 }
 
 // src/index.ts
-var { version } = createRequire2(import.meta.url)("../package.json");
+var version = getCliVersion();
 var program = new Command();
 program.name("evident").description("Run OpenCode locally and connect it to Evident").version(version).option(
   "--endpoint <url>",