opencode-sessions-explorer 0.1.2 → 0.1.4

package/dist/plugin.js

@@ -12889,8 +12889,8 @@ function decodeModel(modelStr) {
 }
 
 // src/lib/export.ts
-import { mkdirSync, existsSync as existsSync2, renameSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "fs";
-import { join as join2 } from "path";
+import { mkdirSync, existsSync as existsSync5, renameSync as renameSync2, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/channel.ts
@@ -12978,50 +12978,506 @@ function looksLikeExactIdentifier(q) {
   return /\b(?:[A-Z][A-Z0-9_]+-\d+|ses_[A-Za-z0-9_-]+|msg_[A-Za-z0-9_-]+|prt_[A-Za-z0-9_-]+)\b/.test(q) || /https?:\/\/\S+/.test(q) || /(?:\/[\w .@-]+){2,}/.test(q);
 }
 
-// src/lib/export.ts
-var DEFAULT_EXPORT_ROOT = join2(homedir2(), ".local/share/opencode-sessions-explorer");
-var BODY_CAP_BYTES = 256 * 1024;
-var SAFETY_PART_CAP_BYTES = 50 * 1024 * 1024;
-var CHANNEL_COMPLETE_MARKER = ".channels_v1_complete";
+// src/lib/export-constants.ts
 var SEARCHABLE_TYPES = ["text", "reasoning", "tool", "file", "patch", "subtask"];
-var PART_CHANNELS = CHANNELS.filter((c) => c !== "session-summary" && c !== "raw");
-function exportRoot() {
-  return process.env.OPENCODE_SESSIONS_EXPLORER_EXPORT_ROOT || DEFAULT_EXPORT_ROOT;
-}
-function ensureRoot(root = exportRoot()) {
-  mkdirSync(join2(root, "by-session"), { recursive: true });
-  return root;
-}
-function channelExportComplete(root = exportRoot()) {
-  return existsSync2(join2(root, CHANNEL_COMPLETE_MARKER));
+
+// src/lib/export-lock.ts
+import { closeSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { hostname as hostname3 } from "os";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+var LOCK_FILE = ".export.lock";
+var DEFAULT_STALE_MS = 2 * 60 * 1000;
+var HEARTBEAT_MS = 15000;
+function acquireExportLock(root, staleMs = DEFAULT_STALE_MS) {
+  const path = join2(root, LOCK_FILE);
+  const first = tryCreateLock(path);
+  if (first)
+    return first;
+  const stale = staleCandidate(path, staleMs);
+  if (!stale)
+    return null;
+  if (!removeStaleLock(path, stale, staleMs))
+    return tryCreateLock(path);
+  return tryCreateLock(path);
 }
-var CURSOR_SCHEMA = "v2";
-function getLastSync(root = exportRoot()) {
-  const p = join2(root, ".last_sync");
-  if (!existsSync2(p))
+function tryCreateLock(path) {
+  let fd = null;
+  try {
+    const token = randomUUID();
+    const now = Date.now();
+    const record2 = { token, pid: process.pid, hostname: hostname3(), created_at: now, updated_at: now };
+    fd = openSync(path, "wx");
+    writeFileSync(fd, JSON.stringify(record2));
+    closeSync(fd);
+    fd = null;
+    let lastHeartbeat = now;
+    return {
+      token,
+      release: () => releaseLock(path, token),
+      heartbeat: () => {
+        const current = Date.now();
+        if (current - lastHeartbeat < HEARTBEAT_MS)
+          return;
+        lastHeartbeat = current;
+        heartbeatLock(path, token, current);
+      }
+    };
+  } catch {
+    if (fd != null)
+      try {
+        closeSync(fd);
+      } catch {}
     return null;
+  }
+}
+function staleCandidate(path, staleMs) {
   try {
-    const raw = readFileSync(p, "utf8").trim();
-    if (!raw)
+    const stat = statSync(path);
+    const now = Date.now();
+    if (now - stat.mtimeMs <= staleMs)
+      return null;
+    const parsed = readLockRecord(path);
+    if (!parsed)
+      return { token: null, updatedAt: null, mtimeMs: stat.mtimeMs };
+    if (now - parsed.updated_at <= staleMs)
       return null;
-    if (raw.startsWith(`${CURSOR_SCHEMA} `)) {
-      const [tsStr, id] = raw.slice(CURSOR_SCHEMA.length + 1).split(":");
-      const ts = Number(tsStr);
-      if (!Number.isFinite(ts) || !id)
-        return null;
-      return { ts, id };
+    if (isLiveLocalOwner(parsed))
+      return null;
+    return { token: parsed.token, updatedAt: parsed.updated_at, mtimeMs: stat.mtimeMs };
+  } catch {
+    return { token: null, updatedAt: null, mtimeMs: 0 };
+  }
+}
+function removeStaleLock(path, stale, staleMs) {
+  try {
+    const stat = statSync(path);
+    if (stat.mtimeMs !== stale.mtimeMs)
+      return false;
+    if (stale.token) {
+      const current = readLockRecord(path);
+      if (current?.token !== stale.token)
+        return false;
+      if (current.updated_at !== stale.updatedAt)
+        return false;
+      const now = Date.now();
+      if (now - current.updated_at <= staleMs)
+        return false;
+      if (now - stat.mtimeMs <= staleMs)
+        return false;
+      if (isLiveLocalOwner(current))
+        return false;
+    } else {
+      if (Date.now() - stat.mtimeMs <= staleMs)
+        return false;
     }
-    return null;
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(path, token) {
+  try {
+    const current = readLockRecord(path);
+    if (current?.token === token)
+      unlinkSync(path);
+  } catch {}
+}
+function heartbeatLock(path, token, now) {
+  try {
+    const current = readLockRecord(path);
+    if (current?.token !== token)
+      return;
+    writeFileSync(path, JSON.stringify({ ...current, updated_at: now }));
+  } catch {}
+}
+function readLockRecord(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.token !== "string")
+      return null;
+    if (typeof parsed.pid !== "number" || !Number.isFinite(parsed.pid))
+      return null;
+    if (typeof parsed.hostname !== "string")
+      return null;
+    if (typeof parsed.created_at !== "number" || !Number.isFinite(parsed.created_at))
+      return null;
+    const updated = typeof parsed.updated_at === "number" && Number.isFinite(parsed.updated_at) ? parsed.updated_at : parsed.created_at;
+    return { token: parsed.token, pid: parsed.pid, hostname: parsed.hostname, created_at: parsed.created_at, updated_at: updated };
   } catch {
     return null;
   }
 }
-function setLastSync(c, root = exportRoot()) {
-  const p = join2(root, ".last_sync");
+function isLiveLocalOwner(record2) {
+  if (record2.hostname !== hostname3())
+    return false;
+  if (!Number.isSafeInteger(record2.pid) || record2.pid <= 0)
+    return false;
+  try {
+    process.kill(record2.pid, 0);
+    return true;
+  } catch (error45) {
+    return error45?.code === "EPERM";
+  }
+}
+
+// src/lib/export-tombstones.ts
+import { existsSync as existsSync2, readdirSync, rmSync, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+var PART_FILE_RE = /^(?:\d{5}-)?(prt_[A-Za-z0-9_-]+)\.txt$/;
+function reconcileTombstones(root, heartbeat = () => {}) {
+  const progress = {
+    scanned_sessions: 0,
+    removed_sessions: 0,
+    removed_parts: 0,
+    removed_channel_sessions: 0
+  };
+  const bySession = join3(root, "by-session");
+  const sessions = loadSessionIds();
+  if (existsSync2(bySession)) {
+    for (const entry of safeReadDir(bySession)) {
+      const dir = join3(bySession, entry);
+      if (!isDirectory(dir))
+        continue;
+      if (!sessions.has(entry)) {
+        rmSync(dir, { recursive: true, force: true });
+        removeChannelSessionDirs(root, entry);
+        progress.removed_sessions++;
+        heartbeat();
+        continue;
+      }
+      progress.scanned_sessions++;
+      progress.removed_parts += removeOrphanPartFiles(root, entry, dir, heartbeat);
+      heartbeat();
+    }
+  }
+  progress.removed_channel_sessions += removeOrphanChannelSessions(root, sessions, heartbeat);
+  return progress;
+}
+function removeOrphanPartFiles(root, sessionId, dir, heartbeat) {
+  const livePartIds = loadSearchablePartIds(sessionId);
+  let removed = 0;
+  for (const file2 of safeReadDir(dir)) {
+    heartbeat();
+    const partId = partIdFromFile(file2);
+    if (!partId || livePartIds.has(partId))
+      continue;
+    try {
+      unlinkSync2(join3(dir, file2));
+      removeChannelPartFiles(root, sessionId, partId);
+      removed++;
+    } catch {}
+  }
+  return removed;
+}
+function removeOrphanChannelSessions(root, sessions, heartbeat) {
+  let removed = 0;
+  for (const channel of CHANNELS) {
+    const base = join3(root, "by-channel", channel, "by-session");
+    if (!existsSync2(base))
+      continue;
+    for (const sessionId of safeReadDir(base)) {
+      heartbeat();
+      const dir = join3(base, sessionId);
+      if (!isDirectory(dir) || sessions.has(sessionId))
+        continue;
+      rmSync(dir, { recursive: true, force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+function removeChannelSessionDirs(root, sessionId) {
+  for (const channel of CHANNELS) {
+    rmSync(channelDir(root, channel, sessionId), { recursive: true, force: true });
+  }
+}
+function removeChannelPartFiles(root, sessionId, partId) {
+  for (const channel of CHANNELS) {
+    const dir = channelDir(root, channel, sessionId);
+    if (!existsSync2(dir))
+      continue;
+    for (const file2 of safeReadDir(dir)) {
+      if (file2 === `${partId}.txt` || file2.endsWith(`-${partId}.txt`)) {
+        try {
+          unlinkSync2(join3(dir, file2));
+        } catch {}
+      }
+    }
+  }
+}
+function channelDir(root, channel, sessionId) {
+  return join3(root, "by-channel", channel, "by-session", sessionId);
+}
+function loadSessionIds() {
+  const rows = stmt(`SELECT id FROM session`).all();
+  return new Set(rows.map((row) => row.id));
+}
+function loadSearchablePartIds(sessionId) {
+  const placeholders = SEARCHABLE_TYPES.map(() => "?").join(",");
+  const rows = stmt(`
+    SELECT id
+      FROM part
+     WHERE session_id = ?
+       AND json_extract(data,'$.type') IN (${placeholders})
+  ORDER BY id ASC`).all(sessionId, ...SEARCHABLE_TYPES);
+  return new Set(rows.map((row) => row.id));
+}
+function safeReadDir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function partIdFromFile(file2) {
+  const match = PART_FILE_RE.exec(file2);
+  return match ? match[1] : null;
+}
+
+// src/lib/export-background.ts
+import { existsSync as existsSync3 } from "fs";
+import { fileURLToPath } from "url";
+var DEFAULT_MIN_INTERVAL_MS = 5 * 60 * 1000;
+var inFlight = false;
+var lastStartedAt = 0;
+function scheduleBackgroundReconcile(opts) {
+  const now = Date.now();
+  const minIntervalMs = opts.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  if (inFlight)
+    return { scheduled: false, reason: "already_running" };
+  if (now - lastStartedAt < minIntervalMs)
+    return { scheduled: false, reason: "throttled" };
+  const url2 = resolveWorkerUrl();
+  try {
+    const worker = new Worker(url2, { type: "module" });
+    inFlight = true;
+    lastStartedAt = now;
+    const cleanup = () => {
+      inFlight = false;
+      worker.terminate();
+    };
+    worker.addEventListener("message", cleanup, { once: true });
+    worker.addEventListener("error", cleanup, { once: true });
+    const maybeUnref = worker;
+    maybeUnref.unref?.();
+    const request = { root: opts.root, batchSize: opts.batchSize ?? 2000 };
+    worker.postMessage(request);
+    return { scheduled: true };
+  } catch {
+    inFlight = false;
+    return { scheduled: false, reason: "worker_unavailable" };
+  }
+}
+function resolveWorkerUrl() {
+  const js = new URL("./export-reconcile-worker.js", import.meta.url);
+  if (existsSync3(fileURLToPath(js)))
+    return js;
+  const ts = new URL("./export-reconcile-worker.ts", import.meta.url);
+  if (existsSync3(fileURLToPath(ts)))
+    return ts;
+  const bundled = new URL("./lib/export-reconcile-worker.js", import.meta.url);
+  if (existsSync3(fileURLToPath(bundled)))
+    return bundled;
+  return js;
+}
+
+// src/lib/export-state.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var CURSOR_SCHEMA = "v3";
+var LAST_SYNC_FILE = ".last_sync";
+function freshSyncState(migratedFrom, legacyCursor = null) {
+  return {
+    schema: CURSOR_SCHEMA,
+    insert_cursor: { id: "" },
+    session_cursor: null,
+    session_dirty_hints: {},
+    reconcile_watermark: null,
+    failed_parts: {},
+    dead_letters: {},
+    last_reconcile_at: null,
+    legacy_cursor: legacyCursor,
+    migrated_from: migratedFrom
+  };
+}
+function getSyncState(root) {
+  const p = join4(root, LAST_SYNC_FILE);
+  if (!existsSync4(p))
+    return freshSyncState();
+  try {
+    return parseSyncState(readFileSync2(p, "utf8"));
+  } catch {
+    return freshSyncState("unreadable");
+  }
+}
+function setSyncState(state, root) {
+  const p = join4(root, LAST_SYNC_FILE);
   const tmp = p + ".tmp";
-  writeFileSync(tmp, `${CURSOR_SCHEMA} ${c.ts}:${c.id}`);
+  writeFileSync2(tmp, `${CURSOR_SCHEMA} ${JSON.stringify(normalizeSyncState(state))}`);
   renameSync(tmp, p);
 }
+function getLastSync(root) {
+  const p = join4(root, LAST_SYNC_FILE);
+  if (!existsSync4(p))
+    return null;
+  const state = getSyncState(root);
+  if (state.legacy_cursor)
+    return state.legacy_cursor;
+  if (!state.insert_cursor.id)
+    return null;
+  return { ts: 0, id: state.insert_cursor.id };
+}
+function parseSyncState(rawInput) {
+  const raw = rawInput.trim();
+  if (!raw)
+    return freshSyncState("empty");
+  if (raw.startsWith(`${CURSOR_SCHEMA} `)) {
+    const parsed = JSON.parse(raw.slice(CURSOR_SCHEMA.length + 1));
+    return normalizeSyncState(parsed);
+  }
+  if (raw.startsWith("{")) {
+    return normalizeSyncState(JSON.parse(raw));
+  }
+  if (raw.startsWith("v2 ")) {
+    return freshSyncState("v2", parseLegacyCursor(raw.slice(3)));
+  }
+  const legacy = parseLegacyCursor(raw);
+  return freshSyncState(legacy ? "v1" : "unknown", legacy);
+}
+function normalizeSyncState(input) {
+  if (!isRecord(input))
+    return freshSyncState("invalid");
+  const state = freshSyncState(asString(input.migrated_from) ?? undefined, cursorOrNull(input.legacy_cursor));
+  const insert = isRecord(input.insert_cursor) ? input.insert_cursor : null;
+  state.insert_cursor.id = asString(insert?.id) ?? "";
+  state.session_cursor = cursorOrNull(input.session_cursor);
+  state.session_dirty_hints = dirtyHints(input.session_dirty_hints);
+  state.reconcile_watermark = reconcileWatermark(input.reconcile_watermark);
+  state.failed_parts = failedParts(input.failed_parts);
+  state.dead_letters = failedParts(input.dead_letters);
+  state.last_reconcile_at = finiteOrNull(input.last_reconcile_at);
+  return state;
+}
+function parseLegacyCursor(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0)
+    return null;
+  const ts = Number(raw.slice(0, idx));
+  const id = raw.slice(idx + 1);
+  if (!Number.isFinite(ts) || !id)
+    return null;
+  return { ts, id };
+}
+function cursorOrNull(value) {
+  if (!isRecord(value))
+    return null;
+  const ts = finiteOrNull(value.ts);
+  const id = asString(value.id);
+  if (ts == null || !id)
+    return null;
+  return { ts, id };
+}
+function dirtyHints(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (!id)
+      continue;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+      out[id] = { time_updated: raw, part_cursor: null };
+      continue;
+    }
+    if (!isRecord(raw))
+      continue;
+    const timeUpdated = finiteOrNull(raw.time_updated);
+    if (timeUpdated == null)
+      continue;
+    out[id] = { time_updated: timeUpdated, part_cursor: asString(raw.part_cursor) };
+  }
+  return out;
+}
+function reconcileWatermark(value) {
+  if (!isRecord(value))
+    return null;
+  const at = finiteOrNull(value.at);
+  if (at == null)
+    return null;
+  return {
+    part_id: asString(value.part_id),
+    session_id: asString(value.session_id),
+    at
+  };
+}
+function failedParts(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (!id || !isRecord(raw))
+      continue;
+    const attempts = finiteOrNull(raw.attempts);
+    const firstFailedAt = finiteOrNull(raw.first_failed_at);
+    const lastFailedAt = finiteOrNull(raw.last_failed_at);
+    if (attempts == null || firstFailedAt == null || lastFailedAt == null)
+      continue;
+    out[id] = {
+      id,
+      attempts,
+      first_failed_at: firstFailedAt,
+      last_failed_at: lastFailedAt,
+      last_error: asString(raw.last_error) ?? "unknown export failure"
+    };
+  }
+  return out;
+}
+function finiteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/export.ts
+var DEFAULT_EXPORT_ROOT = join5(homedir2(), ".local/share/opencode-sessions-explorer");
+var BODY_CAP_BYTES = 256 * 1024;
+var SAFETY_PART_CAP_BYTES = 50 * 1024 * 1024;
+var CHANNEL_COMPLETE_MARKER = ".channels_v1_complete";
+var INSERT_REWIND_MS = 3 * 60 * 1000;
+var INSERT_REWIND_MAX_ROWS = 512;
+var MAX_FAILED_ATTEMPTS = 5;
+var PART_CHANNELS = CHANNELS.filter((c) => c !== "session-summary" && c !== "raw");
+function exportRoot() {
+  return process.env.OPENCODE_SESSIONS_EXPLORER_EXPORT_ROOT || DEFAULT_EXPORT_ROOT;
+}
+function getSyncState2(root = exportRoot()) {
+  return getSyncState(root);
+}
+function setSyncState2(state, root = exportRoot()) {
+  setSyncState(state, root);
+}
+function getLastSync2(root = exportRoot()) {
+  return getLastSync(root);
+}
+function ensureRoot(root = exportRoot()) {
+  mkdirSync(join5(root, "by-session"), { recursive: true });
+  return root;
+}
+function channelExportComplete(root = exportRoot()) {
+  return existsSync5(join5(root, CHANNEL_COMPLETE_MARKER));
+}
 var sessionCache = new Map;
 function getSession(id) {
   const cached2 = sessionCache.get(id);
@@ -13263,46 +13719,46 @@ function writeMeta(s, dir) {
     time_updated: s.time_updated,
     archived: s.time_archived != null
   };
-  const p = join2(dir, "meta.json");
+  const p = join5(dir, "meta.json");
   const tmp = p + ".tmp";
-  writeFileSync(tmp, JSON.stringify(meta, null, 2));
-  renameSync(tmp, p);
+  writeFileSync3(tmp, JSON.stringify(meta, null, 2));
+  renameSync2(tmp, p);
 }
 function writePartFile(dir, filename, content) {
-  const p = join2(dir, filename);
-  const tmp = join2(dir, "." + filename + ".tmp");
-  writeFileSync(tmp, content);
-  renameSync(tmp, p);
+  const p = join5(dir, filename);
+  const tmp = join5(dir, "." + filename + ".tmp");
+  writeFileSync3(tmp, content);
+  renameSync2(tmp, p);
   const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(filename);
   if (!m)
     return;
   const myPartId = m[2];
   try {
-    for (const f of readdirSync(dir)) {
+    for (const f of readdirSync2(dir)) {
       if (f === filename || !f.endsWith(".txt") || f.startsWith("."))
         continue;
       const fm = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
       if (fm && fm[2] === myPartId) {
         try {
-          unlinkSync(join2(dir, f));
+          unlinkSync3(join5(dir, f));
         } catch {}
       }
     }
   } catch {}
 }
-function channelDir(root, channel, sessionId) {
-  return join2(root, "by-channel", channel, "by-session", sessionId);
+function channelDir2(root, channel, sessionId) {
+  return join5(root, "by-channel", channel, "by-session", sessionId);
 }
 function deleteChannelPartFiles(root, sessionId, partId) {
   for (const ch of PART_CHANNELS) {
-    const dir = channelDir(root, ch, sessionId);
-    if (!existsSync2(dir))
+    const dir = channelDir2(root, ch, sessionId);
+    if (!existsSync5(dir))
       continue;
     try {
-      for (const f of readdirSync(dir)) {
+      for (const f of readdirSync2(dir)) {
         if (f === `${partId}.txt` || f.endsWith(`-${partId}.txt`)) {
           try {
-            unlinkSync(join2(dir, f));
+            unlinkSync3(join5(dir, f));
           } catch {}
         }
       }
@@ -13312,20 +13768,20 @@ function deleteChannelPartFiles(root, sessionId, partId) {
 function writeChannelFiles(root, sessionId, filename, partId, docs) {
   deleteChannelPartFiles(root, sessionId, partId);
   for (const doc2 of docs) {
-    const dir = channelDir(root, doc2.channel, sessionId);
-    if (!existsSync2(dir))
+    const dir = channelDir2(root, doc2.channel, sessionId);
+    if (!existsSync5(dir))
       mkdirSync(dir, { recursive: true });
     writePartFile(dir, filename, doc2.content);
   }
 }
 function writeSessionSummaryChannel(s, dirRoot = exportRoot()) {
-  const dir = channelDir(dirRoot, "session-summary", s.id);
-  if (!existsSync2(dir))
+  const dir = channelDir2(dirRoot, "session-summary", s.id);
+  if (!existsSync5(dir))
     mkdirSync(dir, { recursive: true });
-  const p = join2(dir, "summary.txt");
+  const p = join5(dir, "summary.txt");
   const tmp = p + ".tmp";
-  writeFileSync(tmp, buildSessionSummaryDocument(s));
-  renameSync(tmp, p);
+  writeFileSync3(tmp, buildSessionSummaryDocument(s));
+  renameSync2(tmp, p);
 }
 function buildSessionSummaryDocument(s) {
   const firstPrompt = firstUserPrompt(s.id, "ASC");
@@ -13379,7 +13835,7 @@ function getFileIndex(sessionId, dir) {
     return idx;
   idx = { nextSeq: 1, byPartId: new Map };
   try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".txt") && !f.startsWith("."));
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".txt") && !f.startsWith("."));
     let max = 0;
     for (const f of files) {
       const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
@@ -13400,112 +13856,324 @@ function getFileIndex(sessionId, dir) {
 }
 async function runExport(opts = {}) {
   const root = ensureRoot(opts.root ?? exportRoot());
-  const cursor = opts.fromCursor !== undefined ? opts.fromCursor : getLastSync(root);
   const batchSize = opts.batchSize ?? 1000;
-  const start = Date.now();
-  const progress = { exported: 0, inserts: 0, updates: 0, skipped_nontext: 0, skipped_oversize: 0, failed: 0, last_cursor: cursor };
-  let where = "";
-  const params = [];
-  if (cursor) {
-    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
-    params.push(cursor.ts, cursor.ts, cursor.id);
-  }
-  let updates = 0;
-  let inserts = 0;
-  const touchedSessions = new Set;
-  while (true) {
-    if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+  const progress = emptyProgress(getLastSync2(root));
+  const lock = acquireExportLock(root);
+  if (!lock) {
+    progress.lock_skipped = true;
+    return progress;
+  }
+  try {
+    const state = getSyncState2(root);
+    applyCursorOverride(state, opts.fromCursor);
+    const start = Date.now();
+    const touchedSessions = new Set;
+    retryFailedParts(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    runInsertFastPath(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    runSessionDirtyFastPath(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    refreshTouchedSessions(root, touchedSessions);
+    if (!opts.budgetMs) {
+      lock.heartbeat();
+      const tombstones = reconcileTombstones(root, lock.heartbeat);
+      applyTombstoneProgress(progress, tombstones);
+      state.last_reconcile_at = Date.now();
+      state.reconcile_watermark = {
+        part_id: state.insert_cursor.id || null,
+        session_id: state.session_cursor?.id ?? null,
+        at: state.last_reconcile_at
+      };
+    }
+    progress.last_cursor = state.legacy_cursor;
+    setSyncState2(state, root);
+  } finally {
+    lock.release();
+  }
+  if (opts.budgetMs && !opts.skipBackgroundReconcile) {
+    scheduleBackgroundReconcile({ root });
+  }
+  return progress;
+}
+function emptyProgress(cursor) {
+  return {
+    exported: 0,
+    inserts: 0,
+    updates: 0,
+    skipped_nontext: 0,
+    skipped_oversize: 0,
+    failed: 0,
+    retried: 0,
+    dead_lettered: 0,
+    tombstones_removed_parts: 0,
+    tombstones_removed_sessions: 0,
+    lock_skipped: false,
+    last_cursor: cursor
+  };
+}
+function applyCursorOverride(state, cursor) {
+  if (cursor === undefined)
+    return;
+  state.legacy_cursor = cursor;
+  state.insert_cursor.id = cursor?.id ?? "";
+  state.session_cursor = cursor && cursor.ts > 0 ? cursor : null;
+  state.session_dirty_hints = {};
+}
+function retryFailedParts(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  const ids = Object.keys(state.failed_parts).sort().slice(0, batchSize);
+  for (const id of ids) {
+    if (timeExceeded(start, budgetMs))
       break;
-    const rows = stmt(`
-      SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated, p.data, LENGTH(p.data) AS data_bytes,
-             json_extract(m.data,'$.role') AS role
-        FROM part p
-        LEFT JOIN message m ON m.id = p.message_id
-        ${where}
-    ORDER BY p.time_updated ASC, p.id ASC
-       LIMIT ?`).all(...params, batchSize);
+    progress.retried++;
+    const row = loadPartById(id);
+    if (!row) {
+      clearPartFailure(state, id);
+      continue;
+    }
+    exportPartRow(root, state, row, progress, touchedSessions);
+    reportProgress(progress, onProgress, heartbeat);
+  }
+}
+function runInsertFastPath(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  const recentSafeRows = [];
+  let scanCursor = state.insert_cursor.id;
+  while (!timeExceeded(start, budgetMs)) {
+    const rows = loadPartRowsAfterId(scanCursor, batchSize);
     if (rows.length === 0)
       break;
-    for (const r of rows) {
-      if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+    for (const row of rows) {
+      if (timeExceeded(start, budgetMs))
+        break;
+      scanCursor = row.id;
+      const safe = exportPartRow(root, state, row, progress, touchedSessions);
+      if (safe)
+        rememberSafeRow(recentSafeRows, row);
+      reportProgress(progress, onProgress, heartbeat);
+    }
+    if (rows.length < batchSize)
+      break;
+  }
+  if (recentSafeRows.length > 0) {
+    state.insert_cursor.id = chooseInsertCursor(state.insert_cursor.id, recentSafeRows, budgetMs !== undefined);
+  }
+}
+function runSessionDirtyFastPath(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  scanDirtySessionHints(state, start, budgetMs, Math.min(batchSize, 500));
+  for (const [sessionId, hint] of sortedDirtyHints(state.session_dirty_hints)) {
+    while (!timeExceeded(start, budgetMs)) {
+      const rows = loadSessionPartRows(sessionId, hint.part_cursor, batchSize);
+      if (rows.length === 0) {
+        delete state.session_dirty_hints[sessionId];
+        break;
+      }
+      for (const row of rows) {
+        if (timeExceeded(start, budgetMs))
+          break;
+        hint.part_cursor = row.id;
+        exportPartRow(root, state, row, progress, touchedSessions);
+        reportProgress(progress, onProgress, heartbeat);
+      }
+      if (rows.length < batchSize) {
+        delete state.session_dirty_hints[sessionId];
         break;
-      if (r.data_bytes > SAFETY_PART_CAP_BYTES) {
-        progress.skipped_oversize++;
-      } else {
-        try {
-          const s = getSession(r.session_id);
-          if (!s) {
-            progress.failed++;
-            continue;
-          }
-          const built = buildPartFile(r.id, r.session_id, r.message_id, r.data, s.time_archived != null);
-          if (!built) {
-            progress.skipped_nontext++;
-            continue;
-          }
-          const channelDocs = buildChannelDocuments(r.id, r.session_id, r.message_id, r.data, s.time_archived != null, r.role ?? null, s.directory);
-          const dir = join2(root, "by-session", r.session_id);
-          if (!existsSync2(dir)) {
-            mkdirSync(dir, { recursive: true });
-            writeMeta(s, dir);
-          }
-          const idx = getFileIndex(r.session_id, dir);
-          const existing = idx.byPartId.get(r.id);
-          if (existing) {
-            writePartFile(dir, existing, built.content);
-            updates++;
-          } else {
-            const seq = idx.nextSeq++;
-            const filename2 = safePartFilename(seq, r.id);
-            writePartFile(dir, filename2, built.content);
-            idx.byPartId.set(r.id, filename2);
-            inserts++;
-          }
-          const filename = idx.byPartId.get(r.id);
-          if (filename)
-            writeChannelFiles(root, r.session_id, filename, r.id, channelDocs);
-          touchedSessions.add(r.session_id);
-          progress.exported++;
-        } catch {
-          progress.failed++;
-        }
       }
-      progress.last_cursor = { ts: r.time_updated, id: r.id };
     }
-    const last = rows[rows.length - 1];
-    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
-    params.length = 0;
-    params.push(last.time_updated, last.time_updated, last.id);
-    if (opts.onProgress && progress.exported % 5000 === 0)
-      opts.onProgress(progress);
-    if (progress.last_cursor && progress.exported > 0 && progress.exported % 5000 === 0) {
-      setLastSync(progress.last_cursor, root);
+    if (timeExceeded(start, budgetMs))
+      break;
+  }
+}
+function scanDirtySessionHints(state, start, budgetMs, limit) {
+  while (!timeExceeded(start, budgetMs)) {
+    const rows = loadDirtySessionsAfter(state.session_cursor, limit);
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      state.session_dirty_hints[row.id] = { time_updated: row.time_updated, part_cursor: null };
+      state.session_cursor = { ts: row.time_updated, id: row.id };
     }
+    if (rows.length < limit)
+      break;
   }
+}
+function exportPartRow(root, state, row, progress, touchedSessions) {
+  if (row.data_bytes > SAFETY_PART_CAP_BYTES) {
+    removeExistingPartExport(root, row.session_id, row.id);
+    progress.skipped_oversize++;
+    markSafeCursor(state, progress, row);
+    clearPartFailure(state, row.id);
+    return true;
+  }
+  try {
+    const session = getSession(row.session_id);
+    if (!session)
+      throw new Error(`missing session ${row.session_id}`);
+    const archived = session.time_archived != null;
+    const built = buildPartFile(row.id, row.session_id, row.message_id, row.data, archived);
+    if (!built) {
+      removeExistingPartExport(root, row.session_id, row.id);
+      progress.skipped_nontext++;
+      markSafeCursor(state, progress, row);
+      clearPartFailure(state, row.id);
+      return true;
+    }
+    const channelDocs = buildChannelDocuments(row.id, row.session_id, row.message_id, row.data, archived, row.role, session.directory);
+    const dir = join5(root, "by-session", row.session_id);
+    if (!existsSync5(dir)) {
+      mkdirSync(dir, { recursive: true });
+      writeMeta(session, dir);
+    }
+    const idx = getFileIndex(row.session_id, dir);
+    const existing = idx.byPartId.get(row.id);
+    if (existing) {
+      writePartFile(dir, existing, built.content);
+      progress.updates++;
+    } else {
+      const filename2 = safePartFilename(idx.nextSeq++, row.id);
+      writePartFile(dir, filename2, built.content);
+      idx.byPartId.set(row.id, filename2);
+      progress.inserts++;
+    }
+    const filename = idx.byPartId.get(row.id);
+    if (filename)
+      writeChannelFiles(root, row.session_id, filename, row.id, channelDocs);
+    touchedSessions.add(row.session_id);
+    progress.exported++;
+    markSafeCursor(state, progress, row);
+    clearPartFailure(state, row.id);
+    return true;
+  } catch (error45) {
+    progress.failed++;
+    markPartFailure(state, row.id, errorMessage(error45), progress);
+    return false;
+  }
+}
+function removeExistingPartExport(root, sessionId, partId) {
+  const dir = join5(root, "by-session", sessionId);
+  try {
+    if (existsSync5(dir)) {
+      const idx = getFileIndex(sessionId, dir);
+      const existing = idx.byPartId.get(partId);
+      if (existing)
+        unlinkSync3(join5(dir, existing));
+      idx.byPartId.delete(partId);
+    }
+    deleteChannelPartFiles(root, sessionId, partId);
+  } catch {}
+}
+function markSafeCursor(state, progress, row) {
+  const cursor = { ts: row.time_updated, id: row.id };
+  state.legacy_cursor = cursor;
+  progress.last_cursor = cursor;
+}
+function markPartFailure(state, partId, message, progress) {
+  if (state.dead_letters[partId])
+    return;
+  const now = Date.now();
+  const existing = state.failed_parts[partId];
+  const failure = {
+    id: partId,
+    attempts: (existing?.attempts ?? 0) + 1,
+    first_failed_at: existing?.first_failed_at ?? now,
+    last_failed_at: now,
+    last_error: message
+  };
+  if (failure.attempts >= MAX_FAILED_ATTEMPTS) {
+    state.dead_letters[partId] = failure;
+    delete state.failed_parts[partId];
+    progress.dead_lettered++;
+  } else {
+    state.failed_parts[partId] = failure;
+  }
+}
+function clearPartFailure(state, partId) {
+  delete state.failed_parts[partId];
+}
+function rememberSafeRow(rows, row) {
+  rows.push(row);
+  const maxRows = INSERT_REWIND_MAX_ROWS * 4;
+  if (rows.length > maxRows)
+    rows.splice(0, rows.length - maxRows);
+}
+function chooseInsertCursor(previousId, rows, useRewind) {
+  const last = rows[rows.length - 1];
+  if (!last || !useRewind || rows.length <= INSERT_REWIND_MAX_ROWS)
+    return last?.id ?? previousId;
+  const maxCreated = rows.reduce((max, row) => Math.max(max, row.time_created), 0);
+  const cutoff = maxCreated - INSERT_REWIND_MS;
+  const timeIndex = rows.findIndex((row) => row.time_created >= cutoff);
+  const rewindIndex = Math.max(timeIndex <= 0 ? rows.length - INSERT_REWIND_MAX_ROWS : timeIndex - 1, rows.length - INSERT_REWIND_MAX_ROWS);
+  return rows[Math.max(0, rewindIndex)]?.id ?? last.id;
+}
+function sortedDirtyHints(hints) {
+  return Object.entries(hints).sort((a, b) => a[1].time_updated - b[1].time_updated || a[0].localeCompare(b[0]));
+}
+function refreshTouchedSessions(root, touchedSessions) {
   for (const sid of touchedSessions) {
-    const s = getSession(sid);
-    if (s) {
-      const dir = join2(root, "by-session", sid);
-      const fresh = stmt(`
-        SELECT id, title, project_id, directory, agent, model, cost,
-               time_created, time_updated, time_archived, parent_id
-          FROM session WHERE id = ?`).get(sid);
-      if (fresh)
-        writeMeta(fresh, dir);
-      if (fresh)
-        writeSessionSummaryChannel(fresh, root);
-    }
-  }
-  if (progress.last_cursor)
-    setLastSync(progress.last_cursor, root);
-  progress.updates = updates;
-  progress.inserts = inserts;
-  return progress;
+    const dir = join5(root, "by-session", sid);
+    const fresh = stmt(`
+      SELECT id, title, project_id, directory, agent, model, cost,
+             time_created, time_updated, time_archived, parent_id
+        FROM session WHERE id = ?`).get(sid);
+    if (fresh) {
+      writeMeta(fresh, dir);
+      writeSessionSummaryChannel(fresh, root);
+    }
+  }
+}
+function applyTombstoneProgress(progress, tombstones) {
+  progress.tombstones_removed_parts = tombstones.removed_parts;
+  progress.tombstones_removed_sessions = tombstones.removed_sessions;
+}
+function loadPartById(partId) {
+  return stmt(partSelectSql("WHERE p.id = ?")).get(partId);
+}
+function loadPartRowsAfterId(afterId, limit) {
+  if (!afterId)
+    return stmt(`${partSelectSql("")} ORDER BY p.id ASC LIMIT ?`).all(limit);
+  return stmt(`${partSelectSql("WHERE p.id > ?")} ORDER BY p.id ASC LIMIT ?`).all(afterId, limit);
+}
+function loadSessionPartRows(sessionId, afterId, limit) {
+  if (!afterId) {
+    return stmt(`${partSelectSql("WHERE p.session_id = ?")} ORDER BY p.id ASC LIMIT ?`).all(sessionId, limit);
+  }
+  return stmt(`${partSelectSql("WHERE p.session_id = ? AND p.id > ?")} ORDER BY p.id ASC LIMIT ?`).all(sessionId, afterId, limit);
+}
+function loadDirtySessionsAfter(cursor, limit) {
+  if (!cursor) {
+    return stmt(`SELECT id, time_updated FROM session ORDER BY time_updated ASC, id ASC LIMIT ?`).all(limit);
+  }
+  return stmt(`
+    SELECT id, time_updated
+      FROM session
+     WHERE (time_updated > ? OR (time_updated = ? AND id > ?))
+  ORDER BY time_updated ASC, id ASC
+     LIMIT ?`).all(cursor.ts, cursor.ts, cursor.id, limit);
+}
+function partSelectSql(where) {
+  return `
+    SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated,
+           p.data, LENGTH(p.data) AS data_bytes,
+           json_extract(m.data,'$.role') AS role
+      FROM part p
+      LEFT JOIN message m ON m.id = p.message_id
+      ${where}`;
+}
+function timeExceeded(start, budgetMs) {
+  return budgetMs !== undefined && Date.now() - start > budgetMs;
+}
+function reportProgress(progress, onProgress, heartbeat) {
+  heartbeat();
+  if (!onProgress)
+    return;
+  const processed = progress.exported + progress.skipped_nontext + progress.skipped_oversize + progress.failed;
+  if (processed > 0 && processed % 5000 === 0)
+    onProgress(progress);
+}
+function errorMessage(error45) {
+  return error45 instanceof Error ? error45.message : String(error45);
 }
 
 // src/tools/current-session.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { dirname, join as join6 } from "path";
 var currentSession = tool({
   description: "opencode-sessions-explorer: identify the CURRENT OpenCode session you (the assistant) are running in \u2014 return this session's id, message id, agent, model, directory, parent_id, cost-so-far, message/part/tool-call counters, immediate child sessions, and useful filesystem paths (opencode.db, the opencode-sessions-explorer tree, this session's export subdirectory and meta.json). " + `Answers: "what session am I in", "what's my current session id", "tell me about this session", "who am I (which agent/model)", "where am I (directory/worktree)", "my session context", "this session's metadata", "first-call orientation", "self-introspection", "what's the OpenCode db path", "where is the export tree", "what's my session id so I can pass it to other opencode-sessions-explorer-* tools". ` + "Useful as the FIRST opencode-sessions-explorer-* call when you need to know your own context \u2014 e.g. to then feed your own session_id into session-timeline, session-genealogy, grep-session, or to compare against siblings via list-sessions / search-sessions-meta. " + "Default detail is compact to avoid noise. Pass detail:'full' for counters, child sessions, paths, and suggestions. " + "Takes no args. Cap 8 KB.",
   args: {
@@ -13520,8 +14188,8 @@ var currentSession = tool({
       const directory = ctx?.directory ?? "";
       const worktree = ctx?.worktree ?? "";
       const root = exportRoot();
-      const sessionDir = sessionId ? join3(root, "by-session", sessionId) : null;
-      const sessionMeta = sessionDir ? join3(sessionDir, "meta.json") : null;
+      const sessionDir = sessionId ? join6(root, "by-session", sessionId) : null;
+      const sessionMeta = sessionDir ? join6(sessionDir, "meta.json") : null;
       const dbPath = safe(() => locateDb());
       let sessionRow = null;
       if (sessionId) {
@@ -13613,10 +14281,10 @@ var currentSession = tool({
           db: dbPath ?? null,
           export_root: root,
           this_session_export_dir: sessionDir,
-          this_session_export_dir_exists: sessionDir ? existsSync3(sessionDir) : false,
+          this_session_export_dir_exists: sessionDir ? existsSync6(sessionDir) : false,
           this_session_meta_json: sessionMeta,
-          this_session_meta_json_exists: sessionMeta ? existsSync3(sessionMeta) : false,
-          tool_output_dir: dbPath ? join3(dirname2(dbPath), "tool-output") : null
+          this_session_meta_json_exists: sessionMeta ? existsSync6(sessionMeta) : false,
+          tool_output_dir: dbPath ? join6(dirname(dbPath), "tool-output") : null
         },
         suggestions
       };
@@ -13859,7 +14527,7 @@ import { resolve as resolve2 } from "path";
 
 // src/lib/path-guard.ts
 import { homedir as homedir3, platform as platform2 } from "os";
-import { resolve, join as join4 } from "path";
+import { resolve, join as join7 } from "path";
 import { realpathSync } from "fs";
 function defaultToolOutputDir() {
   if (process.env.OPENCODE_SESSIONS_EXPLORER_TOOL_OUTPUT_DIR) {
@@ -13868,13 +14536,13 @@ function defaultToolOutputDir() {
   const home = homedir3();
   switch (platform2()) {
     case "win32": {
-      const local = process.env.LOCALAPPDATA ?? join4(home, "AppData", "Local");
+      const local = process.env.LOCALAPPDATA ?? join7(home, "AppData", "Local");
       return resolve(local, "opencode", "tool-output");
     }
     case "darwin":
     case "linux":
     default: {
-      const dataHome = process.env.XDG_DATA_HOME ?? join4(home, ".local", "share");
+      const dataHome = process.env.XDG_DATA_HOME ?? join7(home, ".local", "share");
       return resolve(dataHome, "opencode", "tool-output");
     }
   }
@@ -14084,11 +14752,10 @@ var getSession2 = tool({
 
 // src/lib/ck.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
 function defaultCkCandidates() {
   const home = process.env.HOME ?? "";
   const candidates = [
-    process.env.OPENCODE_SESSIONS_EXPLORER_CK_BIN,
     home ? `${home}/.cargo/bin/ck` : null,
     "/usr/local/bin/ck",
     "/opt/homebrew/bin/ck",
@@ -14097,8 +14764,10 @@ function defaultCkCandidates() {
   return candidates;
 }
 function locateCk() {
+  if (process.env.OPENCODE_SESSIONS_EXPLORER_CK_BIN)
+    return process.env.OPENCODE_SESSIONS_EXPLORER_CK_BIN;
   for (const c of defaultCkCandidates()) {
-    if (c.startsWith("/") && existsSync4(c))
+    if (c.startsWith("/") && existsSync7(c))
       return c;
   }
   return "ck";
@@ -14160,6 +14829,7 @@ async function runCk(opts) {
   let timedOut = false;
   proc.stdout.setEncoding("utf8");
   proc.stderr.setEncoding("utf8");
+  let procError = null;
   proc.stdout.on("data", (chunk) => {
     buf += chunk;
     let idx;
@@ -14181,7 +14851,8 @@ async function runCk(opts) {
   });
   const rc = await new Promise((resolve3) => {
     proc.on("error", (e) => {
-      if (e?.name === "AbortError" || ctl.signal.aborted) {
+      procError = e;
+      if (e.name === "AbortError" || ctl.signal.aborted) {
         timedOut = true;
         resolve3(124);
       } else
@@ -14191,6 +14862,12 @@ async function runCk(opts) {
   });
   if (timer)
     clearTimeout(timer);
+  const childError = procError;
+  if (childError && !timedOut) {
+    if (childError.code === "ENOENT")
+      throw new SessionsError("CK_NOT_FOUND", `ck CLI not found at '${locateCk()}'; install via 'cargo install ck-search'`);
+    throw new SessionsError("CK_FAILED", `ck process failed: ${childError.message}`);
+  }
   if (buf.trim()) {
     try {
       const obj = JSON.parse(buf.trim());
@@ -14198,7 +14875,22 @@ async function runCk(opts) {
         hits.push(obj);
     } catch {}
   }
-  return { hits, rc, stderr, durationMs: Date.now() - start, timedOut };
+  const totalScopes = opts.scopes.length === 0 ? 1 : opts.scopes.length;
+  return {
+    hits,
+    rc,
+    stderr,
+    durationMs: Date.now() - start,
+    timedOut,
+    scopeCoverage: {
+      strategy: "single",
+      searched_scopes: totalScopes,
+      total_scopes: totalScopes,
+      omitted_scopes: 0,
+      truncated: false,
+      timed_out: timedOut
+    }
+  };
 }
 async function runCkMultiScope(opts) {
   const start = Date.now();
@@ -14206,6 +14898,7 @@ async function runCkMultiScope(opts) {
   let stderr = "";
   let rc = 1;
   let timedOut = false;
+  let searchedScopes = 0;
   const topk = opts.topk ?? 50;
   const perScopeTopk = Math.max(5, Math.ceil(topk / Math.max(1, opts.scopes.length)));
   for (const scope of opts.scopes) {
@@ -14216,6 +14909,7 @@ async function runCkMultiScope(opts) {
       break;
     }
     const res = await runCk({ ...opts, scopes: [scope], timeoutMs: remaining, topk: perScopeTopk });
+    searchedScopes++;
     hits.push(...res.hits);
     if (res.stderr)
       stderr += (stderr && !stderr.endsWith(`
@@ -14227,30 +14921,211 @@ async function runCkMultiScope(opts) {
       rc = 0;
     else if (rc !== 0 && res.rc !== 1)
       rc = res.rc;
+    if (timedOut && opts.timeoutMs != null && Date.now() - start >= opts.timeoutMs)
+      break;
   }
+  const truncated = searchedScopes < opts.scopes.length;
+  if (truncated && timedOut && rc === 1)
+    rc = 124;
   return {
     hits: hits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, topk),
     rc,
     stderr,
     durationMs: Date.now() - start,
-    timedOut
+    timedOut,
+    scopeCoverage: {
+      strategy: "fanout",
+      searched_scopes: searchedScopes,
+      total_scopes: opts.scopes.length,
+      omitted_scopes: Math.max(0, opts.scopes.length - searchedScopes),
+      truncated,
+      timed_out: timedOut
+    }
   };
 }
-function ckIndexPresent(root = exportRoot()) {
+async function ckIndexFreshness(root = exportRoot(), timeoutMs = 1500) {
   const manifestPath = `${root}/.ck/manifest.json`;
-  if (!existsSync4(manifestPath))
-    return { present: false, embedded_chunks: null };
+  const markerMs = exportMarkerMtime(root);
+  const manifest = readManifestProbe(manifestPath);
+  if (!manifest.present) {
+    return {
+      status: "missing",
+      present: false,
+      embedded_chunks: null,
+      index_updated_ms: null,
+      export_marker_ms: markerMs,
+      status_json_available: false,
+      source: "missing",
+      warning: ckIndexWarning("missing", root)
+    };
+  }
+  const statusJson = await readStatusJson(root, timeoutMs);
+  const statusProbe = statusJson.ok ? probeFromUnknown(statusJson.value) : null;
+  const embedded = statusProbe?.embedded_chunks ?? manifest.embedded_chunks;
+  const indexUpdated = statusProbe?.index_updated_ms ?? manifest.index_updated_ms;
+  let status = statusFromProbe(statusProbe?.status, embedded, indexUpdated, markerMs);
+  const source = statusProbe ? "status-json" : "manifest";
+  if (!statusJson.ok && status === "fresh")
+    status = "partial";
+  const warning = status === "fresh" ? null : ckIndexWarning(status, root, statusJson.ok ? null : statusJson.reason);
+  return {
+    status,
+    present: true,
+    embedded_chunks: embedded,
+    index_updated_ms: indexUpdated,
+    export_marker_ms: markerMs,
+    status_json_available: statusJson.ok,
+    source,
+    warning
+  };
+}
+function statusFromProbe(explicit, embeddedChunks, indexUpdatedMs, exportMarkerMs) {
+  if (explicit === "missing" || explicit === "stale" || explicit === "partial")
+    return explicit;
+  if (embeddedChunks != null && embeddedChunks <= 0)
+    return "partial";
+  if (indexUpdatedMs == null)
+    return "partial";
+  if (exportMarkerMs != null && indexUpdatedMs + 1000 < exportMarkerMs)
+    return "stale";
+  return "fresh";
+}
+function ckIndexWarning(status, root, probeFailure) {
+  const prewarm = `opencode-sessions-explorer will not call ck --index or ck --reindex inline; run 'cd "${root}" && ck --index .' or 'ck --reindex .' only to prewarm or troubleshoot.`;
+  if (status === "missing")
+    return `ck semantic index is missing at ${root}/.ck. ck will lazily create or update the index during sem/hybrid search; the first run may be slow. ${prewarm}`;
+  if (status === "stale")
+    return `ck semantic index appears stale relative to the export tree; ck will attempt a lazy refresh during sem/hybrid search. Results may be partial if refresh fails or times out. ${prewarm}`;
+  const reason = probeFailure ? ` (${probeFailure})` : "";
+  return `ck semantic index freshness is partial/unverified${reason}; ck will attempt lazy index refresh during sem/hybrid search. Results may cover only indexed files if refresh fails or times out. ${prewarm}`;
+}
+function exportMarkerMtime(root) {
+  const markers = [".last_sync", ".channels_v1_complete"];
+  let newest = null;
+  for (const marker of markers) {
+    const path = `${root}/${marker}`;
+    if (!existsSync7(path))
+      continue;
+    try {
+      const mtime = statSync3(path).mtimeMs;
+      newest = newest == null ? mtime : Math.max(newest, mtime);
+    } catch {}
+  }
+  return newest;
+}
+function readManifestProbe(manifestPath) {
+  if (!existsSync7(manifestPath))
+    return { present: false, embedded_chunks: null, index_updated_ms: null };
   try {
-    const m = JSON.parse(readFileSync2(manifestPath, "utf8"));
-    return { present: true, embedded_chunks: m?.totals?.embedded_chunks ?? null };
+    return { present: true, ...probeFromUnknown(JSON.parse(readFileSync3(manifestPath, "utf8"))) };
   } catch {
-    return { present: true, embedded_chunks: null };
+    return { present: true, embedded_chunks: null, index_updated_ms: null, status: "partial" };
+  }
+}
+function probeFromUnknown(value) {
+  return {
+    embedded_chunks: firstNumber(value, [["totals", "embedded_chunks"], ["embedded_chunks"], ["index", "embedded_chunks"]]),
+    index_updated_ms: firstTimeMs(value, [["index_updated"], ["index_updated_ms"], ["indexed_at"], ["updated_at"], ["last_indexed"], ["manifest", "index_updated"]]),
+    status: firstStatus(value)
+  };
+}
+function firstStatus(value) {
+  const raw = firstString(value, [["status"], ["index_status"], ["semantic_status"], ["index", "status"]])?.toLowerCase();
+  if (raw === "fresh" || raw === "stale" || raw === "missing" || raw === "partial")
+    return raw;
+  return null;
+}
+function firstNumber(value, paths) {
+  for (const path of paths) {
+    const n = numberFromUnknown(valueAtPath(value, path));
+    if (n != null)
+      return n;
+  }
+  return null;
+}
+function firstTimeMs(value, paths) {
+  for (const path of paths) {
+    const ms = timeMsFromUnknown(valueAtPath(value, path));
+    if (ms != null)
+      return ms;
+  }
+  return null;
+}
+function firstString(value, paths) {
+  for (const path of paths) {
+    const v = valueAtPath(value, path);
+    if (typeof v === "string" && v.trim())
+      return v.trim();
+  }
+  return null;
+}
+function valueAtPath(value, path) {
+  let cur = value;
+  for (const key of path) {
+    if (!cur || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+function numberFromUnknown(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const n = Number(value);
+    if (Number.isFinite(n))
+      return n;
+  }
+  return null;
+}
+function timeMsFromUnknown(value) {
+  const numeric = numberFromUnknown(value);
+  if (numeric != null)
+    return numeric < 10000000000 ? numeric * 1000 : numeric;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return null;
+}
+async function readStatusJson(root, timeoutMs) {
+  const ctl = new AbortController;
+  const timer = setTimeout(() => ctl.abort(), timeoutMs);
+  let proc;
+  try {
+    proc = spawn(locateCk(), ["--status-json"], { cwd: root, signal: ctl.signal });
+  } catch (e) {
+    clearTimeout(timer);
+    return { ok: false, reason: `ck --status-json spawn failed: ${e.message}` };
+  }
+  let stdout = "";
+  let stderr = "";
+  proc.stdout.setEncoding("utf8");
+  proc.stderr.setEncoding("utf8");
+  proc.stdout.on("data", (chunk) => {
+    stdout += chunk;
+  });
+  proc.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  const rc = await new Promise((resolve3) => {
+    proc.on("error", (e) => resolve3(e.name === "AbortError" || ctl.signal.aborted ? 124 : 2));
+    proc.on("close", (code) => resolve3(code ?? 0));
+  });
+  clearTimeout(timer);
+  if (rc !== 0)
+    return { ok: false, reason: `ck --status-json unavailable (rc=${rc}${stderr ? `: ${stderr.trim().slice(0, 120)}` : ""})` };
+  try {
+    return { ok: true, value: JSON.parse(stdout.trim()) };
+  } catch {
+    return { ok: false, reason: "ck --status-json returned non-JSON output" };
   }
 }
 
 // src/tools/grep-session.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
 var grepSession = tool({
   description: "opencode-sessions-explorer: grep/regex search inside ONE specific OpenCode session's body content (when you already have the session id). " + 'Answers: "inside session ses_X, grep for Y", "search session ses_Z for pattern P", "find references to X within session ses_Y", "regex search in a single session", "look up keyword W inside session ses_V". ' + "Operates only on the filesystem export of one session's parts (~50-500 files) so it's fast (<200ms typical). Auto delta-syncs any new parts since the last call. " + "Default surface is `recall`, searching curated conversation/session-summary channels when available. Use `surface:'forensics'` or channels:['raw'] to search raw exported bodies including tool output and reasoning. " + "Modes: 'regex' (default \u2014 like grep) or 'lex' (BM25 phrase). Supports fixed_string (literal match, no regex special chars), case_sensitive, whole_word, context_lines (lines before/after match). " + "For CROSS-SESSION content search (across ALL your OpenCode sessions) use search-text instead \u2014 that one supports group_by_session, role filter, and semantic modes.",
   args: {
@@ -14273,7 +15148,12 @@ var grepSession = tool({
         fail("NOT_FOUND", `session not found: ${args.session_id}`);
       try {
         const syncRes = await runExport({ budgetMs: 3000 });
-        ctx.indexStatus = syncRes.exported > 0 ? "fresh" : "fresh";
+        if (syncRes.lock_skipped) {
+          ctx.warnings.push("delta sync skipped: export lock is held by another process; results may use stale/partial export data.");
+          ctx.indexStatus = "stale";
+        } else {
+          ctx.indexStatus = "fresh";
+        }
       } catch (e) {
         ctx.warnings.push(`delta sync skipped: ${e.message}`);
         ctx.indexStatus = "stale";
@@ -14296,6 +15176,7 @@ var grepSession = tool({
       });
       if (ck.timedOut)
         ctx.warnings.push("ck timed out at 10 s");
+      warnOnPartialScopeCoverage(ctx, ck.scopeCoverage);
       if (ck.rc !== 0 && ck.rc !== 1)
         ctx.warnings.push(`ck rc=${ck.rc} stderr=${truncateString(ck.stderr, 256).value}`);
       const matches = ck.hits.slice(0, args.limit).map((h) => enrichHit(h, args.redact));
@@ -14309,11 +15190,17 @@ var grepSession = tool({
         mode: args.mode,
         scanned_files: matches.length,
         matches: table(matches, { dict: ["channel"] }),
-        ck_duration_ms: ck.durationMs
+        ck_duration_ms: ck.durationMs,
+        ck_scope_coverage: ck.scopeCoverage
       };
     });
   }
 });
+function warnOnPartialScopeCoverage(ctx, coverage) {
+  if (!coverage.truncated)
+    return;
+  ctx.warnings.push(`ck searched ${coverage.searched_scopes}/${coverage.total_scopes} scopes before stopping; results are partial and ${coverage.omitted_scopes} scopes were not searched. ` + "Narrow channels/surface or retry with a smaller session export.");
+}
 function enrichHit(h, redact) {
   const parsed = parseHitPath(h.path);
   let snippet2 = h.snippet ?? "";
@@ -14339,20 +15226,20 @@ function parseHitPath(p) {
   return { partId: m?.[1] ?? null, channel: "raw" };
 }
 function resolveSessionScopes(root, sessionId, channels, ctx) {
-  const rawDir = join5(root, "by-session", sessionId);
+  const rawDir = join8(root, "by-session", sessionId);
   if (channels.includes("raw"))
-    return existsSync5(rawDir) ? [rawDir] : [];
+    return existsSync8(rawDir) ? [rawDir] : [];
   if (!channelExportComplete(root)) {
-    if (existsSync5(rawDir)) {
+    if (existsSync8(rawDir)) {
       ctx.warnings.push("curated channel export is partial \u2014 using raw session export to avoid false negatives. Run opencode-sessions-explorer-bulk-export --reset to enable curated channels by default.");
       return [rawDir];
     }
     return [];
   }
-  const channelDirs = channels.map((ch) => join5(root, "by-channel", ch, "by-session", sessionId)).filter((p) => existsSync5(p));
+  const channelDirs = channels.map((ch) => join8(root, "by-channel", ch, "by-session", sessionId)).filter((p) => existsSync8(p));
   if (channelDirs.length > 0)
     return channelDirs;
-  if (existsSync5(rawDir)) {
+  if (existsSync8(rawDir)) {
     ctx.warnings.push("curated channel export missing for this session \u2014 falling back to raw session export.");
     return [rawDir];
   }
@@ -14771,10 +15658,10 @@ var searchSessionsMeta = tool({
 });
 
 // src/tools/search-text.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
 var searchText = tool({
-  description: "opencode-sessions-explorer: full-text search across the BODIES of all your prior OpenCode sessions (the actual conversation content \u2014 user prompts, assistant responses, tool inputs/outputs, reasoning, file references, patches, subtask prompts). " + 'Answers any of: "where in my OpenCode history did I mention X", "find sessions about Y", "have I ever discussed Z", "look up earlier conversations about W", "all references to V across my OpenCode sessions", "did this topic come up before", "when did I last talk about Q", "find the session where I worked on R", "search my prior chat content for S", "grep across all OpenCode sessions for T", "have I asked about this before". ' + "Default surface is `recall`: session-first, channel-aware, and evidence-limited. It searches high-signal conversation/session-summary views first and returns ranked sessions with raw part refs. " + "Use `surface:'forensics'` (or explicit channels including `raw`) for exhaustive raw replay over tool output, reasoning, patches, and all exported bodies. " + "ARG `group_by_session`: when true, rolls hits up to one row per session with hit_count, first/last seen timestamps, evidence snippets, and channel counts. If omitted, unscoped recall defaults to true; scoped one-session searches default to flat hits. " + `CRITICAL ARG \`role\` (default 'any'): which message roles to search inside. **Default to 'any'** for natural-language questions like "where did I mention X", "find sessions about Y", "did I discuss Z" \u2014 these are asking about appearances ANYWHERE in your conversations (user prompts AND assistant text AND tool I/O AND reasoning). ` + `Only set role='user' when the user EXPLICITLY narrows to authored messages: "what prompts have I typed containing X", "my user-authored messages mentioning Y", "questions I sent OpenCode with Z". Phrases like "did I mention" / "in my history" / "have I discussed" do NOT imply role='user' \u2014 those are asking about the corpus as a whole. ` + `Only set role='assistant' for questions explicitly about what the AI said ("what has the assistant said about X"). ` + "Modes: 'regex' (default \u2014 drop-in grep, no index needed), 'lex' (BM25 phrase search, auto-builds Tantivy index), 'sem' (semantic embeddings, requires `ck --index .` to be run once outside this tool), 'hybrid' (regex + sem). " + "Pre-filter cross-session searches via session_ids[], project_id, agent, since_ms/until_ms \u2014 unscoped full-corpus search can take 10-30 seconds. Scoped searches return in <1s. " + "For grep INSIDE a single known session use grep-session instead (faster, narrower).",
+  description: "opencode-sessions-explorer: full-text search across the BODIES of all your prior OpenCode sessions (the actual conversation content \u2014 user prompts, assistant responses, tool inputs/outputs, reasoning, file references, patches, subtask prompts). " + 'Answers any of: "where in my OpenCode history did I mention X", "find sessions about Y", "have I ever discussed Z", "look up earlier conversations about W", "all references to V across my OpenCode sessions", "did this topic come up before", "when did I last talk about Q", "find the session where I worked on R", "search my prior chat content for S", "grep across all OpenCode sessions for T", "have I asked about this before". ' + "Default surface is `recall`: session-first, channel-aware, and evidence-limited. It searches high-signal conversation/session-summary views first and returns ranked sessions with raw part refs. " + "Use `surface:'forensics'` (or explicit channels including `raw`) for exhaustive raw replay over tool output, reasoning, patches, and all exported bodies. " + "ARG `group_by_session`: when true, rolls hits up to one row per session with hit_count, first/last seen timestamps, evidence snippets, and channel counts. If omitted, unscoped recall defaults to true; scoped one-session searches default to flat hits. " + `CRITICAL ARG \`role\` (default 'any'): which message roles to search inside. **Default to 'any'** for natural-language questions like "where did I mention X", "find sessions about Y", "did I discuss Z" \u2014 these are asking about appearances ANYWHERE in your conversations (user prompts AND assistant text AND tool I/O AND reasoning). ` + `Only set role='user' when the user EXPLICITLY narrows to authored messages: "what prompts have I typed containing X", "my user-authored messages mentioning Y", "questions I sent OpenCode with Z". Phrases like "did I mention" / "in my history" / "have I discussed" do NOT imply role='user' \u2014 those are asking about the corpus as a whole. ` + `Only set role='assistant' for questions explicitly about what the AI said ("what has the assistant said about X"). ` + "Modes: 'regex' (default \u2014 drop-in grep, no index needed), 'lex' (BM25 phrase search, lets ck auto-build/update its Tantivy index), 'sem' (semantic embeddings, lets ck lazily build/refresh its index), 'hybrid' (regex + sem). " + "Pre-filter cross-session searches via session_ids[], project_id, agent, since_ms/until_ms \u2014 unscoped full-corpus search can take 10-30 seconds. Scoped searches return in <1s. " + "For grep INSIDE a single known session use grep-session instead (faster, narrower).",
   args: {
     q: tool.schema.string().describe("Search query (regex pattern, BM25 phrase, or natural-language depending on mode)"),
     mode: tool.schema.enum(["regex", "lex", "sem", "hybrid"]).default("regex"),
@@ -14802,36 +15689,38 @@ var searchText = tool({
       const groupBySession = args.group_by_session ?? (surface !== "forensics" && !args.session_ids?.length);
       const scopeIds = resolveScope(args);
       const root = exportRoot();
-      let scopes = resolveCkScopes(root, scopeIds, channels, ctx);
-      if (scopeIds !== "all") {
-        if (scopes.length === 0) {
-          return groupBySession ? { sessions: table([]), hits_total: 0, mode: args.mode, surface, channels, scope_session_count: 0, ck_duration_ms: 0, suppressed: emptySuppressed(channels) } : { hits: table([]), mode: args.mode, scope_session_count: 0, ck_duration_ms: 0 };
-        }
-      } else if (surface === "forensics" || channels.includes("raw")) {
+      if (scopeIds !== "all" && scopeIds.length === 0) {
+        return groupBySession ? { sessions: table([]), hits_total: 0, mode: args.mode, surface, channels, scope_session_count: 0, ck_duration_ms: 0, suppressed: emptySuppressed(channels) } : { hits: table([]), mode: args.mode, scope_session_count: 0, ck_duration_ms: 0 };
+      }
+      if (scopeIds === "all" && (surface === "forensics" || channels.includes("raw"))) {
         ctx.warnings.push("raw unscoped forensic search can take 10-30s. Add session_ids/project_id/agent/since_ms to narrow.");
       }
+      let exportStatus = "fresh";
       try {
-        await runExport({ budgetMs: 4000 });
-        ctx.indexStatus = "fresh";
+        exportStatus = applyExportProgress(ctx, await runExport({ budgetMs: 4000 }));
       } catch (e) {
         ctx.warnings.push(`delta sync skipped: ${e.message}`);
         ctx.indexStatus = "stale";
+        exportStatus = "stale";
+      }
+      const scopes = resolveCkScopes(root, scopeIds, channels, ctx);
+      if (scopeIds !== "all" && scopes.length === 0) {
+        ctx.warnings.push(`export scope missing after delta sync for ${scopeIds.length} DB session(s); returning empty results from stale/partial export data.`);
+        return groupBySession ? { sessions: table([]), hits_total: 0, mode: args.mode, surface, channels, scope_session_count: scopeIds.length, ck_duration_ms: 0, suppressed: emptySuppressed(channels) } : { hits: table([]), mode: args.mode, scope_session_count: scopeIds.length, ck_duration_ms: 0 };
       }
       let effectiveMode = args.mode;
+      let preSearchFreshness = null;
       if (args.mode === "sem" || args.mode === "hybrid") {
-        const ck = ckIndexPresent(root);
-        if (!ck.present) {
-          ctx.warnings.push(`ck semantic index not present at ${root}/.ck \u2014 falling back to regex. Run 'ck --index .' inside the export root to enable semantic search.`);
-          effectiveMode = "regex";
-          ctx.mode = "fallback-regex";
-        } else if (ck.embedded_chunks != null) {
-          ctx.warnings.push(`ck index present (${ck.embedded_chunks} embedded chunks). Semantic results limited to indexed files only.`);
-        }
+        preSearchFreshness = await ckIndexFreshness(root);
+        ctx.indexStatus = combineExportAndCkStatus(exportStatus, preSearchFreshness.status);
       }
       if (!ctx.mode)
         ctx.mode = effectiveMode;
       const ckTopk = groupBySession ? Math.min(Math.max(args.limit * 20, 100), 500) : Math.min(args.limit * (effectiveMode === "regex" ? 2 : 3), 150);
-      return await runWithCk(args, scopes, effectiveMode, ctx, scopeIds === "all" ? null : scopeIds.length, ckTopk, channels, surface, groupBySession);
+      const result = await runWithCk(args, scopes, effectiveMode, ctx, scopeIds === "all" ? null : scopeIds.length, ckTopk, channels, surface, groupBySession);
+      if (preSearchFreshness)
+        await refreshCkStatusAfterSearch(ctx, root, exportStatus, preSearchFreshness);
+      return result;
     });
   }
 });
@@ -14871,33 +15760,42 @@ function resolveScope(args) {
 function normalizeChannels(channels) {
   return Array.from(new Set(channels.length ? channels : ["conversation", "session-summary"]));
 }
+function applyExportProgress(ctx, progress) {
+  if (progress.lock_skipped) {
+    ctx.warnings.push("delta sync skipped: export lock is held by another process; results may use stale/partial export data.");
+    ctx.indexStatus = "stale";
+    return "stale";
+  }
+  ctx.indexStatus = "fresh";
+  return "fresh";
+}
 function resolveCkScopes(root, scopeIds, channels, ctx) {
   const rawOnly = channels.includes("raw");
-  const rawRoot = join6(root, "by-session");
+  const rawRoot = join9(root, "by-session");
   if (rawOnly) {
     if (scopeIds === "all")
-      return existsSync6(rawRoot) ? [rawRoot] : [root];
-    return scopeIds.map((id) => join6(rawRoot, id)).filter((p) => existsSync6(p));
+      return existsSync9(rawRoot) ? [rawRoot] : [root];
+    return scopeIds.map((id) => join9(rawRoot, id)).filter((p) => existsSync9(p));
   }
   if (!channelExportComplete(root)) {
     ctx.warnings.push("curated channel export is partial \u2014 using raw by-session export to avoid false negatives. Run opencode-sessions-explorer-bulk-export --reset to enable curated channels by default.");
     if (scopeIds === "all")
-      return existsSync6(rawRoot) ? [rawRoot] : [root];
-    return scopeIds.map((id) => join6(rawRoot, id)).filter((p) => existsSync6(p));
+      return existsSync9(rawRoot) ? [rawRoot] : [root];
+    return scopeIds.map((id) => join9(rawRoot, id)).filter((p) => existsSync9(p));
   }
-  const channelRoots = channels.map((ch) => join6(root, "by-channel", ch, "by-session"));
+  const channelRoots = channels.map((ch) => join9(root, "by-channel", ch, "by-session"));
   if (scopeIds === "all") {
-    const existing = channelRoots.filter((p) => existsSync6(p));
+    const existing = channelRoots.filter((p) => existsSync9(p));
     if (existing.length > 0)
       return existing;
     ctx.warnings.push("curated channel export is not backfilled yet \u2014 falling back to raw by-session export. Run opencode-sessions-explorer-bulk-export to build channels.");
-    return existsSync6(rawRoot) ? [rawRoot] : [root];
+    return existsSync9(rawRoot) ? [rawRoot] : [root];
   }
-  const scoped = channelRoots.flatMap((base) => scopeIds.map((id) => join6(base, id))).filter((p) => existsSync6(p));
+  const scoped = channelRoots.flatMap((base) => scopeIds.map((id) => join9(base, id))).filter((p) => existsSync9(p));
   if (scoped.length > 0)
     return scoped;
   ctx.warnings.push("curated channel export missing for scoped sessions \u2014 falling back to raw session export.");
-  return scopeIds.map((id) => join6(rawRoot, id)).filter((p) => existsSync6(p));
+  return scopeIds.map((id) => join9(rawRoot, id)).filter((p) => existsSync9(p));
 }
 function emptySuppressed(channels) {
   return { duplicate_hits: 0, omitted_channels: CHANNELS.filter((c) => !channels.includes(c) && c !== "raw") };
@@ -14915,6 +15813,7 @@ async function runWithCk(args, scopes, mode, ctx, sessionCount, topk, channels,
   });
   if (ck.timedOut)
     ctx.warnings.push(`ck timed out at ${args.timeout_ms}ms`);
+  warnOnPartialScopeCoverage2(ctx, ck.scopeCoverage, args.timeout_ms);
   if (ck.rc !== 0 && ck.rc !== 1)
     ctx.warnings.push(`ck rc=${ck.rc} stderr=${truncateString(ck.stderr, 256).value}`);
   const parsed = ck.hits.map((h) => ({ ...parsePath(h.path), ck: h }));
@@ -15042,6 +15941,7 @@ async function runWithCk(args, scopes, mode, ctx, sessionCount, topk, channels,
       scope_session_count: sessionCount,
       ck_duration_ms: ck.durationMs,
       ck_timed_out: ck.timedOut,
+      ck_scope_coverage: ck.scopeCoverage,
       role_filter: args.role,
       suppressed: { ...emptySuppressed(channels), duplicate_hits: duplicateCount }
     };
@@ -15064,10 +15964,35 @@ async function runWithCk(args, scopes, mode, ctx, sessionCount, topk, channels,
     scope_session_count: sessionCount,
     ck_duration_ms: ck.durationMs,
     ck_timed_out: ck.timedOut,
+    ck_scope_coverage: ck.scopeCoverage,
     role_filter: args.role,
     suppressed: { ...emptySuppressed(channels), duplicate_hits: duplicateCount }
   };
 }
+function combineExportAndCkStatus(exportStatus, ckStatus) {
+  if (ckStatus === "missing" || ckStatus === "partial")
+    return ckStatus;
+  if (exportStatus === "stale")
+    return "stale";
+  return ckStatus;
+}
+async function refreshCkStatusAfterSearch(ctx, root, exportStatus, preSearchFreshness) {
+  try {
+    const postSearchFreshness = await ckIndexFreshness(root);
+    ctx.indexStatus = combineExportAndCkStatus(exportStatus, postSearchFreshness.status);
+    if (postSearchFreshness.status !== "fresh") {
+      ctx.warnings.push(postSearchFreshness.warning ?? preSearchFreshness.warning ?? "ck semantic index freshness is not verified after search; results may be partial.");
+    }
+  } catch (e) {
+    ctx.indexStatus = combineExportAndCkStatus(exportStatus, preSearchFreshness.status);
+    ctx.warnings.push(preSearchFreshness.warning ?? `ck semantic index freshness recheck failed after search: ${e.message}`);
+  }
+}
+function warnOnPartialScopeCoverage2(ctx, coverage, timeoutMs) {
+  if (!coverage.truncated)
+    return;
+  ctx.warnings.push(`ck searched ${coverage.searched_scopes}/${coverage.total_scopes} scopes before stopping; results are partial and ${coverage.omitted_scopes} scopes were not searched. ` + `Narrow session_ids/project_id/since_ms or raise timeout_ms (current ${timeoutMs}ms).`);
+}
 function parsePath(p) {
   const ch = /\/by-channel\/([^/]+)\/by-session\/(ses_[A-Za-z0-9_-]+)\/(?:summary\.txt|(?:\d{5}-)?(prt_[A-Za-z0-9_-]+)\.txt)$/.exec(p);
   if (ch)