@evident-ai/cli 3.5.2-dev.da3340e → 3.5.2-dev.df1ae49

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
@@ -1158,7 +1157,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.da3340e" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.df1ae49" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1172,6 +1171,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 +1253,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 +1265,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 {
@@ -1300,6 +1320,219 @@ var EventTypes = {
 
 // src/lib/runner-activity-telemetry.ts
 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"]),
@@ -1317,25 +1550,81 @@ function parseOpenCodeLogLine(line) {
   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 messageMatch = normalisedLine.match(/(?:^|\s)message=(?:"((?:\\.|[^"])*)"|(\S+))/);
+  const parsed = {
+    level: level === "WARN" ? "warn" : "error",
+    sessionID: sessionMatch?.[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 } : {},
+      ...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}`;
+    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) {
@@ -1346,7 +1635,16 @@ 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;
@@ -1372,7 +1670,7 @@ function redactHomeDirectory(message) {
   }
   return result + message.slice(searchFrom);
 }
-function redact(message) {
+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);
 }
@@ -1384,14 +1682,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]);
     }
@@ -1409,8 +1710,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;
@@ -1420,8 +1721,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;
@@ -1436,7 +1737,7 @@ function forwardRunnerActivity(entry, context) {
     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,
@@ -1444,8 +1745,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)}`
     );
   }
 }
@@ -1735,8 +2036,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
@@ -1890,6 +2229,7 @@ function isSessionActivelyGenerating(messages) {
   if (roleOf(last) !== "assistant") return false;
   return completedOf(last) == null;
 }
+var FULL_SESSION_ENUMERATION_MAX_SESSIONS = 3200;
 function sessionLastActivityMs(session) {
   const candidates = [
     session.time?.updated,
@@ -1904,30 +2244,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) {
@@ -3060,13 +3430,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) {
@@ -3397,16 +3771,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"
     );
   }
@@ -3687,9 +4062,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 { mkdirSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname2, resolve as resolvePath } from "node:path";
+import { dirname as dirname3, resolve as resolvePath } from "node:path";
 
 // src/lib/runner-synchroniser.ts
 import { spawn } from "node:child_process";
@@ -3814,7 +4189,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(
@@ -3939,7 +4314,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(
@@ -3969,7 +4344,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(
@@ -4130,7 +4505,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;
@@ -4219,7 +4594,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;
@@ -4285,7 +4660,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) {
@@ -4866,7 +5241,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) {
@@ -4926,13 +5304,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) {
@@ -4958,7 +5336,7 @@ function buildSessionStoreSizeWarning(input) {
 }
 
 // src/lib/opencode/log-tail.ts
-import { statSync as statSync4 } from "node:fs";
+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";
@@ -4981,7 +5359,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) {
@@ -5040,129 +5418,6 @@ function tailOpenCodeLogFile(logPath, onChunk, opts = {}) {
   };
 }
 
-// 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",
-          detail: "a session turn is live"
-        };
-      }
-      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", detail: skipReason };
-      }
-      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 };
-    }
-    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 };
-    }
-    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
 import WebSocket2 from "ws";
 
@@ -5392,6 +5647,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) {
@@ -5434,6 +5691,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;
@@ -5505,10 +5763,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 = [];
@@ -5538,6 +5813,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));
@@ -5571,6 +5847,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);
@@ -5595,6 +5872,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");
@@ -5606,7 +5884,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);
     });
@@ -5614,9 +5893,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. */
@@ -5625,10 +5905,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;
@@ -5664,14 +5951,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}`);
               });
@@ -6010,6 +6307,83 @@ 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 homedir6 } from "node:os";
 
@@ -6468,6 +6842,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;
@@ -6529,6 +6904,7 @@ var ChannelDriver = class _ChannelDriver {
   maxActiveSessions;
   watcherStallMs;
   wedgeWarningIntervalMs;
+  sessionStoreHealth;
   openCodeClient;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
@@ -6898,6 +7274,7 @@ var ChannelDriver = class _ChannelDriver {
     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";
@@ -6913,7 +7290,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);
@@ -8369,6 +8748,7 @@ var ChannelDriver = class _ChannelDriver {
       b2AbandonedSignalled: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
     const buffered = this.bufferedSessionErrors.get(sessionId);
@@ -8487,6 +8867,7 @@ var ChannelDriver = class _ChannelDriver {
       b2AbandonedSignalled: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
   }
@@ -8900,6 +9281,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;
@@ -9079,6 +9464,16 @@ 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;
           this.log({
             level: "warn",
@@ -9137,6 +9532,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",
@@ -9416,6 +9821,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).
@@ -12147,6 +12612,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;
@@ -12365,7 +12831,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}`
@@ -12384,7 +12852,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) {
@@ -12617,9 +13085,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]);
@@ -12676,61 +13144,96 @@ 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) {
-      logSessionCleanupActivity(state, "sweep", {
+    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})`,
-        metadata: {
-          outcome: "sweep-skipped",
-          reason: "opencode-unreachable"
-        }
+        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)` : "";
       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,
@@ -12738,25 +13241,27 @@ async function runSweep(state, driver, config) {
           after_bytes: reclaimResult.afterBytes,
           checkpoint_busy: reclaimResult.checkpoint.busy,
           wal_frames_pending: reclaimResult.checkpoint.log,
-          sessions_inspected: sessions.length,
-          sessions_deleted: deleted,
-          sessions_failed: failed,
-          sessions_skipped_active: skippedNewlyActive
+          stopped_by: reclaimResult.stoppedBy,
+          freelist_before: reclaimResult.freelistBefore,
+          freelist_after: reclaimResult.freelistAfter,
+          pages_reclaimed: reclaimResult.pagesReclaimed,
+          reclaim_elapsed_ms: reclaimResult.elapsedMs,
+          ...sessionMetadata
         }
       });
     } else {
+      if (reclaimResult.skipped === "disk-exhaustion") {
+        state.sessionStoreHealth.observeUnwritable();
+      }
       logSessionCleanupActivity(state, "sweep", {
         type: "info",
-        level: reclaimResult.skipped === "reclaim-error" || reclaimResult.skipped === "insufficient-disk-space" ? "warn" : "info",
+        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 } : {},
-          sessions_inspected: sessions.length,
-          sessions_deleted: deleted,
-          sessions_failed: failed,
-          sessions_skipped_active: skippedNewlyActive
+          ...sessionMetadata
         }
       });
     }
@@ -13013,6 +13518,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) {
@@ -13259,6 +13777,7 @@ async function run(options) {
     opencodeClient: null,
     opencodeV2CredentialImportGuard: { inFlight: false },
     sessionDbProvenanceAnomaly: false,
+    sessionStoreHealth: createSessionStoreHealth(),
     opencodeProcess: null,
     stopOpenCodeLogTail: null,
     litestreamProcess: null,
@@ -13276,10 +13795,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,
@@ -13465,13 +13986,21 @@ async function run(options) {
       if (githubTokenPopulated) await configureGitHubAccess(credentialContext);
     }
     state.credentialSync?.arm();
-    state.stopOpenCodeLogTail = tailOpenCodeLogFile(
-      resolveOpenCodeLogPath(homedir7(), 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");
@@ -13755,6 +14284,7 @@ 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,
@@ -13780,12 +14310,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);
@@ -13806,7 +14337,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);
@@ -13828,13 +14364,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) => {
@@ -13934,7 +14475,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
@@ -13977,7 +14518,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>",