chat-recall 0.7.0 → 0.7.2

package/dist/watch.js

@@ -6585,7 +6585,7 @@ var init_raw = __esm({
 // ../engine/dist/transcript/shadow.js
 import { gzipSync as gzipSync2, gunzipSync as gunzipSync2 } from "zlib";
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync as renameSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync as renameSync2, statSync as statSync4, openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
 import { dirname as dirname7, join as join8 } from "path";
 function shadowRoot() {
   return join8(getDataDir(), "shadow");
@@ -6809,6 +6809,29 @@ function seedShadow(sessionId, container) {
   }
   return fullest;
 }
+function shadowUncompressedBytes(tool, rawId) {
+  const path = shadowFileFor(tool, rawId);
+  let fd = null;
+  try {
+    const size = statSync4(path).size;
+    if (size < 18)
+      return 0;
+    fd = openSync2(path, "r");
+    const tail = Buffer.alloc(4);
+    if (readSync2(fd, tail, 0, 4, size - 4) !== 4)
+      return 0;
+    return tail.readUInt32LE(0);
+  } catch {
+    return 0;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+    }
+  }
+}
 function shadowSizeOnDisk(tool, rawId) {
   try {
     return statSync4(shadowFileFor(tool, rawId)).size;
@@ -6829,7 +6852,7 @@ var init_shadow = __esm({
 });
 
 // ../engine/dist/core/live-session-scan.js
-import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync4, statSync as statSync5, openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync4, statSync as statSync5, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
 import { join as join9, basename as basename5 } from "path";
 function detectTool(sessionId) {
   return getBackendForId(sessionId)?.id ?? "claude";
@@ -6856,6 +6879,15 @@ function sessionFileIndex() {
     return indexCache;
   const byId = /* @__PURE__ */ new Map();
   const seenRoots = /* @__PURE__ */ new Set();
+  const projectPaths = /* @__PURE__ */ new Map();
+  const projectPathOf = (dirName) => {
+    let p = projectPaths.get(dirName);
+    if (p === void 0) {
+      p = resolveProjectDirName(dirName);
+      projectPaths.set(dirName, p);
+    }
+    return p;
+  };
   for (const root of claudeProjectDirs()) {
     if (seenRoots.has(root) || !existsSync7(root))
       continue;
@@ -6883,7 +6915,7 @@ function sessionFileIndex() {
         const located = {
           path: join9(dir, name),
           projectDir: entry.name,
-          projectPath: resolveProjectDirName(entry.name)
+          projectPath: projectPathOf(entry.name)
         };
         const prior = byId.get(id);
         if (prior)
@@ -7565,7 +7597,7 @@ var init_flat_string = __esm({
 });
 
 // ../engine/dist/core/first-prompt.js
-import { createReadStream as createReadStream2, existsSync as existsSync9, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync9, openSync as openSync4, readSync as readSync4, closeSync as closeSync4 } from "fs";
 import { StringDecoder } from "string_decoder";
 function stripBanners2(s) {
   let out = s;
@@ -7619,7 +7651,7 @@ function extractFirstUserPromptSync(filePath, options = {}) {
   const maxBytes = options.maxBytes ?? 4 * 1024 * 1024;
   let fd;
   try {
-    fd = openSync3(filePath, "r");
+    fd = openSync4(filePath, "r");
   } catch {
     return "";
   }
@@ -7631,7 +7663,7 @@ function extractFirstUserPromptSync(filePath, options = {}) {
     let pos = 0;
     let lineNo = 0;
     for (; ; ) {
-      const n = readSync3(fd, buf, 0, CHUNK, pos);
+      const n = readSync4(fd, buf, 0, CHUNK, pos);
       if (n <= 0)
         break;
       pos += n;
@@ -7657,7 +7689,7 @@ function extractFirstUserPromptSync(filePath, options = {}) {
     return "";
   } finally {
     try {
-      closeSync3(fd);
+      closeSync4(fd);
     } catch {
     }
   }
@@ -7676,8 +7708,8 @@ var init_first_prompt = __esm({
 });
 
 // ../engine/dist/core/backends/tail-read.js
-import { openSync as openSync4, readSync as readSync4, closeSync as closeSync4, statSync as statSync6 } from "node:fs";
-function readTailFromOffset(path, offset) {
+import { openSync as openSync5, readSync as readSync5, closeSync as closeSync5, statSync as statSync6 } from "node:fs";
+function readTailFromOffset(path, offset, maxBytes = TAIL_READ_MAX_BYTES) {
   let size = 0;
   try {
     size = statSync6(path).size;
@@ -7686,14 +7718,14 @@ function readTailFromOffset(path, offset) {
   }
   if (size <= offset)
     return { text: "", newOffset: offset };
-  const len = Math.min(size - offset, 16 * 1024 * 1024);
+  const len = Math.min(size - offset, Math.max(1, maxBytes));
   const buf = Buffer.allocUnsafe(len);
   let fd = null;
   try {
-    fd = openSync4(path, "r");
+    fd = openSync5(path, "r");
     let got = 0;
     while (got < len) {
-      const n = readSync4(fd, buf, got, len - got, offset + got);
+      const n = readSync5(fd, buf, got, len - got, offset + got);
       if (n <= 0)
         break;
       got += n;
@@ -7702,25 +7734,47 @@ function readTailFromOffset(path, offset) {
       return { text: "", newOffset: offset };
     const slice = got < len ? buf.subarray(0, got) : buf;
     const lastNl = slice.lastIndexOf(10);
-    if (lastNl < 0) {
-      return { text: "", newOffset: offset };
+    if (lastNl >= 0) {
+      const text = slice.subarray(0, lastNl + 1).toString("utf-8");
+      return { text, newOffset: offset + lastNl + 1 };
     }
-    const text = slice.subarray(0, lastNl + 1).toString("utf-8");
-    return { text, newOffset: offset + lastNl + 1 };
+    if (offset + got >= size)
+      return { text: "", newOffset: offset };
+    const end = findNewline(fd, offset + got, size);
+    if (end < 0)
+      return { text: "", newOffset: offset };
+    return { text: "", newOffset: end + 1, skippedBytes: end + 1 - offset };
   } catch {
     return { text: "", newOffset: offset };
   } finally {
     if (fd !== null) {
       try {
-        closeSync4(fd);
+        closeSync5(fd);
       } catch {
       }
     }
   }
 }
+function findNewline(fd, from, size) {
+  const block = Buffer.allocUnsafe(SKIP_SCAN_BYTES);
+  let pos = from;
+  while (pos < size) {
+    const n = readSync5(fd, block, 0, Math.min(SKIP_SCAN_BYTES, size - pos), pos);
+    if (n <= 0)
+      return -1;
+    const i = block.subarray(0, n).indexOf(10);
+    if (i >= 0)
+      return pos + i;
+    pos += n;
+  }
+  return -1;
+}
+var TAIL_READ_MAX_BYTES, SKIP_SCAN_BYTES;
 var init_tail_read = __esm({
   "../engine/dist/core/backends/tail-read.js"() {
     "use strict";
+    TAIL_READ_MAX_BYTES = 16 * 1024 * 1024;
+    SKIP_SCAN_BYTES = 1024 * 1024;
   }
 });
 
@@ -7997,7 +8051,7 @@ var init_generic_engine = __esm({
 });
 
 // ../engine/dist/core/backends/claude.js
-import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync5, statSync as statSync7, openSync as openSync5, readSync as readSync5, closeSync as closeSync5 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync5, statSync as statSync7, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
 import { join as join10, basename as basename8 } from "path";
 function stripReminders(text) {
   return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
@@ -8094,13 +8148,13 @@ var init_claude2 = __esm({
           return null;
         let head;
         try {
-          const fd = openSync5(located.path, "r");
+          const fd = openSync6(located.path, "r");
           try {
             const buf = Buffer.alloc(65536);
-            const n = readSync5(fd, buf, 0, buf.length, 0);
+            const n = readSync6(fd, buf, 0, buf.length, 0);
             head = buf.toString("utf-8", 0, n);
           } finally {
-            closeSync5(fd);
+            closeSync6(fd);
           }
         } catch {
           return null;
@@ -8145,12 +8199,12 @@ var init_claude2 = __esm({
         const seen = /* @__PURE__ */ new Set();
         const out = [];
         for (const root of claudeProjectDirs()) {
-          this.collectSessionsFromRoot(root, cutoff, filter, seen, out);
+          this.collectSessionsFromRoot(root, cutoff, filter, seen, out, opts.previews !== false);
         }
         out.sort((a, b) => b.mtime - a.mtime);
         return opts.limit ? out.slice(0, opts.limit) : out;
       }
-      collectSessionsFromRoot(root, cutoff, filter, seen, out) {
+      collectSessionsFromRoot(root, cutoff, filter, seen, out, previews) {
         if (!existsSync10(root))
           return;
         for (const proj of readdirSync7(root, { withFileTypes: true })) {
@@ -8209,7 +8263,7 @@ var init_claude2 = __esm({
             }
             if (stat3.mtimeMs < cutoff)
               continue;
-            const firstPrompt = extractFirstUserPromptSync(fullPath, { maxLength: 200 });
+            const firstPrompt = previews ? extractFirstUserPromptSync(fullPath, { maxLength: 200 }) : "";
             out.push({
               toolId: "claude",
               rawId: sessionId,
@@ -8572,14 +8626,14 @@ var init_claude2 = __esm({
       spansMultipleSources(prefixedId) {
         return findSessionFiles(this.toRawId(prefixedId)).length > 1;
       }
-      async readFromOffset(prefixedId, offset) {
+      async readFromOffset(prefixedId, offset, maxBytes) {
         const rawId = this.toRawId(prefixedId);
         const copies = findSessionFiles(rawId);
         if (copies.length === 0)
           return { text: "", newOffset: offset };
         if (copies.length > 1)
           return { text: "", newOffset: offset };
-        return readTailFromOffset(copies[0].path, offset);
+        return readTailFromOffset(copies[0].path, offset, maxBytes);
       }
     };
     claudeBackend = new ClaudeBackend();
@@ -8807,23 +8861,8 @@ var init_opencode = __esm({
             const projectPath = row.project_path || row.directory || "";
             if (filter && !projectPath.toLowerCase().includes(filter))
               continue;
-            const firstUser = db.prepare(`
-          SELECT p.data
-          FROM part p JOIN message m ON m.id = p.message_id
-          WHERE p.session_id = ?
-            AND p.data LIKE '%"type":"text"%'
-            AND m.data LIKE '%"role":"user"%'
-          ORDER BY p.time_created ASC LIMIT 1
-        `).get(row.id);
-            let firstPrompt = "";
-            if (firstUser) {
-              try {
-                const parsed = JSON.parse(firstUser.data);
-                firstPrompt = flatString(String(parsed?.text || "").slice(0, 200));
-              } catch {
-              }
-            }
-            const messageCount = db.prepare("SELECT COUNT(*) as c FROM message WHERE session_id = ?").get(row.id)?.c ?? 0;
+            const firstPrompt = opts.previews === false ? "" : this.firstUserPrompt(db, row.id);
+            const messageCount = opts.previews === false ? 0 : db.prepare("SELECT COUNT(*) as c FROM message WHERE session_id = ?").get(row.id)?.c ?? 0;
             const created = new Date(row.time_created || row.time_updated).toISOString();
             const modified = new Date(row.time_updated).toISOString();
             out.push({
@@ -8847,6 +8886,45 @@ var init_opencode = __esm({
           db.close();
         }
       }
+      /**
+       * The first user text part of a session.
+       *
+       * Walks the session's user messages oldest first through the
+       * (session_id, time_created, id) index and stops at the first one with a
+       * text part. The role and the text are read by SQLite: a first message can
+       * carry whole diffs in `summary` (107 MB on one row), and parsing that in JS
+       * to read one field took the process to 510 MB. The earlier query filtered
+       * every part and message with LIKE and then sorted, so it read all of a
+       * session's data: 423 MB for a 236-session listing.
+       */
+      firstUserPrompt(db, sessionId) {
+        try {
+          const has = (table, col) => !!db.prepare(`SELECT 1 FROM pragma_table_info(?) WHERE name = ?`).get(table, col);
+          const msgOrder = has("message", "time_created") ? "time_created, id" : "rowid";
+          const partOrder = has("part", "time_created") ? "time_created, id" : "rowid";
+          const nextUser = db.prepare(`SELECT id, ${msgOrder === "rowid" ? "rowid AS k1, 0 AS k2" : "time_created AS k1, id AS k2"} FROM message
+          WHERE session_id = ? AND (${msgOrder === "rowid" ? "rowid, 0" : "time_created, id"}) > (?, ?)
+            AND json_extract(data, '$.role') = 'user'
+          ORDER BY ${msgOrder} LIMIT 1`);
+          const firstText = db.prepare(`SELECT substr(json_extract(data, '$.text'), 1, 400) AS text FROM part
+          WHERE message_id = ? AND json_extract(data, '$.type') = 'text'
+            AND length(trim(json_extract(data, '$.text'))) > 0
+          ORDER BY ${partOrder} LIMIT 1`);
+          let k1 = Number.MIN_SAFE_INTEGER, k2 = msgOrder === "rowid" ? 0 : "";
+          for (; ; ) {
+            const m = nextUser.get(sessionId, k1, k2);
+            if (!m)
+              return "";
+            k1 = m.k1;
+            k2 = m.k2;
+            const t = firstText.get(m.id);
+            if (t?.text)
+              return flatString(t.text.slice(0, 200));
+          }
+        } catch {
+          return "";
+        }
+      }
       /** OpenCode auto-generates a session title (model-written, distinct from the
        *  first prompt — e.g. "Replacing Claude with Gemini CLI"). It's a plain
        *  column on the session row. */
@@ -9163,7 +9241,7 @@ var init_opencode = __esm({
 });
 
 // ../engine/dist/core/backends/codex.js
-import { readdirSync as readdirSync8, readFileSync as readFileSync6, statSync as statSync8, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync6, statSync as statSync8, openSync as openSync7, readSync as readSync7, closeSync as closeSync7 } from "fs";
 import { basename as basename9, dirname as dirname10, join as join12 } from "path";
 function parseShellWrites(cmd) {
   const out = [];
@@ -9409,28 +9487,29 @@ var init_codex2 = __esm({
               continue;
             let firstPrompt = "";
             let messageCount = 0;
-            try {
-              const lines = readFileSync6(filePath, "utf-8").split("\n");
-              for (const line of lines) {
-                if (!line.trim())
-                  continue;
-                let ev;
-                try {
-                  ev = JSON.parse(line);
-                } catch {
-                  continue;
-                }
-                if (ev.type === "event_msg" && ev.payload?.type === "user_message") {
-                  messageCount++;
-                  if (!firstPrompt && ev.payload.message) {
-                    firstPrompt = flatString(String(ev.payload.message).slice(0, 200));
+            if (opts.previews !== false)
+              try {
+                const lines = readFileSync6(filePath, "utf-8").split("\n");
+                for (const line of lines) {
+                  if (!line.trim())
+                    continue;
+                  let ev;
+                  try {
+                    ev = JSON.parse(line);
+                  } catch {
+                    continue;
+                  }
+                  if (ev.type === "event_msg" && ev.payload?.type === "user_message") {
+                    messageCount++;
+                    if (!firstPrompt && ev.payload.message) {
+                      firstPrompt = flatString(String(ev.payload.message).slice(0, 200));
+                    }
+                  } else if (ev.type === "response_item" && ev.payload?.type === "message") {
+                    messageCount++;
                   }
-                } else if (ev.type === "response_item" && ev.payload?.type === "message") {
-                  messageCount++;
                 }
+              } catch {
               }
-            } catch {
-            }
             const prior = seen.get(rawId);
             if (prior) {
               if (stat3.mtimeMs > prior.mtime) {
@@ -9837,10 +9916,10 @@ var init_codex2 = __esm({
               if (p === loc.path)
                 continue;
               try {
-                const fd = openSync6(p, "r");
+                const fd = openSync7(p, "r");
                 const buf = Buffer.alloc(4096);
-                const n = readSync6(fd, buf, 0, 4096, 0);
-                closeSync6(fd);
+                const n = readSync7(fd, buf, 0, 4096, 0);
+                closeSync7(fd);
                 const head = buf.toString("utf-8", 0, n);
                 if (head.includes(parentId) && head.includes("parent_thread_id"))
                   push(p, `subagents/${f}`);
@@ -9865,11 +9944,11 @@ var init_codex2 = __esm({
           return 0;
         }
       }
-      async readFromOffset(prefixedId, offset) {
+      async readFromOffset(prefixedId, offset, maxBytes) {
         const loc = this.findSession(prefixedId);
         if (!loc)
           return { text: "", newOffset: offset };
-        return readTailFromOffset(loc.path, offset);
+        return readTailFromOffset(loc.path, offset, maxBytes);
       }
     };
     codexBackend = new CodexBackend();
@@ -10120,21 +10199,22 @@ var init_agy = __esm({
             const projectDir = projectPath ? basename10(projectPath) : "";
             let firstPrompt = "";
             let messageCount = 0;
-            try {
-              const lines = readFileSync7(filePath, "utf-8").split("\n").filter(Boolean);
-              messageCount = lines.length;
-              for (const line of lines) {
-                const obj = JSON.parse(line);
-                if (obj.source === "USER_EXPLICIT" && obj.type === "USER_INPUT" && typeof obj.content === "string") {
-                  const content = obj.content;
-                  const match = content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
-                  const rawText = match ? match[1].trim() : content.trim();
-                  firstPrompt = flatString(rawText.slice(0, 200));
-                  break;
+            if (opts.previews !== false)
+              try {
+                const lines = readFileSync7(filePath, "utf-8").split("\n").filter(Boolean);
+                messageCount = lines.length;
+                for (const line of lines) {
+                  const obj = JSON.parse(line);
+                  if (obj.source === "USER_EXPLICIT" && obj.type === "USER_INPUT" && typeof obj.content === "string") {
+                    const content = obj.content;
+                    const match = content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+                    const rawText = match ? match[1].trim() : content.trim();
+                    firstPrompt = flatString(rawText.slice(0, 200));
+                    break;
+                  }
                 }
+              } catch {
               }
-            } catch {
-            }
             if (seenIds.has(rawId))
               continue;
             seenIds.add(rawId);
@@ -10430,11 +10510,11 @@ var init_agy = __esm({
           return 0;
         }
       }
-      async readFromOffset(prefixedId, offset) {
+      async readFromOffset(prefixedId, offset, maxBytes) {
         const loc = this.findSession(prefixedId);
         if (!loc)
           return { text: "", newOffset: offset };
-        return readTailFromOffset(loc.path, offset);
+        return readTailFromOffset(loc.path, offset, maxBytes);
       }
     };
     agyBackend = new AgyBackend();
@@ -12895,10 +12975,10 @@ var init_types = __esm({
 
 // ../engine/dist/transcript/opencode.js
 async function parseOpenCodeSubagents(parentSessionId) {
-  const { existsSync: existsSync50 } = await import("fs");
+  const { existsSync: existsSync51 } = await import("fs");
   const { opencodeBackend: opencodeBackend2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
   const dbPath = opencodeBackend2.dbPath();
-  if (!existsSync50(dbPath))
+  if (!existsSync51(dbPath))
     return [];
   const realParent = parentSessionId.replace("opencode_", "");
   const db = openSqliteReadonlyOrThrow(dbPath);
@@ -12939,10 +13019,10 @@ async function parseOpenCodeSubagents(parentSessionId) {
   }
 }
 async function parseOpenCodeTranscript(sessionId) {
-  const { existsSync: existsSync50 } = await import("fs");
+  const { existsSync: existsSync51 } = await import("fs");
   const { opencodeBackend: opencodeBackend2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
   const dbPath = opencodeBackend2.dbPath();
-  if (!existsSync50(dbPath))
+  if (!existsSync51(dbPath))
     return [];
   const realId = sessionId.replace("opencode_", "");
   const db = openSqliteReadonlyOrThrow(dbPath);
@@ -13019,6 +13099,7 @@ __export(transcript_exports, {
   shadowFileFor: () => shadowFileFor,
   shadowRoot: () => shadowRoot,
   shadowSizeOnDisk: () => shadowSizeOnDisk,
+  shadowUncompressedBytes: () => shadowUncompressedBytes,
   snapshotShadow: () => snapshotShadow,
   trimTranscriptForSync: () => trimTranscriptForSync,
   updateShadow: () => updateShadow,
@@ -13201,12 +13282,13 @@ function resolveProjectId(inputPath) {
   if (!isAbsolute(inputPath)) {
     return { id: `path:${inputPath}`, displayName: inputPath, source: "path" };
   }
+  const known = inputCache.get(inputPath);
+  if (known)
+    return known;
   const realPath = safeRealpath(inputPath);
-  const cached = resolveCache.get(realPath);
-  if (cached)
-    return cached;
-  const result = doResolve(realPath);
+  const result = resolveCache.get(realPath) ?? doResolve(realPath);
   resolveCache.set(realPath, result);
+  inputCache.set(inputPath, result);
   return result;
 }
 function doResolve(realPath) {
@@ -13485,7 +13567,7 @@ function globToRegex(glob) {
 function escapeRe(s) {
   return s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 }
-var DEFAULT_AUTO_WORKSPACE_MIN_REPOS, BOT_WORKTREE_MARKERS, resolveCache, gitCache, workspaceCache, cachedConfig, GIT_TIMEOUT_MS, AUTO_WORKSPACE_MAX_DEPTH;
+var DEFAULT_AUTO_WORKSPACE_MIN_REPOS, BOT_WORKTREE_MARKERS, resolveCache, inputCache, gitCache, workspaceCache, cachedConfig, GIT_TIMEOUT_MS, AUTO_WORKSPACE_MAX_DEPTH;
 var init_project_resolver = __esm({
   "../engine/dist/core/project-resolver.js"() {
     "use strict";
@@ -13493,6 +13575,7 @@ var init_project_resolver = __esm({
     DEFAULT_AUTO_WORKSPACE_MIN_REPOS = 3;
     BOT_WORKTREE_MARKERS = [".claude-pr-bot"];
     resolveCache = /* @__PURE__ */ new Map();
+    inputCache = /* @__PURE__ */ new Map();
     gitCache = /* @__PURE__ */ new Map();
     workspaceCache = /* @__PURE__ */ new Map();
     cachedConfig = null;
@@ -17875,7 +17958,7 @@ var init_sync_fields = __esm({
 });
 
 // ../engine/dist/core/index-lock.js
-import { existsSync as existsSync39, mkdirSync as mkdirSync8, openSync as openSync7, writeFileSync as writeFileSync7, readFileSync as readFileSync31, rmSync as rmSync4, statSync as statSync35, closeSync as closeSync7 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync8, openSync as openSync8, writeFileSync as writeFileSync7, readFileSync as readFileSync31, rmSync as rmSync4, statSync as statSync35, closeSync as closeSync8 } from "fs";
 import { dirname as dirname17, join as join40 } from "path";
 function acquireIndexLock(opts) {
   const lockPath = lockFilePath();
@@ -17887,7 +17970,7 @@ function acquireIndexLock(opts) {
   }
   let fd;
   try {
-    fd = openSync7(lockPath, "wx", 384);
+    fd = openSync8(lockPath, "wx", 384);
   } catch (err) {
     if (err.code === "EEXIST")
       return null;
@@ -17897,7 +17980,7 @@ function acquireIndexLock(opts) {
   try {
     writeFileSync7(fd, JSON.stringify(holder));
   } finally {
-    closeSync7(fd);
+    closeSync8(fd);
   }
   let released = false;
   return {
@@ -17988,7 +18071,7 @@ var init_http = __esm({
       CLI_VERSION = JSON.parse(readFileSync32(new URL("../package.json", import.meta.url), "utf-8")).version || CLI_VERSION;
     } catch {
       try {
-        if (true) CLI_VERSION = "0.7.0";
+        if (true) CLI_VERSION = "0.7.2";
       } catch {
       }
     }
@@ -18460,16 +18543,16 @@ async function flush() {
 }
 function stableMark(value) {
   try {
-    const { createHash: createHash13 } = __require("node:crypto");
-    return createHash13("sha256").update(value).digest("hex").slice(0, 12);
+    const { createHash: createHash14 } = __require("node:crypto");
+    return createHash14("sha256").update(value).digest("hex").slice(0, 12);
   } catch {
     return "";
   }
 }
 function hashHost() {
   try {
-    const { createHash: createHash13 } = __require("node:crypto");
-    return createHash13("sha256").update(hostname()).digest("hex").slice(0, 12);
+    const { createHash: createHash14 } = __require("node:crypto");
+    return createHash14("sha256").update(hostname()).digest("hex").slice(0, 12);
   } catch {
     return "";
   }
@@ -18483,7 +18566,7 @@ var init_telemetry = __esm({
     init_sync_client();
     cliVersion = () => {
       try {
-        return true ? "0.7.0" : "dev";
+        return true ? "0.7.2" : "dev";
       } catch {
         return "dev";
       }
@@ -18708,16 +18791,17 @@ __export(auto_update_exports, {
   noteUpdateFailure: () => noteUpdateFailure,
   planAutoUpdate: () => planAutoUpdate,
   readUpdateState: () => readUpdateState,
+  resolveNpm: () => resolveNpm,
   runAutoUpdate: () => runAutoUpdate,
   runningPrefix: () => runningPrefix,
   sweepStaleStaging: () => sweepStaleStaging,
   tarballUrl: () => tarballUrl
 });
-import { execSync as execSync2 } from "node:child_process";
-import { readFileSync as readFileSync34 } from "node:fs";
+import { execSync as execSync2, execFileSync as execFileSync3 } from "node:child_process";
+import { readFileSync as readFileSync34, existsSync as existsSync41 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { writeFileSync as writeFileSync8, mkdtempSync as mkdtempSync3, rmSync as rmSync5, readdirSync as readdirSync31, statSync as statSync36, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join41, dirname as dirname18, sep as sep2 } from "node:path";
+import { join as join41, dirname as dirname18, sep as sep2, posix as pathPosix, win32 as pathWin32 } from "node:path";
 import { tmpdir as tmpdir2, homedir as homedir15 } from "node:os";
 import { createHash as createHash7 } from "node:crypto";
 function compareVersions(a, b) {
@@ -18832,25 +18916,46 @@ function runningPrefix(moduleUrl = import.meta.url) {
   const beforeNodeModules = here.slice(0, at);
   return beforeNodeModules.endsWith(`${sep2}lib`) ? beforeNodeModules.slice(0, -4) : beforeNodeModules;
 }
-function npmInstall(cmd) {
+function npmInstall(npm, args) {
   try {
-    execSync2(cmd, { stdio: ["ignore", "ignore", "pipe"] });
+    const opts = { stdio: ["ignore", "ignore", "pipe"], env: npm.env };
+    if (npm.shell) execSync2([npm.file, ...npm.args, ...args].map((a) => `"${a}"`).join(" "), opts);
+    else execFileSync3(npm.file, [...npm.args, ...args], opts);
   } catch (e) {
     const err = e;
     const detail = String(err.stderr ?? "").trim().split("\n").filter((l) => l.trim() && !/^npm (notice|warn)\b/i.test(l)).slice(-4).join(" | ").slice(0, 400);
     throw new Error(detail ? `${err.message ?? "install failed"} \u2014 ${detail}` : err.message ?? "install failed");
   }
 }
+function resolveNpm(loc) {
+  const win = loc.platform === "win32";
+  const p = win ? pathWin32 : pathPosix;
+  const nodeDir = p.dirname(loc.execPath);
+  const cliUnder = (root) => win ? p.join(root, "node_modules", "npm", "bin", "npm-cli.js") : p.join(root, "lib", "node_modules", "npm", "bin", "npm-cli.js");
+  const candidates2 = [
+    cliUnder(win ? nodeDir : p.join(nodeDir, "..")),
+    ...loc.prefix ? [cliUnder(loc.prefix)] : []
+  ];
+  const pathKey = Object.keys(loc.env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
+  const binDirs = [nodeDir, ...loc.prefix ? [win ? loc.prefix : p.join(loc.prefix, "bin")] : []];
+  const delimiter3 = win ? ";" : ":";
+  const current = loc.env[pathKey] ?? "";
+  const env = { ...loc.env, [pathKey]: [...binDirs, ...current ? [current] : []].join(delimiter3) };
+  const cli = candidates2.find((c) => loc.exists(c));
+  if (cli) return { file: loc.execPath, args: [cli], env, shell: false };
+  return { file: "npm", args: [], env, shell: true };
+}
 function realInstall(tgz) {
   const prefix = runningPrefix();
+  const npm = resolveNpm({ execPath: process.execPath, prefix, platform: process.platform, env: process.env, exists: existsSync41 });
   if (prefix) {
-    npmInstall(`npm install -g --prefix "${prefix}" "${tgz}"`);
+    npmInstall(npm, ["install", "-g", "--prefix", prefix, tgz]);
     return;
   }
   try {
-    npmInstall(`npm install -g "${tgz}"`);
+    npmInstall(npm, ["install", "-g", tgz]);
   } catch {
-    npmInstall(`npm install -g --prefix "${process.env.HOME}/.local" "${tgz}"`);
+    npmInstall(npm, ["install", "-g", "--prefix", join41(homedir15(), ".local"), tgz]);
   }
 }
 function realRestart(platform2) {
@@ -19434,7 +19539,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   const listSinceMs = changedWalk ? Math.max(0, (opts.sinceMs ?? 0) - CHANGED_WALK_OVERLAP_MS) : opts.useLedger ? void 0 : opts.sinceMs;
   const refs = listAvailableBackends().flatMap((b) => {
     try {
-      return b.listSessions({ sinceMs: listSinceMs });
+      return b.listSessions({ sinceMs: listSinceMs, previews: false });
     } catch {
       return [];
     }
@@ -19653,16 +19758,53 @@ async function syncToTargetInScope(cred, opts = {}) {
       clearTimeout(timer);
     }
   };
+  const postChunkedHead = async (conv, fileSize) => {
+    const headers = { "content-type": "application/json" };
+    if (cred.token) headers.authorization = `Bearer ${cred.token}`;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new Error(`upload timed out after ${UPLOAD_TIMEOUT_MS}ms`)), UPLOAD_TIMEOUT_MS);
+    try {
+      const res = await fetch(`${base2}/api/sync`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ conversations: [conv] }),
+        signal: ac.signal
+      });
+      if (!res.ok) throw new Error(`chunked head sync failed: HTTP ${res.status} ${await res.text().catch(() => "")}`);
+      const body = await res.json().catch(() => ({}));
+      const id = conv.session_id;
+      const guarded = (body.shrink_guarded ?? []).find((g) => g.session_id === id);
+      const mtime = conv.mtime;
+      try {
+        if (!guarded) {
+          markSynced(base2, [{ id, mtime, offset: conv.from_offset, size: conv.from_offset, acked: true }]);
+        } else if (typeof guarded.o === "number" && guarded.o > 0 && guarded.o <= fileSize) {
+          markSynced(base2, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true }]);
+        } else {
+          markSynced(base2, [{ id, mtime }]);
+        }
+      } catch {
+      }
+      appendResults.uploaded++;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
   let appendBatch = [];
+  let appendBatchBytes = 0;
   const APPEND_BATCH_SIZE = 50;
+  const APPEND_BATCH_MAX_BYTES = SYNC_CHUNK_BYTES;
   const appendFlush = async () => {
     if (appendBatch.length === 0) return;
     const batch = appendBatch;
     appendBatch = [];
+    appendBatchBytes = 0;
     await postAppend(batch);
   };
-  const appendAdd = async (conv) => {
+  const appendAdd = async (conv, bytes = 0) => {
+    if (appendBatch.length > 0 && appendBatchBytes + bytes > APPEND_BATCH_MAX_BYTES) await appendFlush();
     appendBatch.push(conv);
+    appendBatchBytes += bytes;
     if (appendBatch.length >= APPEND_BATCH_SIZE) await appendFlush();
   };
   const itemsBatch = makeBatcher("items", 100);
@@ -19712,7 +19854,7 @@ async function syncToTargetInScope(cred, opts = {}) {
         cred,
         () => listAvailableBackends().flatMap((b) => {
           try {
-            return b.listSessions({});
+            return b.listSessions({ previews: false });
           } catch {
             return [];
           }
@@ -19741,7 +19883,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   let externalFindings = null;
   if (scanSecrets) {
     externalFindings = /* @__PURE__ */ new Map();
-    const toScan = slice.filter((ref) => modeOf(ref) === "full" && sessionFileBytes(ref) <= FULL_BUILD_MAX_BYTES);
+    const toScan = slice.filter((ref) => modeOf(ref) === "full" && sessionBuildBytes(ref) <= FULL_BUILD_MAX_BYTES);
     trace?.(`batch secret scan start: ${toScan.length} session(s), \u2264${(BATCH_SCAN_MAX_BYTES / 1048576).toFixed(0)}MB per slice`);
     const batch = batchScanExternal(
       toScan.map((ref) => ({
@@ -19785,11 +19927,17 @@ async function syncToTargetInScope(cred, opts = {}) {
       const ack = ledger.get(ref.prefixedId);
       try {
         const tail = await buildConversationTail(ref, ack.o ?? 0, { mapPath, tenantRules });
-        if (tail && tail.findings.length > 0) {
+        const chunked = sessionBuildBytes(ref) > FULL_BUILD_MAX_BYTES;
+        if (tail && tail.findings.length > 0 && !chunked) {
           promotedForFindings = true;
         } else if (tail) {
           redactions += tail.redactions;
-          await appendAdd(tail.conv);
+          await appendAdd(tail.conv, tail.bytes);
+          if (tail.findings.length > 0) {
+            await appendFlush();
+            const all = await scanTranscriptFindingsChunked(ref, tenantRules);
+            if (all.length > 0) await findingsBatch.add(all);
+          }
           walked++;
           if (walked % 250 === 0) console.error(`[sync] ${walked}/${slice.length} sessions\u2026`);
           continue;
@@ -19837,12 +19985,13 @@ async function syncToTargetInScope(cred, opts = {}) {
     }
     redactions += built.redactions;
     if (built.srcHash) shippedHash.set(ref.prefixedId, built.srcHash);
-    await convBatch.add(built.conv);
+    if (built.conv.chunked) await postChunkedHead(built.conv, sessionFileBytes(ref));
+    else await convBatch.add(built.conv);
     if (built.findings.length > 0) await findingsBatch.add(built.findings);
     if (upload.sessionMeta) {
       await accumulateKg(extractEntities(built.kgText, { projectPath: built.projectPath, sourceType: "session", sessionId: ref.prefixedId, validFrom: ref.mtime ? new Date(ref.mtime).toISOString().slice(0, 10) : void 0 }), ref.prefixedId);
     }
-    if (upload.sessionMeta && sessionFileBytes(ref) <= FULL_BUILD_MAX_BYTES) {
+    if (upload.sessionMeta && sessionFileBytes(ref) <= DERIVED_MAX_BYTES) {
       try {
         const count = { redactions: 0 };
         const offloaded = await scanPool().runDerived({
@@ -20022,35 +20171,70 @@ async function syncToTargetInScope(cred, opts = {}) {
     scanMs: Math.round(scanMs)
   };
 }
+async function scanTranscriptFindingsChunked(ref, tenantRules) {
+  const backend = getBackendForId(ref.prefixedId);
+  const findings = [];
+  if (!backend?.readFromOffset) return findings;
+  let offset = 0;
+  let lineBase = 0;
+  for (; ; ) {
+    const chunk = await backend.readFromOffset(ref.prefixedId, offset, SYNC_CHUNK_BYTES);
+    if (chunk.newOffset <= offset) break;
+    offset = chunk.newOffset;
+    if (chunk.skippedBytes) {
+      lineBase += 1;
+      continue;
+    }
+    try {
+      for (const f of scanTextForFindings(chunk.text)) {
+        findings.push({ session_id: ref.prefixedId, detector: "builtin", rule: f.rule, line: lineBase + f.line, preview: f.preview });
+      }
+      if (tenantRules && tenantRules.length > 0) {
+        for (const f of scanTenantRules(chunk.text, tenantRules)) {
+          findings.push({ session_id: ref.prefixedId, detector: f.detector, rule: f.rule, line: lineBase + f.line, preview: f.preview });
+        }
+      }
+    } catch {
+    }
+    for (let i = chunk.text.indexOf("\n"); i >= 0; i = chunk.text.indexOf("\n", i + 1)) lineBase++;
+  }
+  return dropFuzzyFindings(findings, (f) => ({ detector: f.detector, rule: f.rule }));
+}
 function sessionFileBytes(ref) {
   const backend = getBackendForId(ref.prefixedId);
   if (!backend?.isAppendOnly?.()) return 0;
   return backend.fileSize?.(ref.prefixedId) ?? 0;
 }
+function sessionBuildBytes(ref) {
+  const main = sessionFileBytes(ref);
+  if (main === 0) return 0;
+  return Math.max(main, shadowUncompressedBytes(ref.toolId, ref.rawId));
+}
 async function buildConversationSync(ref, mtime, opts = {}) {
   const mapPath = opts.mapPath ?? ((p) => p);
   let includeRaw = opts.includeRaw !== false;
   let includeMeta = opts.includeMeta !== false;
   let srcHash;
-  const fileBytes = sessionFileBytes(ref);
-  const oversized = fileBytes > FULL_BUILD_MAX_BYTES;
-  let tailText = "";
-  let tailOffsetEnd = 0;
+  const oversized = sessionBuildBytes(ref) > FULL_BUILD_MAX_BYTES;
+  let headOffsetEnd = 0;
+  let oversizedFindings = null;
   let transcript = null;
   let fullestContainer = null;
   if (oversized) {
     const backend = getBackendForId(ref.prefixedId);
     if (!backend?.readFromOffset) return null;
     try {
-      const tail = await backend.readFromOffset(ref.prefixedId, fileBytes - FULL_BUILD_TAIL_BYTES);
-      tailText = tail.text;
-      tailOffsetEnd = tail.newOffset;
-      const messages = parseTailMessages(ref.toolId, tailText);
+      let head = await backend.readFromOffset(ref.prefixedId, 0, SYNC_CHUNK_BYTES);
+      for (let hops = 0; head.skippedBytes && hops < 8; hops++) {
+        head = await backend.readFromOffset(ref.prefixedId, head.newOffset, SYNC_CHUNK_BYTES);
+      }
+      headOffsetEnd = head.newOffset;
+      const messages = parseTailMessages(ref.toolId, head.text);
       if (messages.length > 0) transcript = { messages, subagents: [] };
     } catch {
     }
     includeRaw = false;
-    includeMeta = false;
+    oversizedFindings = await scanTranscriptFindingsChunked(ref, opts.tenantRules);
   } else {
     try {
       const backend = getBackendForId(ref.prefixedId) ?? getBackend("claude");
@@ -20111,7 +20295,6 @@ async function buildConversationSync(ref, mtime, opts = {}) {
   );
   let projectPath = ref.projectPath;
   const meta = { messageCount: textMessages.length };
-  if (oversized) meta.truncated = true;
   if (textMessages.filter((m) => m.role === "user").length <= 1) meta.oneShot = true;
   try {
     const cwd = ref.fullPath ? readCwdFromJsonl(ref.fullPath) : "";
@@ -20225,21 +20408,7 @@ async function buildConversationSync(ref, mtime, opts = {}) {
     }
     scanMs = performance.now() - t0;
   }
-  if (oversized && tailText) {
-    const t0 = performance.now();
-    try {
-      for (const f of scanTextForFindings(tailText)) {
-        findings.push({ session_id: ref.prefixedId, detector: "builtin", rule: f.rule, line: f.line, preview: f.preview });
-      }
-      if (opts.tenantRules && opts.tenantRules.length > 0) {
-        for (const f of scanTenantRules(tailText, opts.tenantRules)) {
-          findings.push({ session_id: ref.prefixedId, detector: f.detector, rule: f.rule, line: f.line, preview: f.preview });
-        }
-      }
-    } catch {
-    }
-    scanMs = performance.now() - t0;
-  }
+  if (oversizedFindings) findings.push(...oversizedFindings);
   const keptFindings = dropFuzzyFindings(findings, (f) => ({ detector: f.detector, rule: f.rule }));
   findings.length = 0;
   findings.push(...keptFindings);
@@ -20285,7 +20454,10 @@ async function buildConversationSync(ref, mtime, opts = {}) {
       // (convBatch onFlush uses this, not a recomputed size) so the next
       // append's base_offset matches exactly — no spurious continuity misses on
       // an actively-growing session. undefined for non-append-only backends.
-      from_offset: oversized ? tailOffsetEnd : getBackendForId(ref.prefixedId)?.fileSize?.(ref.rawId),
+      from_offset: oversized ? headOffsetEnd : getBackendForId(ref.prefixedId)?.fileSize?.(ref.rawId),
+      // The head of a chunked session. The server reports back when its shrink
+      // guard keeps a fuller stored copy, so the client appends from there.
+      ...oversized ? { chunked: true } : {},
       meta,
       mtime
     },
@@ -20307,12 +20479,30 @@ async function buildConversationTail(ref, fromOffset, opts = {}) {
   const backend = getBackendForId(ref.prefixedId);
   if (!backend?.readFromOffset) return null;
   const mapPath = opts.mapPath ?? ((p) => p);
-  const { text: tailText, newOffset } = await backend.readFromOffset(ref.prefixedId, fromOffset);
-  if (!tailText.trim()) return null;
-  const messages = parseTailMessages(ref.toolId, tailText);
-  if (messages.length === 0) return null;
+  const { text: tailText, newOffset, skippedBytes } = await backend.readFromOffset(ref.prefixedId, fromOffset, SYNC_CHUNK_BYTES);
+  if (newOffset <= fromOffset) return null;
+  const messages = skippedBytes ? [] : parseTailMessages(ref.toolId, tailText);
   const textMessages = messages.filter((m) => m.role !== "summary" && m.content?.trim());
-  if (textMessages.length === 0 && !messages.some((m) => m.toolCalls?.length)) return null;
+  const hasContent = textMessages.length > 0 || messages.some((m) => m.toolCalls?.length);
+  if (!hasContent) {
+    return {
+      conv: {
+        session_id: ref.prefixedId,
+        tool: ref.toolId,
+        project_path: mapPath(ref.projectPath),
+        append: true,
+        base_offset: fromOffset,
+        from_offset: newOffset,
+        redacted_text: "",
+        envelope: { v: TRANSCRIPT_VERSION, messages: [], subagents: [] },
+        mtime: Math.floor(ref.mtime) || 0
+      },
+      redactions: 0,
+      newOffset,
+      findings: [],
+      bytes: 0
+    };
+  }
   const firstUser = textMessages.find((m) => m.role === "user");
   if (isInternalToolPrompt(firstUser?.content)) return null;
   const count = { redactions: 0 };
@@ -20355,7 +20545,8 @@ async function buildConversationTail(ref, fromOffset, opts = {}) {
     },
     redactions: count.redactions,
     newOffset,
-    findings
+    findings,
+    bytes: Buffer.byteLength(tailText)
   };
 }
 function isSyncSkip(r) {
@@ -20385,7 +20576,7 @@ async function syncIncremental(opts = {}) {
     lock.release();
   }
 }
-var ownVersion, ERROR_CLASS, STANDING_FAILURE, walkProgressForUpload, lastServerPackSpec, credPath, _securityConfigCache, SECURITY_CONFIG_TTL_MS, _syncConfigCache, EMPTY_SYNC_CONFIG, SYNC_RULES_REFUSAL, hashPath, acceptedUploads, MAX_DERIVED_ROW_BYTES, isLocalHost, CAPS_TTL_MS, capsOk, advertisedIngestConc, advertisedGzipBody, FULL_BUILD_MAX_BYTES, FULL_BUILD_TAIL_BYTES, BATCH_SCAN_MAX_BYTES;
+var ownVersion, ERROR_CLASS, STANDING_FAILURE, walkProgressForUpload, lastServerPackSpec, credPath, _securityConfigCache, SECURITY_CONFIG_TTL_MS, _syncConfigCache, EMPTY_SYNC_CONFIG, SYNC_RULES_REFUSAL, hashPath, acceptedUploads, MAX_DERIVED_ROW_BYTES, isLocalHost, CAPS_TTL_MS, capsOk, advertisedIngestConc, advertisedGzipBody, FULL_BUILD_MAX_BYTES, DERIVED_MAX_BYTES, SYNC_CHUNK_BYTES, BATCH_SCAN_MAX_BYTES;
 var init_sync_client = __esm({
   "src/sync-client.ts"() {
     "use strict";
@@ -20430,7 +20621,7 @@ var init_sync_client = __esm({
       ownVersion = JSON.parse(readFileSync35(join42(dir, "../package.json"), "utf-8")).version || ownVersion;
     } catch {
       try {
-        if (true) ownVersion = "0.7.0";
+        if (true) ownVersion = "0.7.2";
       } catch {
       }
     }
@@ -20456,8 +20647,9 @@ var init_sync_client = __esm({
     capsOk = /* @__PURE__ */ new Map();
     advertisedIngestConc = /* @__PURE__ */ new Map();
     advertisedGzipBody = /* @__PURE__ */ new Set();
-    FULL_BUILD_MAX_BYTES = Math.max(8, parseInt(process.env.CHAT_RECALL_FULL_BUILD_MAX_MB || "64", 10)) * 1024 * 1024;
-    FULL_BUILD_TAIL_BYTES = 16 * 1024 * 1024;
+    FULL_BUILD_MAX_BYTES = Math.max(8, parseInt(process.env.CHAT_RECALL_FULL_BUILD_MAX_MB || "24", 10)) * 1024 * 1024;
+    DERIVED_MAX_BYTES = Math.max(8, parseInt(process.env.CHAT_RECALL_DERIVED_MAX_MB || "64", 10)) * 1024 * 1024;
+    SYNC_CHUNK_BYTES = 8 * 1024 * 1024;
     BATCH_SCAN_MAX_BYTES = Math.max(1, parseInt(process.env.CHAT_RECALL_BATCHSCAN_MAX_MB || "64", 10)) * 1024 * 1024;
   }
 });
@@ -20606,7 +20798,7 @@ var init_artifact_codec = __esm({
 });
 
 // ../engine/dist/core/toolkit-sync.js
-import { existsSync as existsSync41, mkdirSync as mkdirSync11, readFileSync as readFileSync37, writeFileSync as writeFileSync10, cpSync } from "fs";
+import { existsSync as existsSync42, mkdirSync as mkdirSync11, readFileSync as readFileSync37, writeFileSync as writeFileSync10, cpSync } from "fs";
 import { dirname as dirname20, join as join44, basename as basename22 } from "path";
 import { homedir as homedir17 } from "os";
 function rowFromMemoryItem(type, item) {
@@ -20640,11 +20832,11 @@ function skillsDirFor(tool) {
 }
 function copySkill(row, toTool) {
   const skillDir = row.extra.skillDir || dirname20(row.filePath);
-  if (!existsSync41(skillDir))
+  if (!existsSync42(skillDir))
     return { ok: false, status: 404, error: `Source dir missing: ${skillDir}` };
   const name = row.extra.skillName || basename22(skillDir);
   const targetDir = join44(skillsDirFor(toTool), name);
-  if (existsSync41(targetDir))
+  if (existsSync42(targetDir))
     return { ok: false, status: 409, error: `Already exists: ${targetDir}` };
   try {
     mkdirSync11(dirname20(targetDir), { recursive: true });
@@ -20676,7 +20868,7 @@ function readMcpEntry(tool, name) {
       return entry;
   }
   for (const t of tries) {
-    if (!existsSync41(t.path))
+    if (!existsSync42(t.path))
       continue;
     try {
       const cfg = JSON.parse(readFileSync37(t.path, "utf-8"));
@@ -20689,7 +20881,7 @@ function readMcpEntry(tool, name) {
   return null;
 }
 function readCodexMcpEntry(path, target) {
-  if (!existsSync41(path))
+  if (!existsSync42(path))
     return null;
   let content;
   try {
@@ -20743,7 +20935,7 @@ function readCodexMcpEntry(path, target) {
 }
 function writeCodexMcpEntry(path, name, entry) {
   let content = "";
-  if (existsSync41(path))
+  if (existsSync42(path))
     content = readFileSync37(path, "utf-8");
   const header = `[mcp_servers.${name}]`;
   if (content.includes(header))
@@ -20801,7 +20993,7 @@ function writeMcpEntry(toTool, name, entry) {
     key2 = "mcp";
   }
   let cfg = {};
-  if (existsSync41(path)) {
+  if (existsSync42(path)) {
     try {
       cfg = JSON.parse(readFileSync37(path, "utf-8"));
     } catch {
@@ -20865,7 +21057,7 @@ function copyCommandOrAgent(type, row, toTool) {
     return { ok: false, status: 404, error: `Source unreadable: ${e instanceof Error ? e.message : "failed"}` };
   }
   const out = emit(type, art, toTool);
-  if (existsSync41(out.path))
+  if (existsSync42(out.path))
     return { ok: false, status: 409, error: `Already exists: ${out.path}` };
   try {
     mkdirSync11(dirname20(out.path), { recursive: true });
@@ -20885,7 +21077,7 @@ function copyInstructions(row, toTool) {
     return { ok: false, status: 404, error: `Source unreadable: ${e instanceof Error ? e.message : "failed"}` };
   }
   const out = emit("instructions", art, toTool, row.projectPath || void 0);
-  if (existsSync41(out.path))
+  if (existsSync42(out.path))
     return { ok: false, status: 409, error: `Already exists: ${out.path}` };
   try {
     mkdirSync11(dirname20(out.path), { recursive: true });
@@ -21028,7 +21220,7 @@ var init_toolkit_sync = __esm({
 });
 
 // ../engine/dist/core/which.js
-import { existsSync as existsSync43, statSync as statSync39, accessSync, constants } from "node:fs";
+import { existsSync as existsSync44, statSync as statSync39, accessSync, constants } from "node:fs";
 import { join as join46, isAbsolute as isAbsolute2, delimiter as delimiter2, sep as sep3 } from "node:path";
 function executable(p) {
   try {
@@ -21069,7 +21261,7 @@ function resolveOnPath(name) {
       continue;
     for (const c of candidates(name)) {
       const full = join46(dir, c);
-      if (existsSync43(full) && executable(full))
+      if (existsSync44(full) && executable(full))
         return full;
     }
   }
@@ -21094,7 +21286,7 @@ __export(toolkit_pull_exports, {
   planPull: () => planPull,
   portableCommand: () => portableCommand
 });
-import { existsSync as existsSync44, mkdirSync as mkdirSync13, statSync as statSync40, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync13, statSync as statSync40, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname22, join as join47, basename as basename23, isAbsolute as isAbsolute3 } from "node:path";
 function isExecutableFile(p) {
   try {
@@ -21247,7 +21439,7 @@ function executePull(rows, opts = {}) {
     for (const tool of tools) {
       const dir = join47(skillsDirFor(tool), name);
       const file = join47(dir, "SKILL.md");
-      if (existsSync44(file)) {
+      if (existsSync45(file)) {
         outcomes.push({ type: "skill", name, tool, status: "present" });
         continue;
       }
@@ -21292,7 +21484,7 @@ function executePull(rows, opts = {}) {
         outcomes.push({ type, name, tool, status: "failed", reason: e instanceof Error ? e.message : "emit failed" });
         continue;
       }
-      if (existsSync44(out.path)) {
+      if (existsSync45(out.path)) {
         outcomes.push({ type, name, tool, status: "present" });
         continue;
       }
@@ -21468,6 +21660,9 @@ async function repairSession(id, opts = {}) {
       note: "archive count is a lower bound; the rebuild also unions the on-disk tail"
     };
   }
+  if (!opts.force && endpoints.every((ep) => (currentOnServer.get(ep.url) ?? 0) >= fullest.messages)) {
+    return { sessionId: id, status: "already-full", fullestMessages: fullest.messages, fullestSource: fullest.source, pushed: [] };
+  }
   seedShadow(rawId, fullest.container);
   const located = backend.findSession(rawId);
   const projectPath = located?.projectPath || cwdFromContainer(fullest.container);
@@ -21510,7 +21705,7 @@ async function repairSession(id, opts = {}) {
     try {
       const res = await fetchWithTimeout(`${ep.url}/api/sync`, { method: "POST", headers, body: JSON.stringify({ conversations: [built.conv] }) }, 6e4);
       if (!res.ok) {
-        pushed.push({ server: ep.url, before, after: before });
+        pushed.push({ server: ep.url, before, after: before, error: `HTTP ${res.status}` });
         log6(`push to ${ep.url} FAILED: HTTP ${res.status}`);
         continue;
       }
@@ -21519,10 +21714,21 @@ async function repairSession(id, opts = {}) {
       pushed.push({ server: ep.url, before, after: afterN });
       log6(`pushed to ${ep.url}: ${before} \u2192 ${afterN} msg(s)`);
     } catch (e) {
-      pushed.push({ server: ep.url, before, after: before });
-      log6(`push to ${ep.url} errored: ${e instanceof Error ? e.message : e}`);
+      const error = e instanceof Error ? e.message : String(e);
+      pushed.push({ server: ep.url, before, after: before, error });
+      log6(`push to ${ep.url} errored: ${error}`);
     }
   }
+  if (pushed.every((p) => p.error)) {
+    return {
+      sessionId: id,
+      status: "error",
+      fullestMessages: builtCount,
+      fullestSource: fullest.source,
+      pushed,
+      note: `every push failed: ${pushed.map((p) => `${p.server}: ${p.error}`).join("; ")}`
+    };
+  }
   return { sessionId: id, status: "repaired", fullestMessages: builtCount, fullestSource: fullest.source, pushed };
 }
 async function repairSessions(ids, opts = {}) {
@@ -21592,7 +21798,7 @@ __export(shadow_prune_exports, {
   DEFAULT_MAX_TOTAL_BYTES: () => DEFAULT_MAX_TOTAL_BYTES,
   pruneShadow: () => pruneShadow
 });
-import { readdirSync as readdirSync33, statSync as statSync42, unlinkSync as unlinkSync3 } from "fs";
+import { readdirSync as readdirSync33, statSync as statSync43, unlinkSync as unlinkSync3 } from "fs";
 import { join as join50 } from "path";
 function listShadows(isFullyAcked) {
   const out = [];
@@ -21617,7 +21823,7 @@ function listShadows(isFullyAcked) {
       const path = join50(dir, name);
       let st;
       try {
-        st = statSync42(path);
+        st = statSync43(path);
       } catch {
         continue;
       }
@@ -21689,9 +21895,9 @@ var init_shadow_prune = __esm({
 });
 
 // ../engine/dist/types/code-intel.js
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 function shortHash(s) {
-  return createHash11("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(s).digest("hex").slice(0, 16);
 }
 function snippetKey(snippet) {
   return (snippet ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
@@ -21732,11 +21938,11 @@ var init_code_intel = __esm({
 });
 
 // ../engine/dist/core/companions.js
-import { existsSync as existsSync47, mkdirSync as mkdirSync16, statSync as statSync43, chmodSync as chmodSync4, unlinkSync as unlinkSync4, renameSync as renameSync5, createWriteStream, readFileSync as readFileSync42, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync48, mkdirSync as mkdirSync16, statSync as statSync44, chmodSync as chmodSync4, unlinkSync as unlinkSync4, renameSync as renameSync5, createWriteStream, readFileSync as readFileSync42, writeFileSync as writeFileSync15 } from "node:fs";
 import { homedir as homedir19 } from "node:os";
 import { join as join51 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function expectedCodeindexSha256(artifact) {
   return CODEINDEX_SHA256[artifact.replace(/^codeindex-/, "").replace(/\.exe$/, "")] ?? null;
 }
@@ -21783,7 +21989,7 @@ function checkCodeindexStatus() {
     status.installed = true;
     status.path = foundPath;
     try {
-      status.size = statSync43(foundPath).size;
+      status.size = statSync44(foundPath).size;
     } catch {
     }
     try {
@@ -21844,7 +22050,7 @@ async function installCodeindex(opts = {}) {
     if (!expected) {
       throw new Error(`No pinned checksum for ${status.artifactName} \u2014 refusing to install an unverified binary. Add its sha256 to CODEINDEX_SHA256 in companions.ts.`);
     }
-    const actual = createHash12("sha256").update(readFileSync42(tmpPath)).digest("hex");
+    const actual = createHash13("sha256").update(readFileSync42(tmpPath)).digest("hex");
     if (actual !== expected) {
       throw new Error(`Checksum mismatch for ${status.artifactName}.
   expected ${expected}
@@ -21855,7 +22061,7 @@ Refusing to install. The release may have been re-uploaded, or something is serv
     renameSync5(tmpPath, CODEINDEX_BIN_PATH);
   } catch (err) {
     try {
-      if (existsSync47(tmpPath))
+      if (existsSync48(tmpPath))
         unlinkSync4(tmpPath);
     } catch {
     }
@@ -22008,7 +22214,10 @@ async function resolveCodeindexBin(autoInstall = true) {
 }
 function runMcp(binPath, workspace, calls, timeoutMs = 18e4) {
   return new Promise((resolve3, reject) => {
-    const p = spawn2(binPath, ["--mcp", "--workspace", workspace], { stdio: ["pipe", "pipe", "ignore"] });
+    const p = spawn2(binPath, ["--mcp", "--workspace", workspace], {
+      stdio: ["pipe", "pipe", "ignore"],
+      env: { ...process.env, CODEINDEX_NO_DAEMON: "1" }
+    });
     const res = /* @__PURE__ */ new Map();
     let pending = "";
     let failed = false;
@@ -22939,7 +23148,7 @@ __export(service_installer_exports, {
   uninstallService: () => uninstallService
 });
 import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync48, mkdirSync as mkdirSync17, readFileSync as readFileSync44, rmSync as rmSync7, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync17, readFileSync as readFileSync44, rmSync as rmSync7, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir20 } from "os";
 import { join as join53 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -22966,7 +23175,7 @@ function isServiceRunning() {
     return /com\.chat-recall\.watch/.test(tryCmd("launchctl list 2>/dev/null"));
   }
   if (process.platform === "linux") {
-    return /active/.test(tryCmd("systemctl --user is-active chat-recall-watch.service 2>/dev/null"));
+    return /^active$/m.test(tryCmd("systemctl --user is-active chat-recall-watch.service 2>/dev/null"));
   }
   return false;
 }
@@ -22975,7 +23184,7 @@ function refreshServiceDefinition() {
   try {
     const { watchJs, node, logFile } = resolveDaemonPaths();
     const unitPath = join53(homedir20(), ".config", "systemd", "user", "chat-recall-watch.service");
-    if (!existsSync48(unitPath)) return false;
+    if (!existsSync49(unitPath)) return false;
     const current = readFileSync44(unitPath, "utf8");
     if (!current.includes(watchJs)) return false;
     const wanted = renderSystemdUnit(watchJs, node, logFile);
@@ -23042,7 +23251,12 @@ function renderSystemdUnit(watchJs, node, logFile) {
     // sawtooth. 1536MB keeps GC honest (768 OOMed on the largest subagent-fanout session) with plenty of headroom for the
     // largest transcripts.
     `ExecStart=${node} --max-old-space-size=1536 ${watchJs}`,
-    "Restart=on-failure",
+    // ALWAYS: the collector never ends its own work, so any exit systemd did
+    // not ask for is a fault. Under on-failure a clean exit left it dead: on
+    // 2026-09-16 the unit went "inactive (dead) … status=0/SUCCESS" and stayed
+    // down for 8 days, so nothing synced and the auto-update tick, which runs
+    // inside the daemon, never ran. `systemctl stop` still stops it.
+    "Restart=always",
     "RestartSec=10",
     "Nice=10",
     // NEVER STOP RETRYING. systemd's default start limiter gives up after a
@@ -23138,7 +23352,7 @@ function uninstallService() {
     } catch {
     }
     const unitPath = join53(homedir20(), ".config", "systemd", "user", "chat-recall-watch.service");
-    if (existsSync48(unitPath)) {
+    if (existsSync49(unitPath)) {
       rmSync7(unitPath, { force: true });
       removed = true;
     }
@@ -23155,7 +23369,7 @@ function uninstallService() {
     } catch {
     }
     let removed = false;
-    if (existsSync48(plistPath)) {
+    if (existsSync49(plistPath)) {
       rmSync7(plistPath, { force: true });
       removed = true;
     }
@@ -23212,12 +23426,12 @@ init_codex2();
 init_cursor();
 init_opencode();
 init_agy();
-import { existsSync as existsSync45, readFileSync as readFileSync39, writeFileSync as writeFileSync13, appendFileSync, mkdirSync as mkdirSync14 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync39, writeFileSync as writeFileSync13, appendFileSync, mkdirSync as mkdirSync14 } from "node:fs";
 import { join as join48 } from "node:path";
 
 // src/project-tasks.ts
 init_http();
-import { existsSync as existsSync42, readFileSync as readFileSync38, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, statSync as statSync38 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync38, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, statSync as statSync38 } from "node:fs";
 import { join as join45, dirname as dirname21 } from "node:path";
 import { homedir as homedir18 } from "node:os";
 
@@ -23325,7 +23539,7 @@ async function pushProjectTaskStatuses(base2, authHeaders, opts = {}) {
     }
     for (const project of projects) {
       const file = join45(project, fk.filename);
-      if (!existsSync42(file)) continue;
+      if (!existsSync43(file)) continue;
       let mtime;
       try {
         mtime = statSync38(file).mtimeMs;
@@ -23386,7 +23600,7 @@ function instructionTargets(rootPath, isGlobal) {
   const tools = installed.length ? installed : [INSTRUCTION_TOOLS[0]];
   if (isGlobal) return [...new Set(tools.map((t) => instructionsPath(t.id)))];
   if (!rootPath) return [];
-  const present = INSTRUCTION_FILENAMES.map((f) => join48(rootPath, f)).filter((p) => existsSync45(p));
+  const present = INSTRUCTION_FILENAMES.map((f) => join48(rootPath, f)).filter((p) => existsSync46(p));
   if (present.length) return present;
   return [...new Set(tools.map((t) => join48(rootPath, instructionsFilename(t.id))))];
 }
@@ -23414,7 +23628,7 @@ function applyCodeRecommendation(intent) {
           mkdirSync14(dir, { recursive: true });
         } catch {
         }
-        const existing = existsSync45(file) ? readFileSync39(file, "utf8") : "";
+        const existing = existsSync46(file) ? readFileSync39(file, "utf8") : "";
         if (existing.includes(text)) {
           skipped.push(file);
           continue;
@@ -23516,7 +23730,7 @@ try {
   ownVersion2 = JSON.parse(readFileSync39(join48(dir, "../package.json"), "utf-8")).version || ownVersion2;
 } catch {
   try {
-    if (true) ownVersion2 = "0.7.0";
+    if (true) ownVersion2 = "0.7.2";
   } catch {
   }
 }
@@ -23581,7 +23795,9 @@ init_auto_update();
 
 // src/code-index-cursor.ts
 init_paths();
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
+import { readFileSync as readFileSync40, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, statSync as statSync41 } from "fs";
+import { execFileSync as execFileSync4 } from "child_process";
+import { createHash as createHash10 } from "crypto";
 import { join as join49, dirname as dirname24 } from "path";
 var cursorPath = () => join49(getDataDir(), "code-index-cursor.json");
 function readCursor() {
@@ -23590,7 +23806,11 @@ function readCursor() {
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       const out = {};
       for (const [k, v] of Object.entries(raw)) {
-        if (typeof v === "number" && Number.isFinite(v)) out[k] = v;
+        if (typeof v === "number" && Number.isFinite(v)) out[k] = { at: v };
+        else if (v && typeof v === "object" && typeof v.at === "number" && Number.isFinite(v.at)) {
+          const fp = v.fp;
+          out[k] = typeof fp === "string" ? { at: v.at, fp } : { at: v.at };
+        }
       }
       return out;
     }
@@ -23606,13 +23826,44 @@ function writeCursor(c) {
   } catch {
   }
 }
-function noteIndexed(workspace, now = Date.now()) {
+function noteIndexed(workspace, now = Date.now(), fp) {
   const c = readCursor();
-  c[workspace] = now;
+  c[workspace] = fp ? { at: now, fp } : { at: now };
   writeCursor(c);
 }
+function workspaceFingerprint(workspace, collectorVersion) {
+  try {
+    const git2 = (args) => execFileSync4(
+      "git",
+      ["-C", workspace, ...args],
+      { encoding: "utf-8", timeout: 1e4, maxBuffer: 16 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const head = git2(["rev-parse", "HEAD"]).trim();
+    const status = git2(["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    const h = createHash10("sha256").update(`v${collectorVersion}\0${head}\0`);
+    for (const entry of status.split("\0")) {
+      if (entry.length < 4) continue;
+      const rel = entry.slice(3);
+      let stamp2 = "gone";
+      try {
+        const s = statSync41(join49(workspace, rel));
+        stamp2 = `${s.size}:${Math.floor(s.mtimeMs)}`;
+      } catch {
+      }
+      h.update(`${entry.slice(0, 2)}\0${rel}\0${stamp2}\0`);
+    }
+    return h.digest("hex");
+  } catch {
+    return null;
+  }
+}
+var UNCHANGED_RESEND_MS = 7 * 24 * 3600 * 1e3;
+function isUnchangedSinceIndexed(workspace, fp, cursor, now = Date.now()) {
+  const e = cursor[workspace];
+  return !!fp && !!e && e.fp === fp && now - e.at < UNCHANGED_RESEND_MS;
+}
 function orderByStaleness(workspaces, cursor = readCursor()) {
-  return workspaces.map((w, i) => ({ w, i, at: cursor[w] ?? -1 })).sort((a, b) => a.at - b.at || a.i - b.i).map((e) => e.w);
+  return workspaces.map((w, i) => ({ w, i, at: cursor[w]?.at ?? -1 })).sort((a, b) => a.at - b.at || a.i - b.i).map((e) => e.w);
 }
 function pruneCursor(known) {
   const keep = new Set(known);
@@ -23732,7 +23983,7 @@ init_telemetry();
 // src/self-restart.ts
 import { spawn } from "child_process";
 import { readFileSync as readFileSync41 } from "fs";
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 var EXIT_CODE_CODE_CHANGED = 75;
 function codeFingerprint(entry = process.argv[1]) {
   if (!entry) return null;
@@ -23741,7 +23992,7 @@ function codeFingerprint(entry = process.argv[1]) {
     return {
       path: entry,
       size: buf.byteLength,
-      hash: createHash10("sha256").update(buf).digest("hex")
+      hash: createHash11("sha256").update(buf).digest("hex")
     };
   } catch {
     return null;
@@ -23804,11 +24055,11 @@ function checkSelfRestart(opts) {
 }
 
 // src/log-rotate.ts
-import { statSync as statSync41, copyFileSync as copyFileSync3, truncateSync } from "fs";
+import { statSync as statSync42, copyFileSync as copyFileSync3, truncateSync } from "fs";
 var LOG_MAX_BYTES = 32 * 1024 * 1024;
 function rotateLogIfLarge(logPath, maxBytes = LOG_MAX_BYTES) {
   try {
-    const size = statSync41(logPath).size;
+    const size = statSync42(logPath).size;
     if (size < maxBytes) return { rotated: false, sizeBefore: 0 };
     copyFileSync3(logPath, `${logPath}.1`);
     truncateSync(logPath, 0);
@@ -23820,8 +24071,8 @@ function rotateLogIfLarge(logPath, maxBytes = LOG_MAX_BYTES) {
 
 // src/collector-migrate.ts
 init_http();
-import { existsSync as existsSync46 } from "node:fs";
-function selectProjectsToReindex(projects, current, existsFn = existsSync46) {
+import { existsSync as existsSync47 } from "node:fs";
+function selectProjectsToReindex(projects, current, existsFn = existsSync47) {
   const reindex = [];
   const missing = [];
   for (const p of projects) {
@@ -23863,8 +24114,8 @@ async function runCollectorMigration(opts) {
 // auto-indexer/indexer.ts
 init_sync_ledger();
 init_collector_health();
-import { existsSync as existsSync49, readFileSync as readFileSync45, statSync as statSync44 } from "fs";
-var CLI_VERSION3 = true ? "0.7.0" : "0.0.0";
+import { existsSync as existsSync50, readFileSync as readFileSync45, statSync as statSync45 } from "fs";
+var CLI_VERSION3 = true ? "0.7.2" : "0.0.0";
 var DEBOUNCE_MS = 5e3;
 var CLAUDE_DIR = claudeBackend.projectsDir();
 var PLANS_DIR = claudeBackend.plansDir();
@@ -23969,7 +24220,7 @@ var WATCH_WINDOW_MS = Math.max(1, Number(process.env.CHAT_RECALL_WATCH_WINDOW_DA
 var sessionWatcher = watchWithFallback("sessions", `${CLAUDE_DIR}/**/*.jsonl`, {
   ignored: (p, stats) => {
     if (/agent-/.test(p) || /^\./.test(basename25(p))) return true;
-    const st = stats ?? statSync44(p, { throwIfNoEntry: false });
+    const st = stats ?? statSync45(p, { throwIfNoEntry: false });
     if (!st || st.isDirectory()) return false;
     return st.mtimeMs < Date.now() - WATCH_WINDOW_MS;
   },
@@ -24249,7 +24500,7 @@ function discoverWorkspaces() {
   for (const b of listAvailableBackends()) {
     let refs = [];
     try {
-      refs = b.listSessions({ sinceMs });
+      refs = b.listSessions({ sinceMs, previews: false });
     } catch {
     }
     for (const r of refs) {
@@ -24269,7 +24520,7 @@ function discoverWorkspaces() {
   const isExcluded = (p) => excluded.some((x) => p.includes(x));
   const candidates2 = [...newest.entries()].filter(([p]) => !isExcluded(p)).filter(([p]) => !isPersonalPath(p, includeProjects)).filter(([p]) => {
     try {
-      return existsSync49(p);
+      return existsSync50(p);
     } catch {
       return false;
     }
@@ -24301,7 +24552,7 @@ function isCodeWorkspace(p) {
   }
   return WORKSPACE_MARKERS.some((m) => {
     try {
-      return existsSync49(join54(p, m));
+      return existsSync50(join54(p, m));
     } catch {
       return false;
     }
@@ -24317,7 +24568,7 @@ async function codeIndexTick() {
     if (discovered.length === 0) return;
     pruneCursor(discovered);
     const workspaces = orderByStaleness(discovered);
-    const { collectCode: collectCode2, resolveCodeindexBin: resolveCodeindexBin2 } = await Promise.resolve().then(() => (init_collector(), collector_exports));
+    const { collectCode: collectCode2, resolveCodeindexBin: resolveCodeindexBin2, COLLECTOR_VERSION: COLLECTOR_VERSION2 } = await Promise.resolve().then(() => (init_collector(), collector_exports));
     let bin;
     try {
       bin = await resolveCodeindexBin2(true);
@@ -24325,8 +24576,14 @@ async function codeIndexTick() {
       daemonLog.error(`code intelligence skipped \u2014 codeindex unavailable: ${e instanceof Error ? e.message : e}`);
       return;
     }
-    let ok = 0;
+    let ok = 0, unchanged = 0;
+    const cursor = readCursor();
     for (const ws of workspaces) {
+      const fp = workspaceFingerprint(ws, COLLECTOR_VERSION2);
+      if (isUnchangedSinceIndexed(ws, fp, cursor)) {
+        unchanged++;
+        continue;
+      }
       const t0 = Date.now();
       daemonLog.info(`code intelligence: indexing ${ws} \u2026`);
       let result;
@@ -24344,10 +24601,10 @@ async function codeIndexTick() {
         } catch {
         }
       }
-      noteIndexed(ws);
+      noteIndexed(ws, Date.now(), fp);
       ok++;
     }
-    if (ok > 0) daemonLog.info(`code intelligence: indexed ${ok}/${workspaces.length} workspace(s)`);
+    if (ok > 0 || unchanged > 0) daemonLog.info(`code intelligence: indexed ${ok}/${workspaces.length} workspace(s), ${unchanged} unchanged`);
   } finally {
     codeIndexInFlight = false;
   }