@evident-ai/cli 3.6.1-dev.98128d1 → 3.6.1-dev.981b738

package/dist/index.js

@@ -723,6 +723,9 @@ async function reportResourceUsage(agentId, authHeader, usage) {
     opencode_db_bytes: usage.opencodeDbBytes
   });
 }
+async function reportSessionDeletions(agentId, authHeader, deletions) {
+  return postBestEffort(`/runners/${agentId}/session-deletions`, authHeader, { deletions });
+}
 async function getRunnerCredentialVault(agentId, authHeader) {
   const empty = { prefix: null, vaultId: null, source: null };
   try {
@@ -1176,9 +1179,9 @@ async function claudeUsage() {
 }
 
 // src/commands/run.ts
-import { chmodSync as chmodSync3, existsSync as existsSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { isAbsolute as isAbsolute4, join as join13, parse, resolve as resolvePath2 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join16, parse, resolve as resolvePath2 } from "node:path";
 import chalk7 from "chalk";
 
 // ../../packages/types/src/agents/index.ts
@@ -1442,7 +1445,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.6.1-dev.98128d1" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.6.1-dev.981b738" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -2192,6 +2195,7 @@ 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"]),
+  "cli.session-archive": /* @__PURE__ */ new Set(["info", "warn", "error"]),
   "cli.runtime-provenance": /* @__PURE__ */ new Set(["info", "warn", "error"])
 };
 var SEVERITY_BY_LEVEL = {
@@ -2594,48 +2598,1101 @@ function buildSessionDbRecoveryActivity(record) {
       })();
       return { level, metadata: withoutContractFields(record), message };
     }
-    case "schema_provenance_mismatch":
-      return {
-        level,
-        metadata: withoutContractFields(record),
-        message: `Session database schema provenance mismatch for ${record.dbPath ?? record.db_path ?? "unknown"}: recorded version=${record.recorded_version ?? "unknown"}, current version=${record.current_version ?? "unknown"}, reason=${record.provenance_reason ?? "unknown"}, migration delta=${record.provenance_migration_delta ?? "unknown"}. Inspect the session database and runner backup before continuing.`
+    case "schema_provenance_mismatch":
+      return {
+        level,
+        metadata: withoutContractFields(record),
+        message: `Session database schema provenance mismatch for ${record.dbPath ?? record.db_path ?? "unknown"}: recorded version=${record.recorded_version ?? "unknown"}, current version=${record.current_version ?? "unknown"}, reason=${record.provenance_reason ?? "unknown"}, migration delta=${record.provenance_migration_delta ?? "unknown"}. Inspect the session database and runner backup before continuing.`
+      };
+    default:
+      return null;
+  }
+}
+function withoutContractFields(record) {
+  const { v: _v, event: _event, ...metadata } = record;
+  return metadata;
+}
+var OUTCOMES = /* @__PURE__ */ new Set([
+  "replica_recovered",
+  "restore_retried",
+  "fresh_session_db",
+  "history_rolled_back",
+  "restore_misconfigured",
+  "session_db_boot_refused",
+  "schema_provenance_mismatch"
+]);
+var STAGES = /* @__PURE__ */ new Set(["restore", "verify"]);
+var SEVERITIES = /* @__PURE__ */ new Set(["warning", "error"]);
+var NUMBER_FIELDS = [
+  "litestream_exit_code",
+  "attempt",
+  "replica_objects",
+  "replica_bytes",
+  "quarantined_objects",
+  "quarantine_failed_objects",
+  "quarantined_bytes",
+  "restore_points_tried"
+];
+var STRING_OR_NULL_FIELDS = ["quarantine_destination", "verified_restore_point"];
+function isSessionDbRecoveryRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.v === 1 && record.event === "session_db_recovery" && typeof record.at === "string" && STAGES.has(record.stage) && OUTCOMES.has(record.outcome) && SEVERITIES.has(record.severity) && typeof record.reason === "string" && (record.replication_suspended === void 0 || typeof record.replication_suspended === "boolean") && (record.provenance_reason === void 0 || record.provenance_reason === null || typeof record.provenance_reason === "string") && (record.provenance_migration_delta === void 0 || record.provenance_migration_delta === null || Number.isInteger(record.provenance_migration_delta)) && NUMBER_FIELDS.every((field) => record[field] === null || Number.isInteger(record[field])) && STRING_OR_NULL_FIELDS.every(
+    (field) => record[field] === null || typeof record[field] === "string"
+  );
+}
+
+// src/lib/opencode/session-deletion-report.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { dirname as dirname4, join as join4 } from "node:path";
+var SESSION_DELETION_SPOOL_MAX_RECORDS = 1e3;
+var MAX_DIAGNOSTIC_LENGTH = 200;
+function sessionDeletionReportPath(homeDir, env) {
+  const override = env.EVIDENT_SESSION_DELETION_REPORT?.trim();
+  return override || join4(homeDir, ".local", "state", "evident", "session-deletions.jsonl");
+}
+function appendSessionDeletionRecords(path, records) {
+  if (records.length === 0) return 0;
+  mkdirSync(dirname4(path), { recursive: true });
+  const current = readSessionDeletionRecords(path);
+  if (current.readError !== null) {
+    throw new Error(`cannot enforce the spool limit after reading ${path}: ${current.readError}`);
+  }
+  const combined = [...current.records, ...records];
+  const kept = combined.slice(-SESSION_DELETION_SPOOL_MAX_RECORDS);
+  const dropped = combined.length - kept.length;
+  if (dropped > 0) {
+    writeFileSync(path, `${kept.map((record) => JSON.stringify(record)).join("\n")}
+`, "utf8");
+  } else {
+    appendFileSync(path, `${records.map((record) => JSON.stringify(record)).join("\n")}
+`, "utf8");
+  }
+  return dropped;
+}
+function readSessionDeletionRecords(path) {
+  let content;
+  try {
+    content = readFileSync3(path, "utf8");
+  } catch (error2) {
+    if (isMissingFile(error2)) return { records: [], skippedLines: 0, readError: null };
+    const readError = boundedError(error2);
+    console.error(`[session-deletion-report] could not read ${path}: ${readError}`);
+    return { records: [], skippedLines: 0, readError };
+  }
+  let skippedLines = 0;
+  const records = content.split("\n").flatMap((line) => {
+    if (!line.trim()) return [];
+    const record = parseRecord(line, path);
+    if (record) return [record];
+    skippedLines++;
+    return [];
+  });
+  return { records, skippedLines, readError: null };
+}
+function removeDeliveredSessionDeletionRecords(path, delivered) {
+  let content;
+  try {
+    content = readFileSync3(path, "utf8");
+  } catch (error2) {
+    if (isMissingFile(error2)) return;
+    console.error(
+      `[session-deletion-report] could not read ${path} before removing delivered records: ${boundedError(error2)}`
+    );
+    throw error2;
+  }
+  const toRemove = /* @__PURE__ */ new Map();
+  for (const record of delivered) {
+    toRemove.set(record.opencode_session_id, (toRemove.get(record.opencode_session_id) ?? 0) + 1);
+  }
+  const remaining = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    const record = parseRecord(line, path);
+    const count = record ? toRemove.get(record.opencode_session_id) ?? 0 : 0;
+    if (record && count > 0) {
+      if (count === 1) toRemove.delete(record.opencode_session_id);
+      else toRemove.set(record.opencode_session_id, count - 1);
+    } else {
+      remaining.push(line);
+    }
+  }
+  try {
+    if (remaining.length === 0) unlinkSync2(path);
+    else writeFileSync(path, `${remaining.join("\n")}
+`, "utf8");
+  } catch (error2) {
+    if (isMissingFile(error2)) return;
+    console.error(
+      `[session-deletion-report] could not write ${path} after removing delivered records: ${boundedError(error2)}`
+    );
+    throw error2;
+  }
+}
+function parseRecord(line, path) {
+  try {
+    const value = JSON.parse(line);
+    if (isSessionDeletionRecord(value)) return value;
+    console.error(`[session-deletion-report] skipped malformed record in ${path}: invalid shape`);
+    return null;
+  } catch (error2) {
+    console.error(
+      `[session-deletion-report] skipped malformed record in ${path}: ${boundedError(error2)}`
+    );
+    return null;
+  }
+}
+function isSessionDeletionRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  const policy = record.policy;
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const fields = policy;
+  return typeof record.opencode_session_id === "string" && record.opencode_session_id.length > 0 && typeof record.deleted_at === "string" && record.reason === "auto_cleanup" && (fields.max_age_ms === null || typeof fields.max_age_ms === "number") && (fields.max_count === null || typeof fields.max_count === "number") && (fields.last_activity_at === null || typeof fields.last_activity_at === "string");
+}
+function isMissingFile(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+function boundedError(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return message.slice(0, MAX_DIAGNOSTIC_LENGTH);
+}
+
+// src/lib/opencode/session-binding-ledger.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname5, join as join5 } from "node:path";
+var SESSION_BINDING_LEDGER_MAX_RECORDS = 1e3;
+var MAX_DIAGNOSTIC_LENGTH2 = 200;
+function sessionBindingLedgerPath(homeDir, env) {
+  const override = env.EVIDENT_SESSION_BINDING_LEDGER?.trim();
+  return override || join5(homeDir, ".local", "state", "evident", "session-bindings.jsonl");
+}
+function appendSessionBinding(path, record, log3) {
+  mkdirSync2(dirname5(path), { recursive: true });
+  const current = readSessionBindingRecords(path, log3);
+  if (current.readError !== null) {
+    throw new Error(`cannot enforce the ledger limit after reading ${path}: ${current.readError}`);
+  }
+  if (current.records.some(
+    (existing) => existing.conversation_id === record.conversation_id && existing.opencode_session_id === record.opencode_session_id
+  )) {
+    return;
+  }
+  const kept = [...current.records, record].slice(-SESSION_BINDING_LEDGER_MAX_RECORDS);
+  if (kept.length > current.records.length) {
+    appendFileSync2(path, `${JSON.stringify(record)}
+`, "utf8");
+  } else {
+    writeFileSync2(path, `${kept.map((entry) => JSON.stringify(entry)).join("\n")}
+`, "utf8");
+  }
+}
+function readSessionBindings(path, log3) {
+  const result = readSessionBindingRecords(path, log3);
+  if (result.readError !== null) {
+    log3(`[session-binding-ledger] could not read ${path}: ${result.readError}`);
+  }
+  return new Map(
+    result.records.map((record) => [record.opencode_session_id, record.conversation_id])
+  );
+}
+function readSessionBindingRecords(path, log3) {
+  let content;
+  try {
+    content = readFileSync4(path, "utf8");
+  } catch (error2) {
+    if (isMissingFile2(error2)) return { records: [], readError: null };
+    const readError = boundedError2(error2);
+    return { records: [], readError };
+  }
+  const records = content.split("\n").flatMap((line) => {
+    if (!line.trim()) return [];
+    const record = parseRecord2(line, path, log3);
+    return record ? [record] : [];
+  });
+  return { records, readError: null };
+}
+function parseRecord2(line, path, log3) {
+  try {
+    const value = JSON.parse(line);
+    if (isSessionBindingRecord(value)) return value;
+    log3(`[session-binding-ledger] skipped malformed record in ${path}: invalid shape`);
+  } catch (error2) {
+    log3(`[session-binding-ledger] skipped malformed record in ${path}: ${boundedError2(error2)}`);
+  }
+  return null;
+}
+function isSessionBindingRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.conversation_id === "string" && record.conversation_id.length > 0 && typeof record.opencode_session_id === "string" && record.opencode_session_id.length > 0 && typeof record.observed_at === "string";
+}
+function isMissingFile2(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+function boundedError2(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return message.slice(0, MAX_DIAGNOSTIC_LENGTH2);
+}
+
+// src/lib/opencode/session-archive-config.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+
+// src/lib/opencode/session-cleanup.ts
+var DURATION_UNIT_MS = {
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3
+};
+function parseDurationMs(input) {
+  const trimmed = input.trim();
+  const match = /^(\d+)([smhd])$/.exec(trimmed);
+  if (!match) {
+    throw new Error(
+      `Invalid duration "${input}": expected <number><unit> where unit is one of s, m, h, d (e.g. "7d", "24h", "30m", "90s").`
+    );
+  }
+  const value = Number(match[1]);
+  if (value <= 0) {
+    throw new Error(`Invalid duration "${input}": must be a positive value.`);
+  }
+  return value * DURATION_UNIT_MS[match[2]];
+}
+function selectSessionsToDelete(sessions, opts) {
+  const { maxAgeMs, maxCount, nowMs, protectedIds } = opts;
+  if (maxAgeMs === void 0 && maxCount === void 0) return [];
+  const ageEligible = (s) => {
+    if (maxAgeMs === void 0) return false;
+    if (s.lastActivityMs === null) return true;
+    return nowMs - s.lastActivityMs > maxAgeMs;
+  };
+  const countEligibleIds = /* @__PURE__ */ new Set();
+  if (maxCount !== void 0) {
+    const byActivityDesc = [...sessions].sort(
+      (a, b) => (b.lastActivityMs ?? -Infinity) - (a.lastActivityMs ?? -Infinity)
+    );
+    for (const s of byActivityDesc.slice(maxCount)) {
+      countEligibleIds.add(s.id);
+    }
+  }
+  const toDelete = [];
+  for (const s of sessions) {
+    if (protectedIds.has(s.id)) continue;
+    if (ageEligible(s) || countEligibleIds.has(s.id)) {
+      toDelete.push(s.id);
+    }
+  }
+  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 resolve2(flag, envValue, fallback) {
+  return flag ?? envValue ?? fallback;
+}
+function parseMaxCount(input) {
+  const trimmed = input.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`Invalid max-count "${input}": expected a positive integer.`);
+  }
+  const value = Number(trimmed);
+  if (value <= 0) {
+    throw new Error(`Invalid max-count "${input}": must be greater than 0.`);
+  }
+  return value;
+}
+function resolveSessionCleanupConfig(flags, env = process.env) {
+  const warnings = [];
+  const maxAgeRaw = resolve2(flags.maxAge, env.EVIDENT_SESSION_CLEANUP_MAX_AGE);
+  const maxCountRaw = resolve2(flags.maxCount, env.EVIDENT_SESSION_CLEANUP_MAX_COUNT);
+  const intervalRaw = resolve2(
+    flags.interval,
+    env.EVIDENT_SESSION_CLEANUP_INTERVAL,
+    DEFAULT_INTERVAL
+  );
+  let maxAgeMs;
+  if (maxAgeRaw !== void 0) {
+    try {
+      maxAgeMs = parseDurationMs(maxAgeRaw);
+    } catch (err) {
+      warnings.push(
+        `Ignoring invalid --session-cleanup-max-age: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  let maxCount;
+  if (maxCountRaw !== void 0) {
+    try {
+      maxCount = parseMaxCount(maxCountRaw);
+    } catch (err) {
+      warnings.push(
+        `Ignoring invalid --session-cleanup-max-count: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  let intervalMs;
+  try {
+    intervalMs = parseDurationMs(intervalRaw ?? DEFAULT_INTERVAL);
+  } catch (err) {
+    warnings.push(
+      `Ignoring invalid --session-cleanup-interval, using default ${DEFAULT_INTERVAL}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    intervalMs = parseDurationMs(DEFAULT_INTERVAL);
+  }
+  const enabled = maxAgeMs !== void 0 || maxCount !== void 0;
+  return { enabled, maxAgeMs, maxCount, intervalMs, warnings };
+}
+
+// src/lib/opencode/session-archive-config.ts
+var DEFAULT_INTERVAL2 = "1h";
+var DEFAULT_FLUSH_BUDGET_MS = 2e3;
+var MAX_SESSION_ARCHIVE_TIMER_DELAY_MS = 2147483647;
+var STATE_PREFIX_FILE = "/dev/shm/evident-state-prefix";
+var ENABLED_VALUES = /* @__PURE__ */ new Set(["on", "true", "1"]);
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["off", "false", "0"]);
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function parseFlushBudgetMs(value) {
+  const trimmed = value.trim();
+  const budgetMs = Number(trimmed);
+  if (!/^\d+$/.test(trimmed) || !Number.isSafeInteger(budgetMs) || budgetMs <= 0 || budgetMs > MAX_SESSION_ARCHIVE_TIMER_DELAY_MS) {
+    throw new Error(
+      `Invalid flush budget "${value}": expected a positive integer number of milliseconds no greater than ${MAX_SESSION_ARCHIVE_TIMER_DELAY_MS}.`
+    );
+  }
+  return budgetMs;
+}
+function resolveSessionArchiveConfig(flags, env = process.env) {
+  const warnings = [];
+  const archiveRaw = env.EVIDENT_SESSION_ARCHIVE;
+  let enabled = flags.enabled ?? false;
+  if (flags.enabled === void 0 && archiveRaw !== void 0 && archiveRaw.trim() !== "") {
+    const normalized = archiveRaw.trim().toLowerCase();
+    if (ENABLED_VALUES.has(normalized)) {
+      enabled = true;
+    } else if (DISABLED_VALUES.has(normalized)) {
+      enabled = false;
+    } else {
+      warnings.push(
+        `Ignoring invalid EVIDENT_SESSION_ARCHIVE "${archiveRaw}": expected on or off; session archiving remains off.`
+      );
+    }
+  }
+  let intervalMs;
+  const intervalRaw = flags.interval ?? env.EVIDENT_SESSION_ARCHIVE_INTERVAL ?? DEFAULT_INTERVAL2;
+  try {
+    intervalMs = parseDurationMs(intervalRaw);
+    if (intervalMs > MAX_SESSION_ARCHIVE_TIMER_DELAY_MS) {
+      throw new Error(
+        `Duration "${intervalRaw}" exceeds Node's maximum timer delay of ${MAX_SESSION_ARCHIVE_TIMER_DELAY_MS}ms.`
+      );
+    }
+  } catch (err) {
+    warnings.push(
+      `Ignoring invalid session archive interval, using default ${DEFAULT_INTERVAL2}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    intervalMs = parseDurationMs(DEFAULT_INTERVAL2);
+  }
+  let flushBudgetMs;
+  const flushBudgetRaw = env.EVIDENT_SESSION_ARCHIVE_FLUSH_MS ?? String(DEFAULT_FLUSH_BUDGET_MS);
+  try {
+    flushBudgetMs = parseFlushBudgetMs(flushBudgetRaw);
+  } catch (err) {
+    warnings.push(
+      `Ignoring invalid EVIDENT_SESSION_ARCHIVE_FLUSH_MS, using default ${DEFAULT_FLUSH_BUDGET_MS}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    flushBudgetMs = DEFAULT_FLUSH_BUDGET_MS;
+  }
+  const bucket = nonEmpty(env.PERSISTENCE_BUCKET);
+  let keyPrefix = nonEmpty(env.LITESTREAM_PREFIX);
+  if (enabled && bucket === null) {
+    warnings.push("Session archiving is off because PERSISTENCE_BUCKET is unset or empty.");
+    enabled = false;
+  }
+  if (enabled && keyPrefix === null) {
+    let fallbackReadError = null;
+    try {
+      keyPrefix = nonEmpty(readFileSync5(STATE_PREFIX_FILE, "utf8"));
+    } catch (err) {
+      fallbackReadError = err instanceof Error ? err.message : String(err);
+    }
+    if (keyPrefix === null) {
+      const readFailure = fallbackReadError ? ` Could not read ${STATE_PREFIX_FILE}: ${fallbackReadError}.` : "";
+      warnings.push(
+        `Session archiving is off because neither LITESTREAM_PREFIX nor ${STATE_PREFIX_FILE} contains a prefix.${readFailure}`
+      );
+      enabled = false;
+    }
+  }
+  return { enabled, bucket, keyPrefix, intervalMs, flushBudgetMs, warnings };
+}
+
+// src/lib/opencode/session-archive-snapshot.ts
+import { createHash } from "node:crypto";
+var SessionArchiveExportError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SessionArchiveExportError";
+  }
+};
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (typeof value !== "object" || value === null) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, nested]) => [key, canonicalize(nested)])
+  );
+}
+function contentForFingerprint(archive) {
+  return JSON.stringify(
+    canonicalize({
+      opencode_api_version: archive.opencode_api_version,
+      opencode_session_id: archive.opencode_session_id,
+      evident_conversation_id: archive.evident_conversation_id,
+      messages: archive.messages
+    })
+  );
+}
+function fingerprintArchive(archive) {
+  return createHash("sha256").update(contentForFingerprint(archive)).digest("hex");
+}
+function buildSessionArchive(input) {
+  const archive = {
+    schema_version: 1,
+    opencode_api_version: input.apiVersion,
+    opencode_session_id: input.session.id,
+    evident_conversation_id: input.conversationId,
+    evident_runner_id: input.runnerId,
+    binding_source: input.bindingSource,
+    session: input.session,
+    messages: input.messages,
+    message_count: input.messages.length,
+    archived_at: input.archivedAt
+  };
+  return { ...archive, content_fingerprint: fingerprintArchive(archive) };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage2(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function invalidResponse(version2, sessionId, path, reason) {
+  return new SessionArchiveExportError(
+    "invalid-response",
+    `OpenCode ${version2} session ${sessionId} returned an invalid response from GET ${path}: ${reason}`
+  );
+}
+async function requestPage(client, sessionId, path, signal) {
+  let response;
+  try {
+    response = await client.request(path, signal ? { signal } : void 0, {
+      allowStatuses: Array.from({ length: 500 }, (_, index) => index + 100)
+    });
+  } catch (error2) {
+    throw new SessionArchiveExportError(
+      "request-failed",
+      `OpenCode ${client.version} session ${sessionId} request GET ${path} failed: ${errorMessage2(error2)}`
+    );
+  }
+  if (response.status === 404) {
+    throw new SessionArchiveExportError(
+      "not-found",
+      `OpenCode ${client.version} session ${sessionId} was not found at GET ${path} (HTTP 404)`
+    );
+  }
+  if (!response.ok) {
+    throw new SessionArchiveExportError(
+      "request-failed",
+      `OpenCode ${client.version} session ${sessionId} request GET ${path} returned HTTP ${response.status}`
+    );
+  }
+  let bodyText;
+  try {
+    bodyText = await response.text();
+  } catch (error2) {
+    throw new SessionArchiveExportError(
+      "request-failed",
+      `OpenCode ${client.version} session ${sessionId} response body from GET ${path} could not be read: ${errorMessage2(error2)}`
+    );
+  }
+  try {
+    return { response, body: JSON.parse(bodyText) };
+  } catch (error2) {
+    if (!(error2 instanceof SyntaxError)) throw error2;
+    const contentType = response.headers.get("content-type") ?? "";
+    const looksLikeHtml = contentType.toLowerCase().includes("text/html") || /^\s*<!doctype\s+html|^\s*<html/i.test(bodyText);
+    throw invalidResponse(
+      client.version,
+      sessionId,
+      path,
+      looksLikeHtml ? "received text/html, expected JSON" : "received non-JSON content, expected JSON"
+    );
+  }
+}
+function v1NextCursor(response, sessionId, path) {
+  const headerCursor = response.headers.get("x-next-cursor")?.trim() || null;
+  const linkHeader = response.headers.get("link");
+  const nextLink = linkHeader?.split(",").map((link) => link.trim()).find((link) => /;\s*rel\s*=\s*"?next"?/i.test(link));
+  let linkCursor = null;
+  if (nextLink) {
+    const target = nextLink.match(/<([^>]+)>/)?.[1];
+    if (!target) {
+      throw new SessionArchiveExportError(
+        "pagination-failed",
+        `OpenCode v1 session ${sessionId} returned a next Link without a URL for GET ${path}`
+      );
+    }
+    try {
+      linkCursor = new URL(target, "http://127.0.0.1").searchParams.get("before");
+    } catch (error2) {
+      throw new SessionArchiveExportError(
+        "pagination-failed",
+        `OpenCode v1 session ${sessionId} returned an invalid next Link for GET ${path}: ${errorMessage2(error2)}`
+      );
+    }
+  }
+  if (headerCursor && linkCursor && headerCursor !== linkCursor) {
+    throw new SessionArchiveExportError(
+      "pagination-failed",
+      `OpenCode v1 session ${sessionId} returned conflicting next cursors for GET ${path}`
+    );
+  }
+  const cursor = headerCursor ?? linkCursor;
+  if ((headerCursor || nextLink) && !cursor) {
+    throw new SessionArchiveExportError(
+      "pagination-failed",
+      `OpenCode v1 session ${sessionId} returned a next page without a usable cursor for GET ${path}`
+    );
+  }
+  return cursor;
+}
+function v1Messages(body, sessionId, path) {
+  if (!Array.isArray(body)) {
+    throw invalidResponse("v1", sessionId, path, "expected an array of messages");
+  }
+  return body;
+}
+async function exportV1SessionMessages(client, sessionId, signal) {
+  const basePath = `/session/${encodeURIComponent(sessionId)}/message`;
+  const firstPage = await requestPage(client, sessionId, basePath, signal);
+  let messages = v1Messages(firstPage.body, sessionId, basePath);
+  let cursor = v1NextCursor(firstPage.response, sessionId, basePath);
+  const seenCursors = /* @__PURE__ */ new Set();
+  while (cursor !== null) {
+    if (seenCursors.has(cursor)) {
+      throw new SessionArchiveExportError(
+        "pagination-failed",
+        `OpenCode v1 session ${sessionId} repeated cursor while reading GET ${basePath}`
+      );
+    }
+    seenCursors.add(cursor);
+    const path = `${basePath}?${new URLSearchParams({ before: cursor }).toString()}`;
+    const page = await requestPage(client, sessionId, path, signal);
+    messages = [...v1Messages(page.body, sessionId, path), ...messages];
+    cursor = v1NextCursor(page.response, sessionId, path);
+  }
+  return messages;
+}
+async function exportV2SessionMessages(client, sessionId, signal) {
+  const basePath = `/api/session/${encodeURIComponent(sessionId)}/message`;
+  const messages = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  let hasNextPage = true;
+  while (hasNextPage) {
+    const params = new URLSearchParams({ limit: "100" });
+    if (cursor === void 0) {
+      params.set("order", "asc");
+    } else {
+      params.set("cursor", cursor);
+    }
+    const path = `${basePath}?${params.toString()}`;
+    const { body } = await requestPage(client, sessionId, path, signal);
+    if (!isRecord(body) || !Array.isArray(body.data) || !isRecord(body.cursor)) {
+      throw invalidResponse("v2", sessionId, path, "expected a {data: [], cursor: {\u2026}} envelope");
+    }
+    messages.push(...body.data);
+    const next = body.cursor.next;
+    if (next === void 0 || next === null) {
+      hasNextPage = false;
+      continue;
+    }
+    if (typeof next !== "string" || next.length === 0 || seenCursors.has(next)) {
+      throw new SessionArchiveExportError(
+        "pagination-failed",
+        `OpenCode v2 session ${sessionId} returned an invalid or repeated cursor from GET ${path}`
+      );
+    }
+    seenCursors.add(next);
+    cursor = next;
+  }
+  return messages;
+}
+async function exportSessionMessages(client, sessionId, signal) {
+  if (client.version === "v1") return exportV1SessionMessages(client, sessionId, signal);
+  if (client.version === "v2") return exportV2SessionMessages(client, sessionId, signal);
+  throw new SessionArchiveExportError(
+    "unsupported-dialect",
+    `OpenCode session ${sessionId} cannot be archived: unsupported API dialect ${String(client.version)}`
+  );
+}
+
+// src/lib/opencode/session-archive-watermarks.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname6, join as join6 } from "node:path";
+function sessionArchiveWatermarkPath(homeDir, env) {
+  const override = env.EVIDENT_SESSION_ARCHIVE_WATERMARK?.trim();
+  return override || join6(homeDir, ".local", "state", "evident", "session-archive-watermarks.json");
+}
+function readWatermarks(path, log3) {
+  let content;
+  try {
+    content = readFileSync6(path, "utf8");
+  } catch (error2) {
+    if (isMissingFile3(error2)) return /* @__PURE__ */ new Map();
+    log3(`[session-archive-watermarks] could not read ${path}; treating every session as changed`);
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (!isRecord2(parsed)) throw new Error("invalid watermark object");
+    const entries = Object.entries(parsed);
+    if (!entries.every(([sessionId, value]) => sessionId.length > 0 && isWatermark(value))) {
+      throw new Error("invalid watermark entry");
+    }
+    return new Map(entries);
+  } catch (error2) {
+    log3(`[session-archive-watermarks] could not parse ${path}; treating every session as changed`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+function recordUpload(path, sessionId, entry, watermarks) {
+  const updated = new Map(watermarks);
+  updated.set(sessionId, entry);
+  mkdirSync3(dirname6(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(Object.fromEntries(updated))}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  watermarks.clear();
+  for (const [id, watermark] of updated) watermarks.set(id, watermark);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWatermark(value) {
+  if (!isRecord2(value)) return false;
+  return typeof value.fingerprint === "string" && typeof value.uploaded_at === "string" && typeof value.key === "string";
+}
+function isMissingFile3(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+
+// src/lib/runner-synchroniser.ts
+import { spawn } from "node:child_process";
+
+// ../../runner/synchroniser/src/shell-contract.json
+var shell_contract_default = {
+  commands: [
+    "env",
+    "litestream-config",
+    "restore",
+    "sync-once",
+    "model-auth-ready",
+    "self-stop",
+    "session-db-classify",
+    "session-db-verify",
+    "archive-put"
+  ],
+  archiveStdinMaxBytes: 16777216
+};
+
+// src/lib/runner-synchroniser.ts
+var MAX_ARCHIVE_STDIN_BYTES = shell_contract_default.archiveStdinMaxBytes;
+var ERROR_CLOSE_FALLBACK_MS = 1e3;
+function isPipeClosed(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "EPIPE";
+}
+function appendError(stderr, error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return stderr === "" ? message : `${stderr}
+${message}`;
+}
+function runSynchroniser(args, opts) {
+  return new Promise((resolve5) => {
+    let child;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let shuttingDown = false;
+    let timedOut = false;
+    let stdinFailure;
+    let childFailure;
+    const timer = {};
+    const closeFallbackTimer = {};
+    let abortListener;
+    let spawnListener;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer.handle) clearTimeout(timer.handle);
+      if (closeFallbackTimer.handle) clearTimeout(closeFallbackTimer.handle);
+      if (abortListener) opts.signal?.removeEventListener("abort", abortListener);
+      if (spawnListener) child.removeListener("spawn", spawnListener);
+      resolve5(result);
+    };
+    const armErrorCloseFallback = () => {
+      if (closeFallbackTimer.handle) return;
+      closeFallbackTimer.handle = setTimeout(() => {
+        const failure = stdinFailure ?? childFailure;
+        finish({
+          code: null,
+          stdout,
+          stderr: failure === void 0 ? stderr : appendError(stderr, failure),
+          timedOut
+        });
+      }, ERROR_CLOSE_FALLBACK_MS);
+    };
+    const terminateChild = () => {
+      if (!shuttingDown) {
+        shuttingDown = true;
+        child.stdin?.destroy();
+      }
+      if (child.pid !== void 0) {
+        child.kill("SIGKILL");
+      } else if (!spawnListener) {
+        spawnListener = () => {
+          if (child.pid !== void 0) child.kill("SIGKILL");
+        };
+        child.once("spawn", spawnListener);
+      }
+    };
+    try {
+      child = spawn("runner-synchroniser", args, {
+        env: opts.env ?? process.env,
+        stdio: [opts.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+      });
+    } catch (error2) {
+      finish({ code: null, stdout, stderr: appendError(stderr, error2), timedOut: false });
+      return;
+    }
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error2) => {
+      childFailure = error2;
+      if (child.pid !== void 0) terminateChild();
+      armErrorCloseFallback();
+    });
+    child.once("close", (code) => {
+      const failure = stdinFailure ?? childFailure;
+      finish({
+        code: failure === void 0 ? code : null,
+        stdout,
+        stderr: failure === void 0 ? stderr : appendError(stderr, failure),
+        timedOut
+      });
+    });
+    const stdin = child.stdin;
+    const failStdin = (error2) => {
+      if (settled || shuttingDown || isPipeClosed(error2)) return;
+      stdinFailure = error2;
+      terminateChild();
+      armErrorCloseFallback();
+    };
+    stdin?.once("error", failStdin);
+    if (opts.stdin !== void 0 && stdin === null) {
+      failStdin(new Error("synchroniser stdin is unavailable"));
+    } else if (opts.stdin !== void 0 && stdin !== null) {
+      const drained = stdin.write(opts.stdin, (error2) => {
+        if (error2) failStdin(error2);
+      });
+      if (!drained) {
+        stdin.once("drain", () => stdin.end());
+      } else {
+        stdin.end();
+      }
+    }
+    if (opts.signal) {
+      const killChild = () => {
+        terminateChild();
       };
-    default:
-      return null;
+      abortListener = killChild;
+      if (opts.signal.aborted) {
+        abortListener();
+      } else {
+        opts.signal.addEventListener("abort", abortListener, { once: true });
+        if (opts.signal.aborted) abortListener();
+      }
+    }
+    timer.handle = setTimeout(
+      () => {
+        timedOut = true;
+        terminateChild();
+      },
+      Math.max(0, opts.timeoutMs)
+    );
+  });
+}
+
+// src/lib/opencode/session-archive-upload.ts
+var MAX_SESSION_ARCHIVE_BYTES = MAX_ARCHIVE_STDIN_BYTES;
+var EXIT_ARCHIVE_CONFIG_MISSING = 50;
+var EXIT_ARCHIVE_ACCESS_DENIED = 51;
+function transportFailure(bytes, reason) {
+  const message = reason === "missing-executable" ? "runner-synchroniser is unavailable; session archival requires a hosted runner." : reason === "timeout" ? "runner-synchroniser timed out before the archive upload completed." : "session archive upload did not complete.";
+  return { kind: "transport-failed", bytes, reason, message };
+}
+function isJson(body) {
+  try {
+    JSON.parse(body.toString("utf8"));
+    return true;
+  } catch (error2) {
+    void error2;
+    return false;
   }
 }
-function withoutContractFields(record) {
-  const { v: _v, event: _event, ...metadata } = record;
-  return metadata;
+async function uploadSessionArchive(key, body, options) {
+  const bytes = Buffer.from(body);
+  if (bytes.byteLength > MAX_SESSION_ARCHIVE_BYTES) {
+    return transportFailure(bytes.byteLength, "too-large");
+  }
+  if (!isJson(bytes)) return transportFailure(bytes.byteLength, "invalid-json");
+  const run2 = options.runSynchroniser ?? runSynchroniser;
+  let result;
+  try {
+    result = await run2(["archive-put", key], {
+      timeoutMs: options.timeoutMs,
+      env: options.env,
+      signal: options.signal,
+      stdin: bytes
+    });
+  } catch (error2) {
+    return transportFailure(
+      bytes.byteLength,
+      error2 instanceof Error && /ENOENT|runner-synchroniser/i.test(error2.message) ? "missing-executable" : "spawn-failed"
+    );
+  }
+  if (result.timedOut) return transportFailure(bytes.byteLength, "timeout");
+  if (result.code === 0) return { kind: "ok", bytes: bytes.byteLength };
+  if (result.code === EXIT_ARCHIVE_CONFIG_MISSING) {
+    return { kind: "config-missing", bytes: bytes.byteLength };
+  }
+  if (result.code === EXIT_ARCHIVE_ACCESS_DENIED) {
+    return { kind: "access-denied", bytes: bytes.byteLength };
+  }
+  if (result.code === null && /ENOENT|runner-synchroniser/i.test(result.stderr)) {
+    return transportFailure(bytes.byteLength, "missing-executable");
+  }
+  return transportFailure(
+    bytes.byteLength,
+    result.code === null ? "spawn-failed" : "process-failed"
+  );
 }
-var OUTCOMES = /* @__PURE__ */ new Set([
-  "replica_recovered",
-  "restore_retried",
-  "fresh_session_db",
-  "history_rolled_back",
-  "restore_misconfigured",
-  "session_db_boot_refused",
-  "schema_provenance_mismatch"
-]);
-var STAGES = /* @__PURE__ */ new Set(["restore", "verify"]);
-var SEVERITIES = /* @__PURE__ */ new Set(["warning", "error"]);
-var NUMBER_FIELDS = [
-  "litestream_exit_code",
-  "attempt",
-  "replica_objects",
-  "replica_bytes",
-  "quarantined_objects",
-  "quarantine_failed_objects",
-  "quarantined_bytes",
-  "restore_points_tried"
-];
-var STRING_OR_NULL_FIELDS = ["quarantine_destination", "verified_restore_point"];
-function isSessionDbRecoveryRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  return record.v === 1 && record.event === "session_db_recovery" && typeof record.at === "string" && STAGES.has(record.stage) && OUTCOMES.has(record.outcome) && SEVERITIES.has(record.severity) && typeof record.reason === "string" && (record.replication_suspended === void 0 || typeof record.replication_suspended === "boolean") && (record.provenance_reason === void 0 || record.provenance_reason === null || typeof record.provenance_reason === "string") && (record.provenance_migration_delta === void 0 || record.provenance_migration_delta === null || Number.isInteger(record.provenance_migration_delta)) && NUMBER_FIELDS.every((field) => record[field] === null || Number.isInteger(record[field])) && STRING_OR_NULL_FIELDS.every(
-    (field) => record[field] === null || typeof record[field] === "string"
+
+// src/lib/opencode/session-archive-run.ts
+var SESSION_ARCHIVE_UPLOAD_TIMEOUT_MS = 6e4;
+function updatedAt(session) {
+  const updated = session.time?.updated;
+  return typeof updated === "number" && Number.isFinite(updated) ? updated : -Infinity;
+}
+function sessionArchiveKey(prefix, sessionId) {
+  return `${prefix.replace(/\/+$/, "")}/conversation-archives/${encodeURIComponent(sessionId)}.json`;
+}
+function failureMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function isBudgetExpired(deadline, now, signal) {
+  return signal?.aborted === true || now() >= deadline;
+}
+function createBudgetSignal(parent, timeoutMs) {
+  const controller = new AbortController();
+  const forwardAbort = () => controller.abort(parent?.reason);
+  if (parent?.aborted) forwardAbort();
+  else parent?.addEventListener("abort", forwardAbort, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(new Error("session archive budget exceeded")),
+    timeoutMs
   );
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", forwardAbort);
+    }
+  };
+}
+async function runSessionArchive({
+  sessions,
+  deps,
+  budgetMs,
+  now = Date.now
+}) {
+  const startedAt = now();
+  const deadline = startedAt + Math.max(0, budgetMs);
+  const summary = {
+    inspected: sessions.length,
+    uploaded: 0,
+    unchanged: 0,
+    failed: 0,
+    uploadAttempts: 0,
+    uploadFailures: 0,
+    skippedBudget: 0,
+    skippedBudgetIds: [],
+    neverWatermarkedFailures: 0,
+    unmappedIds: [],
+    archivedSessionIds: [],
+    failures: [],
+    staleSince: null
+  };
+  const ordered = [...sessions].sort((left, right) => updatedAt(right) - updatedAt(left));
+  const upload = deps.upload ?? uploadSessionArchive;
+  const exportMessages = deps.exportMessages ?? exportSessionMessages;
+  const writeWatermark = deps.recordWatermark ?? recordUpload;
+  const failedWatermarks = [];
+  const recordFailedWatermark = (watermark) => {
+    if (watermark) failedWatermarks.push(watermark.uploaded_at);
+    else summary.neverWatermarkedFailures++;
+  };
+  for (let index = 0; index < ordered.length; index++) {
+    const session = ordered[index];
+    const remainingMs = Math.floor(deadline - now());
+    if (remainingMs <= 0 || deps.signal?.aborted) {
+      summary.skippedBudgetIds.push(...ordered.slice(index).map(({ id }) => id));
+      summary.skippedBudget = summary.skippedBudgetIds.length;
+      break;
+    }
+    const conversationId = deps.bindings.get(session.id) ?? null;
+    if (conversationId === null) summary.unmappedIds.push(session.id);
+    const exportBudget = createBudgetSignal(deps.signal, remainingMs);
+    let messages;
+    try {
+      messages = await exportMessages(deps.client, session.id, exportBudget.signal);
+    } catch (error2) {
+      if (isBudgetExpired(deadline, now, deps.signal) || exportBudget.signal.aborted) {
+        summary.skippedBudgetIds.push(...ordered.slice(index).map(({ id }) => id));
+        summary.skippedBudget = summary.skippedBudgetIds.length;
+        break;
+      }
+      summary.failed++;
+      const reason = error2 instanceof SessionArchiveExportError ? error2.code : "export-failed";
+      summary.failures.push({
+        sessionId: session.id,
+        outcome: "export-failed",
+        reason,
+        message: failureMessage(error2),
+        archived: false
+      });
+      recordFailedWatermark(deps.watermarks.get(session.id));
+      continue;
+    } finally {
+      exportBudget.dispose();
+    }
+    if (isBudgetExpired(deadline, now, deps.signal) || exportBudget.signal.aborted) {
+      summary.skippedBudgetIds.push(...ordered.slice(index).map(({ id }) => id));
+      summary.skippedBudget = summary.skippedBudgetIds.length;
+      break;
+    }
+    try {
+      const archivedAt = new Date(now()).toISOString();
+      const snapshot = buildSessionArchive({
+        session,
+        messages,
+        apiVersion: deps.client.version,
+        conversationId,
+        bindingSource: conversationId === null ? "unmapped" : "ledger",
+        runnerId: deps.runnerId,
+        archivedAt
+      });
+      const key = sessionArchiveKey(deps.keyPrefix, session.id);
+      const existing = deps.watermarks.get(session.id);
+      if (existing?.fingerprint === snapshot.content_fingerprint) {
+        summary.unchanged++;
+        summary.archivedSessionIds.push(session.id);
+        continue;
+      }
+      const uploadRemainingMs = Math.floor(deadline - now());
+      if (uploadRemainingMs <= 0 || deps.signal?.aborted) {
+        summary.skippedBudgetIds.push(...ordered.slice(index).map(({ id }) => id));
+        summary.skippedBudget = summary.skippedBudgetIds.length;
+        break;
+      }
+      summary.uploadAttempts++;
+      const uploadBudget = createBudgetSignal(deps.signal, uploadRemainingMs);
+      let outcome;
+      try {
+        outcome = await upload(key, JSON.stringify(snapshot), {
+          timeoutMs: Math.min(uploadRemainingMs, SESSION_ARCHIVE_UPLOAD_TIMEOUT_MS),
+          signal: uploadBudget.signal
+        });
+      } finally {
+        uploadBudget.dispose();
+      }
+      if (outcome.kind !== "ok") {
+        summary.failed++;
+        summary.uploadFailures++;
+        const reason = "reason" in outcome ? outcome.reason : void 0;
+        summary.failures.push({
+          sessionId: session.id,
+          outcome: outcome.kind,
+          ...reason !== void 0 ? { reason } : {},
+          ..."message" in outcome ? { message: outcome.message } : {},
+          archived: false
+        });
+        recordFailedWatermark(existing);
+        if (uploadBudget.signal.aborted) {
+          summary.skippedBudgetIds.push(...ordered.slice(index + 1).map(({ id }) => id));
+          summary.skippedBudget = summary.skippedBudgetIds.length;
+          break;
+        }
+        continue;
+      }
+      summary.uploaded++;
+      summary.archivedSessionIds.push(session.id);
+      const watermark = {
+        fingerprint: snapshot.content_fingerprint,
+        uploaded_at: new Date(now()).toISOString(),
+        key
+      };
+      try {
+        writeWatermark(deps.watermarkPath, session.id, watermark, deps.watermarks);
+      } catch (error2) {
+        summary.failures.push({
+          sessionId: session.id,
+          outcome: "watermark-write-failed",
+          message: failureMessage(error2),
+          archived: true
+        });
+      }
+    } catch (error2) {
+      if (isBudgetExpired(deadline, now, deps.signal)) {
+        summary.skippedBudgetIds.push(...ordered.slice(index).map(({ id }) => id));
+        summary.skippedBudget = summary.skippedBudgetIds.length;
+        break;
+      }
+      summary.failed++;
+      summary.failures.push({
+        sessionId: session.id,
+        outcome: "archive-failed",
+        message: failureMessage(error2),
+        archived: false
+      });
+      recordFailedWatermark(deps.watermarks.get(session.id));
+    }
+  }
+  summary.staleSince = failedWatermarks.sort()[0] ?? null;
+  return summary;
 }
 
 // src/lib/opencode/auth.ts
@@ -2656,8 +3713,26 @@ async function checkOpenCodeHealth(port) {
     if (!response.ok) {
       return { healthy: false, error: `HTTP ${response.status}` };
     }
-    const data = await response.json().catch(() => ({}));
-    return { healthy: true, version: data.version };
+    const body = await response.text();
+    let data;
+    try {
+      data = JSON.parse(body);
+    } catch (error2) {
+      return {
+        healthy: false,
+        okWithNonJsonBody: true,
+        error: `HTTP ${response.status}: invalid JSON health response${bodyExcerpt(body)}: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      return {
+        healthy: false,
+        okWithNonJsonBody: true,
+        error: `HTTP ${response.status}: invalid health response${bodyExcerpt(body)}: expected JSON object`
+      };
+    }
+    const version2 = data.version;
+    return typeof version2 === "string" ? { healthy: true, version: version2 } : { healthy: true };
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : "Unknown error";
     return { healthy: false, error: message };
@@ -2673,10 +3748,17 @@ async function checkOpenCode2Health(port, password) {
     if (password !== void 0) {
       headers.Authorization = buildOpenCodeBasicAuthHeader(password);
     }
-    const response = await fetch(`http://127.0.0.1:${port}/api/health`, {
+    let response = await fetch(`http://127.0.0.1:${port}/api/info`, {
       headers,
       signal: AbortSignal.timeout(2e3)
     });
+    const usesHealthFallback = response.status === 404;
+    if (usesHealthFallback) {
+      response = await fetch(`http://127.0.0.1:${port}/api/health`, {
+        headers,
+        signal: AbortSignal.timeout(2e3)
+      });
+    }
     if (response.status === 401) {
       return { healthy: false, authFailed: true, error: "HTTP 401" };
     }
@@ -2691,23 +3773,29 @@ async function checkOpenCode2Health(port, password) {
     } catch (error2) {
       return {
         healthy: false,
-        error: `Invalid JSON health response${excerpt}: ${error2 instanceof Error ? error2.message : String(error2)}`
+        error: `HTTP ${response.status}: invalid JSON health response${excerpt}: ${error2 instanceof Error ? error2.message : String(error2)}`
       };
     }
     if (typeof data !== "object" || data === null || Array.isArray(data)) {
       return {
         healthy: false,
-        error: `Invalid health response${excerpt}: expected healthy=true`
+        error: `HTTP ${response.status}: invalid health response${excerpt}: expected healthy=true`
       };
     }
-    const health = data;
-    if (health.healthy !== true) {
+    const bodyObject = data;
+    if (usesHealthFallback && bodyObject.healthy !== true) {
       return {
         healthy: false,
         error: `Invalid health response${excerpt}: expected healthy=true`
       };
     }
-    return typeof health.version === "string" ? { healthy: true, version: health.version } : { healthy: true };
+    if (!usesHealthFallback) {
+      return typeof bodyObject.version === "string" && bodyObject.version.length > 0 ? { healthy: true, version: bodyObject.version } : {
+        healthy: false,
+        error: `HTTP ${response.status}: invalid info response${excerpt}: expected a non-empty version`
+      };
+    }
+    return typeof bodyObject.version === "string" ? { healthy: true, version: bodyObject.version } : { healthy: true };
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : "Unknown error";
     return { healthy: false, error: message };
@@ -2765,10 +3853,18 @@ function describeRequestOperation(input, init) {
 function withRequestTimeout(fetchImpl, timeoutMs) {
   return (async (input, init) => {
     const startedAt = Date.now();
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(init?.signal?.reason);
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const abortFromTimeout = () => controller.abort(timeoutSignal.reason);
+    if (init?.signal?.aborted) abortFromCaller();
+    else init?.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    if (timeoutSignal.aborted) abortFromTimeout();
+    else timeoutSignal.addEventListener("abort", abortFromTimeout, { once: true });
     try {
-      return await fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+      return await fetchImpl(input, { ...init, signal: controller.signal });
     } catch (error2) {
-      if (error2?.name === "TimeoutError") {
+      if (timeoutSignal.aborted) {
         throw new RequestTimeoutError(
           describeRequestOperation(input, init),
           timeoutMs,
@@ -2776,6 +3872,9 @@ function withRequestTimeout(fetchImpl, timeoutMs) {
         );
       }
       throw error2;
+    } finally {
+      init?.signal?.removeEventListener("abort", abortFromCaller);
+      timeoutSignal.removeEventListener("abort", abortFromTimeout);
     }
   });
 }
@@ -2959,28 +4058,38 @@ function sessionListPath(options) {
 async function listSessionPage(port, client, options) {
   const path = sessionListPath(options);
   try {
-    const res = await requestWithClient(port, client, path);
-    if (!res.ok) return null;
+    const res = await requestWithClient(
+      port,
+      client,
+      path,
+      options?.signal ? { signal: options.signal } : void 0,
+      { allowStatuses: ALL_HTTP_STATUSES }
+    );
+    if (!res.ok) {
+      console.error(`[listSessionPage] GET ${path} returned HTTP ${res.status} (port ${port})`);
+      return null;
+    }
     const body = await res.json();
     return Array.isArray(body) ? body : null;
   } catch (error2) {
-    console.error(
-      `[listSessionPage] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-    );
+    if (options?.signal?.aborted) return null;
+    const errorName = error2 instanceof Error && ["AbortError", "Error", "TimeoutError", "TypeError"].includes(error2.name) ? error2.name : "unknown error";
+    console.error(`[listSessionPage] GET ${path} failed (port ${port}): ${errorName}`);
     return null;
   }
 }
 async function listSessions(port, client, options) {
-  if (client?.version === "v2") return listV2Sessions(client);
+  if (client?.version === "v2") return listV2Sessions(client, options?.signal);
   return listSessionPage(port, client, options);
 }
-async function listAllSessions(port, client) {
+async function listAllSessions(port, client, signal) {
   if (client?.version === "v2") {
-    const sessions2 = await listV2Sessions(client);
+    const sessions2 = await listV2Sessions(client, signal);
     return sessions2 === null ? { sessions: null, reason: "opencode-unreachable" } : { sessions: sessions2 };
   }
   const sessions = await listSessionPage(port, client, {
-    limit: FULL_SESSION_ENUMERATION_MAX_SESSIONS
+    limit: FULL_SESSION_ENUMERATION_MAX_SESSIONS,
+    signal
   });
   if (sessions === null) return { sessions: null, reason: "opencode-unreachable" };
   if (sessions.length >= FULL_SESSION_ENUMERATION_MAX_SESSIONS) {
@@ -3669,9 +4778,17 @@ function isPreamblePinnedRunning(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   return completedOf(reply) != null && finishOf(reply) === "tool-calls";
 }
+function isMidFlightPinnedRunning(messages, userMessageId) {
+  if (messageRunState(messages, userMessageId) !== "running") return false;
+  const reply = findLastAssistantReplyFor(messages, userMessageId);
+  return reply !== null && isAssistantInFlight(reply) && completedOf(reply) == null;
+}
 function isB2AbandonmentConfirmed(params) {
   return params.pinnedForMs >= params.minPinnedMs && params.descendantOngoing === false && params.rootOngoing === false;
 }
+function isMidFlightOrphanConfirmed(params) {
+  return params.pinnedForMs >= params.minPinnedMs && params.notOngoingStreak >= params.minNotOngoingStreak;
+}
 function isAmbiguousTerminalFinish(m) {
   if (completedOf(m) == null) return false;
   if (errorOf(m) != null) return false;
@@ -3773,8 +4890,8 @@ function classifyReplyAuthError(reply) {
       };
     }
   }
-  const errorMessage3 = typeof data?.message === "string" ? data.message : typeof e.message === "string" ? e.message : null;
-  if (errorMessage3 !== null && CLAUDE_AUTH_EXPIRY_MESSAGES.some((knownMessage) => errorMessage3.includes(knownMessage))) {
+  const errorMessage4 = typeof data?.message === "string" ? data.message : typeof e.message === "string" ? e.message : null;
+  if (errorMessage4 !== null && CLAUDE_AUTH_EXPIRY_MESSAGES.some((knownMessage) => errorMessage4.includes(knownMessage))) {
     return {
       kind: "model_auth",
       providerId: typeof data?.providerID === "string" && data.providerID || replyProviderId,
@@ -4045,14 +5162,15 @@ async function probeOpenCodeRequestReadiness(port, client) {
 }
 
 // src/lib/opencode/session-v2.ts
-function isRecord(value) {
+var ALL_HTTP_STATUSES2 = Array.from({ length: 500 }, (_, index) => index + 100);
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function adaptTime(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const created = finiteNumber2(value.created);
   const completed = finiteNumber2(value.completed);
   if (created === void 0 && completed === void 0) return void 0;
@@ -4062,11 +5180,11 @@ function adaptTime(value) {
   };
 }
 function adaptTokens(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const input = finiteNumber2(value.input);
   const output = finiteNumber2(value.output);
   const reasoning = finiteNumber2(value.reasoning);
-  const cache = isRecord(value.cache) ? {
+  const cache = isRecord3(value.cache) ? {
     ...finiteNumber2(value.cache.read) !== void 0 ? { read: finiteNumber2(value.cache.read) } : {},
     ...finiteNumber2(value.cache.write) !== void 0 ? { write: finiteNumber2(value.cache.write) } : {}
   } : void 0;
@@ -4090,7 +5208,7 @@ function adaptMessageInfo(value, role) {
   if (typeof value.finish === "string") info.finish = value.finish;
   if ("error" in value) info.error = value.error;
   if (typeof value.agent === "string") info.agent = value.agent;
-  if (isRecord(value.model)) {
+  if (isRecord3(value.model)) {
     if (typeof value.model.id === "string") info.modelID = value.model.id;
     if (typeof value.model.providerID === "string") info.providerID = value.model.providerID;
   }
@@ -4100,7 +5218,7 @@ function adaptMessageInfo(value, role) {
   return info;
 }
 function adaptV2Message(value) {
-  if (!isRecord(value) || typeof value.id !== "string" || typeof value.type !== "string") {
+  if (!isRecord3(value) || typeof value.id !== "string" || typeof value.type !== "string") {
     return null;
   }
   if (value.type === "user") {
@@ -4113,7 +5231,7 @@ function adaptV2Message(value) {
   if (value.type !== "assistant" || !Array.isArray(value.content)) return null;
   const parts = [];
   for (const content of value.content) {
-    if (!isRecord(content) || typeof content.type !== "string") return null;
+    if (!isRecord3(content) || typeof content.type !== "string") return null;
     if (content.type === "text") {
       if (typeof content.text !== "string") return null;
       parts.push({ type: "text", text: content.text });
@@ -4127,23 +5245,23 @@ function adaptV2Message(value) {
   };
 }
 function adaptFormTool(value) {
-  if (!isRecord(value) || typeof value.messageID !== "string" || typeof value.id !== "string") {
+  if (!isRecord3(value) || typeof value.messageID !== "string" || typeof value.id !== "string") {
     return void 0;
   }
   return { messageID: value.messageID, callID: value.id };
 }
 function adaptV2FormWire(value) {
-  if (!isRecord(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
+  if (!isRecord3(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
     return null;
   }
   return value;
 }
 function adaptV2FormField(value, header) {
-  if (!isRecord(value)) return null;
+  if (!isRecord3(value)) return null;
   const question = typeof value.title === "string" ? value.title : typeof value.question === "string" ? value.question : typeof value.key === "string" ? value.key : null;
   if (!question) return null;
   const options = Array.isArray(value.options) ? value.options.flatMap((option) => {
-    if (!isRecord(option)) return [];
+    if (!isRecord3(option)) return [];
     const label = typeof option.label === "string" ? option.label : typeof option.value === "string" ? option.value : null;
     if (!label) return [];
     return [
@@ -4161,7 +5279,7 @@ function adaptV2Form(value) {
   const header = typeof form.title === "string" ? form.title : "";
   const questions = form.fields.map((field) => adaptV2FormField(field, header)).filter((question) => question !== null);
   if (questions.length === 0) return null;
-  const tool = isRecord(form.metadata) ? adaptFormTool(form.metadata.tool) : void 0;
+  const tool = isRecord3(form.metadata) ? adaptFormTool(form.metadata.tool) : void 0;
   return {
     id: form.id,
     sessionID: form.sessionID,
@@ -4171,7 +5289,7 @@ function adaptV2Form(value) {
   };
 }
 function adaptV2FormList(value) {
-  if (!isRecord(value) || !Array.isArray(value.data)) return null;
+  if (!isRecord3(value) || !Array.isArray(value.data)) return null;
   return value.data.map(adaptV2Form).filter((form) => form !== null);
 }
 function adaptPattern(value) {
@@ -4182,7 +5300,7 @@ function adaptPattern(value) {
   return void 0;
 }
 function adaptV2PermissionWire(value) {
-  if (!isRecord(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
+  if (!isRecord3(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
     return null;
   }
   if (typeof value.permission !== "string" && typeof value.action !== "string") return null;
@@ -4194,12 +5312,12 @@ function adaptV2Permission(value) {
   const type = permission.permission ?? permission.action;
   if (!type) return null;
   const pattern = adaptPattern(permission.pattern) ?? adaptPattern(permission.patterns) ?? adaptPattern(permission.resources);
-  const time = isRecord(permission.time) ? finiteNumber2(permission.time.created) !== void 0 ? { created: finiteNumber2(permission.time.created) } : void 0 : void 0;
+  const time = isRecord3(permission.time) ? finiteNumber2(permission.time.created) !== void 0 ? { created: finiteNumber2(permission.time.created) } : void 0 : void 0;
   return {
     id: permission.id,
     type,
     sessionID: permission.sessionID,
-    metadata: isRecord(permission.metadata) ? permission.metadata : {},
+    metadata: isRecord3(permission.metadata) ? permission.metadata : {},
     raw: permission,
     ...pattern !== void 0 ? { pattern } : {},
     ...typeof permission.messageID === "string" ? { messageID: permission.messageID } : {},
@@ -4209,12 +5327,12 @@ function adaptV2Permission(value) {
   };
 }
 function adaptV2PermissionList(value) {
-  if (!isRecord(value) || !Array.isArray(value.data)) return null;
+  if (!isRecord3(value) || !Array.isArray(value.data)) return null;
   return value.data.map(adaptV2Permission).filter((permission) => permission !== null);
 }
 function adaptV2Session(value) {
-  if (!isRecord(value) || typeof value.id !== "string" || value.id.length === 0) return null;
-  const time = isRecord(value.time) ? {
+  if (!isRecord3(value) || typeof value.id !== "string" || value.id.length === 0) return null;
+  const time = isRecord3(value.time) ? {
     ...finiteNumber2(value.time.created) !== void 0 ? { created: finiteNumber2(value.time.created) } : {},
     ...finiteNumber2(value.time.updated) !== void 0 ? { updated: finiteNumber2(value.time.updated) } : {}
   } : void 0;
@@ -4226,7 +5344,7 @@ function adaptV2Session(value) {
   };
 }
 function adaptV2SessionList(value) {
-  if (!isRecord(value) || !Array.isArray(value.data) || !isRecord(value.cursor)) return null;
+  if (!isRecord3(value) || !Array.isArray(value.data) || !isRecord3(value.cursor)) return null;
   return {
     data: value.data.map(adaptV2Session).filter((session) => session !== null),
     cursor: value.cursor
@@ -4235,18 +5353,18 @@ function adaptV2SessionList(value) {
 function adaptV2Location(value) {
   const candidates = [
     value,
-    isRecord(value) ? value.data : void 0,
-    isRecord(value) ? value.location : void 0
+    isRecord3(value) ? value.data : void 0,
+    isRecord3(value) ? value.location : void 0
   ];
   for (const candidate of candidates) {
-    if (!isRecord(candidate) || typeof candidate.directory !== "string") continue;
+    if (!isRecord3(candidate) || typeof candidate.directory !== "string") continue;
     const directory = candidate.directory.trim();
     if (directory) return directory;
   }
   return null;
 }
 function adaptV2Messages(value) {
-  if (!isRecord(value) || !Array.isArray(value.data)) return [];
+  if (!isRecord3(value) || !Array.isArray(value.data)) return [];
   return value.data.slice().reverse().map(adaptV2Message).filter((message) => message !== null);
 }
 async function readJson(response) {
@@ -4261,7 +5379,7 @@ async function readJson(response) {
 async function readData(client, path, init) {
   const response = await client.request(path, init);
   const body = await readJson(response);
-  if (!isRecord(body) || !("data" in body)) {
+  if (!isRecord3(body) || !("data" in body)) {
     throw new Error(`OpenCode V2 response for ${path} was missing its data envelope`);
   }
   return body.data;
@@ -4288,7 +5406,7 @@ async function createV2Session(client, directory) {
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ location: { directory } })
   });
-  if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
+  if (!isRecord3(data) || typeof data.id !== "string" || data.id.length === 0) {
     throw new Error("OpenCode V2 create session response was missing data.id");
   }
   return data.id;
@@ -4299,25 +5417,35 @@ async function getV2Session(client, sessionId) {
   if (!session) throw new Error("OpenCode V2 get session response contained an invalid session");
   return session;
 }
-async function listV2SessionPage(client, cursor) {
+async function listV2SessionPage(client, cursor, signal) {
+  const operation = cursor ? "GET /api/session (next page)" : "GET /api/session";
   const path = cursor ? `/api/session?cursor=${encodeURIComponent(cursor)}` : "/api/session";
   try {
-    return adaptV2SessionList(await readJson(await client.request(path)));
+    const response = await client.request(path, signal ? { signal } : void 0, {
+      allowStatuses: ALL_HTTP_STATUSES2
+    });
+    if (!response.ok) {
+      console.error(
+        `[listV2SessionPage] ${operation} returned HTTP ${response.status} (port ${client.port})`
+      );
+      return null;
+    }
+    return adaptV2SessionList(await readJson(response));
   } catch (error2) {
-    console.error(
-      `[listV2SessionPage] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-    );
+    if (signal?.aborted) return null;
+    const errorName = error2 instanceof Error && ["AbortError", "Error", "TimeoutError", "TypeError"].includes(error2.name) ? error2.name : "unknown error";
+    console.error(`[listV2SessionPage] ${operation} failed (port ${client.port}): ${errorName}`);
     return null;
   }
 }
-async function listV2Sessions(client) {
+async function listV2Sessions(client, signal) {
   const sessions = [];
   const seenCursors = /* @__PURE__ */ new Set();
   let cursor;
   let hasNextPage = true;
   try {
     while (hasNextPage) {
-      const page = await listV2SessionPage(client, cursor);
+      const page = await listV2SessionPage(client, cursor, signal);
       if (!page) return null;
       sessions.push(...page.data);
       const next = page.cursor.next;
@@ -4333,8 +5461,9 @@ async function listV2Sessions(client) {
     }
     return sessions;
   } catch (error2) {
+    const errorName = error2 instanceof Error && ["AbortError", "Error", "TimeoutError", "TypeError"].includes(error2.name) ? error2.name : "unknown error";
     console.error(
-      `[listV2Sessions] session pagination failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+      `[listV2Sessions] GET /api/session pagination failed (port ${client.port}): ${errorName}`
     );
     return null;
   }
@@ -4344,7 +5473,7 @@ async function deleteV2Session(client, sessionId) {
     const response = await client.request(
       `/api/session/${encodeURIComponent(sessionId)}`,
       { method: "DELETE" },
-      { allowStatuses: Array.from({ length: 500 }, (_, index) => index + 100) }
+      { allowStatuses: ALL_HTTP_STATUSES2 }
     );
     if (response.status >= 200 && response.status < 300) {
       return { ok: true, status: response.status };
@@ -4395,8 +5524,8 @@ async function sendV2Prompt(client, sessionId, text) {
       `OpenCode V2 prompt response could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
-  const data = isRecord(body) && "data" in body ? body.data : void 0;
-  if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
+  const data = isRecord3(body) && "data" in body ? body.data : void 0;
+  if (!isRecord3(data) || typeof data.id !== "string" || data.id.length === 0) {
     throw new OpenCodeV2PromptAckError("OpenCode V2 prompt response was missing data.id");
   }
   return data.id;
@@ -4405,7 +5534,7 @@ async function getV2SessionMessages(client, sessionId) {
   const path = `/api/session/${encodeURIComponent(sessionId)}/message?order=desc&limit=200`;
   try {
     const body = await readJson(await client.request(path));
-    if (!isRecord(body) || !Array.isArray(body.data) || !isRecord(body.cursor)) return null;
+    if (!isRecord3(body) || !Array.isArray(body.data) || !isRecord3(body.cursor)) return null;
     return adaptV2Messages(body);
   } catch (error2) {
     console.error(
@@ -4444,7 +5573,7 @@ async function interruptV2Session(client, sessionId) {
 async function getV2ActiveSessions(client) {
   try {
     const body = await readJson(await client.request("/api/session/active"));
-    if (!isRecord(body) || !isRecord(body.data)) return null;
+    if (!isRecord3(body) || !isRecord3(body.data)) return null;
     return body.data;
   } catch (error2) {
     console.error(
@@ -4460,8 +5589,8 @@ async function isV2SessionOngoing(client, sessionId) {
 }
 function sessionErrorReason2(value) {
   if (typeof value === "string" && value.trim()) return value.trim().slice(0, 500);
-  if (isRecord(value)) {
-    const data = isRecord(value.data) ? value.data : void 0;
+  if (isRecord3(value)) {
+    const data = isRecord3(value.data) ? value.data : void 0;
     const reason = typeof data?.message === "string" && data.message || typeof value.message === "string" && value.message || typeof value.name === "string" && value.name;
     if (reason) return reason.replace(/\s+/g, " ").trim().slice(0, 500);
   }
@@ -4477,17 +5606,17 @@ function adaptV2SessionErrorEvent(value) {
       return null;
     }
   }
-  if (!isRecord(parsed)) return null;
+  if (!isRecord3(parsed)) return null;
   try {
     const establishedShape = parseSessionErrorFrame(JSON.stringify(parsed));
     if (establishedShape) return establishedShape;
   } catch (error2) {
     void error2;
   }
-  const candidates = [parsed, parsed.payload, parsed.data].filter(isRecord);
+  const candidates = [parsed, parsed.payload, parsed.data].filter(isRecord3);
   for (const event of candidates) {
     if (event.type !== "session.error") continue;
-    const properties = [event.properties, event.data, event].find(isRecord);
+    const properties = [event.properties, event.data, event].find(isRecord3);
     if (!properties) continue;
     const sessionId = typeof properties.sessionID === "string" && properties.sessionID || typeof properties.sessionId === "string" && properties.sessionId;
     if (!sessionId) continue;
@@ -4537,13 +5666,13 @@ async function readV2SessionErrorStream(client, options) {
 }
 
 // src/lib/opencode/credential-import-v2.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/lib/openai-usage.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join7 } from "node:path";
 var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 var OPENCODE_AUTH_SEGMENTS = [".local", "share", "opencode", "auth.json"];
 var OpenAiUsageError = class extends Error {
@@ -4557,7 +5686,7 @@ function isLocalCredentialProblem2(err) {
 }
 function readOpenCodeChatGptCredentials() {
   try {
-    const raw = readFileSync3(join4(homedir3(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
+    const raw = readFileSync7(join7(homedir3(), ...OPENCODE_AUTH_SEGMENTS), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -4623,7 +5752,7 @@ function parseCodexUsageHeaders(headers) {
 function normalizeProbeModel(model) {
   return model.endsWith("-fast") ? model.slice(0, -"-fast".length) : model;
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function unsupportedProbeModels(reason, port) {
@@ -4634,14 +5763,14 @@ async function resolveV1ProbeModels(client, port) {
   try {
     const response = await client.request("/config/providers");
     const body = await response.json();
-    if (!isRecord2(body) || !Array.isArray(body.providers)) {
+    if (!isRecord4(body) || !Array.isArray(body.providers)) {
       return unsupportedProbeModels("V1 provider response did not contain a providers array", port);
     }
     const provider = body.providers.find(
-      (candidate) => isRecord2(candidate) && candidate.id === "openai"
+      (candidate) => isRecord4(candidate) && candidate.id === "openai"
     );
-    if (!provider || !isRecord2(provider.models)) return { status: "supported", models: [] };
-    const defaults2 = isRecord2(body.default) ? body.default : void 0;
+    if (!provider || !isRecord4(provider.models)) return { status: "supported", models: [] };
+    const defaults2 = isRecord4(body.default) ? body.default : void 0;
     const candidates = [
       ...typeof defaults2?.openai === "string" ? [defaults2.openai] : [],
       ...Object.keys(provider.models)
@@ -4663,14 +5792,14 @@ async function resolveV2ProbeModels(client, port) {
   try {
     const response = await client.request(path);
     const body = await response.json();
-    if (!isRecord2(body) || !Array.isArray(body.data)) {
+    if (!isRecord4(body) || !Array.isArray(body.data)) {
       return unsupportedProbeModels(`V2 GET ${path} did not contain a provider data array`, port);
     }
     const provider = body.data.find(
-      (candidate) => isRecord2(candidate) && candidate.id === "openai"
+      (candidate) => isRecord4(candidate) && candidate.id === "openai"
     );
     if (!provider) return { status: "supported", models: [] };
-    if (!isRecord2(provider.models)) {
+    if (!isRecord4(provider.models)) {
       return unsupportedProbeModels(
         "V2 provider response has no safe OpenAI model catalogue",
         port
@@ -4780,7 +5909,7 @@ var CONNECT_KEY_MAX_ATTEMPTS = 3;
 var CONNECT_KEY_RETRY_DELAY_MS = 250;
 var INTEGRATION_LIST_MAX_READS = 10;
 var INTEGRATION_LIST_RETRY_DELAY_MS = 1e3;
-function isRecord3(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var sleep2 = (milliseconds) => new Promise((resolve5) => setTimeout(resolve5, milliseconds));
@@ -4789,14 +5918,14 @@ function emptyResult(unsupported = [], outcome = "completed") {
 }
 function readOpenCodeCredentials(homeDir, log3) {
   try {
-    const raw = readFileSync4(join5(homeDir, ...OPENCODE_AUTH_SEGMENTS), "utf8");
+    const raw = readFileSync8(join8(homeDir, ...OPENCODE_AUTH_SEGMENTS), "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
     } catch (error2) {
       return null;
     }
-    return isRecord3(parsed) ? parsed : null;
+    return isRecord5(parsed) ? parsed : null;
   } catch (error2) {
     const code = error2.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -4809,7 +5938,7 @@ function classifyOpenCodeCredentials(credentials2) {
   const importable = [];
   const unsupported = [];
   for (const [integrationId, value] of Object.entries(credentials2)) {
-    if (!isRecord3(value) || typeof value.type !== "string") {
+    if (!isRecord5(value) || typeof value.type !== "string") {
       unsupported.push({ integrationId, reason: "unrecognised credential entry" });
       continue;
     }
@@ -4824,7 +5953,7 @@ function classifyOpenCodeCredentials(credentials2) {
       unsupported.push({ integrationId, reason: "unrecognised credential entry" });
       continue;
     }
-    if (value.metadata === void 0 || isRecord3(value.metadata) && Object.keys(value.metadata).length === 0) {
+    if (value.metadata === void 0 || isRecord5(value.metadata) && Object.keys(value.metadata).length === 0) {
       importable.push({ integrationId, key: value.key });
     } else {
       unsupported.push({ integrationId, reason: "needs the interactive connect flow" });
@@ -4837,7 +5966,7 @@ function statusFromRequestError(error2) {
   const match = /^OpenCode request failed: HTTP (\d{3})/.exec(error2.message);
   return match ? Number(match[1]) : void 0;
 }
-function failureMessage(status2) {
+function failureMessage2(status2) {
   return status2 === void 0 ? "OpenCode credential import request failed" : `OpenCode credential import request failed with HTTP ${status2}`;
 }
 function isRetryableStatus(status2) {
@@ -4864,18 +5993,18 @@ async function importOneCredential(request3, credential, sleepForRetry, log3) {
       const failure = {
         integrationId: credential.integrationId,
         status: response.status,
-        message: failureMessage(response.status)
+        message: failureMessage2(response.status)
       };
-      log3(`${failureMessage(failure.status)} for ${failure.integrationId}`, "warn");
+      log3(`${failureMessage2(failure.status)} for ${failure.integrationId}`, "warn");
       return { ok: false, failure };
     } catch (error2) {
       const status2 = statusFromRequestError(error2);
       const failure = {
         integrationId: credential.integrationId,
         ...status2 === void 0 ? {} : { status: status2 },
-        message: failureMessage(status2)
+        message: failureMessage2(status2)
       };
-      log3(`${failureMessage(status2)} for ${failure.integrationId}`, "warn");
+      log3(`${failureMessage2(status2)} for ${failure.integrationId}`, "warn");
       return { ok: false, failure };
     }
   }
@@ -4901,10 +6030,10 @@ async function importOpenCodeCredentials({
   return result;
 }
 function parseIntegrationList(value) {
-  if (!isRecord3(value) || !Array.isArray(value.data)) return null;
+  if (!isRecord5(value) || !Array.isArray(value.data)) return null;
   const integrationIds = /* @__PURE__ */ new Set();
   for (const integration of value.data) {
-    if (!isRecord3(integration) || typeof integration.id !== "string" || !Array.isArray(integration.connections)) {
+    if (!isRecord5(integration) || typeof integration.id !== "string" || !Array.isArray(integration.connections)) {
       return null;
     }
     if (integration.connections.length > 0) integrationIds.add(integration.id);
@@ -4963,113 +6092,35 @@ async function importOpenCodeV2Credentials({
   guard.inFlight = true;
   try {
     const credentials2 = readOpenCodeCredentials(homeDir, log3);
-    if (credentials2 === null) return emptyResult();
-    const classified = classifyOpenCodeCredentials(credentials2);
-    if (classified.importable.length === 0) return emptyResult(classified.unsupported);
-    const connectedIntegrationIds = await getConnectedOpenCodeIntegrationIds({
-      request: request3,
-      directory,
-      sleepForRetry,
-      log: log3
-    });
-    if (connectedIntegrationIds === null) {
-      return emptyResult(classified.unsupported, "connection-list-unavailable");
-    }
-    return importOpenCodeCredentials({
-      request: request3,
-      classified,
-      connectedIntegrationIds,
-      sleepForRetry,
-      log: log3
-    });
-  } finally {
-    guard.inFlight = false;
-  }
-}
-
-// src/lib/opencode/session-db-boot.ts
-import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, resolve as resolvePath } from "node:path";
-
-// src/lib/runner-synchroniser.ts
-import { spawn } from "node:child_process";
-function appendError(stderr, error2) {
-  const message = error2 instanceof Error ? error2.message : String(error2);
-  return stderr === "" ? message : `${stderr}
-${message}`;
-}
-function runSynchroniser(args, opts) {
-  return new Promise((resolve5) => {
-    let child;
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const timer = {};
-    let abortListener;
-    let spawnListener;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      if (timer.handle) clearTimeout(timer.handle);
-      if (abortListener) opts.signal?.removeEventListener("abort", abortListener);
-      if (spawnListener) child.removeListener("spawn", spawnListener);
-      resolve5(result);
-    };
-    try {
-      child = spawn("runner-synchroniser", args, {
-        env: opts.env ?? process.env,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch (error2) {
-      finish({ code: null, stdout, stderr: appendError(stderr, error2), timedOut: false });
-      return;
-    }
-    child.stdout?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.once("error", (error2) => {
-      finish({ code: null, stdout, stderr: appendError(stderr, error2), timedOut: false });
-    });
-    child.once("close", (code) => {
-      finish({ code, stdout, stderr, timedOut: false });
+    if (credentials2 === null) return emptyResult();
+    const classified = classifyOpenCodeCredentials(credentials2);
+    if (classified.importable.length === 0) return emptyResult(classified.unsupported);
+    const connectedIntegrationIds = await getConnectedOpenCodeIntegrationIds({
+      request: request3,
+      directory,
+      sleepForRetry,
+      log: log3
     });
-    if (opts.signal) {
-      const killChild = () => {
-        if (child.pid === void 0) {
-          if (!spawnListener) {
-            spawnListener = killChild;
-            child.once("spawn", spawnListener);
-          }
-          return;
-        }
-        child.kill("SIGKILL");
-      };
-      abortListener = killChild;
-      if (opts.signal.aborted) {
-        abortListener();
-      } else {
-        opts.signal.addEventListener("abort", abortListener, { once: true });
-        if (opts.signal.aborted) abortListener();
-      }
+    if (connectedIntegrationIds === null) {
+      return emptyResult(classified.unsupported, "connection-list-unavailable");
     }
-    timer.handle = setTimeout(
-      () => {
-        child.kill("SIGKILL");
-        finish({ code: null, stdout, stderr, timedOut: true });
-      },
-      Math.max(0, opts.timeoutMs)
-    );
-  });
+    return importOpenCodeCredentials({
+      request: request3,
+      classified,
+      connectedIntegrationIds,
+      sleepForRetry,
+      log: log3
+    });
+  } finally {
+    guard.inFlight = false;
+  }
 }
 
 // src/lib/opencode/session-db-boot.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync4, statSync as statSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname7, resolve as resolvePath } from "node:path";
 var SESSION_DB_RESTORE_TIMEOUT_MS = 3e5;
 var SESSION_DB_VERIFY_TIMEOUT_MS = 36e4;
 var SESSION_DB_SYNCHRONISER_TIMEOUT_MS = 12e4;
@@ -5107,7 +6158,7 @@ function reportRecord(stage, outcome, reason, litestreamExitCode, options) {
 function clearMarker(options) {
   if (!options.noReplicateMarker) return;
   try {
-    unlinkSync2(options.noReplicateMarker);
+    unlinkSync3(options.noReplicateMarker);
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") return;
     options.log(
@@ -5119,8 +6170,8 @@ function clearMarker(options) {
 function markNoReplicate(options, message) {
   if (options.noReplicateMarker) {
     try {
-      mkdirSync(dirname4(options.noReplicateMarker), { recursive: true });
-      writeFileSync(options.noReplicateMarker, "");
+      mkdirSync4(dirname7(options.noReplicateMarker), { recursive: true });
+      writeFileSync4(options.noReplicateMarker, "");
     } catch (error2) {
       options.log(
         `Could not write session-DB no-replicate marker ${options.noReplicateMarker}: ${error2 instanceof Error ? error2.message : String(error2)}`,
@@ -5133,7 +6184,7 @@ function markNoReplicate(options, message) {
 function discardSessionDbDebris(options) {
   for (const path of [options.dbPath, `${options.dbPath}-wal`, `${options.dbPath}-shm`]) {
     try {
-      unlinkSync2(path);
+      unlinkSync3(path);
     } catch (error2) {
       if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") continue;
       options.log(
@@ -5274,8 +6325,8 @@ async function ensureLitestreamConfig(options, env) {
     return null;
   }
   try {
-    mkdirSync(dirname4(configPath), { recursive: true });
-    writeFileSync(configPath, rendered.stdout);
+    mkdirSync4(dirname7(configPath), { recursive: true });
+    writeFileSync4(configPath, rendered.stdout);
   } catch (error2) {
     options.log(
       `Could not write ${configPath}: ${error2 instanceof Error ? error2.message : String(error2)}`,
@@ -5540,8 +6591,8 @@ 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 dirname5, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname8, join as join9 } from "node:path";
 var require2 = createRequire(import.meta.url);
 function readSessionDbMigrationIds(dbPath) {
   let db;
@@ -5578,12 +6629,12 @@ function readSessionDbMigrationIds(dbPath) {
 }
 function sessionDbProvenanceStatePath(homeDir, env) {
   const override = env.EVIDENT_SESSION_DB_PROVENANCE_STATE?.trim();
-  return override || join6(homeDir, ".local", "state", "evident", "session-db-provenance.json");
+  return override || join9(homeDir, ".local", "state", "evident", "session-db-provenance.json");
 }
 function loadSessionDbProvenanceState(path) {
   let value;
   try {
-    value = JSON.parse(readFileSync5(path, "utf8"));
+    value = JSON.parse(readFileSync9(path, "utf8"));
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") return {};
     console.error(
@@ -5607,8 +6658,8 @@ function loadSessionDbProvenanceState(path) {
 }
 function saveSessionDbProvenanceState(path, state) {
   try {
-    mkdirSync2(dirname5(path), { recursive: true });
-    writeFileSync2(path, `${JSON.stringify(state, null, 2)}
+    mkdirSync5(dirname8(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   } catch (error2) {
     console.error(
@@ -5663,6 +6714,26 @@ function isSessionDbProvenanceRecord(value) {
   return typeof record.opencodeVersion === "string" && Array.isArray(record.migrationIds) && record.migrationIds.every((id) => typeof id === "string") && typeof record.updatedAt === "string";
 }
 
+// src/lib/opencode/detect.ts
+function describeProbe(route, result) {
+  if (result.error?.startsWith("HTTP ")) return `${route}: ${result.error}`;
+  if (result.error) return `${route}: no HTTP response (${result.error})`;
+  return `${route}: ${result.healthy ? "healthy" : "no response detail"}`;
+}
+async function classifyRunningOpenCode(port) {
+  const v1 = await checkOpenCodeHealth(port);
+  if (v1.healthy) return { kind: "v1", version: v1.version ?? null };
+  const v2 = await checkOpenCode2Health(port);
+  if (v2.healthy) return { kind: "v2", version: v2.version ?? null };
+  const detail = [
+    describeProbe("V1 /global/health", v1),
+    describeProbe("V2 /api/info (or /api/health fallback)", v2)
+  ].join("; ");
+  if (v1.okWithNonJsonBody && v2.authFailed) return { kind: "v2", version: null };
+  if (v1.authFailed && v2.authFailed) return { kind: "authenticated-unknown", detail };
+  return { kind: "no-server-identified", detail };
+}
+
 // src/lib/opencode/opencode2-package.ts
 var OPENCODE2_PACKAGE_SPEC = "@opencode-ai/cli@0.0.0-beta-17823";
 
@@ -5971,26 +7042,28 @@ async function startOpenCode(port, options = {}) {
 }
 async function startOpenCode2(port, options = {}) {
   const password = randomBytes(24).toString("hex");
-  let command = "opencode2";
+  let command = options.command ?? "opencode2";
   const logLevel = options.inheritStdio ? ["--log-level", resolveOpenCode2LogLevel(process.env)] : [];
   let args = ["serve", "--port", port.toString(), "--hostname", "127.0.0.1", ...logLevel];
-  try {
-    execSync("which opencode2", { stdio: "ignore" });
-  } catch {
-    command = "npx";
-    args = [
-      "-y",
-      "-p",
-      OPENCODE2_PACKAGE_SPEC,
-      "--",
-      "opencode2",
-      "serve",
-      "--port",
-      port.toString(),
-      "--hostname",
-      "127.0.0.1",
-      ...logLevel
-    ];
+  if (options.command === void 0) {
+    try {
+      execSync("which opencode2", { stdio: "ignore" });
+    } catch {
+      command = "npx";
+      args = [
+        "-y",
+        "-p",
+        OPENCODE2_PACKAGE_SPEC,
+        "--",
+        "opencode2",
+        "serve",
+        "--port",
+        port.toString(),
+        "--hostname",
+        "127.0.0.1",
+        ...logLevel
+      ];
+    }
   }
   const child = spawn3(command, args, {
     env: { ...process.env, OPENCODE_SERVER_PASSWORD: password },
@@ -6047,6 +7120,56 @@ function isOpenCode2Installed() {
     return false;
   }
 }
+function readVersionOutput(command) {
+  try {
+    return execSync2(`${command} --version`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch (error2) {
+    const output = typeof error2 === "object" && error2 !== null ? [
+      "stdout" in error2 ? String(error2.stdout ?? "").trim() : "",
+      "stderr" in error2 ? String(error2.stderr ?? "").trim() : ""
+    ].filter(Boolean).join("\n") : "";
+    return output || (error2 instanceof Error ? error2.message : String(error2));
+  }
+}
+function parseOpenCodeVersion(rawVersion) {
+  const output = rawVersion.trim();
+  const prefix = output.match(/^(opencode2|opencode)\s+/i)?.[1]?.toLowerCase();
+  const version2 = (prefix ? output.slice(prefix.length).trim() : output).replace(/^v/i, "");
+  if (prefix === "opencode2") return { major: "v2", version: version2 };
+  const major = version2.match(/^(\d+)(?:\.\d+)*(?:[-+][0-9A-Za-z.-]+)?$/)?.[1];
+  if (!major) return null;
+  if (Number(major) === 1) return { major: "v1", version: version2 };
+  if (Number(major) >= 2) return { major: "v2", version: version2 };
+  return null;
+}
+function resolveInstalledOpenCode() {
+  let opencode2Available = false;
+  if (isOpenCodeInstalled()) {
+    const rawVersion = readVersionOutput("opencode");
+    const parsed = parseOpenCodeVersion(rawVersion);
+    if (parsed?.major === "v1") {
+      return { kind: "installed", major: "v1", command: "opencode", version: parsed.version };
+    }
+    if (parsed?.major === "v2") {
+      return { kind: "installed", major: "v2", command: "opencode", version: parsed.version };
+    }
+    opencode2Available = isOpenCode2Installed();
+    if (!opencode2Available) return { kind: "unknown", command: "opencode", rawVersion };
+  }
+  if (opencode2Available || isOpenCode2Installed()) {
+    const parsed = parseOpenCodeVersion(readVersionOutput("opencode2"));
+    return {
+      kind: "installed",
+      major: "v2",
+      command: "opencode2",
+      version: parsed?.version
+    };
+  }
+  return { kind: "none" };
+}
 async function promptOpenCodeInstall(interactive) {
   if (!interactive) {
     console.log(
@@ -6147,124 +7270,17 @@ function buildNoProviderWarning(hasProvider) {
   return "Warning: opencode has no authenticated model provider configured, so it won't be able to answer prompts. Run `opencode auth login` to set one up (see https://opencode.ai for details).";
 }
 
-// src/lib/opencode/session-cleanup.ts
-var DURATION_UNIT_MS = {
-  s: 1e3,
-  m: 60 * 1e3,
-  h: 60 * 60 * 1e3,
-  d: 24 * 60 * 60 * 1e3
-};
-function parseDurationMs(input) {
-  const trimmed = input.trim();
-  const match = /^(\d+)([smhd])$/.exec(trimmed);
-  if (!match) {
-    throw new Error(
-      `Invalid duration "${input}": expected <number><unit> where unit is one of s, m, h, d (e.g. "7d", "24h", "30m", "90s").`
-    );
-  }
-  const value = Number(match[1]);
-  if (value <= 0) {
-    throw new Error(`Invalid duration "${input}": must be a positive value.`);
-  }
-  return value * DURATION_UNIT_MS[match[2]];
-}
-function selectSessionsToDelete(sessions, opts) {
-  const { maxAgeMs, maxCount, nowMs, protectedIds } = opts;
-  if (maxAgeMs === void 0 && maxCount === void 0) return [];
-  const ageEligible = (s) => {
-    if (maxAgeMs === void 0) return false;
-    if (s.lastActivityMs === null) return true;
-    return nowMs - s.lastActivityMs > maxAgeMs;
-  };
-  const countEligibleIds = /* @__PURE__ */ new Set();
-  if (maxCount !== void 0) {
-    const byActivityDesc = [...sessions].sort(
-      (a, b) => (b.lastActivityMs ?? -Infinity) - (a.lastActivityMs ?? -Infinity)
-    );
-    for (const s of byActivityDesc.slice(maxCount)) {
-      countEligibleIds.add(s.id);
-    }
-  }
-  const toDelete = [];
-  for (const s of sessions) {
-    if (protectedIds.has(s.id)) continue;
-    if (ageEligible(s) || countEligibleIds.has(s.id)) {
-      toDelete.push(s.id);
-    }
-  }
-  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 resolve2(flag, envValue, fallback) {
-  return flag ?? envValue ?? fallback;
-}
-function parseMaxCount(input) {
-  const trimmed = input.trim();
-  if (!/^\d+$/.test(trimmed)) {
-    throw new Error(`Invalid max-count "${input}": expected a positive integer.`);
-  }
-  const value = Number(trimmed);
-  if (value <= 0) {
-    throw new Error(`Invalid max-count "${input}": must be greater than 0.`);
-  }
-  return value;
-}
-function resolveSessionCleanupConfig(flags, env = process.env) {
-  const warnings = [];
-  const maxAgeRaw = resolve2(flags.maxAge, env.EVIDENT_SESSION_CLEANUP_MAX_AGE);
-  const maxCountRaw = resolve2(flags.maxCount, env.EVIDENT_SESSION_CLEANUP_MAX_COUNT);
-  const intervalRaw = resolve2(
-    flags.interval,
-    env.EVIDENT_SESSION_CLEANUP_INTERVAL,
-    DEFAULT_INTERVAL
-  );
-  let maxAgeMs;
-  if (maxAgeRaw !== void 0) {
-    try {
-      maxAgeMs = parseDurationMs(maxAgeRaw);
-    } catch (err) {
-      warnings.push(
-        `Ignoring invalid --session-cleanup-max-age: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  let maxCount;
-  if (maxCountRaw !== void 0) {
-    try {
-      maxCount = parseMaxCount(maxCountRaw);
-    } catch (err) {
-      warnings.push(
-        `Ignoring invalid --session-cleanup-max-count: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  let intervalMs;
-  try {
-    intervalMs = parseDurationMs(intervalRaw ?? DEFAULT_INTERVAL);
-  } catch (err) {
-    warnings.push(
-      `Ignoring invalid --session-cleanup-interval, using default ${DEFAULT_INTERVAL}: ${err instanceof Error ? err.message : String(err)}`
-    );
-    intervalMs = parseDurationMs(DEFAULT_INTERVAL);
-  }
-  const enabled = maxAgeMs !== void 0 || maxCount !== void 0;
-  return { enabled, maxAgeMs, maxCount, intervalMs, warnings };
-}
-
 // src/lib/opencode/session-db-size.ts
 import { statSync as statSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join10 } from "node:path";
 var LARGE_DB_THRESHOLD_BYTES = 268435456;
 function statSessionDbBytes(homeDir) {
-  const dbPath = join7(homeDir, ".local", "share", "opencode", "opencode.db");
+  const dbPath = join10(homeDir, ".local", "share", "opencode", "opencode.db");
   try {
     return statSync4(dbPath).size;
   } catch (err) {
-    const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
-    if (!isMissingFile) {
+    const isMissingFile4 = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (!isMissingFile4) {
       console.error(
         `[statSessionDbBytes] could not stat ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
       );
@@ -6289,12 +7305,12 @@ function buildSessionStoreSizeWarning(input) {
 // src/lib/opencode/log-tail.ts
 import { statSync as statSync5 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join11 } from "node:path";
 import { open as open2, stat } from "node:fs/promises";
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 function resolveOpenCodeLogPath(homeDir = homedir5(), env = process.env) {
-  const dataDir = env.XDG_DATA_HOME || join8(homeDir, ".local", "share");
-  return join8(dataDir, "opencode", "log", "opencode.log");
+  const dataDir = env.XDG_DATA_HOME || join11(homeDir, ".local", "share");
+  return join11(dataDir, "opencode", "log", "opencode.log");
 }
 function isEnoent(error2) {
   return error2?.code === "ENOENT";
@@ -6779,8 +7795,8 @@ function connectTunnel(options) {
           }
           forwarder.handleBinaryBodyFrame(frame.sid, frame.payload);
         } catch (error2) {
-          const errorMessage3 = error2 instanceof Error ? error2.message : "Unknown error";
-          onError?.(`Failed to handle binary message: ${errorMessage3}`);
+          const errorMessage4 = error2 instanceof Error ? error2.message : "Unknown error";
+          onError?.(`Failed to handle binary message: ${errorMessage4}`);
         }
         return;
       }
@@ -6788,8 +7804,8 @@ function connectTunnel(options) {
       try {
         message = JSON.parse(data.toString());
       } catch (error2) {
-        const errorMessage3 = error2 instanceof Error ? error2.message : "Unknown error";
-        onError?.(`Failed to handle message: ${errorMessage3}`);
+        const errorMessage4 = error2 instanceof Error ? error2.message : "Unknown error";
+        onError?.(`Failed to handle message: ${errorMessage4}`);
         return;
       }
       if (isStreamFrame(message)) {
@@ -6961,10 +7977,10 @@ var RunnerConnection = class _RunnerConnection {
 };
 
 // src/lib/tunnel/ready-marker.ts
-import { writeFileSync as writeFileSync3 } from "node:fs";
+import { writeFileSync as writeFileSync6 } from "node:fs";
 function writeTunnelReadyMarker(path, agentId) {
   try {
-    writeFileSync3(path, `${agentId}
+    writeFileSync6(path, `${agentId}
 `);
     return { ok: true };
   } catch (error2) {
@@ -6989,7 +8005,7 @@ async function stopSessionDbReplication(child, timeoutMs) {
 }
 
 // src/lib/process-liveness.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -7004,7 +8020,7 @@ function isProcessAlive(pid) {
   }
   if (process.platform !== "linux") return true;
   try {
-    const status2 = readFileSync6(`/proc/${pid}/status`, "utf8");
+    const status2 = readFileSync10(`/proc/${pid}/status`, "utf8");
     return !/^State:\s+Z(?:\s|$)/m.test(status2);
   } catch (error2) {
     console.error(
@@ -7071,8 +8087,8 @@ function resolveOpenAiUsageReportingMode(flagValue, env) {
 }
 
 // src/lib/resource-usage-reporting.ts
-var ENABLED_VALUES = /* @__PURE__ */ new Set(["on", "true", "1"]);
-var DISABLED_VALUES = /* @__PURE__ */ new Set(["off", "false", "0"]);
+var ENABLED_VALUES2 = /* @__PURE__ */ new Set(["on", "true", "1"]);
+var DISABLED_VALUES2 = /* @__PURE__ */ new Set(["off", "false", "0"]);
 function resolveResourceUsageReportingEnabled(flagValue, env) {
   if (flagValue === false) {
     return { enabled: false, warnings: [] };
@@ -7082,10 +8098,10 @@ function resolveResourceUsageReportingEnabled(flagValue, env) {
     return { enabled: true, warnings: [] };
   }
   const normalized = raw.trim().toLowerCase();
-  if (DISABLED_VALUES.has(normalized)) {
+  if (DISABLED_VALUES2.has(normalized)) {
     return { enabled: false, warnings: [] };
   }
-  if (ENABLED_VALUES.has(normalized)) {
+  if (ENABLED_VALUES2.has(normalized)) {
     return { enabled: true, warnings: [] };
   }
   return {
@@ -7363,18 +8379,18 @@ function createSessionStoreHealth(options = {}) {
 import { homedir as homedir6 } from "node:os";
 
 // src/lib/runner-file-sync.ts
-import { join as join10 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/lib/file-push.ts
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, open as open3, realpath, rename, unlink } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+import { basename as basename2, dirname as dirname9, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 var FILE_MODE = 384;
 var DIRECTORY_MODE = 448;
 async function writePushedFile(request3) {
-  const { requestedPath, content, allowedDirectories, homeDir } = request3;
+  const { requestedPath, content, allowedDirectories, allowedFiles, homeDir } = request3;
   const bytes = content.byteLength;
-  if (allowedDirectories.length === 0) {
+  if (allowedDirectories.length === 0 && allowedFiles.length === 0) {
     return refuse("file_sync_disabled", "File sync is not enabled on this runner.", {
       path: requestedPath,
       bytes
@@ -7399,10 +8415,10 @@ async function writePushedFile(request3) {
   }
   try {
     const { existingAncestor, missingSegments } = await resolveNearestExistingAncestor(
-      dirname6(candidate)
+      dirname9(candidate)
     );
-    const realTarget = join9(existingAncestor, ...missingSegments, basename2(candidate));
-    const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget);
+    const realTarget = join12(existingAncestor, ...missingSegments, basename2(candidate));
+    const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget) ?? await findMatchingAllowedFile(allowedFiles, realTarget);
     if (allowedDirectory === null) {
       return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
         path: realTarget,
@@ -7411,8 +8427,8 @@ async function writePushedFile(request3) {
     }
     if (missingSegments.length > 0) {
       await createMissingDirectories(existingAncestor, missingSegments);
-      const realParent = await realpath(dirname6(realTarget));
-      if (realParent !== dirname6(realTarget) || !contains(allowedDirectory, realTarget)) {
+      const realParent = await realpath(dirname9(realTarget));
+      if (realParent !== dirname9(realTarget) || !contains(allowedDirectory, realTarget)) {
         return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
           path: realTarget,
           bytes,
@@ -7437,7 +8453,7 @@ function expandAndValidate(requestedPath, homeDir) {
   if (requestedPath.trim() === "" || requestedPath.includes("\0")) {
     return null;
   }
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join9(homeDir, requestedPath.slice(2)) : requestedPath;
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join12(homeDir, requestedPath.slice(2)) : requestedPath;
   if (expanded.split(/[/\\]/).includes("..")) {
     return null;
   }
@@ -7455,7 +8471,7 @@ async function resolveNearestExistingAncestor(directory) {
     try {
       return { existingAncestor: await realpath(current), missingSegments };
     } catch (err) {
-      const parent = dirname6(current);
+      const parent = dirname9(current);
       if (err.code !== "ENOENT" || parent === current) {
         throw err;
       }
@@ -7477,6 +8493,22 @@ async function findContainingAllowedDirectory(allowedDirectories, realTarget) {
   }
   return null;
 }
+async function findMatchingAllowedFile(allowedFiles, realTarget) {
+  for (const entry of allowedFiles) {
+    if (!isAbsolute2(entry)) {
+      log("warn", "file_push_allowed_directory_skipped", {
+        directory: entry,
+        reason: "not_absolute_file"
+      });
+      continue;
+    }
+    const realParent = await realpathCreatingIfMissing(dirname9(entry));
+    if (realParent !== null && join12(realParent, basename2(entry)) === realTarget) {
+      return realParent;
+    }
+  }
+  return null;
+}
 async function realpathCreatingIfMissing(directory) {
   try {
     return await realpath(directory);
@@ -7510,13 +8542,13 @@ function contains(realDirectory, realTarget) {
 async function createMissingDirectories(existingAncestor, missingSegments) {
   let current = existingAncestor;
   for (const segment of missingSegments) {
-    current = join9(current, segment);
+    current = join12(current, segment);
     await mkdir(current, { recursive: true, mode: DIRECTORY_MODE });
     await chmod(current, DIRECTORY_MODE);
   }
 }
 async function writeAtomically(realTarget, content) {
-  const temporaryPath = join9(dirname6(realTarget), `.evident-push-${randomUUID()}.tmp`);
+  const temporaryPath = join12(dirname9(realTarget), `.evident-push-${randomUUID()}.tmp`);
   let handle;
   try {
     handle = await open3(temporaryPath, "wx", FILE_MODE);
@@ -7646,16 +8678,16 @@ var NOT_APPLIED = {
   opencodeAuthApplied: false
 };
 function isClaudeCredentialPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join10(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join10(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join13(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join13(homeDir, ...CLAUDE_CREDENTIALS_SEGMENTS);
 }
 function isOpenCodeAuthPath(requestedPath, homeDir) {
-  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join10(homeDir, requestedPath.slice(2)) : requestedPath;
-  return expanded === join10(homeDir, ...OPENCODE_AUTH_SEGMENTS);
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join13(homeDir, requestedPath.slice(2)) : requestedPath;
+  return expanded === join13(homeDir, ...OPENCODE_AUTH_SEGMENTS);
 }
 async function applyOne(options, file) {
   const label = `${file.id.slice(0, 8)} (${file.path})`;
-  if (options.allowedDirectories.length === 0) {
+  if (options.allowedDirectories.length === 0 && options.allowedFiles.length === 0) {
     options.log({
       level: "warn",
       message: `Runner file ${label} rejected: file sync is not enabled on this runner (start it with --enable-file-sync-to)`
@@ -7682,6 +8714,7 @@ async function applyOne(options, file) {
       requestedPath: file.path,
       content: download.content,
       allowedDirectories: options.allowedDirectories,
+      allowedFiles: options.allowedFiles,
       homeDir: options.homeDir
     });
   } catch (err) {
@@ -7789,7 +8822,7 @@ function describe(err) {
 }
 
 // src/lib/vault-file-sync.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 async function syncVaultFiles(options) {
   const files = await listVaultFiles(options);
   if (files === null) return { applied: 0 };
@@ -7885,7 +8918,7 @@ async function reconcileVaultFile(options, file) {
   }
   const content = await downloadVaultFile(options, file);
   if (content === null) return false;
-  const actualSha256 = createHash("sha256").update(content).digest("hex");
+  const actualSha256 = createHash2("sha256").update(content).digest("hex");
   if (actualSha256 !== file.content_sha256) {
     options.log({
       level: "warn",
@@ -7933,6 +8966,7 @@ async function applyVaultFile(options, file, content) {
       requestedPath: file.destination_path,
       content,
       allowedDirectories: options.allowedDirectories,
+      allowedFiles: options.allowedFiles,
       homeDir: options.homeDir
     });
     if (!outcome.ok) {
@@ -8001,7 +9035,7 @@ function messageIdOf(m) {
   return typeof infoId === "string" ? infoId : void 0;
 }
 function composeAbandonmentNote(finish, replyShape, outcome) {
-  const base = `OpenCode ended this turn after a tool call (finish="${finish ?? "(unknown)"}") ` + (outcome === "without-answer" ? "without writing an answer, and confirmed it is no longer working on this conversation. Evident is reporting the run as failed so the failure and its reason are visible in failed runs." : "after writing only part of an answer, and confirmed it is no longer working on this conversation. Evident delivered what was written and is reporting the run as finished.");
+  const base = outcome === "midflight-without-answer" || outcome === "midflight-with-answer" ? "OpenCode stopped this turn without ever finishing, and confirmed the session is no longer running. " + (outcome === "midflight-without-answer" ? "Evident is reporting the run as failed so the failure and its reason are visible in failed runs." : "Evident delivered what was written and is reporting the run as finished.") : `OpenCode ended this turn after a tool call (finish="${finish ?? "(unknown)"}") ` + (outcome === "without-answer" ? "without writing an answer, and confirmed it is no longer working on this conversation. Evident is reporting the run as failed so the failure and its reason are visible in failed runs." : "after writing only part of an answer, and confirmed it is no longer working on this conversation. Evident delivered what was written and is reporting the run as finished.");
   if (replyShape === null) return base;
   return `${base} ${replyShape.lastToolName === null ? "No tool call was recorded" : `The last tool call was "${replyShape.lastToolName}" with status "${replyShape.lastToolStatus ?? "(unknown)"}"`}; the reply's final part types were [${replyShape.partTypes.join(", ")}]${replyShape.droppedPartCount > 0 ? ` (${replyShape.droppedPartCount} earlier part types omitted)` : ""}.`;
 }
@@ -8038,6 +9072,9 @@ var ALIVE_WITHHELD_THRESHOLD_MS = 3 * HEARTBEAT_MS;
 var ABSOLUTE_MAX_PROCESSING_MS = 6 * 60 * 60 * 1e3;
 var B2_ABANDONMENT_MIN_PINNED_MS = 3 * 6e4;
 var AMBIGUOUS_FINISH_MAX_PINNED_MS = 3 * 6e4;
+var MIDFLIGHT_ORPHAN_MIN_PINNED_MS = 3 * 6e4;
+var MIDFLIGHT_ORPHAN_RECHECK_MS = 6e4;
+var MIDFLIGHT_ORPHAN_MIN_NOT_ONGOING_STREAK = 2;
 var B2_ABANDONMENT_RECHECK_MS = HEARTBEAT_MS;
 var POLL_MISS_GRACE_MS = HEARTBEAT_MS;
 var WATCHER_STALL_MS = 3 * POLL_MISS_GRACE_MS;
@@ -8082,6 +9119,7 @@ var ChannelDriver = class _ChannelDriver {
   conversationFilter;
   retry;
   log;
+  recordBinding;
   fetchImpl;
   sleep;
   pausedPollIntervalMs;
@@ -8089,6 +9127,7 @@ var ChannelDriver = class _ChannelDriver {
   stuckQueuedMs;
   now;
   fileSyncDirectories;
+  fileSyncExactFiles;
   homeDir;
   maxActiveSessions;
   watcherStallMs;
@@ -8443,6 +9482,7 @@ var ChannelDriver = class _ChannelDriver {
     this.retry = { ...DEFAULT_RETRY_POLICY, ...config.retry };
     this.log = config.log ?? (() => {
     });
+    this.recordBinding = config.recordBinding;
     this.fetchImpl = withRequestTimeout(
       config.fetchImpl ?? fetch,
       config.requestTimeoutMs ?? REQUEST_TIMEOUT_MS
@@ -8458,6 +9498,7 @@ var ChannelDriver = class _ChannelDriver {
     this.stuckQueuedMs = config.stuckQueuedMs ?? DEFAULT_STUCK_QUEUED_MS;
     this.now = config.now ?? (() => Date.now());
     this.fileSyncDirectories = config.fileSyncDirectories ?? [];
+    this.fileSyncExactFiles = config.fileSyncExactFiles ?? [];
     this.homeDir = config.homeDir ?? homedir6();
     this.maxActiveSessions = config.maxActiveSessions;
     this.watcherStallMs = config.watcherStallMs ?? WATCHER_STALL_MS;
@@ -8555,6 +9596,7 @@ var ChannelDriver = class _ChannelDriver {
         getAuthHeader: this.getAuthHeader,
         fetchImpl: this.fetchImpl,
         allowedDirectories: this.fileSyncDirectories,
+        allowedFiles: this.fileSyncExactFiles,
         homeDir: this.homeDir,
         ackFailures: this.fileAckFailures,
         log: this.log
@@ -8565,6 +9607,7 @@ var ChannelDriver = class _ChannelDriver {
         getAuthHeader: this.getAuthHeader,
         fetchImpl: this.fetchImpl,
         allowedDirectories: this.fileSyncDirectories,
+        allowedFiles: this.fileSyncExactFiles,
         homeDir: this.homeDir,
         outcomes: this.vaultFileOutcomes,
         log: this.log
@@ -8627,6 +9670,9 @@ var ChannelDriver = class _ChannelDriver {
       let cappedSkips = 0;
       for (const conv of conversations) {
         if (this.stopped) break;
+        if (conv.opencode_session_id) {
+          this.recordSessionBinding(conv.id, conv.opencode_session_id);
+        }
         if (this.maxActiveSessions !== void 0) {
           const activeSessionIds = this.activeSessionIdsForCap();
           const resolvedSessionId = this.sessions.get(conv.id) ?? conv.opencode_session_id;
@@ -8709,12 +9755,12 @@ var ChannelDriver = class _ChannelDriver {
     this.sessions.delete(conversationId);
     this.supersede(conversationId, sessionId);
     const dispatchDescription = source === "readopt" ? "re-dispatched message" : "message";
-    const errorMessage3 = `OpenCode accepted this ${dispatchDescription} once, but its assigned id was never confirmed after ${attempts} attempts to match it up \u2014 the message was deliberately not sent again, so no duplicate turn was created; session ${sessionId.slice(0, 8)} was abandoned; a fresh one is used for further messages.`;
-    this.untrackableAck.set(messageId, errorMessage3);
+    const errorMessage4 = `OpenCode accepted this ${dispatchDescription} once, but its assigned id was never confirmed after ${attempts} attempts to match it up \u2014 the message was deliberately not sent again, so no duplicate turn was created; session ${sessionId.slice(0, 8)} was abandoned; a fresh one is used for further messages.`;
+    this.untrackableAck.set(messageId, errorMessage4);
     this.untrackableAckSessionIds.set(messageId, null);
     this.log({
       level: "error",
-      message: errorMessage3,
+      message: errorMessage4,
       conversation_id: conversationId,
       message_id: messageId
     });
@@ -8722,7 +9768,7 @@ var ChannelDriver = class _ChannelDriver {
       conversationId,
       messageId,
       null,
-      errorMessage3
+      errorMessage4
     );
     if (reportError !== null) {
       this.log({
@@ -8903,12 +9949,12 @@ var ChannelDriver = class _ChannelDriver {
           conversation_id: conv.id,
           message_id: message.id
         });
-        const errorMessage3 = this.untrackableAck.get(message.id);
+        const errorMessage4 = this.untrackableAck.get(message.id);
         const reportError = await this.reportUntrackableAck(
           conv.id,
           message.id,
           null,
-          errorMessage3
+          errorMessage4
         );
         if (reportError === null) {
           continue;
@@ -8996,7 +10042,7 @@ var ChannelDriver = class _ChannelDriver {
         const hasProviderAndModel = dispatchedModel !== null && separator > 0 && separator < dispatchedModel.length - 1;
         const providerId = hasProviderAndModel ? dispatchedModel.slice(0, separator) : null;
         const modelId = hasProviderAndModel ? dispatchedModel.slice(separator + 1) : null;
-        const errorMessage3 = `Provider namespace not loaded on this runner: ${message.opencode_model}. Refused before dispatch; no turn was started.`;
+        const errorMessage4 = `Provider namespace not loaded on this runner: ${message.opencode_model}. Refused before dispatch; no turn was started.`;
         this.log({
           level: "error",
           message: `Refusing message ${message.id.slice(0, 8)} in conversation ${conv.id.slice(0, 8)}: provider namespace ${providerId ?? "(unknown)"} is not loaded; no turn was started`,
@@ -9004,7 +10050,7 @@ var ChannelDriver = class _ChannelDriver {
           message_id: message.id
         });
         try {
-          await this.markFailed(conv.id, message.id, sessionId, errorMessage3, void 0, {
+          await this.markFailed(conv.id, message.id, sessionId, errorMessage4, void 0, {
             classification: {
               kind: "model_auth",
               providerId,
@@ -9076,12 +10122,12 @@ var ChannelDriver = class _ChannelDriver {
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (this.isV2 && err instanceof OpenCodeV2PromptAckError) {
-          const errorMessage4 = err instanceof Error ? err.message : String(err);
-          this.untrackableAck.set(message.id, errorMessage4);
+          const errorMessage5 = err instanceof Error ? err.message : String(err);
+          this.untrackableAck.set(message.id, errorMessage5);
           this.untrackableAckSessionIds.set(message.id, null);
           this.log({
             level: "error",
-            message: `V2 prompt dispatch for message ${message.id.slice(0, 8)} failed after a positive ack with no usable id: ${errorMessage4}`,
+            message: `V2 prompt dispatch for message ${message.id.slice(0, 8)} failed after a positive ack with no usable id: ${errorMessage5}`,
             conversation_id: conv.id,
             message_id: message.id
           });
@@ -9089,7 +10135,7 @@ var ChannelDriver = class _ChannelDriver {
             conv.id,
             message.id,
             null,
-            errorMessage4
+            errorMessage5
           );
           if (markError !== null) {
             this.log({
@@ -9124,7 +10170,7 @@ var ChannelDriver = class _ChannelDriver {
           this.signalDispatchNotStarted(conv, message, "session_existence_unknown");
           break;
         }
-        const errorMessage3 = err instanceof Error ? err.message : String(err);
+        const errorMessage4 = err instanceof Error ? err.message : String(err);
         this.sessions.delete(conv.id);
         this.supersede(conv.id, sessionId);
         this.log({
@@ -9133,7 +10179,7 @@ var ChannelDriver = class _ChannelDriver {
           conversation_id: conv.id,
           message_id: message.id
         });
-        await this.markFailed(conv.id, message.id, null, errorMessage3).catch((markErr) => {
+        await this.markFailed(conv.id, message.id, null, errorMessage4).catch((markErr) => {
           this.log({
             level: "warn",
             message: `markFailed PATCH for message ${message.id.slice(0, 8)} (conversation ${conv.id.slice(0, 8)}) failed (best-effort, not retried): ${markErr instanceof Error ? markErr.message : String(markErr)}`,
@@ -9144,7 +10190,7 @@ var ChannelDriver = class _ChannelDriver {
         });
         this.log({
           level: "error",
-          message: `Message ${message.id.slice(0, 8)} dispatch failed: ${errorMessage3}`,
+          message: `Message ${message.id.slice(0, 8)} dispatch failed: ${errorMessage4}`,
           conversation_id: conv.id,
           message_id: message.id
         });
@@ -9931,6 +10977,7 @@ var ChannelDriver = class _ChannelDriver {
         return { sessionId: await this.createAndBindSession(conv.id), created: true };
       }
       this.sessions.set(conv.id, bound);
+      this.recordSessionBinding(conv.id, bound);
       return { sessionId: bound, created: false };
     }
     return { sessionId: await this.createAndBindSession(conv.id), created: true };
@@ -9944,6 +10991,7 @@ var ChannelDriver = class _ChannelDriver {
     const directory = await this.resolveOpenCodeDirectory();
     const sessionId = await this.createOpenCodeSession(directory);
     this.sessions.set(conversationId, sessionId);
+    this.recordSessionBinding(conversationId, sessionId);
     await this.persistSession(conversationId, sessionId).catch((err) => {
       this.log({
         level: "warn",
@@ -9953,6 +11001,18 @@ var ChannelDriver = class _ChannelDriver {
     });
     return sessionId;
   }
+  recordSessionBinding(conversationId, sessionId) {
+    if (!this.recordBinding) return;
+    try {
+      this.recordBinding(conversationId, sessionId);
+    } catch (error2) {
+      this.log({
+        level: "warn",
+        message: `Recording OpenCode session ${sessionId.slice(0, 8)} for conversation ${conversationId.slice(0, 8)} failed (best-effort): ${error2 instanceof Error ? error2.message : String(error2)}`,
+        conversation_id: conversationId
+      });
+    }
+  }
   /**
    * Lazily resolve (and cache) opencode's root directory via the selected client's
    * location lookup.
@@ -10150,6 +11210,12 @@ var ChannelDriver = class _ChannelDriver {
       b2AbandonedWithoutAnswer: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      midFlightPinnedSinceMs: 0,
+      midFlightNotOngoingStreak: 0,
+      midFlightLastStatusCheckMs: 0,
+      midFlightOrphanSignalled: false,
+      midFlightOrphanWithoutAnswer: false,
+      midFlightHeldLogged: false,
       sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
@@ -10289,6 +11355,12 @@ var ChannelDriver = class _ChannelDriver {
       b2AbandonedWithoutAnswer: false,
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false,
+      midFlightPinnedSinceMs: 0,
+      midFlightNotOngoingStreak: 0,
+      midFlightLastStatusCheckMs: 0,
+      midFlightOrphanSignalled: false,
+      midFlightOrphanWithoutAnswer: false,
+      midFlightHeldLogged: false,
       sessionStoreFailurePending: false,
       neverStartedResolved: false
     });
@@ -11060,7 +12132,11 @@ var ChannelDriver = class _ChannelDriver {
             watcher,
             inFlight,
             messages,
-            finish
+            composeAbandonmentNote(
+              finish,
+              describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+              "without-answer"
+            )
           );
         } else {
           await this.settleMessageDone(
@@ -11119,7 +12195,11 @@ var ChannelDriver = class _ChannelDriver {
               watcher,
               inFlight,
               messages,
-              finish
+              composeAbandonmentNote(
+                finish,
+                describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+                "without-answer"
+              )
             );
             return;
           }
@@ -11196,21 +12276,121 @@ var ChannelDriver = class _ChannelDriver {
             run_state: "failed",
             opencode_message_id: inFlight.opencodeMessageId
           });
-          await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+          await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+          return;
+        }
+        inFlight.ambiguousResolved = true;
+        this.log({
+          level: "warn",
+          message: `Message ${id.slice(0, 8)} ambiguous-finish-pinned for ${Math.round(pinnedForMs / 1e3)}s \u2014 resolved (${ongoing === false ? "session confirmed not-ongoing" : "pin exceeded the no-hang cap"}) \u2014 settling done`,
+          conversation_id: conv.id,
+          message_id: id
+        });
+        void this.postSignal(conv.id, id, "ambiguous_finish_resolved", {
+          watched_for_ms: pinnedForMs
+        });
+        await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+        return;
+      }
+    }
+    const midFlightPinnedNow = activelyRunning && isMidFlightPinnedRunning(messages, inFlight.opencodeMessageId);
+    if (!midFlightPinnedNow) {
+      if (snapshotReadable) {
+        inFlight.midFlightPinnedSinceMs = 0;
+        inFlight.midFlightNotOngoingStreak = 0;
+        inFlight.midFlightLastStatusCheckMs = 0;
+        inFlight.midFlightOrphanSignalled = false;
+        inFlight.midFlightOrphanWithoutAnswer = false;
+        inFlight.midFlightHeldLogged = false;
+      }
+    } else {
+      if (inFlight.midFlightOrphanSignalled) {
+        const note = composeAbandonmentNote(
+          void 0,
+          describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+          inFlight.midFlightOrphanWithoutAnswer ? "midflight-without-answer" : "midflight-with-answer"
+        );
+        if (inFlight.midFlightOrphanWithoutAnswer) {
+          await this.settleMessageAbandonedWithoutAnswer(
+            sessionId,
+            watcher,
+            inFlight,
+            messages,
+            note
+          );
+        } else {
+          await this.settleMessageDone(sessionId, watcher, inFlight, messages, note);
+        }
+        return;
+      }
+      if (inFlight.midFlightPinnedSinceMs === 0) {
+        inFlight.midFlightPinnedSinceMs = this.now();
+      }
+      const pinnedForMs = this.now() - inFlight.midFlightPinnedSinceMs;
+      if (pinnedForMs >= MIDFLIGHT_ORPHAN_MIN_PINNED_MS && this.now() - inFlight.midFlightLastStatusCheckMs >= MIDFLIGHT_ORPHAN_RECHECK_MS) {
+        inFlight.midFlightLastStatusCheckMs = this.now();
+        const rootOngoing = await this.isSessionOngoing(sessionId);
+        inFlight.midFlightNotOngoingStreak = rootOngoing === false ? inFlight.midFlightNotOngoingStreak + 1 : 0;
+        if (isMidFlightOrphanConfirmed({
+          pinnedForMs,
+          minPinnedMs: MIDFLIGHT_ORPHAN_MIN_PINNED_MS,
+          notOngoingStreak: inFlight.midFlightNotOngoingStreak,
+          minNotOngoingStreak: MIDFLIGHT_ORPHAN_MIN_NOT_ONGOING_STREAK
+        })) {
+          if (this.sessionStoreHealth?.isUnwritable()) {
+            inFlight.sessionStoreFailurePending = true;
+            void this.postSignal(conv.id, id, "midflight_orphan_resolved", {
+              watched_for_ms: pinnedForMs,
+              ...rootOngoing != null ? { root_ongoing: rootOngoing } : {},
+              opencode_message_id: inFlight.opencodeMessageId,
+              run_state: "failed"
+            });
+            await this.settleMessageSessionStoreUnwritable(sessionId, watcher, inFlight);
+            return;
+          }
+          inFlight.midFlightOrphanSignalled = true;
+          const noteOutcome = extractReplyTextForMessage(messages, inFlight.opencodeMessageId) === null ? "midflight-without-answer" : "midflight-with-answer";
+          inFlight.midFlightOrphanWithoutAnswer = noteOutcome === "midflight-without-answer";
+          void this.postSignal(conv.id, id, "midflight_orphan_resolved", {
+            watched_for_ms: pinnedForMs,
+            ...rootOngoing != null ? { root_ongoing: rootOngoing } : {},
+            opencode_message_id: inFlight.opencodeMessageId,
+            ...inFlight.midFlightOrphanWithoutAnswer ? { run_state: "failed" } : {}
+          });
+          const note = composeAbandonmentNote(
+            void 0,
+            describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
+            noteOutcome
+          );
+          this.log({
+            level: "warn",
+            message: `Message ${id.slice(0, 8)} was pinned mid-flight for ${Math.round(pinnedForMs / 1e3)}s with root_ongoing=${rootOngoing} \u2014 resolving the orphaned turn`,
+            conversation_id: conv.id,
+            message_id: id
+          });
+          if (inFlight.midFlightOrphanWithoutAnswer) {
+            await this.settleMessageAbandonedWithoutAnswer(
+              sessionId,
+              watcher,
+              inFlight,
+              messages,
+              note
+            );
+          } else {
+            await this.settleMessageDone(sessionId, watcher, inFlight, messages, note);
+          }
           return;
         }
-        inFlight.ambiguousResolved = true;
-        this.log({
-          level: "warn",
-          message: `Message ${id.slice(0, 8)} ambiguous-finish-pinned for ${Math.round(pinnedForMs / 1e3)}s \u2014 resolved (${ongoing === false ? "session confirmed not-ongoing" : "pin exceeded the no-hang cap"}) \u2014 settling done`,
-          conversation_id: conv.id,
-          message_id: id
-        });
-        void this.postSignal(conv.id, id, "ambiguous_finish_resolved", {
-          watched_for_ms: pinnedForMs
-        });
-        await this.settleMessageDone(sessionId, watcher, inFlight, messages);
-        return;
+        if (rootOngoing === true && !inFlight.midFlightHeldLogged) {
+          inFlight.midFlightHeldLogged = true;
+          const replyShape = describeAbandonedReplyShape(messages, inFlight.opencodeMessageId);
+          this.log({
+            level: "warn",
+            message: `Message ${id.slice(0, 8)} was pinned mid-flight for ${Math.round(pinnedForMs / 1e3)}s with root_ongoing=true \u2014 holding; last tool ${replyShape?.lastToolName ?? "(unknown)"} status ${replyShape?.lastToolStatus ?? "(unknown)"}`,
+            conversation_id: conv.id,
+            message_id: id
+          });
+        }
       }
     }
     if (watcher.inFlight.has(inFlight.evidentMessageId) && activelyRunning && this.now() - inFlight.processingAnchorMs >= ABSOLUTE_MAX_PROCESSING_MS) {
@@ -11412,13 +12592,8 @@ 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) {
+  async settleMessageAbandonedWithoutAnswer(sessionId, watcher, inFlight, messages, error2) {
     const conv = watcher.conv;
-    const error2 = composeAbandonmentNote(
-      finish,
-      describeAbandonedReplyShape(messages, inFlight.opencodeMessageId),
-      "without-answer"
-    );
     this.anchorDeliveryDeadline(inFlight);
     this.log({
       level: "warn",
@@ -11938,12 +13113,12 @@ var ChannelDriver = class _ChannelDriver {
           conversation_id: row.conversation_id,
           message_id: row.id
         });
-        const errorMessage3 = this.untrackableAck.get(row.id);
+        const errorMessage4 = this.untrackableAck.get(row.id);
         const reportError = await this.reportUntrackableAck(
           row.conversation_id,
           row.id,
           this.untrackableAckSessionIds.get(row.id) ?? null,
-          errorMessage3
+          errorMessage4
         );
         if (reportError !== null) {
           this.log({
@@ -12256,14 +13431,14 @@ var ChannelDriver = class _ChannelDriver {
       this.awaitingReadopt.delete(row.id);
       if (err instanceof ChannelAuthError) throw err;
       if (this.isV2) {
-        const errorMessage3 = err instanceof Error ? err.message : String(err);
+        const errorMessage4 = err instanceof Error ? err.message : String(err);
         const invalidPromptAck = err instanceof OpenCodeV2PromptAckError;
         if (!invalidPromptAck) {
           const exists = await this.sessionExists(sessionId);
           if (exists === false) {
             this.log({
               level: "warn",
-              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch hit a session (${sessionId.slice(0, 8)}) that was deleted mid-dispatch \u2014 deferring to the next drain: ${errorMessage3}`,
+              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch hit a session (${sessionId.slice(0, 8)}) that was deleted mid-dispatch \u2014 deferring to the next drain: ${errorMessage4}`,
               conversation_id: row.conversation_id,
               message_id: row.id
             });
@@ -12273,7 +13448,7 @@ var ChannelDriver = class _ChannelDriver {
           if (exists === null) {
             this.log({
               level: "warn",
-              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch failed and session (${sessionId.slice(0, 8)}) existence could not be confirmed \u2014 deferring to the next drain: ${errorMessage3}`,
+              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch failed and session (${sessionId.slice(0, 8)}) existence could not be confirmed \u2014 deferring to the next drain: ${errorMessage4}`,
               conversation_id: row.conversation_id,
               message_id: row.id
             });
@@ -12281,12 +13456,12 @@ var ChannelDriver = class _ChannelDriver {
             return;
           }
         } else {
-          this.untrackableAck.set(row.id, errorMessage3);
+          this.untrackableAck.set(row.id, errorMessage4);
           this.untrackableAckSessionIds.set(row.id, sessionId);
         }
         this.log({
           level: "error",
-          message: `V2 re-adopt dispatch for message ${row.id.slice(0, 8)} failed: ${errorMessage3}`,
+          message: `V2 re-adopt dispatch for message ${row.id.slice(0, 8)} failed: ${errorMessage4}`,
           conversation_id: row.conversation_id,
           message_id: row.id
         });
@@ -12295,7 +13470,7 @@ var ChannelDriver = class _ChannelDriver {
             row.conversation_id,
             row.id,
             sessionId,
-            errorMessage3
+            errorMessage4
           );
           if (markError !== null) {
             this.log({
@@ -12306,7 +13481,7 @@ var ChannelDriver = class _ChannelDriver {
             });
           }
         } else {
-          await this.markFailed(row.conversation_id, row.id, sessionId, errorMessage3).catch(
+          await this.markFailed(row.conversation_id, row.id, sessionId, errorMessage4).catch(
             (markErr) => {
               this.log({
                 level: "warn",
@@ -13290,9 +14465,9 @@ var ChannelDriver = class _ChannelDriver {
    * trackable. Callers use the returned error to keep their path-specific logging
    * while the same report payload can be retried on a later drain.
    */
-  async reportUntrackableAck(conversationId, messageId, sessionId, errorMessage3) {
+  async reportUntrackableAck(conversationId, messageId, sessionId, errorMessage4) {
     try {
-      await this.markFailed(conversationId, messageId, sessionId, errorMessage3);
+      await this.markFailed(conversationId, messageId, sessionId, errorMessage4);
       return null;
     } catch (err) {
       this.signalUntrackableAck(conversationId, messageId);
@@ -13804,7 +14979,7 @@ import ora3 from "ora";
 import { select as select3 } from "@inquirer/prompts";
 function unknownPasswordError2(port) {
   return new Error(
-    `OpenCode V2 (opencode2) is already running on port ${port} with a password this runner doesn't know. Free the port or pass --port.`
+    `An assistant on port ${port} requires credentials this runner does not have. Released OpenCode V2 generates a server password even when none is configured. This CLI has no option to supply the password for an already-running server, so it will not join one you started. Free port ${port} so Evident can start its own, or pass --port to choose another.`
   );
 }
 var INTERACTIVE_START_TIMEOUT_MS2 = 3e4;
@@ -13822,9 +14997,9 @@ async function ensureOpenCode2Running(ctx) {
       password: null
     };
   }
-  if (!isOpenCode2Installed()) {
+  if (!ctx.command && !isOpenCode2Installed()) {
     throw new Error(
-      `OpenCode V2 (opencode2) is not installed. Install it with: npm install -g ${OPENCODE2_PACKAGE_SPEC}`
+      "OpenCode V2 is not installed. Install it with `npm install -g @opencode/cli` or `curl -fsSL https://opencode.ai/v2/install | bash`."
     );
   }
   let port = ctx.port;
@@ -13852,7 +15027,8 @@ Port ${port} is already in use.`));
   if (!ctx.interactive) {
     ctx.log(`OpenCode V2 is not running on port ${port}. Starting it automatically...`);
     const { child: proc, password } = await startOpenCode2(port, {
-      inheritStdio: ctx.inheritStdio
+      inheritStdio: ctx.inheritStdio,
+      command: ctx.command
     });
     const health = await waitForOpenCode2Health(port, password, ctx.startTimeoutMs);
     if (!health.healthy) {
@@ -13873,13 +15049,14 @@ Port ${port} is already in use.`));
       password
     };
   }
+  const command = ctx.command ?? "opencode2";
   const action = await select3({
     message: "OpenCode V2 is not running. What would you like to do?",
     choices: [
       {
         name: "Start OpenCode V2 for me",
         value: "start",
-        description: `Run 'opencode2 serve --port ${port}'`
+        description: `Run '${command} serve --port ${port}'`
       },
       {
         name: "Show me the command",
@@ -13897,14 +15074,15 @@ Port ${port} is already in use.`));
     blank();
     console.log(chalk6.bold("Run this command in another terminal:"));
     blank();
-    console.log(`  ${chalk6.cyan(`opencode2 serve --port ${port}`)}`);
+    console.log(`  ${chalk6.cyan(`${command} serve --port ${port}`)}`);
     blank();
     throw new Error("Please start OpenCode V2 manually");
   }
   if (action === "start") {
     const spinner = ora3("Starting OpenCode V2...").start();
     const { child: proc, password } = await startOpenCode2(port, {
-      inheritStdio: ctx.inheritStdio
+      inheritStdio: ctx.inheritStdio,
+      command: ctx.command
     });
     const health = await waitForOpenCode2Health(port, password, INTERACTIVE_START_TIMEOUT_MS2);
     if (!health.healthy) {
@@ -13930,7 +15108,7 @@ Port ${port} is already in use.`));
 }
 
 // src/lib/runner-credentials.ts
-import { chmodSync as chmodSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { chmodSync as chmodSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { spawn as spawn5 } from "node:child_process";
 var RUNNER_SECRET_FETCH_TIMEOUT_MS = 6e4;
 var CREDENTIAL_RESTORE_TIMEOUT_MS = 6e4;
@@ -14173,8 +15351,8 @@ async function configureGitHubAccess({ env, log: log3 }) {
   }
   try {
     env.GIT_CONFIG_GLOBAL = GIT_CONFIG_GLOBAL;
-    writeFileSync4(GIT_CONFIG_GLOBAL, "");
-    writeFileSync4(GIT_CREDENTIAL_HELPER, GIT_CREDENTIAL_HELPER_CONTENT, { mode: 448 });
+    writeFileSync7(GIT_CONFIG_GLOBAL, "");
+    writeFileSync7(GIT_CREDENTIAL_HELPER, GIT_CREDENTIAL_HELPER_CONTENT, { mode: 448 });
     chmodSync2(GIT_CREDENTIAL_HELPER, 448);
     const config = [
       ["user.name", env.GIT_USER_NAME ?? "evident-bot"],
@@ -14207,7 +15385,7 @@ async function configureGitHubAccess({ env, log: log3 }) {
 // src/lib/opencode/config-overlay.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { copyFileSync, existsSync as existsSync2, statSync as statSync6 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join11, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join14, resolve as resolve4 } from "node:path";
 function parseConfigContent(content) {
   if (!content?.trim()) return {};
   const parsed = JSON.parse(content);
@@ -14237,7 +15415,7 @@ function applyRunnerOpenCodeConfig({
     return;
   }
   const source = isAbsolute3(overlayPath) ? overlayPath : resolve4(cwd, overlayPath);
-  const target = isFile(join11(cwd, "opencode.jsonc")) ? "opencode.jsonc" : "opencode.json";
+  const target = isFile(join14(cwd, "opencode.jsonc")) ? "opencode.jsonc" : "opencode.json";
   if (!isFile(source)) {
     log3(
       `RUNNER-OPENCODE-CONFIG-MISSING: ${source} is not a file; headless turns will wedge on the first external-directory permission prompt (#563)`,
@@ -14245,7 +15423,7 @@ function applyRunnerOpenCodeConfig({
     );
     return;
   }
-  copyFileSync(source, join11(cwd, target));
+  copyFileSync(source, join14(cwd, target));
   try {
     execFileSync2("git", ["-C", cwd, "update-index", "--skip-worktree", target], {
       stdio: "ignore"
@@ -14254,13 +15432,13 @@ function applyRunnerOpenCodeConfig({
     const detail = error2 instanceof Error ? error2.message : String(error2);
     log3(`could not mark ${target} skip-worktree: ${detail}; it may show as a local change`, "warn");
   }
-  log3(`Applied runner OpenCode config ${source} to ${join11(cwd, target)}`);
+  log3(`Applied runner OpenCode config ${source} to ${join14(cwd, target)}`);
 }
 
 // src/lib/opencode/runtime-provenance.ts
-import { readFileSync as readFileSync7, readdirSync } from "node:fs";
+import { readFileSync as readFileSync11, readdirSync } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join15 } from "node:path";
 var PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i;
 var REGISTRY_SPEC = /^[a-z0-9.*+^~<>=|-]+$/i;
 function errorKind(error2) {
@@ -14328,7 +15506,7 @@ function parseJsonc(value) {
   return JSON.parse(output);
 }
 function openCodeCacheRoot(env = process.env, homeDir = homedir7()) {
-  return join12(env.XDG_CACHE_HOME ?? join12(homeDir, ".cache"), "opencode");
+  return join15(env.XDG_CACHE_HOME ?? join15(homeDir, ".cache"), "opencode");
 }
 function readConfiguredPluginSpecs({
   cwd = process.cwd(),
@@ -14337,10 +15515,10 @@ function readConfiguredPluginSpecs({
   let config;
   try {
     try {
-      config = parseJsonc(readFileSync7(join12(cwd, "opencode.jsonc"), "utf8"));
+      config = parseJsonc(readFileSync11(join15(cwd, "opencode.jsonc"), "utf8"));
     } catch (error2) {
       if (!("code" in Object(error2)) || Object(error2).code !== "ENOENT") throw error2;
-      config = parseJsonc(readFileSync7(join12(cwd, "opencode.json"), "utf8"));
+      config = parseJsonc(readFileSync11(join15(cwd, "opencode.json"), "utf8"));
     }
   } catch (error2) {
     log3(`Could not read OpenCode plugin configuration: ${errorKind(error2)}`);
@@ -14368,7 +15546,7 @@ function resolveInstalledPluginVersions({
   homeDir = homedir7(),
   log: log3
 }) {
-  const packagesRoot = join12(cacheRoot ?? openCodeCacheRoot(env, homeDir), "packages");
+  const packagesRoot = join15(cacheRoot ?? openCodeCacheRoot(env, homeDir), "packages");
   let directories;
   try {
     directories = readdirSync(packagesRoot, { withFileTypes: true });
@@ -14389,8 +15567,8 @@ function resolveInstalledPluginVersions({
     let resolvedVersion = null;
     try {
       const packageJson = JSON.parse(
-        readFileSync7(
-          join12(packagesRoot, directory.name, "node_modules", parsed.name, "package.json"),
+        readFileSync11(
+          join15(packagesRoot, directory.name, "node_modules", parsed.name, "package.json"),
           "utf8"
         )
       );
@@ -14411,7 +15589,7 @@ function resolveInstalledPluginVersions({
 }
 
 // src/lib/credential-sync.ts
-import { renameSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { renameSync, writeFileSync as writeFileSync8 } from "node:fs";
 var CREDENTIAL_SYNC_TICK_TIMEOUT_MS = 3e4;
 var CREDENTIAL_FLUSH_DEADLINE_MS = 8e3;
 var CREDENTIAL_FLUSH_ABORT_GRACE_MS = 500;
@@ -14421,7 +15599,7 @@ var MAX_FLUSH_PASSES = 2;
 function outcomesWith(outcome) {
   return { claude: outcome, opencode: outcome };
 }
-function errorMessage2(error2) {
+function errorMessage3(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 function waitForSettlement(promise, timeoutMs) {
@@ -14445,10 +15623,10 @@ function writeMarker(markerPath, outcomes, log3) {
 `;
   const temporaryPath = `${markerPath}.tmp`;
   try {
-    writeFileSync5(temporaryPath, body, { mode: 384 });
+    writeFileSync8(temporaryPath, body, { mode: 384 });
     renameSync(temporaryPath, markerPath);
   } catch (error2) {
-    log3(`CREDENTIAL-FLUSH-MARKER-UNWRITABLE: ${markerPath}: ${errorMessage2(error2)}`, "warn");
+    log3(`CREDENTIAL-FLUSH-MARKER-UNWRITABLE: ${markerPath}: ${errorMessage3(error2)}`, "warn");
   }
 }
 function intervalSeconds(env, log3) {
@@ -14480,7 +15658,7 @@ async function runFlushStore(store, env, synchroniserRunner, log3, deadlineAt) {
     },
     (error2) => {
       failed = true;
-      log3(`CREDENTIAL-FLUSH-ERROR: ${store}: ${errorMessage2(error2)}`, "warn");
+      log3(`CREDENTIAL-FLUSH-ERROR: ${store}: ${errorMessage3(error2)}`, "warn");
     }
   );
   const abortTimer = setTimeout(() => controller.abort(), remainingMs);
@@ -14540,7 +15718,7 @@ function createCredentialSync({
           outcomes[store] = !result.timedOut && result.code === 0 ? "ok" : "failed";
         } catch (error2) {
           outcomes[store] = "failed";
-          log3(`CREDENTIAL-SYNC-TICK-ERROR: ${store}: ${errorMessage2(error2)}`, "debug");
+          log3(`CREDENTIAL-SYNC-TICK-ERROR: ${store}: ${errorMessage3(error2)}`, "debug");
         }
       }
       const failed = STORES.some((store) => outcomes[store] === "failed");
@@ -14690,6 +15868,18 @@ function readSetup(value) {
   }
   return setup;
 }
+function readModelDescriptors(value) {
+  if (!Array.isArray(value)) return null;
+  return value.every(
+    (descriptor) => typeof descriptor === "object" && descriptor !== null && typeof descriptor.id === "string" && typeof descriptor.provider === "string"
+  ) ? value : null;
+}
+function logDescriptorRefreshFallback(options, branch, generation) {
+  options.log(
+    `MANAGED-INFERENCE-DESCRIPTORS-${branch}: runner=${options.agentId} generation=${generation}`,
+    "warn"
+  );
+}
 function clearLocalSetup(options) {
   const env = options.env ?? process.env;
   const store = options.store ?? defaultStore;
@@ -14821,7 +16011,27 @@ async function reaffirmStored(options, credential) {
   if (!setup || setup.generation !== credential.generation || setup.token_id !== credential.tokenId) {
     return { kind: "failed", reason: "Managed credential reaffirmation returned a mismatch" };
   }
-  const failure = applyCredential(options, credential);
+  const descriptorsValue = body?.model_descriptors;
+  const refreshedDescriptors = readModelDescriptors(descriptorsValue);
+  let credentialToApply = credential;
+  if (descriptorsValue === void 0 || descriptorsValue === null) {
+    logDescriptorRefreshFallback(options, "UNAVAILABLE", credential.generation);
+  } else if (refreshedDescriptors === null) {
+    logDescriptorRefreshFallback(options, "MALFORMED", credential.generation);
+  } else if (refreshedDescriptors.length === 0) {
+    logDescriptorRefreshFallback(options, "EMPTY", credential.generation);
+  } else {
+    const { config, unsupportedProviders } = buildCredentialProxyNativeConfig({
+      inferenceBaseUrl: credential.inferenceBaseUrl,
+      modelDescriptors: refreshedDescriptors
+    });
+    if (unsupportedProviders.length > 0 || Object.keys(config.provider).length === 0) {
+      logDescriptorRefreshFallback(options, "UNSUPPORTED-PROVIDER", credential.generation);
+    } else {
+      credentialToApply = { ...credential, modelDescriptors: refreshedDescriptors };
+    }
+  }
+  const failure = applyCredential(options, credentialToApply);
   return failure ? { kind: "failed", reason: failure } : { kind: "ready", generation: credential.generation, tokenId: credential.tokenId };
 }
 async function prepareManagedInferenceSetup(options, discovery, health) {
@@ -14855,10 +16065,8 @@ async function prepareManagedInferenceSetup(options, discovery, health) {
   const setup = readSetup(body?.setup);
   const token = body?.inference_token;
   const inferenceBaseUrl = body?.inference_base_url;
-  const modelDescriptors = body?.model_descriptors;
-  if (!setup || setup.generation !== discovery.setup.generation || typeof setup.token_id !== "string" || typeof token !== "string" || typeof inferenceBaseUrl !== "string" || !Array.isArray(modelDescriptors) || !modelDescriptors.every(
-    (descriptor) => typeof descriptor === "object" && descriptor !== null && typeof descriptor.id === "string" && typeof descriptor.provider === "string"
-  )) {
+  const modelDescriptors = readModelDescriptors(body?.model_descriptors);
+  if (!setup || setup.generation !== discovery.setup.generation || typeof setup.token_id !== "string" || typeof token !== "string" || typeof inferenceBaseUrl !== "string" || modelDescriptors === null) {
     return { kind: "failed", reason: "Managed credential bootstrap returned an invalid response" };
   }
   const credential = {
@@ -14927,33 +16135,49 @@ function resolveLogLevel(options) {
   }
   return "info";
 }
-function resolveFileSyncDirectories(raw, homeDir) {
-  const directories = [];
+function resolveFileSyncEntry(entry, homeDir, flagName, labels) {
+  const trimmed = entry.trim();
+  if (trimmed === "") {
+    throw new Error(`${flagName} requires a ${labels.noun} path (got an empty value)`);
+  }
+  const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join16(homeDir, trimmed.slice(2)) : trimmed;
+  if (!isAbsolute4(expanded)) {
+    throw new Error(`${flagName} requires an absolute ${labels.noun} path; got "${entry}"`);
+  }
+  const normalized = resolvePath2(expanded);
+  if (parse(normalized).root === normalized) {
+    throw new Error(
+      `${flagName} will not allow-list the filesystem root ("${entry}"); name the specific ${labels.noun} the credentials belong in (for example ${labels.rootExample})`
+    );
+  }
+  return normalized;
+}
+function resolveFileSyncAllowList(raw, homeDir, flagName, labels) {
+  const paths = [];
   for (const entry of raw ?? []) {
-    const trimmed = entry.trim();
-    if (trimmed === "") {
-      throw new Error("--enable-file-sync-to requires a directory path (got an empty value)");
-    }
-    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join13(homeDir, trimmed.slice(2)) : trimmed;
-    if (!isAbsolute4(expanded)) {
-      throw new Error(`--enable-file-sync-to requires an absolute directory path; got "${entry}"`);
-    }
-    const normalized = resolvePath2(expanded);
-    if (parse(normalized).root === normalized) {
-      throw new Error(
-        `--enable-file-sync-to will not allow-list the filesystem root ("${entry}"); name the specific directory the credentials belong in (for example ~/.claude)`
-      );
-    }
-    if (!directories.includes(normalized)) {
-      directories.push(normalized);
-    }
+    const normalized = resolveFileSyncEntry(entry, homeDir, flagName, labels);
+    if (!paths.includes(normalized)) paths.push(normalized);
   }
-  if (directories.length > MAX_FILE_SYNC_DIRECTORIES) {
+  if (paths.length > MAX_FILE_SYNC_DIRECTORIES) {
     throw new Error(
-      `--enable-file-sync-to accepts at most ${MAX_FILE_SYNC_DIRECTORIES} directories; got ${directories.length}`
+      `${flagName} accepts at most ${MAX_FILE_SYNC_DIRECTORIES} ${labels.plural}; got ${paths.length}`
     );
   }
-  return directories;
+  return paths;
+}
+function resolveFileSyncDirectories(raw, homeDir) {
+  return resolveFileSyncAllowList(raw, homeDir, "--enable-file-sync-to", {
+    noun: "directory",
+    plural: "directories",
+    rootExample: "~/.claude"
+  });
+}
+function resolveFileSyncExactFiles(raw, homeDir) {
+  return resolveFileSyncAllowList(raw, homeDir, "--enable-file-sync-to-exact-file", {
+    noun: "file",
+    plural: "files",
+    rootExample: "~/.local/share/opencode/mcp-auth.json"
+  });
 }
 var DEFAULT_OPENCODE_START_TIMEOUT_SECONDS = 180;
 var MAX_OPENCODE_START_TIMEOUT_SECONDS = 3600;
@@ -14969,13 +16193,13 @@ function resolveOpenCodeVersion(options, env = process.env) {
     raw = env[OPENCODE_VERSION_ENV];
     source = OPENCODE_VERSION_ENV;
   } else {
-    return { version: "v1", warnings: [] };
+    return { version: "auto", warnings: [] };
   }
   const normalized = raw.trim().toLowerCase();
-  if (normalized !== "v1" && normalized !== "v2") {
+  if (normalized !== "v1" && normalized !== "v2" && normalized !== "auto") {
     return {
-      version: "v1",
-      warnings: [`Ignoring invalid ${source} "${raw}": expected v1 or v2; using the default v1`]
+      version: "auto",
+      warnings: [`Ignoring invalid ${source} "${raw}": expected v1, v2, or auto; using auto`]
     };
   }
   return { version: normalized, warnings: [] };
@@ -15485,8 +16709,8 @@ async function driveChannels(state, driver) {
         state.running = false;
         break;
       }
-      const errorMessage3 = error2 instanceof Error ? error2.message : String(error2);
-      logActivity(state, { type: "error", error: `Channel processing error: ${errorMessage3}` });
+      const errorMessage4 = error2 instanceof Error ? error2.message : String(error2);
+      logActivity(state, { type: "error", error: `Channel processing error: ${errorMessage4}` });
       if (state.interactive) displayStatus(state);
       if (driver.hasInFlightWatchers()) {
         consecutiveDrainFailures = 0;
@@ -15576,6 +16800,7 @@ async function driveChannels(state, driver) {
   }
 }
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
+var SESSION_ARCHIVE_FIRST_RUN_MS = SESSION_CLEANUP_FIRST_SWEEP_MS + 1e3;
 var SESSION_CLEANUP_MAX_DELETES_PER_SWEEP = 100;
 var SESSION_CLEANUP_MAX_ISOLATED_DELETE_FAILURES = 2;
 var SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES = 2;
@@ -15590,7 +16815,7 @@ function shouldWarnForReclaimSkip(reason) {
   return major > 22 || major === 22 && (minor > 13 || minor === 13 && patch >= 0);
 }
 function sessionDbPath() {
-  return join13(homedir8(), ".local", "share", "opencode", "opencode.db");
+  return join16(homedir8(), ".local", "share", "opencode", "opencode.db");
 }
 function logSessionCleanupActivity(state, phase, entry) {
   logActivity(state, {
@@ -15599,6 +16824,104 @@ function logSessionCleanupActivity(state, phase, entry) {
     metadata: { ...entry.metadata, phase }
   });
 }
+function logSessionArchiveActivity(state, phase, entry) {
+  logActivity(state, {
+    ...entry,
+    source: "cli.session-archive",
+    metadata: { ...entry.metadata, phase }
+  });
+}
+function logSessionArchiveSummary(state, phase, summary) {
+  const everyUploadFailed = summary.uploadAttempts > 0 && summary.uploadFailures === summary.uploadAttempts;
+  const staleSince = everyUploadFailed && summary.staleSince !== null ? `; archive stale since ${summary.staleSince}` : "";
+  const neverWatermarked = summary.neverWatermarkedFailures > 0 ? `; ${summary.neverWatermarkedFailures} failed session(s) had no prior successful upload` : "";
+  const warning2 = summary.failed > 0 || summary.failures.length > 0 || everyUploadFailed;
+  logSessionArchiveActivity(state, phase, {
+    type: "info",
+    level: warning2 ? "warn" : "info",
+    message: `Session archive: inspected ${summary.inspected}, uploaded ${summary.uploaded}, unchanged ${summary.unchanged}, failed ${summary.failed}, skipped budget ${summary.skippedBudget}, unmapped ${summary.unmappedIds.length}` + staleSince + neverWatermarked,
+    metadata: {
+      outcome: "archive-run-complete",
+      sessions_inspected: summary.inspected,
+      sessions_uploaded: summary.uploaded,
+      sessions_unchanged: summary.unchanged,
+      sessions_failed: summary.failed,
+      uploads_attempted: summary.uploadAttempts,
+      uploads_failed: summary.uploadFailures,
+      sessions_skipped_budget: summary.skippedBudget,
+      sessions_unmapped: summary.unmappedIds.length,
+      sessions_without_prior_watermark: summary.neverWatermarkedFailures,
+      ...everyUploadFailed && summary.staleSince !== null ? { stale_since: summary.staleSince } : {}
+    }
+  });
+  for (const failure of summary.failures) {
+    const permanentSizeFailure = failure.reason === "too-large";
+    const safeMessage = failure.message ? `: ${redactDiagnosticText(failure.message).slice(0, 200)}` : "";
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: `Session archive: session ${failure.sessionId} ` + (permanentSizeFailure ? "failed permanently (too-large payload)" : `failed (${failure.outcome}`) + (permanentSizeFailure ? "" : failure.reason ? `, reason=${failure.reason})` : ")") + safeMessage,
+      metadata: {
+        outcome: failure.outcome,
+        session_id: failure.sessionId,
+        archived: failure.archived,
+        ...failure.reason !== void 0 ? { reason: failure.reason } : {}
+      }
+    });
+  }
+  if (summary.unmappedIds.length > 0) {
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: `Session archive: ${summary.unmappedIds.length} unmapped session(s): ` + summary.unmappedIds.join(", "),
+      metadata: {
+        outcome: "unmapped-sessions",
+        sessions_unmapped: summary.unmappedIds.length
+      }
+    });
+  }
+}
+async function drainSessionDeletionReports(state) {
+  const path = sessionDeletionReportPath(homedir8(), process.env);
+  let delivered = 0;
+  let failure = null;
+  try {
+    const spool = readSessionDeletionRecords(path);
+    if (spool.readError !== null) {
+      failure = `could not read spool: ${spool.readError}`;
+    } else if (spool.records.length === 0) {
+      return;
+    } else if (!state.agentId || !state.authHeader) {
+      failure = "runner authentication is not available";
+    } else {
+      for (let offset = 0; offset < spool.records.length; offset += 200) {
+        const batch = spool.records.slice(offset, offset + 200);
+        const result = await reportSessionDeletions(state.agentId, state.authHeader, batch);
+        if (!result.ok) {
+          failure = result.error ?? "unknown API error";
+          break;
+        }
+        removeDeliveredSessionDeletionRecords(path, batch);
+        delivered += batch.length;
+      }
+    }
+  } catch (error2) {
+    failure = error2 instanceof Error ? error2.message : String(error2);
+  }
+  const pending = readSessionDeletionRecords(path);
+  const pendingCount = pending.readError === null ? pending.records.length : null;
+  const message = `Session deletion reports: delivered ${delivered}, ${pendingCount === null ? "pending count unavailable" : `${pendingCount} pending`}` + (failure === null ? "." : `; delivery failed: ${failure}.`);
+  logActivity(state, {
+    type: "info",
+    level: failure === null ? "info" : "warn",
+    message,
+    metadata: {
+      outcome: failure === null ? "session-deletion-reports-drained" : "session-deletion-reports-pending",
+      delivered,
+      pending: pendingCount
+    }
+  });
+}
 function logSessionDbProvenanceMismatch(state, provenance, currentVersion, preBootMigrationCount) {
   const record = {
     v: 1,
@@ -15655,18 +16978,25 @@ async function runSweep(state, driver, config) {
     let failedOtherStatus = 0;
     let failedThrew = 0;
     let skippedNewlyActive = 0;
+    let skippedArchive = 0;
     let remaining = 0;
+    const deletionRecords = [];
     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 snapshots = sessions.map((session) => ({
+        id: session.id,
+        lastActivityMs: sessionLastActivityMs(session)
+      }));
+      const lastActivityById = new Map(
+        snapshots.map(({ id, lastActivityMs }) => [id, lastActivityMs])
       );
+      const sessionById = new Map(sessions.map((session) => [session.id, session]));
+      const toDelete = selectSessionsToDelete(snapshots, {
+        maxAgeMs: config.maxAgeMs,
+        maxCount: config.maxCount,
+        nowMs: Date.now(),
+        protectedIds: protectedNow
+      });
       const eligibleToDelete = toDelete.filter(
         (id) => (state.sessionDeleteFailures.get(id)?.isolatedFailures ?? 0) < SESSION_CLEANUP_GIVE_UP_AFTER_FAILURES
       );
@@ -15683,9 +17013,56 @@ async function runSweep(state, driver, config) {
           });
           continue;
         }
+        if (state.sessionArchiveConfig.enabled) {
+          const candidate = sessionById.get(id);
+          const archiveConfig = state.sessionArchiveConfig;
+          const archiveBudgetMs = Math.min(
+            archiveConfig.intervalMs + SESSION_ARCHIVE_UPLOAD_TIMEOUT_MS,
+            MAX_SESSION_ARCHIVE_TIMER_DELAY_MS
+          );
+          const archived = candidate ? await runSessionArchiveTask(
+            state,
+            "sweep",
+            archiveBudgetMs,
+            (signal) => runSessionArchiveBatch(state, "sweep", [candidate], archiveBudgetMs, signal)
+          ) : null;
+          if (!archived?.archivedSessionIds.includes(id)) {
+            skippedArchive++;
+            logSessionArchiveActivity(state, "sweep", {
+              type: "info",
+              level: "warn",
+              message: `Session cleanup: retaining session ${id}; deletion is held back pending successful archival`,
+              metadata: {
+                outcome: "deletion-held-for-archive",
+                session_id: id
+              }
+            });
+            continue;
+          }
+          protectedNow = driver.protectedSessionIds();
+          if (protectedNow.has(id)) {
+            skippedNewlyActive++;
+            logActivity(state, {
+              type: "info",
+              message: `Session cleanup: skipping ${id} \u2014 became active/bound during archival (${mode})`
+            });
+            continue;
+          }
+        }
         const outcome = await deleteSession(state.port, id, state.opencodeClient ?? void 0);
         if (outcome.ok) {
           deleted++;
+          const lastActivityMs = lastActivityById.get(id) ?? null;
+          deletionRecords.push({
+            opencode_session_id: id,
+            deleted_at: (/* @__PURE__ */ new Date()).toISOString(),
+            reason: "auto_cleanup",
+            policy: {
+              max_age_ms: config.maxAgeMs ?? null,
+              max_count: config.maxCount ?? null,
+              last_activity_at: lastActivityMs === null ? null : new Date(lastActivityMs).toISOString()
+            }
+          });
         } else if (outcome.status === "threw") {
           failed++;
           failedThrew++;
@@ -15735,12 +17112,39 @@ async function runSweep(state, driver, config) {
       }
       const failedNote = failed > 0 ? `, failed ${failed}` : "";
       const skippedNote = skippedNewlyActive > 0 ? `, skipped ${skippedNewlyActive} newly-active` : "";
+      const archiveHeldNote = skippedArchive > 0 ? `, archive held ${skippedArchive}` : "";
       const remainingNote = remaining > 0 ? `, remaining ${remaining}` : "";
       logActivity(state, {
         type: "info",
-        message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote}${remainingNote} (${mode})`
+        message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote}${archiveHeldNote}${remainingNote} (${mode})`
       });
     }
+    if (deletionRecords.length > 0) {
+      try {
+        const dropped = appendSessionDeletionRecords(
+          sessionDeletionReportPath(homedir8(), process.env),
+          deletionRecords
+        );
+        if (dropped > 0) {
+          logSessionCleanupActivity(state, "sweep", {
+            type: "info",
+            level: "warn",
+            message: `Session cleanup: dropped ${dropped} oldest pending deletion report(s) after reaching the spool limit`,
+            metadata: { outcome: "deletion-reports-dropped", dropped_count: dropped }
+          });
+        }
+      } catch (error2) {
+        logSessionCleanupActivity(state, "sweep", {
+          type: "info",
+          level: "warn",
+          message: `Session cleanup: could not persist ${deletionRecords.length} confirmed deletion report(s): ${error2 instanceof Error ? error2.message : String(error2)}`,
+          metadata: {
+            outcome: "deletion-report-spool-write-failed",
+            records: deletionRecords.length
+          }
+        });
+      }
+    }
     const sessionMetadata = {
       sessions_inspected: sessions?.length ?? null,
       sessions_deleted: deleted,
@@ -15750,6 +17154,7 @@ async function runSweep(state, driver, config) {
       sessions_failed_other: failedOtherStatus,
       sessions_failed_threw: failedThrew,
       sessions_skipped_active: skippedNewlyActive,
+      sessions_archive_held: skippedArchive,
       sessions_remaining: remaining,
       ...enumerationReason !== null ? { session_enumeration_reason: enumerationReason } : {}
     };
@@ -15810,6 +17215,7 @@ async function runSweep(state, driver, config) {
         }
       });
     }
+    await drainSessionDeletionReports(state);
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     logSessionCleanupActivity(state, "sweep", {
@@ -15880,6 +17286,186 @@ function scheduleSessionCleanup(state, driver, options) {
   );
   state.sessionCleanupTimers.push(interval, firstSweep);
 }
+function runSessionArchiveTask(state, phase, budgetMs, work) {
+  if (state.sessionArchiveInFlight) {
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "debug",
+      message: "Session archive skipped \u2014 previous archive run still in progress",
+      metadata: { outcome: "skipped-in-flight" }
+    });
+    return Promise.resolve(null);
+  }
+  const controller = new AbortController();
+  state.sessionArchiveAbortController = controller;
+  const timeout = setTimeout(() => {
+    controller.abort();
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: `Session archive exceeded ${budgetMs}ms; remaining sessions were not confirmed archived`,
+      metadata: { outcome: "archive-budget-exceeded", budget_ms: budgetMs }
+    });
+  }, budgetMs);
+  const task = Promise.resolve().then(() => work(controller.signal)).catch((error2) => {
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: `Session archive run failed: ${redactDiagnosticText(error2 instanceof Error ? error2.message : String(error2)).slice(0, 200)}`,
+      metadata: { outcome: "archive-run-failed" }
+    });
+    return null;
+  }).finally(() => {
+    clearTimeout(timeout);
+    if (state.sessionArchiveInFlight === task) {
+      state.sessionArchiveInFlight = null;
+      state.sessionArchiveAbortController = null;
+    }
+  });
+  state.sessionArchiveInFlight = task;
+  return task;
+}
+async function runSessionArchiveBatch(state, phase, sessions, budgetMs, signal) {
+  const config = state.sessionArchiveConfig;
+  const client = state.opencodeClient;
+  const watermarkPath = state.sessionArchiveWatermarkPath;
+  if (!client || !config.keyPrefix || !watermarkPath || !state.agentId) {
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: "Session archive skipped because runner identity or archive configuration is unavailable",
+      metadata: { outcome: "archive-configuration-unavailable" }
+    });
+    return null;
+  }
+  const summary = await runSessionArchive({
+    sessions,
+    deps: {
+      client,
+      runnerId: state.agentId,
+      keyPrefix: config.keyPrefix,
+      bindings: readSessionBindings(
+        sessionBindingLedgerPath(homedir8(), process.env),
+        (message) => logSessionArchiveActivity(state, phase, {
+          type: "info",
+          level: "warn",
+          message: redactDiagnosticText(message),
+          metadata: { outcome: "binding-ledger-read-failed" }
+        })
+      ),
+      watermarks: state.sessionArchiveWatermarks,
+      watermarkPath,
+      signal,
+      upload: uploadSessionArchive,
+      exportMessages: exportSessionMessages,
+      recordWatermark: recordUpload
+    },
+    budgetMs
+  });
+  logSessionArchiveSummary(state, phase, summary);
+  return summary;
+}
+async function runSessionArchiveFleet(state, phase, budgetMs, signal) {
+  const startedAt = Date.now();
+  const enumeration = await listAllSessions(state.port, state.opencodeClient ?? void 0, signal);
+  if (enumeration.sessions === null) {
+    const interrupted = signal.aborted;
+    logSessionArchiveActivity(state, phase, {
+      type: "info",
+      level: "warn",
+      message: interrupted ? "Session archive: enumeration was interrupted before the complete store was known; no session was marked archived" : `Session archive: could not enumerate the complete session store (${enumeration.reason}); no session was marked archived`,
+      metadata: {
+        outcome: interrupted ? "enumeration-interrupted" : "enumeration-refused",
+        ...!interrupted ? { reason: enumeration.reason } : {}
+      }
+    });
+    return null;
+  }
+  return runSessionArchiveBatch(
+    state,
+    phase,
+    enumeration.sessions,
+    Math.max(0, budgetMs - (Date.now() - startedAt)),
+    signal
+  );
+}
+async function runSessionArchiveShutdownFlush(state, budgetMs) {
+  const deadline = Date.now() + budgetMs;
+  const previousRun = state.sessionArchiveInFlight;
+  if (previousRun) {
+    state.sessionArchiveAbortController?.abort(
+      new Error("graceful shutdown archive flush requested")
+    );
+    let timeout;
+    const settled = await Promise.race([
+      previousRun.then(() => true),
+      new Promise((resolve5) => {
+        timeout = setTimeout(() => resolve5(false), budgetMs);
+      })
+    ]);
+    if (timeout) clearTimeout(timeout);
+    if (!settled) {
+      state.sessionArchiveAbortController?.abort(new Error("session archive flush budget expired"));
+      logSessionArchiveActivity(state, "shutdown", {
+        type: "info",
+        level: "warn",
+        message: `Session archive exceeded ${budgetMs}ms while stopping a prior run; remaining sessions were not confirmed archived`,
+        metadata: { outcome: "archive-budget-exceeded", budget_ms: budgetMs }
+      });
+      return null;
+    }
+  }
+  const remainingMs = Math.floor(deadline - Date.now());
+  if (remainingMs <= 0) {
+    logSessionArchiveActivity(state, "shutdown", {
+      type: "info",
+      level: "warn",
+      message: `Session archive exceeded ${budgetMs}ms while stopping a prior run; remaining sessions were not confirmed archived`,
+      metadata: { outcome: "archive-budget-exceeded", budget_ms: budgetMs }
+    });
+    return null;
+  }
+  return runSessionArchiveTask(
+    state,
+    "shutdown",
+    remainingMs,
+    (signal) => runSessionArchiveFleet(state, "shutdown", remainingMs, signal)
+  );
+}
+function scheduleSessionArchive(state) {
+  const config = state.sessionArchiveConfig;
+  if (!config.enabled) return;
+  state.sessionArchiveWatermarkPath = sessionArchiveWatermarkPath(homedir8(), process.env);
+  state.sessionArchiveWatermarks = readWatermarks(
+    state.sessionArchiveWatermarkPath,
+    (message) => logSessionArchiveActivity(state, "startup", {
+      type: "info",
+      level: "warn",
+      message: redactDiagnosticText(message),
+      metadata: { outcome: "watermark-read-failed" }
+    })
+  );
+  logSessionArchiveActivity(state, "startup", {
+    type: "info",
+    message: `Session archive enabled (interval=${config.intervalMs}ms)`,
+    metadata: { outcome: "armed", interval_ms: config.intervalMs }
+  });
+  const cycleBudgetMs = Math.min(
+    config.intervalMs + SESSION_ARCHIVE_UPLOAD_TIMEOUT_MS,
+    MAX_SESSION_ARCHIVE_TIMER_DELAY_MS
+  );
+  const run2 = (phase = "scheduled") => {
+    void runSessionArchiveTask(
+      state,
+      phase,
+      cycleBudgetMs,
+      (signal) => runSessionArchiveFleet(state, phase, cycleBudgetMs, signal)
+    );
+  };
+  const interval = setInterval(run2, config.intervalMs);
+  const firstRun = setTimeout(() => run2(), SESSION_ARCHIVE_FIRST_RUN_MS);
+  state.sessionArchiveTimers.push(interval, firstRun);
+}
 function scheduleUsageReporting(state, params) {
   const { mode, warnings } = params.resolved;
   for (const warning2 of warnings) {
@@ -16154,6 +17740,12 @@ async function cleanup(state, opts = {}) {
     clearTimeout(timer);
   }
   state.sessionCleanupTimers = [];
+  for (const timer of state.sessionArchiveTimers) {
+    clearInterval(timer);
+    clearTimeout(timer);
+  }
+  state.sessionArchiveTimers = [];
+  state.sessionArchiveAbortController?.abort(new Error("runner cleanup started"));
   state.stopOpenCodeLogTail?.();
   state.stopOpenCodeLogTail = null;
   if (state.claudeUsageTimer) {
@@ -16221,6 +17813,15 @@ async function cleanup(state, opts = {}) {
     await timeShutdownPhase(state, durations, "tunnel_close", () => connection.close());
     state.connection = null;
   }
+  if (opts.graceful && state.sessionArchiveConfig.enabled) {
+    const budgetMs = state.sessionArchiveConfig.flushBudgetMs;
+    await timeShutdownPhase(
+      state,
+      durations,
+      "session_archive_flush",
+      () => runSessionArchiveShutdownFlush(state, budgetMs)
+    );
+  }
   if (state.opencodeProcess) {
     const opencodeProcess = state.opencodeProcess;
     const result = await timeShutdownPhase(
@@ -16292,9 +17893,11 @@ async function run(options) {
   const interactive = isInteractive(options.json);
   let logLevel;
   let fileSyncDirectories;
+  let fileSyncExactFiles;
   try {
     logLevel = resolveLogLevel(options);
     fileSyncDirectories = resolveFileSyncDirectories(options.enableFileSyncTo, homedir8());
+    fileSyncExactFiles = resolveFileSyncExactFiles(options.enableFileSyncToExactFile, homedir8());
     if (options.restoreSessionDb && !options.sessionDbNoReplicateMarker) {
       throw new Error(
         "--restore-session-db requires --session-db-no-replicate-marker <path>; restore failures must block Litestream replication"
@@ -16342,6 +17945,18 @@ async function run(options) {
     messageCount: 0,
     lastProxiedActivityAt: null,
     sessionCleanupTimers: [],
+    sessionArchiveConfig: resolveSessionArchiveConfig(
+      {
+        enabled: options.sessionArchive,
+        interval: options.sessionArchiveInterval
+      },
+      process.env
+    ),
+    sessionArchiveTimers: [],
+    sessionArchiveWatermarks: /* @__PURE__ */ new Map(),
+    sessionArchiveWatermarkPath: null,
+    sessionArchiveInFlight: null,
+    sessionArchiveAbortController: null,
     sessionDeleteFailures: /* @__PURE__ */ new Map(),
     claudeUsageTimer: null,
     claudeUsageRearm: null,
@@ -16355,6 +17970,14 @@ async function run(options) {
   };
   setTelemetryAuthProvider(() => ({ authHeader: state.authHeader, agentId: state.agentId }));
   setTelemetryDiagnosticsReporter((message) => log2(state, message, "warn"));
+  for (const warning2 of state.sessionArchiveConfig.warnings) {
+    logSessionArchiveActivity(state, "startup", {
+      type: "info",
+      level: "warn",
+      message: `Session archive: ${warning2}`,
+      metadata: { outcome: "configuration-warning" }
+    });
+  }
   if (options.credentialSyncMarker) {
     state.credentialSync = createCredentialSync({
       markerPath: options.credentialSyncMarker,
@@ -16370,7 +17993,11 @@ async function run(options) {
   }
   if (fileSyncDirectories.length > 0) {
     log2(state, `File sync enabled for: ${fileSyncDirectories.join(", ")}`);
-  } else {
+  }
+  if (fileSyncExactFiles.length > 0) {
+    log2(state, `File sync exact files enabled for: ${fileSyncExactFiles.join(", ")}`);
+  }
+  if (fileSyncDirectories.length === 0 && fileSyncExactFiles.length === 0) {
     log2(state, "File sync is disabled (no --enable-file-sync-to given)", "debug");
   }
   if (!options.runner && options.agent) {
@@ -16652,6 +18279,7 @@ async function run(options) {
       }
     }
     reportSessionDbRecovery(state);
+    await drainSessionDeletionReports(state);
     if (sessionDbVerifyFatal) {
       throw new Error(
         sessionDbVerifyFatalReason === void 0 ? "SESSION-DB-INTEGRITY-EXHAUSTED: the corrupt session DB could not be proven separated from the active backup prefix or removed from disk" : `SESSION-DB-VERIFY-TIMEOUT: session DB verification timed out (${sessionDbVerifyFatalReason}); refusing to start`
@@ -16671,13 +18299,75 @@ async function run(options) {
     for (const warning2 of opencodeStartTimeoutWarnings) {
       logActivity(state, { type: "info", level: "warn", message: warning2 });
     }
-    const { version: opencodeVersion, warnings: opencodeVersionWarnings } = resolveOpenCodeVersion(
-      options,
-      process.env
-    );
+    const { version: opencodeVersionSelection, warnings: opencodeVersionWarnings } = resolveOpenCodeVersion(options, process.env);
     for (const warning2 of opencodeVersionWarnings) {
       logActivity(state, { type: "info", level: "warn", message: warning2 });
     }
+    let opencodeMajor;
+    let opencodeV2Command;
+    let opencodeDetectionSource;
+    let opencodeDetectionLevel = "info";
+    let opencodeDetectionMessage;
+    if (opencodeVersionSelection === "v1") {
+      opencodeMajor = "v1";
+      opencodeDetectionSource = "explicit";
+      opencodeDetectionMessage = "OpenCode V1 was selected explicitly.";
+    } else if (opencodeVersionSelection === "v2") {
+      const installed = resolveInstalledOpenCode();
+      opencodeMajor = "v2";
+      opencodeDetectionSource = "explicit";
+      if (installed.kind === "installed" && installed.major === "v2") {
+        opencodeV2Command = installed.command;
+        opencodeDetectionMessage = `OpenCode V2 was selected explicitly; using ${installed.command}${installed.version ? ` (${installed.version})` : ""}.`;
+      } else if (installed.kind === "unknown") {
+        opencodeDetectionMessage = `OpenCode V2 was selected explicitly; ${installed.command} reported ${JSON.stringify(installed.rawVersion)}, but no V2 command was resolved.`;
+      } else if (installed.kind === "installed") {
+        opencodeDetectionMessage = `OpenCode V2 was selected explicitly; ${installed.command} reported V1 ${installed.version ?? "with an unknown version"}, so no V2 command was resolved.`;
+      } else {
+        opencodeDetectionMessage = "OpenCode V2 was selected explicitly, but no V2 command was resolved.";
+      }
+    } else {
+      const running = await classifyRunningOpenCode(state.port);
+      if (running.kind === "v1") {
+        opencodeMajor = "v1";
+        opencodeDetectionSource = "running-server";
+        opencodeDetectionMessage = `OpenCode detection: found V1 on port ${state.port}${running.version ? ` (${running.version})` : " (version unknown)"}.`;
+      } else if (running.kind === "v2") {
+        opencodeMajor = "v2";
+        opencodeDetectionSource = "running-server";
+        opencodeDetectionMessage = `OpenCode detection: found V2 on port ${state.port}${running.version ? ` (${running.version})` : " (version unknown)"}.`;
+      } else if (running.kind === "authenticated-unknown") {
+        const message = `A server on port ${state.port} requires credentials this runner does not have. This can be a password-protected V1 or a V2 server, so the protocol cannot be established. Select it explicitly with --opencode-version v1 or --opencode-version v2.`;
+        logActivity(state, {
+          type: "info",
+          level: "warn",
+          message: `OpenCode detection: authenticated-unknown on port ${state.port}; ${running.detail}. ${message}`
+        });
+        throw new Error(message);
+      } else {
+        const installed = resolveInstalledOpenCode();
+        opencodeDetectionLevel = "warn";
+        if (installed.kind === "installed") {
+          opencodeMajor = installed.major;
+          opencodeDetectionSource = "installed-binary";
+          if (installed.major === "v2") opencodeV2Command = installed.command;
+          opencodeDetectionMessage = `OpenCode detection: no server identified on port ${state.port} (${running.detail}); using installed ${installed.major} command ${installed.command}${installed.version ? ` (${installed.version})` : " with an unknown version"}.`;
+        } else if (installed.kind === "unknown") {
+          opencodeMajor = "v1";
+          opencodeDetectionSource = "fallback-v1";
+          opencodeDetectionMessage = `OpenCode detection: no server identified on port ${state.port} (${running.detail}); ${installed.command} reported ${JSON.stringify(installed.rawVersion)}, so assuming V1. Use --opencode-version v2 to select V2 explicitly.`;
+        } else {
+          opencodeMajor = "v1";
+          opencodeDetectionSource = "fallback-v1";
+          opencodeDetectionMessage = `OpenCode detection: no server identified on port ${state.port} (${running.detail}); no recognizable OpenCode binary is installed, so continuing into the V1 install flow.`;
+        }
+      }
+    }
+    logActivity(state, {
+      type: "info",
+      level: opencodeDetectionLevel,
+      message: opencodeDetectionMessage
+    });
     const managedSetupOptions = {
       agentId: state.agentId,
       apiUrl: getApiUrlConfig(),
@@ -16698,7 +18388,7 @@ async function run(options) {
       managedPreparation = managedDiscovery;
       managedSetupOptions.log(`MANAGED-INFERENCE-NOT-READY: ${managedDiscovery.reason}`, "warn");
     } else if (managedDiscovery.kind === "setup") {
-      const managedHealth = opencodeVersion === "v2" ? await checkOpenCode2Health(state.port) : await checkOpenCodeHealth(state.port);
+      const managedHealth = opencodeMajor === "v2" ? await checkOpenCode2Health(state.port) : await checkOpenCodeHealth(state.port);
       managedPreparation = await prepareManagedInferenceSetup(
         managedSetupOptions,
         managedDiscovery,
@@ -16723,13 +18413,14 @@ async function run(options) {
     const preBootMigrationIds = readSessionDbMigrationIds(sessionDbPath());
     const ocSpinner = interactive && !state.json ? ora4("Checking OpenCode...").start() : null;
     try {
-      const oc = opencodeVersion === "v2" ? await ensureOpenCode2Running({
+      const oc = opencodeMajor === "v2" ? await ensureOpenCode2Running({
         port: state.port,
         interactive: state.interactive,
         agentId: state.agentId,
         log: (message) => log2(state, message),
         startTimeoutMs: opencodeStartTimeoutMs,
-        inheritStdio: Boolean(options.opencodePidFile)
+        inheritStdio: Boolean(options.opencodePidFile),
+        command: opencodeV2Command
       }) : await ensureOpenCodeRunning({
         port: state.port,
         interactive: state.interactive,
@@ -16741,7 +18432,7 @@ async function run(options) {
       state.port = oc.port;
       state.opencodeProcess = options.opencodePidFile ? null : oc.process;
       state.opencodeVersion = oc.version;
-      state.opencodeApiVersion = opencodeVersion;
+      state.opencodeApiVersion = opencodeMajor;
       let configuredPlugins = [];
       let resolvedPlugins = [];
       try {
@@ -16763,13 +18454,14 @@ async function run(options) {
         metadata: {
           opencode_version: state.opencodeVersion,
           opencode_api_version: state.opencodeApiVersion,
+          opencode_detection_source: opencodeDetectionSource,
           configured_plugins: JSON.stringify(configuredPlugins),
           resolved_plugins: JSON.stringify(resolvedPlugins)
         },
         source: "cli.runtime-provenance"
       });
       let opencodePassword = null;
-      if (opencodeVersion === "v2" && "password" in oc) {
+      if (opencodeMajor === "v2" && "password" in oc) {
         const value = oc.password;
         if (typeof value === "string" || value === null) opencodePassword = value;
       }
@@ -16782,7 +18474,7 @@ async function run(options) {
       state.opencodeClient = openCodeClient;
       if (options.opencodePidFile && oc.process?.pid !== void 0) {
         try {
-          writeFileSync6(options.opencodePidFile, `${oc.process.pid}
+          writeFileSync9(options.opencodePidFile, `${oc.process.pid}
 `, { mode: 384 });
           chmodSync3(options.opencodePidFile, 384);
         } catch (error2) {
@@ -16892,7 +18584,7 @@ async function run(options) {
         let existingPid;
         if (existsSync3(options.litestreamPidFile)) {
           try {
-            const rawPid = readFileSync8(options.litestreamPidFile, "utf8").trim();
+            const rawPid = readFileSync12(options.litestreamPidFile, "utf8").trim();
             const parsedPid = Number(rawPid);
             if (/^\d+$/.test(rawPid) && Number.isSafeInteger(parsedPid) && parsedPid > 0) {
               existingPid = parsedPid;
@@ -16929,7 +18621,7 @@ async function run(options) {
           });
           try {
             if (litestreamProcess.pid !== void 0) {
-              writeFileSync6(options.litestreamPidFile, `${litestreamProcess.pid}
+              writeFileSync9(options.litestreamPidFile, `${litestreamProcess.pid}
 `, {
                 mode: 384
               });
@@ -16979,6 +18671,15 @@ async function run(options) {
       log2(state, `Started litestream replication with config ${options.litestreamConfig}`);
     }
     const tunnelSpinner = interactive && !state.json ? ora4("Connecting tunnel...").start() : null;
+    const recordBinding = state.sessionArchiveConfig.enabled ? (conversationId, sessionId) => appendSessionBinding(
+      sessionBindingLedgerPath(homedir8(), process.env),
+      {
+        conversation_id: conversationId,
+        opencode_session_id: sessionId,
+        observed_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      (message) => logActivity(state, { type: "info", level: "warn", message })
+    ) : void 0;
     const channelDriver = new ChannelDriver({
       agentId: state.agentId,
       port: state.port,
@@ -16988,9 +18689,11 @@ async function run(options) {
       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.
+      recordBinding,
+      // #559: the file-sync allow-lists. Empty ⇒ pending files are REJECTED with
+      // `file_sync_disabled` on the ack, not silently ignored.
       fileSyncDirectories,
+      fileSyncExactFiles,
       homeDir: homedir8(),
       maxActiveSessions,
       log: (entry) => (
@@ -17166,6 +18869,7 @@ async function run(options) {
     }
     if (!state.running) return;
     scheduleSessionCleanup(state, channelDriver, options);
+    scheduleSessionArchive(state);
     state.claudeUsageRearm = scheduleClaudeUsageReporting(state, options);
     state.openaiUsageRearm = scheduleUsageReporting(state, {
       label: "OpenAI",
@@ -17261,8 +18965,8 @@ program.command("run").description("Connect to Evident and process messages").op
   "--opencode-start-timeout <seconds>",
   "Seconds to wait for OpenCode to become healthy when the runner starts it (default: 180). Env: EVIDENT_OPENCODE_START_TIMEOUT"
 ).option(
-  "--opencode-version <v1|v2>",
-  "Which OpenCode major version to launch: v1 or v2 (default: v1). Env: EVIDENT_OPENCODE_VERSION"
+  "--opencode-version <v1|v2|auto>",
+  "OpenCode major version: auto (default) detects the running server, then installed binary; v1 and v2 skip server-protocol detection. Env: EVIDENT_OPENCODE_VERSION"
 ).option("--json", "Output in JSON format").option(
   "--session-cleanup-max-age <duration>",
   "Delete OpenCode sessions idle longer than this (e.g. 7d, 24h). Enables cleanup. Env: EVIDENT_SESSION_CLEANUP_MAX_AGE"
@@ -17275,6 +18979,12 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--session-cleanup-interval <duration>",
   "How often the cleanup sweep runs (default: 1h). Env: EVIDENT_SESSION_CLEANUP_INTERVAL"
+).option(
+  "--session-archive",
+  "Upload full OpenCode transcripts to the runner archive (off by default). Env: EVIDENT_SESSION_ARCHIVE"
+).option(
+  "--session-archive-interval <duration>",
+  "How often session archives are uploaded (default: 1h). Env: EVIDENT_SESSION_ARCHIVE_INTERVAL"
 ).option(
   "--claude-usage-reporting <mode>",
   "Report Claude subscription usage to Evident: auto | on | off (default: auto). Env: EVIDENT_CLAUDE_USAGE_REPORTING"
@@ -17289,6 +18999,11 @@ program.command("run").description("Connect to Evident and process messages").op
   "Allow Evident to write files into this directory (repeatable). Omit to disable file sync entirely.",
   (value, previous) => previous.concat([value]),
   []
+).option(
+  "--enable-file-sync-to-exact-file <path>",
+  "Allow Evident to write files to exactly this path (repeatable).",
+  (value, previous) => previous.concat([value]),
+  []
 ).option(
   "--tunnel-ready-file <path>",
   "Path to write once the tunnel is connected (opt-in; unused unless an operator/image sets it)"
@@ -17341,6 +19056,8 @@ program.command("run").description("Connect to Evident and process messages").op
       sessionCleanupMaxCount: options.sessionCleanupMaxCount,
       maxActiveSessions: options.maxActiveSessions,
       sessionCleanupInterval: options.sessionCleanupInterval,
+      sessionArchive: options.sessionArchive,
+      sessionArchiveInterval: options.sessionArchiveInterval,
       // Raw string — the resolver in run.ts single-sources parsing
       // (resolveClaudeUsageReportingMode).
       claudeUsageReporting: options.claudeUsageReporting,
@@ -17351,6 +19068,9 @@ program.command("run").description("Connect to Evident and process messages").op
       // Raw values — expansion/validation is single-sourced in run.ts's
       // resolveFileSyncDirectories.
       enableFileSyncTo: options.enableFileSyncTo,
+      // Raw values — expansion/validation is single-sourced in run.ts's
+      // resolveFileSyncExactFiles.
+      enableFileSyncToExactFile: options.enableFileSyncToExactFile,
       tunnelReadyFile: options.tunnelReadyFile,
       litestreamConfig: options.litestreamConfig,
       opencodePidFile: options.opencodePidFile,