@evident-ai/cli 3.2.1-dev.da70cd4 → 3.2.1-dev.fa69368

package/README.md

@@ -113,8 +113,8 @@ Options:
   and ignored, which can leave cleanup off if it was the only rule set. Env:
   `EVIDENT_SESSION_CLEANUP_MAX_AGE`. With cleanup off, a runner whose local
   session store has grown large warns once at startup, on the runner's page,
-  naming this flag — pruning stops the store growing, but it does not shrink
-  what has already grown.
+  naming this flag — turning cleanup on both stops the store growing further
+  and reclaims disk space already used by deleted sessions.
 - `--session-cleanup-max-count <n>` — Keep only the newest N OpenCode sessions
   by last activity, deleting the rest. Also enables cleanup; combines with
   `--session-cleanup-max-age` as OR. A session with a turn actively in progress
@@ -135,7 +135,9 @@ Options:
   `EVIDENT_MAX_ACTIVE_SESSIONS`.
 - `--session-cleanup-interval <duration>` — How often the cleanup sweep runs
   (default: `1h`). An invalid value falls back to the default rather than
-  disabling cleanup. Env: `EVIDENT_SESSION_CLEANUP_INTERVAL`.
+  disabling cleanup. Each sweep also reclaims disk space freed by the sessions
+  it deleted, so the store shrinks rather than merely stopping its growth. Env:
+  `EVIDENT_SESSION_CLEANUP_INTERVAL`.
 - `--enable-file-sync-to <dir>` — Let the runner write files Evident has queued
   for it into this directory — it collects them as part of the polling it
   already does, so they land a couple of seconds after you hand them over.

package/dist/index.js

@@ -2106,7 +2106,9 @@ function messageRunState(messages, userMessageId) {
   }
   if (!reply) return "queued";
   if (isAssistantInFlight(reply)) return "running";
-  return errorOf(reply) != null ? "failed" : "done";
+  if (errorOf(reply) != null) return "failed";
+  if (isAmbiguousTerminalFinish(reply)) return "running";
+  return "done";
 }
 function isPreamblePinnedRunning(messages, userMessageId) {
   if (messageRunState(messages, userMessageId) !== "running") return false;
@@ -2116,6 +2118,19 @@ function isPreamblePinnedRunning(messages, userMessageId) {
 function isB2AbandonmentConfirmed(params) {
   return params.pinnedForMs >= params.minPinnedMs && params.descendantOngoing === false;
 }
+function isAmbiguousTerminalFinish(m) {
+  if (completedOf(m) == null) return false;
+  if (errorOf(m) != null) return false;
+  const finish = finishOf(m);
+  return finish !== "tool-calls" && finish !== "stop";
+}
+function isAmbiguousFinishPinnedRunning(messages, userMessageId) {
+  const reply = findLastAssistantReplyFor(messages, userMessageId);
+  return isAmbiguousTerminalFinish(reply);
+}
+function isAmbiguousFinishResolved(params) {
+  return params.sessionOngoing === false || params.pinnedForMs >= params.maxPinnedMs;
+}
 function messageError(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   const error2 = errorOf(reply);
@@ -2341,10 +2356,128 @@ function statSessionDbBytes(homeDir) {
   }
 }
 function buildSessionStoreSizeWarning(input) {
-  const { dbBytes, cleanupEnabled } = input;
-  if (dbBytes === null || dbBytes <= LARGE_DB_THRESHOLD_BYTES || cleanupEnabled) return null;
+  const { dbBytes, cleanupEnabled, reclaimSkipReason } = input;
+  if (dbBytes === null || dbBytes <= LARGE_DB_THRESHOLD_BYTES) return null;
   const mib = Math.round(dbBytes / 1024 / 1024);
-  return `Session store is large: opencode.db is ${mib} MiB and automatic session cleanup is off. Enable it with --session-cleanup-max-age 24h (env EVIDENT_SESSION_CLEANUP_MAX_AGE) to stop it growing \u2014 a store much larger than this can exceed a hosted runner's session-history restore budget on the next start, losing this runner's session history.`;
+  if (!cleanupEnabled) {
+    return `Session store is large: opencode.db is ${mib} MiB and automatic session cleanup is off. Enable it with --session-cleanup-max-age 24h (env EVIDENT_SESSION_CLEANUP_MAX_AGE) to stop it growing \u2014 a store much larger than this can exceed a hosted runner's session-history restore budget on the next start, losing this runner's session history.`;
+  }
+  if (reclaimSkipReason === "sqlite-unavailable" || reclaimSkipReason === "insufficient-disk-space") {
+    const reasonText = reclaimSkipReason === "sqlite-unavailable" ? "this Node runtime lacks node:sqlite (needs Node >=22.5)" : "there is not enough free disk space to compact it";
+    return `Session store is large: opencode.db is ${mib} MiB. Automatic session cleanup is on, but space cannot currently be reclaimed because ${reasonText} \u2014 a store this large can exceed a hosted runner's session-history restore budget on the next start, losing this runner's session history.`;
+  }
+  return null;
+}
+
+// src/lib/opencode/session-db-reclaim.ts
+import { statSync as statSync3, statfsSync } from "fs";
+import { dirname as dirname2 } from "path";
+function insufficientSpaceReason(dbPath, requiredBytes) {
+  try {
+    const fsStats = statfsSync(dirname2(dbPath));
+    const availableBytes = fsStats.bavail * fsStats.bsize;
+    if (availableBytes < requiredBytes) {
+      return `only ${availableBytes} bytes free, need ${requiredBytes} for a second copy`;
+    }
+    return null;
+  } catch (err) {
+    return `could not check free space (${err instanceof Error ? err.message : String(err)}); refusing to guess`;
+  }
+}
+function readLogicalBytes(db) {
+  const pageCount = db.prepare("PRAGMA page_count").get().page_count;
+  const pageSize = db.prepare("PRAGMA page_size").get().page_size;
+  return pageCount * pageSize;
+}
+function readCheckpointResult(db) {
+  const row = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+  return { busy: row.busy !== 0, log: row.log, checkpointed: row.checkpointed };
+}
+async function probeReclaimAvailability(input) {
+  const { dbPath, requiredBytes } = input;
+  let sqlite;
+  try {
+    sqlite = await import("sqlite");
+  } catch (err) {
+    console.warn(
+      `[probeReclaimAvailability] node:sqlite unavailable for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return "sqlite-unavailable";
+  }
+  let autoVacuum = null;
+  try {
+    const db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    try {
+      autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    console.warn(
+      `[probeReclaimAvailability] could not read auto_vacuum mode for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (autoVacuum !== 0) return null;
+  return insufficientSpaceReason(dbPath, requiredBytes) !== null ? "insufficient-disk-space" : null;
+}
+async function reclaimSessionDbSpace(input) {
+  const { dbPath, maxPages, allowFullVacuum = true } = input;
+  let sqlite;
+  try {
+    sqlite = await import("sqlite");
+  } catch (err) {
+    console.warn(
+      `[reclaimSessionDbSpace] node:sqlite unavailable (need Node >=22.5, >=22.13 unflagged) for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { ok: false, skipped: "sqlite-unavailable" };
+  }
+  const { DatabaseSync } = sqlite;
+  let db;
+  try {
+    db = new DatabaseSync(dbPath);
+    const autoVacuum = db.prepare("PRAGMA auto_vacuum").get().auto_vacuum;
+    if (autoVacuum === 0) {
+      if (!allowFullVacuum) {
+        console.warn(
+          `[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: a session turn is live`
+        );
+        return { ok: false, skipped: "full-vacuum-blocked" };
+      }
+      const fileBytesForGuard = statSync3(dbPath).size;
+      const skipReason = insufficientSpaceReason(dbPath, fileBytesForGuard);
+      if (skipReason !== null) {
+        console.warn(
+          `[reclaimSessionDbSpace] skipping VACUUM conversion of ${dbPath}: ${skipReason}`
+        );
+        return { ok: false, skipped: "insufficient-disk-space" };
+      }
+      const beforeBytes = readLogicalBytes(db);
+      db.exec("PRAGMA auto_vacuum=INCREMENTAL");
+      db.exec("VACUUM");
+      const afterBytes = readLogicalBytes(db);
+      const checkpoint = readCheckpointResult(db);
+      return { ok: true, mode: "convert", beforeBytes, afterBytes, checkpoint };
+    }
+    if (autoVacuum === 2) {
+      const beforeBytes = readLogicalBytes(db);
+      const bound = Math.max(0, Math.trunc(maxPages));
+      db.exec(`PRAGMA incremental_vacuum(${bound})`);
+      const afterBytes = readLogicalBytes(db);
+      const checkpoint = readCheckpointResult(db);
+      return { ok: true, mode: "incremental", beforeBytes, afterBytes, checkpoint };
+    }
+    console.warn(
+      `[reclaimSessionDbSpace] ${dbPath} has auto_vacuum=${autoVacuum} (neither NONE nor INCREMENTAL); nothing to reclaim`
+    );
+    return { ok: false, skipped: "auto-vacuum-not-applicable" };
+  } catch (err) {
+    console.error(
+      `[reclaimSessionDbSpace] reclaim failed for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { ok: false, skipped: "reclaim-error" };
+  } finally {
+    db?.close();
+  }
 }
 
 // src/lib/tunnel/connection.ts
@@ -2782,7 +2915,7 @@ import { homedir as homedir2 } from "os";
 // src/lib/file-push.ts
 import { randomUUID } from "crypto";
 import { chmod, mkdir, open as open2, realpath, rename, unlink } from "fs/promises";
-import { basename, dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "path";
+import { basename, dirname as dirname3, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "path";
 var FILE_MODE = 384;
 var DIRECTORY_MODE = 448;
 async function writePushedFile(request) {
@@ -2813,7 +2946,7 @@ async function writePushedFile(request) {
   }
   try {
     const { existingAncestor, missingSegments } = await resolveNearestExistingAncestor(
-      dirname2(candidate)
+      dirname3(candidate)
     );
     const realTarget = join3(existingAncestor, ...missingSegments, basename(candidate));
     const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget);
@@ -2825,8 +2958,8 @@ async function writePushedFile(request) {
     }
     if (missingSegments.length > 0) {
       await createMissingDirectories(existingAncestor, missingSegments);
-      const realParent = await realpath(dirname2(realTarget));
-      if (realParent !== dirname2(realTarget) || !contains(allowedDirectory, realTarget)) {
+      const realParent = await realpath(dirname3(realTarget));
+      if (realParent !== dirname3(realTarget) || !contains(allowedDirectory, realTarget)) {
         return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
           path: realTarget,
           bytes,
@@ -2869,7 +3002,7 @@ async function resolveNearestExistingAncestor(directory) {
     try {
       return { existingAncestor: await realpath(current), missingSegments };
     } catch (err) {
-      const parent = dirname2(current);
+      const parent = dirname3(current);
       if (err.code !== "ENOENT" || parent === current) {
         throw err;
       }
@@ -2930,7 +3063,7 @@ async function createMissingDirectories(existingAncestor, missingSegments) {
   }
 }
 async function writeAtomically(realTarget, content) {
-  const temporaryPath = join3(dirname2(realTarget), `.evident-push-${randomUUID()}.tmp`);
+  const temporaryPath = join3(dirname3(realTarget), `.evident-push-${randomUUID()}.tmp`);
   let handle;
   try {
     handle = await open2(temporaryPath, "wx", FILE_MODE);
@@ -3203,6 +3336,7 @@ var DEFAULT_STUCK_QUEUED_MS = 6e4;
 var HEARTBEAT_MS = 6e4;
 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 B2_ABANDONMENT_RECHECK_MS = HEARTBEAT_MS;
 var POLL_MISS_GRACE_MS = HEARTBEAT_MS;
 var MAX_SUPERSEDED_CONVERSATIONS = 256;
@@ -4037,6 +4171,9 @@ var ChannelDriver = class _ChannelDriver {
         return this.reattachRedrive(conv, sessionId, message, ocId);
       }
       if (ongoing === false) {
+        if (state === "running" && isAmbiguousFinishPinnedRunning(messages, ocId ?? "")) {
+          return this.settleRedrive(conv, sessionId, message, ocId, messages, "done");
+        }
         this.clearRedriveUnresolved(message.id);
         void this.postSignal(conv.id, message.id, "redrive_redispatched");
         return "dispatch";
@@ -4648,7 +4785,9 @@ var ChannelDriver = class _ChannelDriver {
       deliveryDeadlineAnchored: false,
       b2PinnedSinceMs: 0,
       b2LastDescendantCheckMs: 0,
-      b2AbandonedSignalled: false
+      b2AbandonedSignalled: false,
+      ambiguousPinnedSinceMs: 0,
+      ambiguousResolved: false
     });
   }
   /**
@@ -4727,7 +4866,9 @@ var ChannelDriver = class _ChannelDriver {
       deliveryDeadlineAnchored: false,
       b2PinnedSinceMs: 0,
       b2LastDescendantCheckMs: 0,
-      b2AbandonedSignalled: false
+      b2AbandonedSignalled: false,
+      ambiguousPinnedSinceMs: 0,
+      ambiguousResolved: false
     });
   }
   /**
@@ -4995,6 +5136,49 @@ var ChannelDriver = class _ChannelDriver {
         }
       }
     }
+    const ambiguousPinnedNow = activelyRunning && isAmbiguousFinishPinnedRunning(messages, inFlight.opencodeMessageId);
+    if (!ambiguousPinnedNow) {
+      if (snapshotReadable) {
+        inFlight.ambiguousPinnedSinceMs = 0;
+        inFlight.ambiguousResolved = false;
+      }
+    } else {
+      if (inFlight.ambiguousResolved) {
+        await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+        return;
+      }
+      if (inFlight.ambiguousPinnedSinceMs === 0) {
+        inFlight.ambiguousPinnedSinceMs = this.now();
+        const reply = findLastAssistantReplyFor(messages, inFlight.opencodeMessageId);
+        const finish = reply?.info?.finish ?? reply?.finish;
+        this.log({
+          level: "warn",
+          message: `Message ${id.slice(0, 8)} pinned running by an unrecognised finish ("${finish ?? "(absent)"}") \u2014 corroborating against opencode's session status before settling (issue #1493)`,
+          conversation_id: conv.id,
+          message_id: id
+        });
+      }
+      const pinnedForMs = this.now() - inFlight.ambiguousPinnedSinceMs;
+      const ongoing = await isSessionOngoing(this.port, sessionId);
+      if (isAmbiguousFinishResolved({
+        pinnedForMs,
+        maxPinnedMs: AMBIGUOUS_FINISH_MAX_PINNED_MS,
+        sessionOngoing: ongoing
+      })) {
+        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 (activelyRunning && this.now() - inFlight.processingAnchorMs >= ABSOLUTE_MAX_PROCESSING_MS) {
       this.log({
         level: "warn",
@@ -5249,48 +5433,7 @@ var ChannelDriver = class _ChannelDriver {
     const ocId = row.opencode_message_id;
     const state = messageRunState(messages, ocId ?? "");
     if (state === "done") {
-      if (this.doneUndeliverable.has(row.id)) {
-        this.log({
-          level: "debug",
-          message: `Re-adopt: message ${row.id.slice(0, 8)} markDone is terminally undeliverable \u2014 left to the cron; skipping until it leaves processing`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        return;
-      }
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} completed while unwatched \u2014 marking done`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      try {
-        const title = await this.resolveSessionTitle(sessionId, row.conversation_id);
-        const usage = messageUsage(messages, ocId ?? "");
-        await this.markDone(row.conversation_id, row.id, sessionId, ocId, title, usage);
-      } catch (err) {
-        if (err instanceof ChannelAuthError) throw err;
-        if (err instanceof ChannelTerminalError) {
-          this.doneUndeliverable.add(row.id);
-          this.log({
-            level: "warn",
-            message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 parking until it leaves processing; leaving for the cron safety net: ${err.message}`,
-            conversation_id: row.conversation_id,
-            message_id: row.id
-          });
-          void this.postSignal(row.conversation_id, row.id, "readopt_undeliverable");
-          return;
-        }
-        this.log({
-          level: "warn",
-          message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        return;
-      }
-      this.dontRedispatch.delete(row.id);
-      void this.postSignal(row.conversation_id, row.id, "readopt_done");
+      await this.deliverReadoptedDone(sessionId, row, messages, ocId);
       return;
     }
     const restartAborted = state === "failed" && sessionOngoing === false && isAbortedTerminalReply(messages, ocId ?? "");
@@ -5355,6 +5498,17 @@ var ChannelDriver = class _ChannelDriver {
       const ongoing = sessionOngoing;
       statusReadableOngoing = ongoing;
       if (ongoing === false) {
+        if (isAmbiguousFinishPinnedRunning(messages, ocId ?? "")) {
+          const finish = reply?.info?.finish ?? reply?.finish;
+          this.log({
+            level: "info",
+            message: `Re-adopt: message ${row.id.slice(0, 8)} has an ambiguous finish ("${finish ?? "(absent)"}") but session ${sessionId.slice(0, 8)} is confirmed not-ongoing per GET /session/status \u2014 delivering the existing reply instead of re-dispatching`,
+            conversation_id: row.conversation_id,
+            message_id: row.id
+          });
+          await this.deliverReadoptedDone(sessionId, row, messages, ocId);
+          return;
+        }
         this.log({
           level: "info",
           message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} but session ${sessionId.slice(0, 8)} is not-ongoing per GET /session/status (absent/idle) \u2014 re-dispatching from scratch (status-gated recovery)`,
@@ -5431,6 +5585,63 @@ var ChannelDriver = class _ChannelDriver {
     }
     await this.forceReadoptRun(sessionId, row);
   }
+  /**
+   * Deliver a `processing` row whose correlated reply already completed while
+   * nobody was watching (ADR-0046) — the `readoptOne` `state === 'done'` body,
+   * extracted (#1493 Task 2.4) so the ambiguous-finish guard above can call the
+   * SAME delivery instead of duplicating it.
+   *
+   * EVEN IF the row was previously parked in `dontRedispatch` (a give-up stops
+   * re-dispatch, not delivery — Bugbot #202). Guarded EXACTLY like the watcher's
+   * `settleMessageDone`: auth re-throws; terminal → park in `doneUndeliverable` +
+   * leave for cron; transient → log + leave for the next drain (the still-
+   * `processing` row is re-read and retried). markDone is idempotent server-side
+   * (status-gated), so a repeat can never double-post.
+   */
+  async deliverReadoptedDone(sessionId, row, messages, ocId) {
+    if (this.doneUndeliverable.has(row.id)) {
+      this.log({
+        level: "debug",
+        message: `Re-adopt: message ${row.id.slice(0, 8)} markDone is terminally undeliverable \u2014 left to the cron; skipping until it leaves processing`,
+        conversation_id: row.conversation_id,
+        message_id: row.id
+      });
+      return;
+    }
+    this.log({
+      level: "info",
+      message: `Re-adopt: message ${row.id.slice(0, 8)} completed while unwatched \u2014 marking done`,
+      conversation_id: row.conversation_id,
+      message_id: row.id
+    });
+    try {
+      const title = await this.resolveSessionTitle(sessionId, row.conversation_id);
+      const usage = messageUsage(messages, ocId ?? "");
+      await this.markDone(row.conversation_id, row.id, sessionId, ocId, title, usage);
+    } catch (err) {
+      if (err instanceof ChannelAuthError) throw err;
+      if (err instanceof ChannelTerminalError) {
+        this.doneUndeliverable.add(row.id);
+        this.log({
+          level: "warn",
+          message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 parking until it leaves processing; leaving for the cron safety net: ${err.message}`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        void this.postSignal(row.conversation_id, row.id, "readopt_undeliverable");
+        return;
+      }
+      this.log({
+        level: "warn",
+        message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: row.conversation_id,
+        message_id: row.id
+      });
+      return;
+    }
+    this.dontRedispatch.delete(row.id);
+    void this.postSignal(row.conversation_id, row.id, "readopt_done");
+  }
   /**
    * Re-dispatch an orphaned (`unknown`/null-id) `processing` row (ADR-0046 §2).
    *
@@ -6060,17 +6271,25 @@ var ChannelDriver = class _ChannelDriver {
    *               the aborted-in-flight production bug after a restart.
    *   - `b2`    — a COMPLETED reply pinned running only by `finish === "tool-calls"`
    *               (the sub-agent preamble — #253's shape).
-   *   - `other` — any other shape (defensive; a running row is normally b1 or b2).
-   * Reads `info.time.completed` / `info.finish` (tolerating the legacy top-level
-   * shape) directly rather than re-importing the module-private `completedOf`/
-   * `finishOf` — this is a display label only, not a correctness predicate.
+   *   - `ambiguous` — a COMPLETED, non-errored reply whose `finish` is neither
+   *               "tool-calls" nor "stop" (issue #1493, class 4 — see
+   *               `isAmbiguousFinishPinnedRunning`/Task 2.4).
+   *   - `other` — any other shape (defensive; a running row is normally b1, b2 or
+   *               ambiguous).
+   * Reads `info.time.completed` / `info.finish` / `info.error` (tolerating the
+   * legacy top-level shape) directly rather than re-importing the module-private
+   * `completedOf`/`finishOf`/`errorOf` — this is a display label only, not a
+   * correctness predicate (that is `isAmbiguousFinishPinnedRunning`'s job).
    */
   replyCompletionShape(reply) {
     if (!reply) return "other";
     const completed = reply.info?.time?.completed ?? reply.time?.completed;
     if (completed == null) return "b1";
     const finish = reply.info?.finish ?? reply.finish;
-    return finish === "tool-calls" ? "b2" : "other";
+    if (finish === "tool-calls") return "b2";
+    const error2 = reply.info?.error ?? reply.error;
+    if (finish !== "stop" && error2 == null) return "ambiguous";
+    return "other";
   }
   /**
    * Attribute a surfaced interaction to the in-flight message it paused on (M-1).
@@ -6988,6 +7207,10 @@ async function driveChannels(state, driver) {
   }
 }
 var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
+var SESSION_DB_RECLAIM_MAX_PAGES = 2e3;
+function sessionDbPath() {
+  return join4(homedir3(), ".local", "share", "opencode", "opencode.db");
+}
 async function runSweep(state, driver, config) {
   const mode = `age=${config.maxAgeMs ?? "\u2014"} count=${config.maxCount ?? "\u2014"}`;
   try {
@@ -7030,6 +7253,25 @@ async function runSweep(state, driver, config) {
       type: "info",
       message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote} (${mode})`
     });
+    const reclaimResult = await reclaimSessionDbSpace({
+      dbPath: sessionDbPath(),
+      maxPages: SESSION_DB_RECLAIM_MAX_PAGES,
+      allowFullVacuum: protectedNow.size === 0
+    });
+    if (reclaimResult.ok) {
+      const beforeMib = (reclaimResult.beforeBytes / 1024 / 1024).toFixed(1);
+      const afterMib = (reclaimResult.afterBytes / 1024 / 1024).toFixed(1);
+      const checkpointNote = reclaimResult.checkpoint.busy ? ` (on-disk file truncation deferred: checkpoint busy, ${reclaimResult.checkpoint.log} WAL frames pending)` : "";
+      logActivity(state, {
+        type: "info",
+        message: `Session cleanup: reclaimed session-db space (${reclaimResult.mode}): ${beforeMib} MiB -> ${afterMib} MiB${checkpointNote}`
+      });
+    } else {
+      logActivity(state, {
+        type: "info",
+        message: `Session cleanup: session-db space reclaim skipped (${reclaimResult.skipped})`
+      });
+    }
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     logActivity(state, {
@@ -7050,13 +7292,22 @@ function scheduleSessionCleanup(state, driver, options) {
   for (const warning2 of config.warnings) {
     logActivity(state, { type: "info", level: "warn", message: `Session cleanup: ${warning2}` });
   }
-  const sizeWarning = buildSessionStoreSizeWarning({
-    dbBytes: statSessionDbBytes(homedir3()),
-    cleanupEnabled: config.enabled
+  const dbBytes = statSessionDbBytes(homedir3());
+  void (async () => {
+    const reclaimSkipReason = dbBytes !== null && config.enabled ? await probeReclaimAvailability({ dbPath: sessionDbPath(), requiredBytes: dbBytes }) : null;
+    const sizeWarning = buildSessionStoreSizeWarning({
+      dbBytes,
+      cleanupEnabled: config.enabled,
+      reclaimSkipReason
+    });
+    if (sizeWarning !== null) {
+      logActivity(state, { type: "info", level: "warn", message: sizeWarning });
+    }
+  })().catch((err) => {
+    console.error(
+      `[scheduleSessionCleanup] size-warning preflight failed: ${err instanceof Error ? err.message : String(err)}`
+    );
   });
-  if (sizeWarning !== null) {
-    logActivity(state, { type: "info", level: "warn", message: sizeWarning });
-  }
   if (!config.enabled) return;
   logActivity(state, {
     type: "info",