chat-recall 0.7.14 → 0.7.16

package/dist/watch.js

@@ -4458,7 +4458,7 @@ var require_pino = __commonJS({
         messageKey,
         errorKey,
         nestedKey,
-        base: base2,
+        base: base3,
         name,
         level: level2,
         customLevels,
@@ -4497,11 +4497,11 @@ var require_pino = __commonJS({
         [formattersSym]: allFormatters
       });
       let chindings = "";
-      if (base2 !== null) {
+      if (base3 !== null) {
         if (name === void 0) {
-          chindings = coreChindings(base2);
+          chindings = coreChindings(base3);
         } else {
-          chindings = coreChindings(Object.assign({}, base2, { name }));
+          chindings = coreChindings(Object.assign({}, base3, { name }));
         }
       }
       const time2 = timestamp instanceof Function ? timestamp : timestamp ? epochTime : nullTime;
@@ -4881,57 +4881,57 @@ function freshDefaults() {
     team: defaultTeam()
   };
 }
-function mergeSources(base2, partial) {
+function mergeSources(base3, partial) {
   if (!partial)
-    return base2;
+    return base3;
   const legacyGemini = partial.enabled?.gemini;
   const inherited = legacyGemini && typeof legacyGemini === "object" ? (({ sessions: _s, plans: _p, ...rest }) => rest)(legacyGemini) : {};
   const enabled = {
-    claude: { ...base2.enabled.claude, ...partial.enabled?.claude ?? {} },
-    opencode: { ...base2.enabled.opencode, ...partial.enabled?.opencode ?? {} },
-    codex: { ...base2.enabled.codex, ...partial.enabled?.codex ?? {} },
-    agy: { ...base2.enabled.agy, ...inherited, ...partial.enabled?.agy ?? {} },
-    cursor: { ...base2.enabled.cursor, ...partial.enabled?.cursor ?? {} },
-    shared: { ...base2.enabled.shared, ...partial.enabled?.shared ?? {} },
-    common: { ...base2.enabled.common, ...partial.enabled?.common ?? {} }
+    claude: { ...base3.enabled.claude, ...partial.enabled?.claude ?? {} },
+    opencode: { ...base3.enabled.opencode, ...partial.enabled?.opencode ?? {} },
+    codex: { ...base3.enabled.codex, ...partial.enabled?.codex ?? {} },
+    agy: { ...base3.enabled.agy, ...inherited, ...partial.enabled?.agy ?? {} },
+    cursor: { ...base3.enabled.cursor, ...partial.enabled?.cursor ?? {} },
+    shared: { ...base3.enabled.shared, ...partial.enabled?.shared ?? {} },
+    common: { ...base3.enabled.common, ...partial.enabled?.common ?? {} }
   };
   return {
-    claudeHome: partial.claudeHome ?? base2.claudeHome,
-    geminiHome: partial.geminiHome ?? base2.geminiHome,
-    codexHome: partial.codexHome ?? base2.codexHome,
-    opencodeDbPath: partial.opencodeDbPath ?? base2.opencodeDbPath,
-    agyHome: partial.agyHome ?? base2.agyHome,
-    cursorHome: partial.cursorHome ?? base2.cursorHome,
-    cursorIdeHome: partial.cursorIdeHome ?? base2.cursorIdeHome,
-    extraClaudeHomes: partial.extraClaudeHomes ?? base2.extraClaudeHomes,
-    approvedHomes: partial.approvedHomes ?? base2.approvedHomes,
-    declinedHomes: partial.declinedHomes ?? base2.declinedHomes,
-    homesGrandfathered: partial.homesGrandfathered ?? base2.homesGrandfathered,
+    claudeHome: partial.claudeHome ?? base3.claudeHome,
+    geminiHome: partial.geminiHome ?? base3.geminiHome,
+    codexHome: partial.codexHome ?? base3.codexHome,
+    opencodeDbPath: partial.opencodeDbPath ?? base3.opencodeDbPath,
+    agyHome: partial.agyHome ?? base3.agyHome,
+    cursorHome: partial.cursorHome ?? base3.cursorHome,
+    cursorIdeHome: partial.cursorIdeHome ?? base3.cursorIdeHome,
+    extraClaudeHomes: partial.extraClaudeHomes ?? base3.extraClaudeHomes,
+    approvedHomes: partial.approvedHomes ?? base3.approvedHomes,
+    declinedHomes: partial.declinedHomes ?? base3.declinedHomes,
+    homesGrandfathered: partial.homesGrandfathered ?? base3.homesGrandfathered,
     enabled
   };
 }
-function mergePrivacy(base2, partial) {
+function mergePrivacy(base3, partial) {
   if (!partial)
-    return base2;
-  return { ...base2, ...partial };
+    return base3;
+  return { ...base3, ...partial };
 }
-function mergeSync(base2, partial) {
+function mergeSync(base3, partial) {
   if (!partial)
-    return base2;
+    return base3;
   return {
-    ...base2,
+    ...base3,
     ...partial,
-    upload: { ...base2.upload, ...partial.upload ?? {} }
+    upload: { ...base3.upload, ...partial.upload ?? {} }
   };
 }
-function mergeTeam(base2, partial) {
+function mergeTeam(base3, partial) {
   if (!partial)
-    return base2;
+    return base3;
   return {
-    ...base2,
+    ...base3,
     ...partial,
-    publishAllowed: { ...base2.publishAllowed, ...partial.publishAllowed ?? {} },
-    vault: { ...base2.vault, ...partial.vault ?? {} }
+    publishAllowed: { ...base3.publishAllowed, ...partial.publishAllowed ?? {} },
+    vault: { ...base3.vault, ...partial.vault ?? {} }
   };
 }
 function settingsFilePath() {
@@ -5040,15 +5040,15 @@ function loadSettings() {
   }
   try {
     const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    const base2 = freshDefaults();
+    const base3 = freshDefaults();
     const result = {
       v: SCHEMA_VERSION,
-      embedding: { ...base2.embedding, ...parsed.embedding ?? {} },
-      summary: { ...base2.summary, ...parsed.summary ?? {} },
-      sources: mergeSources(base2.sources, parsed.sources),
-      privacy: mergePrivacy(base2.privacy, parsed.privacy),
-      sync: mergeSync(base2.sync, parsed.sync),
-      team: mergeTeam(base2.team, parsed.team)
+      embedding: { ...base3.embedding, ...parsed.embedding ?? {} },
+      summary: { ...base3.summary, ...parsed.summary ?? {} },
+      sources: mergeSources(base3.sources, parsed.sources),
+      privacy: mergePrivacy(base3.privacy, parsed.privacy),
+      sync: mergeSync(base3.sync, parsed.sync),
+      team: mergeTeam(base3.team, parsed.team)
     };
     if (mtimeMs >= 0)
       _settingsCache = { mtimeMs, size, value: structuredClone(result) };
@@ -5154,10 +5154,10 @@ function legacyAutoSyncedHomes() {
     { base: join3(home, ".local", "share", "opencode"), marker: "opencode.db" },
     { base: join3(home, ".cursor"), marker: "chats" }
   ];
-  for (const { base: base2, marker } of bases) {
-    add(base2, marker);
-    const parent = dirname3(base2);
-    const leaf = base2.slice(parent.length + 1);
+  for (const { base: base3, marker } of bases) {
+    add(base3, marker);
+    const parent = dirname3(base3);
+    const leaf = base3.slice(parent.length + 1);
     try {
       for (const e of readdirSync2(parent, { withFileTypes: true })) {
         if (!e.isDirectory())
@@ -5338,17 +5338,17 @@ function cursorHomeDir() {
 function cursorIdeHomeDir() {
   return process.env.CHAT_RECALL_CURSOR_IDE_HOME || sources().cursorIdeHome || (process.platform === "darwin" ? join4(homedir3(), "Library", "Application Support", "Cursor") : join4(homedir3(), ".config", "Cursor"));
 }
-function siblingHomes(base2, overridden, suffix) {
+function siblingHomes(base3, overridden, suffix) {
   const roots = [];
   const add = (home) => {
     const root = suffix ? join4(home, suffix) : home;
     if (existsSync4(root) && !roots.includes(root))
       roots.push(root);
   };
-  add(base2);
+  add(base3);
   if (!overridden) {
-    const parent = dirname4(base2);
-    const leaf = basename(base2);
+    const parent = dirname4(base3);
+    const leaf = basename(base3);
     try {
       for (const entry of readdirSync3(parent, { withFileTypes: true })) {
         if (!entry.isDirectory())
@@ -5844,9 +5844,9 @@ async function parseSessionFile(sessionPath, maxMessages = 50) {
           content.metadata.durationMs += obj.durationMs;
         }
         if (msgType === "file-history-snapshot") {
-          const snapshot = obj.snapshot;
-          if (snapshot && typeof snapshot === "object") {
-            const backups = snapshot.trackedFileBackups;
+          const snapshot2 = obj.snapshot;
+          if (snapshot2 && typeof snapshot2 === "object") {
+            const backups = snapshot2.trackedFileBackups;
             if (backups && typeof backups === "object") {
               for (const filePath2 of Object.keys(backups)) {
                 filesModified.add(filePath2);
@@ -7973,7 +7973,64 @@ var init_first_prompt = __esm({
 });
 
 // ../engine/dist/core/backends/tail-read.js
-import { openSync as openSync5, readSync as readSync5, closeSync as closeSync5, statSync as statSync6 } from "node:fs";
+import { openSync as openSync5, readSync as readSync5, closeSync as closeSync5, statSync as statSync6, fstatSync } from "node:fs";
+function readAt(fd, pos, len) {
+  const buf = Buffer.alloc(len);
+  let got = 0;
+  while (got < len) {
+    const n = readSync5(fd, buf, got, len - got, pos + got);
+    if (n <= 0)
+      break;
+    got += n;
+  }
+  return buf.subarray(0, got);
+}
+function linesBeforeOffset(path, offset) {
+  if (offset <= 0)
+    return 0;
+  let fd = null;
+  try {
+    fd = openSync5(path, "r");
+    const ino = fstatSync(fd).ino;
+    const known = lineCounts.get(path);
+    let pos = 0;
+    let lines = 0;
+    if (known && known.ino === ino && known.offset <= offset) {
+      const edgeStart2 = Math.max(0, known.offset - EDGE_BYTES);
+      if (readAt(fd, edgeStart2, known.offset - edgeStart2).equals(known.edge)) {
+        pos = known.offset;
+        lines = known.lines;
+      }
+    }
+    const block = Buffer.allocUnsafe(SKIP_SCAN_BYTES);
+    while (pos < offset) {
+      const n = readSync5(fd, block, 0, Math.min(SKIP_SCAN_BYTES, offset - pos), pos);
+      if (n <= 0)
+        return void 0;
+      for (let i = block.indexOf(10, 0); i >= 0 && i < n; i = block.indexOf(10, i + 1))
+        lines++;
+      pos += n;
+    }
+    const edgeStart = Math.max(0, offset - EDGE_BYTES);
+    const edge = readAt(fd, edgeStart, offset - edgeStart);
+    if (lineCounts.size >= LINE_COUNT_CACHE_MAX && !lineCounts.has(path)) {
+      const oldest = lineCounts.keys().next().value;
+      if (oldest !== void 0)
+        lineCounts.delete(oldest);
+    }
+    lineCounts.set(path, { offset, lines, ino, edge });
+    return lines;
+  } catch {
+    return void 0;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync5(fd);
+      } catch {
+      }
+    }
+  }
+}
 function readTailFromOffset(path, offset, maxBytes = TAIL_READ_MAX_BYTES) {
   let size = 0;
   try {
@@ -8001,7 +8058,7 @@ function readTailFromOffset(path, offset, maxBytes = TAIL_READ_MAX_BYTES) {
     const lastNl = slice.lastIndexOf(10);
     if (lastNl >= 0) {
       const text = slice.subarray(0, lastNl + 1).toString("utf-8");
-      return { text, newOffset: offset + lastNl + 1 };
+      return { text, newOffset: offset + lastNl + 1, baseLine: linesBeforeOffset(path, offset) };
     }
     if (offset + got >= size)
       return { text: "", newOffset: offset };
@@ -8034,12 +8091,15 @@ function findNewline(fd, from, size) {
   }
   return -1;
 }
-var TAIL_READ_MAX_BYTES, SKIP_SCAN_BYTES;
+var TAIL_READ_MAX_BYTES, SKIP_SCAN_BYTES, lineCounts, LINE_COUNT_CACHE_MAX, EDGE_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;
+    lineCounts = /* @__PURE__ */ new Map();
+    LINE_COUNT_CACHE_MAX = 2048;
+    EDGE_BYTES = 64;
   }
 });
 
@@ -12280,8 +12340,8 @@ function serverRulePackVersion() {
   return serverPack ? serverPack.version || "unversioned" : null;
 }
 function activeRules() {
-  const base2 = settingsView().rules;
-  return serverPack && serverPack.rules.length > 0 ? [...base2, ...serverPack.rules] : base2;
+  const base3 = settingsView().rules;
+  return serverPack && serverPack.rules.length > 0 ? [...base3, ...serverPack.rules] : base3;
 }
 function isRedactionEnabled() {
   const env = isEnvRedactionRequested();
@@ -18064,7 +18124,7 @@ __export(sync_ledger_exports, {
   syncMode: () => syncMode,
   unackedCursorAttemptCount: () => unackedCursorAttemptCount
 });
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync6, renameSync as renameSync4, mkdirSync as mkdirSync7 } from "node:fs";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync6, renameSync as renameSync4, mkdirSync as mkdirSync7, statSync as statSync35 } from "node:fs";
 import { join as join39, dirname as dirname16 } from "node:path";
 function toRow(entry) {
   if (entry === void 0) return void 0;
@@ -18073,32 +18133,94 @@ function toRow(entry) {
 function ledgerFilePath() {
   return ledgerPath();
 }
-function load() {
-  if (cache3) return cache3;
+function stampOf(path) {
+  try {
+    const st = statSync35(path);
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return null;
+  }
+}
+function readDisk(path) {
   try {
-    const parsed = JSON.parse(readFileSync30(ledgerPath(), "utf-8"));
-    cache3 = parsed && typeof parsed === "object" ? parsed : {};
+    const parsed = JSON.parse(readFileSync30(path, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
-    cache3 = {};
+    return {};
+  }
+}
+function snapshot(data) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [server, rows] of Object.entries(data)) {
+    for (const [id, entry] of Object.entries(rows)) out.set(rowKey(server, id), JSON.stringify(entry));
+  }
+  return out;
+}
+function mergeOnto(disk) {
+  const out = {};
+  const put = (server, id, entry) => {
+    (out[server] ??= {})[id] = entry;
+  };
+  const mine = cache3 ?? {};
+  for (const [server, rows] of Object.entries(disk)) {
+    for (const [id, entry] of Object.entries(rows)) {
+      const k = rowKey(server, id);
+      const own = mine[server]?.[id];
+      const was = base.get(k);
+      if (own === void 0) {
+        if (was === void 0) put(server, id, entry);
+      } else {
+        put(server, id, JSON.stringify(own) === was ? entry : own);
+      }
+    }
+  }
+  for (const [server, rows] of Object.entries(mine)) {
+    for (const [id, entry] of Object.entries(rows)) {
+      if (disk[server]?.[id] !== void 0) continue;
+      if (JSON.stringify(entry) !== base.get(rowKey(server, id))) put(server, id, entry);
+    }
   }
+  return out;
+}
+function load() {
+  const path = ledgerPath();
+  const stamp2 = stampOf(path);
+  if (cache3 && stamp2 === diskStamp) return cache3;
+  const disk = readDisk(path);
+  const merged = cache3 ? mergeOnto(disk) : disk;
+  if (cache3) {
+    for (const server of Object.keys(cache3)) if (!(server in merged)) delete cache3[server];
+    for (const [server, rows] of Object.entries(merged)) {
+      const target = cache3[server] ?? (cache3[server] = {});
+      for (const id of Object.keys(target)) if (!(id in rows)) delete target[id];
+      Object.assign(target, rows);
+    }
+  } else {
+    cache3 = merged;
+  }
+  base = snapshot(disk);
+  diskStamp = stamp2;
   return cache3;
 }
-function persistNow(data) {
+function persistNow() {
   const path = ledgerPath();
   mkdirSync7(dirname16(path), { recursive: true });
-  const tmp = `${path}.tmp`;
-  writeFileSync6(tmp, JSON.stringify(data));
+  load();
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync6(tmp, JSON.stringify(cache3 ?? {}));
   renameSync4(tmp, path);
+  base = snapshot(cache3 ?? {});
+  diskStamp = stampOf(path);
   pendingWrite = false;
 }
-function persist(data) {
+function persist(_data) {
   pendingWrite = true;
   if (flushTimer) return;
   flushTimer = setTimeout(() => {
     flushTimer = null;
     if (pendingWrite) {
       try {
-        persistNow(data);
+        persistNow();
       } catch {
       }
     }
@@ -18132,7 +18254,7 @@ function pruneLedgerTargets(configuredServers) {
   }
   const rows = names.reduce((n, s) => n + Object.keys(orphans[s]).length, 0);
   console.error(`[sync] tidied local bookkeeping: ${rows} already-synced marker(s) for ${names.length} server(s) you no longer sync to (${names.join(", ")}) moved to ${side}. Nothing was uploaded there; the file is kept so logging back in re-ships nothing.`);
-  persistNow(data);
+  persistNow();
   return names.length;
 }
 function flushLedger() {
@@ -18141,7 +18263,7 @@ function flushLedger() {
     flushTimer = null;
   }
   if (!pendingWrite || !cache3) return;
-  persistNow(cache3);
+  persistNow();
 }
 function loadItemVersionsAll() {
   if (itemVersionsCache) return itemVersionsCache;
@@ -18207,6 +18329,7 @@ function persistLedgerData(server, serverData) {
   const data = load();
   data[server] = serverData;
   persist(data);
+  flushLedger();
 }
 function unackedCursorAttemptCount() {
   return unackedCursorAttempts;
@@ -18229,13 +18352,13 @@ function markSynced(server, rows) {
     const o = (cursorFromCaller ? r.offset : void 0) ?? prevOS.o ?? 0;
     const s = (cursorFromCaller ? r.size : void 0) ?? prevOS.s ?? 0;
     const ev = extractorVersionForId(r.id);
-    const base2 = prevF ? { m: Math.floor(r.mtime), v: ev, f: prevF } : { m: Math.floor(r.mtime), v: ev };
+    const base3 = prevF ? { m: Math.floor(r.mtime), v: ev, f: prevF } : { m: Math.floor(r.mtime), v: ev };
     if (o > 0 || s > 0) {
-      base2.o = o;
-      base2.s = s;
+      base3.o = o;
+      base3.s = s;
     }
-    if (r.hash !== void 0) base2.h = r.hash;
-    forServer[r.id] = base2;
+    if (r.hash !== void 0) base3.h = r.hash;
+    forServer[r.id] = base3;
   }
   persist(data);
 }
@@ -18304,6 +18427,8 @@ function forceFieldRescan(fieldName, server) {
 function _resetLedgerCacheForTests() {
   flushLedger();
   cache3 = null;
+  base = /* @__PURE__ */ new Map();
+  diskStamp = null;
   reconcileCache = null;
 }
 function markFullResync(server, sessionId) {
@@ -18325,7 +18450,7 @@ function syncMode(row, mtime, fileSize, extractorVersion, isAppendOnly) {
   if (row.m >= Math.floor(mtime)) return "skip";
   return "full";
 }
-var ledgerPath, cache3, LEDGER_FLUSH_MS, pendingWrite, flushTimer, itemVersionsPath, itemVersionsCache, inventoryPath, unackedCursorAttempts, reconcilePath, reconcileCache;
+var ledgerPath, cache3, base, diskStamp, rowKey, LEDGER_FLUSH_MS, pendingWrite, flushTimer, itemVersionsPath, itemVersionsCache, inventoryPath, unackedCursorAttempts, reconcilePath, reconcileCache;
 var init_sync_ledger = __esm({
   "src/sync-ledger.ts"() {
     "use strict";
@@ -18333,6 +18458,9 @@ var init_sync_ledger = __esm({
     init_extractor_version();
     ledgerPath = () => join39(getDataDir(), "sync-ledger.json");
     cache3 = null;
+    base = /* @__PURE__ */ new Map();
+    diskStamp = null;
+    rowKey = (server, id) => `${server}\0${id}`;
     LEDGER_FLUSH_MS = 2e3;
     pendingWrite = false;
     flushTimer = null;
@@ -18371,7 +18499,7 @@ var init_sync_fields = __esm({
 });
 
 // ../engine/dist/core/index-lock.js
-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 { existsSync as existsSync39, mkdirSync as mkdirSync8, openSync as openSync8, writeFileSync as writeFileSync7, readFileSync as readFileSync31, rmSync as rmSync4, statSync as statSync36, closeSync as closeSync8 } from "fs";
 import { dirname as dirname17, join as join40 } from "path";
 function acquireIndexLock(opts) {
   const lockPath = lockFilePath(opts.file);
@@ -18421,7 +18549,7 @@ function lockFilePath(file = ".compact.lock") {
 }
 function stealStaleLock(lockPath, staleAfterMs) {
   try {
-    const s = statSync35(lockPath);
+    const s = statSync36(lockPath);
     const age = Date.now() - s.mtimeMs;
     let payload;
     try {
@@ -18484,7 +18612,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.14";
+        if (true) CLI_VERSION = "0.7.16";
       } catch {
       }
     }
@@ -18978,7 +19106,7 @@ var init_telemetry = __esm({
     init_sync_client();
     cliVersion = () => {
       try {
-        return true ? "0.7.14" : "dev";
+        return true ? "0.7.16" : "dev";
       } catch {
         return "dev";
       }
@@ -19001,11 +19129,11 @@ __export(server_probe_exports, {
 function probeOk(r) {
   return r.kind === "ok" && r.apiVersion >= 2;
 }
-async function probeServer(base2, opts = {}) {
+async function probeServer(base3, opts = {}) {
   const f = opts.fetchImpl || fetch;
   let res;
   try {
-    res = await f(`${base2.replace(/\/+$/, "")}/api/capabilities`, {
+    res = await f(`${base3.replace(/\/+$/, "")}/api/capabilities`, {
       signal: AbortSignal.timeout(opts.timeoutMs ?? 1e4)
     });
   } catch (err) {
@@ -19042,34 +19170,34 @@ async function probeServer(base2, opts = {}) {
     raw: parsed
   };
 }
-function probeAdvice(r, base2) {
+function probeAdvice(r, base3) {
   switch (r.kind) {
     case "ok":
       return r.apiVersion >= 2 ? `apiVersion ${r.apiVersion}${r.edition ? `, edition ${r.edition}` : ""}` : `apiVersion ${r.apiVersion} is too old for this CLI \u2014 upgrade the server`;
     case "moved":
-      return `HTTP ${r.status} \u2014 nothing is served at ${base2}. If the host moved, re-point it: \`chat-recall login <new-server-url>\``;
+      return `HTTP ${r.status} \u2014 nothing is served at ${base3}. If the host moved, re-point it: \`chat-recall login <new-server-url>\``;
     case "unauthorized":
-      return `HTTP ${r.status} \u2014 ${base2} rejected the credential. Re-login: \`chat-recall login ` + base2 + "`";
+      return `HTTP ${r.status} \u2014 ${base3} rejected the credential. Re-login: \`chat-recall login ` + base3 + "`";
     case "server_error":
-      return `HTTP ${r.status} \u2014 ${base2} is up but failing. Nothing to fix locally; check the server.`;
+      return `HTTP ${r.status} \u2014 ${base3} is up but failing. Nothing to fix locally; check the server.`;
     case "not_api":
-      return `${base2} answered ${r.status} with something that is not the chat-recall API (${JSON.stringify(r.snippet)}) \u2014 check the URL, a proxy or a captive portal`;
+      return `${base3} answered ${r.status} with something that is not the chat-recall API (${JSON.stringify(r.snippet)}) \u2014 check the URL, a proxy or a captive portal`;
     case "unreachable":
       switch (r.reason) {
         case "dns":
-          return `cannot resolve the host in ${base2} (${r.error}) \u2014 check the URL for a typo, and your DNS or VPN`;
+          return `cannot resolve the host in ${base3} (${r.error}) \u2014 check the URL for a typo, and your DNS or VPN`;
         case "refused":
-          return `${base2} resolves but refused the connection (${r.error}) \u2014 the server is not running, or the port is wrong`;
+          return `${base3} resolves but refused the connection (${r.error}) \u2014 the server is not running, or the port is wrong`;
         case "tls":
-          return `the TLS certificate at ${base2} was rejected (${r.error}) \u2014 expired, self-signed, or issued for another host. A corporate proxy that re-signs traffic does this.`;
+          return `the TLS certificate at ${base3} was rejected (${r.error}) \u2014 expired, self-signed, or issued for another host. A corporate proxy that re-signs traffic does this.`;
         case "timeout":
-          return `${base2} did not answer in time (${r.error}) \u2014 a firewall or proxy that drops traffic silently looks exactly like this`;
+          return `${base3} did not answer in time (${r.error}) \u2014 a firewall or proxy that drops traffic silently looks exactly like this`;
         case "reset":
-          return `the connection to ${base2} was cut (${r.error}) \u2014 often a proxy or a captive portal`;
+          return `the connection to ${base3} was cut (${r.error}) \u2014 often a proxy or a captive portal`;
         case "bad_port":
-          return `${base2} names a port that Node and every browser refuse to open (the WHATWG bad-port list) \u2014 use the server's real port`;
+          return `${base3} names a port that Node and every browser refuse to open (the WHATWG bad-port list) \u2014 use the server's real port`;
         default:
-          return `no HTTP response from ${base2} (${r.error}) \u2014 check the URL, DNS, or that the server is running`;
+          return `no HTTP response from ${base3} (${r.error}) \u2014 check the URL, DNS, or that the server is running`;
       }
   }
 }
@@ -19102,8 +19230,8 @@ function describeCause(err) {
     const code = e.code;
     if (typeof code === "string" && code && !parts.includes(code)) parts.push(code);
   }
-  const base2 = err instanceof Error ? err.message : String(err);
-  return parts.length ? `${base2}: ${parts.join(" \u2192 ")}` : base2;
+  const base3 = err instanceof Error ? err.message : String(err);
+  return parts.length ? `${base3}: ${parts.join(" \u2192 ")}` : base3;
 }
 function describeUnreachable(err) {
   const reason = classifyUnreachable(err);
@@ -19216,7 +19344,7 @@ __export(auto_update_exports, {
 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 readdirSync30, statSync as statSync36, mkdirSync as mkdirSync9 } from "node:fs";
+import { writeFileSync as writeFileSync8, mkdtempSync as mkdtempSync3, rmSync as rmSync5, readdirSync as readdirSync30, statSync as statSync37, mkdirSync as mkdirSync9 } from "node:fs";
 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";
@@ -19248,12 +19376,12 @@ function installedVersion() {
     return null;
   }
 }
-function planAutoUpdate(base2, caps, ownVersion3, flag) {
+function planAutoUpdate(base3, caps, ownVersion3, flag) {
   const rel = caps.cli;
   if (!rel || !rel.version || !rel.sha256) return { update: false, reason: "server advertises no CLI release" };
   if (!isAutoUpdateEnabled(caps.edition, flag)) return { update: false, reason: `auto-update disabled (edition ${caps.edition ?? "?"})` };
   if (compareVersions(rel.version, ownVersion3) <= 0) return { update: false, reason: `already current (own ${ownVersion3} >= server ${rel.version})` };
-  return { update: true, reason: `server ${rel.version} > own ${ownVersion3}`, url: tarballUrl(base2, rel.version), fallbackUrl: tarballUrl(base2), sha256: rel.sha256, from: ownVersion3, to: rel.version };
+  return { update: true, reason: `server ${rel.version} > own ${ownVersion3}`, url: tarballUrl(base3, rel.version), fallbackUrl: tarballUrl(base3), sha256: rel.sha256, from: ownVersion3, to: rel.version };
 }
 function sweepStaleStaging(root = tmpdir2(), now = Date.now()) {
   const MKDTEMP_SUFFIX = /^cr-update-.{6}$/s;
@@ -19269,7 +19397,7 @@ function sweepStaleStaging(root = tmpdir2(), now = Date.now()) {
     if (!MKDTEMP_SUFFIX.test(name)) continue;
     const dir = join41(root, name);
     try {
-      const st = statSync36(dir);
+      const st = statSync37(dir);
       if (!st.isDirectory() || now - st.mtimeMs < COLD_MS) continue;
       const inside = readdirSync30(dir);
       if (inside.length > 1 || inside.length === 1 && inside[0] !== "chat-recall.tgz") continue;
@@ -19433,20 +19561,20 @@ function clearUpdateFailures() {
 function stopAutoUpdates() {
   stopRequested = true;
 }
-async function runAutoUpdate(base2, authHeaders, ownVersion3, deps) {
+async function runAutoUpdate(base3, authHeaders, ownVersion3, deps) {
   let caps;
   try {
-    const res = await fetchWithTimeout(`${base2.replace(/\/+$/, "")}/api/capabilities`, { headers: authHeaders });
+    const res = await fetchWithTimeout(`${base3.replace(/\/+$/, "")}/api/capabilities`, { headers: authHeaders });
     if (!res.ok) return { updated: false, reason: `capabilities HTTP ${res.status}` };
     caps = await res.json();
   } catch (e) {
     return { updated: false, reason: `capabilities unreachable: ${e instanceof Error ? e.message : e}` };
   }
   const effectiveOwn = newerOf(ownVersion3, installedVersion());
-  const plan = planAutoUpdate(base2, caps, effectiveOwn, process.env.CHAT_RECALL_AUTO_UPDATE);
+  const plan = planAutoUpdate(base3, caps, effectiveOwn, process.env.CHAT_RECALL_AUTO_UPDATE);
   if (!plan.update) {
-    if (/disabled|no CLI release/.test(plan.reason) && !reportedStandingSkip.has(base2)) {
-      reportedStandingSkip.add(base2);
+    if (/disabled|no CLI release/.test(plan.reason) && !reportedStandingSkip.has(base3)) {
+      reportedStandingSkip.add(base3);
       try {
         const { reportClientEvent: reportClientEvent2 } = await Promise.resolve().then(() => (init_client_events(), client_events_exports));
         reportClientEvent2("auto_update_skipped", { message: `${plan.reason} (server offers ${caps.cli?.version ?? "?"}, this device runs ${effectiveOwn})` });
@@ -19502,7 +19630,7 @@ var init_auto_update = __esm({
     "use strict";
     init_http();
     init_index_lock();
-    tarballUrl = (base2, version) => `${base2.replace(/\/+$/, "")}/install/${version ? `chat-recall-${version}.tgz` : "chat-recall.tgz"}`;
+    tarballUrl = (base3, version) => `${base3.replace(/\/+$/, "")}/install/${version ? `chat-recall-${version}.tgz` : "chat-recall.tgz"}`;
     GIVE_UP_AFTER = 3;
     reportedStandingSkip = /* @__PURE__ */ new Set();
     STOPPING_REASON = "not installed: this process is shutting down";
@@ -19513,7 +19641,7 @@ var init_auto_update = __esm({
 
 // src/sync-client.ts
 import { join as join42, dirname as dirname19, basename as basename20 } from "node:path";
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, rmSync as rmSync6, chmodSync as chmodSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync31, statSync as statSync37 } from "node:fs";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, rmSync as rmSync6, chmodSync as chmodSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync31, statSync as statSync38 } from "node:fs";
 import { tmpdir as tmpdir3, hostname as hostname2 } from "node:os";
 import { createHash as createHash8 } from "node:crypto";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -19558,15 +19686,15 @@ function loadAllCredentials() {
   return [];
 }
 async function fetchTenantSecurityConfig(cred) {
-  const base2 = cred.serverUrl.replace(/\/+$/, "");
-  const cached = _securityConfigCache.get(base2);
+  const base3 = cred.serverUrl.replace(/\/+$/, "");
+  const cached = _securityConfigCache.get(base3);
   if (cached && Date.now() - cached.fetchedAt < SECURITY_CONFIG_TTL_MS) return cached.config;
   const headers = { "content-type": "application/json" };
   if (cred.token) headers.authorization = `Bearer ${cred.token}`;
   try {
     const [rulesRes, settingsRes] = await Promise.all([
-      fetchWithTimeout(`${base2}/api/secrets/rules`, { headers }),
-      fetchWithTimeout(`${base2}/api/teams/security-config`, { headers }).catch(() => null)
+      fetchWithTimeout(`${base3}/api/secrets/rules`, { headers }),
+      fetchWithTimeout(`${base3}/api/teams/security-config`, { headers }).catch(() => null)
     ]);
     let tenantRules = [];
     let rulePackVersion = null;
@@ -19591,18 +19719,18 @@ async function fetchTenantSecurityConfig(cred) {
       const body = await settingsRes.json().catch(() => ({}));
       if (typeof body.verifySecrets === "boolean") verifySecrets = body.verifySecrets;
       if (typeof body.telemetry === "boolean") {
-        setTelemetryEligible(base2, body.telemetry);
+        setTelemetryEligible(base3, body.telemetry);
         try {
           const prior = readCollectorHealth()?.telemetryEligible ?? {};
           updateCollectorHealth({
-            telemetryEligible: { ...prior, [base2]: { allowed: body.telemetry, at: Date.now() } }
+            telemetryEligible: { ...prior, [base3]: { allowed: body.telemetry, at: Date.now() } }
           });
         } catch {
         }
       }
     }
     const config = { tenantRules, verifySecrets, rulePackVersion };
-    _securityConfigCache.set(base2, { fetchedAt: Date.now(), config });
+    _securityConfigCache.set(base3, { fetchedAt: Date.now(), config });
     return config;
   } catch {
     return { tenantRules: [], verifySecrets: true, rulePackVersion: null };
@@ -19618,18 +19746,18 @@ function readPersistedSyncConfigs() {
     return {};
   }
 }
-function persistSyncConfig(base2, config) {
+function persistSyncConfig(base3, config) {
   try {
     const all = readPersistedSyncConfigs();
-    all[base2] = { fetchedAt: Date.now(), config };
+    all[base3] = { fetchedAt: Date.now(), config };
     mkdirSync10(dirname19(syncConfigCachePath()), { recursive: true });
     writeFileSync9(syncConfigCachePath(), JSON.stringify(all, null, 2));
   } catch {
   }
 }
 async function fetchTenantSyncConfig(cred) {
-  const base2 = cred.serverUrl.replace(/\/+$/, "");
-  const cached = _syncConfigCache.get(base2);
+  const base3 = cred.serverUrl.replace(/\/+$/, "");
+  const cached = _syncConfigCache.get(base3);
   if (cached && Date.now() - cached.fetchedAt < SECURITY_CONFIG_TTL_MS) return cached.config;
   const headers = { "content-type": "application/json" };
   if (cred.token) headers.authorization = `Bearer ${cred.token}`;
@@ -19637,7 +19765,7 @@ async function fetchTenantSyncConfig(cred) {
     try {
       const sources2 = discoverSessionSources();
       if (sources2.length > 0) {
-        await fetchWithTimeout(`${base2}/api/sync-config/sources`, {
+        await fetchWithTimeout(`${base3}/api/sync-config/sources`, {
           method: "POST",
           headers,
           body: JSON.stringify({ device: deviceLabel(), sources: sources2 })
@@ -19645,12 +19773,12 @@ async function fetchTenantSyncConfig(cred) {
       }
     } catch {
     }
-    const res = await fetchWithTimeout(`${base2}/api/sync-config`, { headers });
+    const res = await fetchWithTimeout(`${base3}/api/sync-config`, { headers });
     if (res.status === 404) {
-      _syncConfigCache.set(base2, { fetchedAt: Date.now(), config: EMPTY_SYNC_CONFIG });
+      _syncConfigCache.set(base3, { fetchedAt: Date.now(), config: EMPTY_SYNC_CONFIG });
       return EMPTY_SYNC_CONFIG;
     }
-    if (!res.ok) return lastKnownSyncConfig(base2, `HTTP ${res.status}`);
+    if (!res.ok) return lastKnownSyncConfig(base3, `HTTP ${res.status}`);
     const body = await res.json().catch(() => ({}));
     const config = {
       excludeTools: Array.isArray(body.excludeTools) ? body.excludeTools.filter((t) => typeof t === "string") : [],
@@ -19687,22 +19815,22 @@ async function fetchTenantSyncConfig(cred) {
       if (decided > 0) console.error(`[sync] applied ${decided} folder decision(s) from the dashboard`);
     } catch {
     }
-    _syncConfigCache.set(base2, { fetchedAt: Date.now(), config });
-    persistSyncConfig(base2, config);
+    _syncConfigCache.set(base3, { fetchedAt: Date.now(), config });
+    persistSyncConfig(base3, config);
     return config;
   } catch (err) {
     if (isSyncRulesRefusal(err)) throw err;
-    return lastKnownSyncConfig(base2, err instanceof Error ? err.message : "request failed");
+    return lastKnownSyncConfig(base3, err instanceof Error ? err.message : "request failed");
   }
 }
-function lastKnownSyncConfig(base2, reason) {
-  const remembered = _syncConfigCache.get(base2) ?? readPersistedSyncConfigs()[base2];
+function lastKnownSyncConfig(base3, reason) {
+  const remembered = _syncConfigCache.get(base3) ?? readPersistedSyncConfigs()[base3];
   if (remembered) {
     console.error(`[sync] could not read server-side sync rules (${reason}) \u2014 applying the last known set from ${new Date(remembered.fetchedAt).toISOString()}`);
     return remembered.config;
   }
   const refusal = new Error(
-    `Cannot read the server-side sync rules from ${base2} (${reason}), and this machine has never successfully read them. Refusing to sync: uploading without knowing your exclusions could ship a project you told the dashboard to hold back. Fix the server or retry.`
+    `Cannot read the server-side sync rules from ${base3} (${reason}), and this machine has never successfully read them. Refusing to sync: uploading without knowing your exclusions could ship a project you told the dashboard to hold back. Fix the server or retry.`
   );
   refusal[SYNC_RULES_REFUSAL] = true;
   throw refusal;
@@ -19810,25 +19938,25 @@ async function syncSessions(opts = {}) {
   ${errors.join("\n  ")}`);
   return { ...agg, perTarget };
 }
-async function postFieldBatch(base2, token, rows) {
+async function postFieldBatch(base3, token, rows) {
   const headers = { "content-type": "application/json" };
   if (token) headers.authorization = `Bearer ${token}`;
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
   for (let attempt = 0; ; attempt++) {
-    const res = await fetchWithTimeout(`${base2}/api/sync`, { method: "POST", headers, body: JSON.stringify({ fields: rows }) }, 6e4);
+    const res = await fetchWithTimeout(`${base3}/api/sync`, { method: "POST", headers, body: JSON.stringify({ fields: rows }) }, 6e4);
     if (res.ok) return;
     const retryable = res.status === 429 || res.status >= 500;
-    if (!retryable || attempt >= 5) throw new Error(`${base2}: fields batch HTTP ${res.status} ${await res.text().catch(() => "")}`);
+    if (!retryable || attempt >= 5) throw new Error(`${base3}: fields batch HTTP ${res.status} ${await res.text().catch(() => "")}`);
     const ra = Number(res.headers.get("retry-after")) || 0;
     await sleep(ra > 0 ? ra * 1e3 : [500, 1500, 4e3, 8e3, 15e3][Math.min(attempt, 4)]);
   }
 }
 async function reconcileFieldsForTarget(cred, fullRefs, opts = {}) {
-  const base2 = cred.serverUrl.replace(/\/+$/, "");
-  const ledger = getSyncedRows(base2);
+  const base3 = cred.serverUrl.replace(/\/+$/, "");
+  const ledger = getSyncedRows(base3);
   let pushed = 0, absent = 0, scanned = 0;
   for (const field of SYNC_FIELDS) {
-    const needFull = !!opts.force || fieldNeedsFullPass(base2, field);
+    const needFull = !!opts.force || fieldNeedsFullPass(base3, field);
     const candidates2 = needFull ? fullRefs() : opts.convRefs ?? fullRefs();
     const send = [];
     const mtimeById = /* @__PURE__ */ new Map();
@@ -19844,15 +19972,15 @@ async function reconcileFieldsForTarget(cred, fullRefs, opts = {}) {
     }
     for (let i = 0; i < send.length; i += 200) {
       const chunk = send.slice(i, i + 200);
-      await postFieldBatch(base2, cred.token, chunk);
-      markFieldCoverage(base2, field, chunk.map((r) => ({ id: r.session_id, present: true, mtime: mtimeById.get(r.session_id) ?? 0 })));
+      await postFieldBatch(base3, cred.token, chunk);
+      markFieldCoverage(base3, field, chunk.map((r) => ({ id: r.session_id, present: true, mtime: mtimeById.get(r.session_id) ?? 0 })));
       pushed += chunk.length;
     }
     if (absentIds.length) {
-      markFieldCoverage(base2, field, absentIds.map((id) => ({ id, present: false, mtime: mtimeById.get(id) ?? 0 })));
+      markFieldCoverage(base3, field, absentIds.map((id) => ({ id, present: false, mtime: mtimeById.get(id) ?? 0 })));
       absent += absentIds.length;
     }
-    if (needFull) markFieldFullPassDone(base2, field);
+    if (needFull) markFieldFullPassDone(base3, field);
   }
   return { pushed, absent, scanned };
 }
@@ -19868,7 +19996,7 @@ function reapStaleScanDirs(dir = tmpdir3(), maxAgeMs = 6 * 36e5, now = Date.now(
     if (!name.startsWith("cr-batchscan-")) continue;
     const p = join42(dir, name);
     try {
-      if (now - statSync37(p).mtimeMs < maxAgeMs) continue;
+      if (now - statSync38(p).mtimeMs < maxAgeMs) continue;
       rmSync6(p, { recursive: true, force: true });
       reaped++;
     } catch {
@@ -19942,25 +20070,25 @@ function serverIngestConcurrency(serverUrl) {
   return advertisedIngestConc.get(serverUrl.replace(/\/$/, "")) ?? null;
 }
 async function verifyServerApi(serverUrl, minApi) {
-  const base2 = serverUrl.replace(/\/$/, "");
-  const seen = capsOk.get(base2);
+  const base3 = serverUrl.replace(/\/$/, "");
+  const seen = capsOk.get(base3);
   if (seen !== void 0 && Date.now() - seen < CAPS_TTL_MS) return true;
   const { probeServer: probeServer2, probeAdvice: probeAdvice2 } = await Promise.resolve().then(() => (init_server_probe(), server_probe_exports));
-  const probe = await probeServer2(base2, {
+  const probe = await probeServer2(base3, {
     fetchImpl: ((url, init) => fetchWithTimeout(String(url), init ?? {}))
   });
-  if (probe.kind !== "ok") throw new Error(probeAdvice2(probe, base2));
+  if (probe.kind !== "ok") throw new Error(probeAdvice2(probe, base3));
   const caps = probe.raw;
   if ((caps.apiVersion ?? 0) < minApi) {
     throw new Error(`server too old: apiVersion ${caps.apiVersion ?? "none"} < required ${minApi} \u2014 update the server image before syncing`);
   }
   const adv = caps.limits?.ingestConcurrencyPerTenant;
   if (typeof adv === "number" && Number.isFinite(adv) && adv >= 1) {
-    advertisedIngestConc.set(base2, Math.floor(adv));
+    advertisedIngestConc.set(base3, Math.floor(adv));
   }
-  if (caps.limits?.acceptsGzipBody === true) advertisedGzipBody.add(base2);
-  else advertisedGzipBody.delete(base2);
-  capsOk.set(base2, Date.now());
+  if (caps.limits?.acceptsGzipBody === true) advertisedGzipBody.add(base3);
+  else advertisedGzipBody.delete(base3);
+  capsOk.set(base3, Date.now());
   return true;
 }
 async function syncToTarget(cred, opts = {}) {
@@ -20025,7 +20153,7 @@ async function syncToTargetInScope(cred, opts = {}) {
       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`, {
+        const res = await fetch(`${base3}/api/sync`, {
           method: "POST",
           // No token ⇒ no auth header: a no-auth local server (AUTH_PROVIDER=none)
           // accepts it as the single 'default' tenant.
@@ -20041,26 +20169,26 @@ async function syncToTargetInScope(cred, opts = {}) {
           acceptedUploads.set(cred.serverUrl, (acceptedUploads.get(cred.serverUrl) ?? 0) + 1);
           const body2 = await res.json().catch(() => ({}));
           if (typeof body2.telemetry === "boolean") {
-            setTelemetryEligible(base2, body2.telemetry);
+            setTelemetryEligible(base3, body2.telemetry);
             try {
               const prior = readCollectorHealth()?.telemetryEligible ?? {};
               updateCollectorHealth({
-                telemetryEligible: { ...prior, [base2]: { allowed: body2.telemetry, at: Date.now() } }
+                telemetryEligible: { ...prior, [base3]: { allowed: body2.telemetry, at: Date.now() } }
               });
             } catch {
             }
           }
           const adv = body2.limits?.ingestConcurrencyPerTenant;
           if (typeof adv === "number" && Number.isFinite(adv) && adv >= 1) {
-            setServerIngestConcurrency(base2, Math.floor(adv));
+            setServerIngestConcurrency(base3, Math.floor(adv));
           }
           if (body2.cli && body2.cli.version) {
             const { planAutoUpdate: planAutoUpdate2, runAutoUpdate: runAutoUpdate2, sweepStaleStaging: sweepStaleStaging2 } = await Promise.resolve().then(() => (init_auto_update(), auto_update_exports));
             const authHeaders = cred.token ? { authorization: `Bearer ${cred.token}` } : {};
-            const plan = planAutoUpdate2(base2, { cli: body2.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
+            const plan = planAutoUpdate2(base3, { cli: body2.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
             sweepStaleStaging2();
             if (plan.update) {
-              void runAutoUpdate2(base2, authHeaders, ownVersion).catch(() => {
+              void runAutoUpdate2(base3, authHeaders, ownVersion).catch(() => {
               });
             }
           }
@@ -20069,7 +20197,7 @@ async function syncToTargetInScope(cred, opts = {}) {
         const retryable = res.status === 429 || res.status >= 500;
         const text = await res.text().catch(() => "");
         if (res.status === 401 || res.status === 403) {
-          throw classedError("auth", `server rejected this machine's device token (HTTP ${res.status} \u2014 revoked?). Reconnect with: chat-recall login ${base2}`);
+          throw classedError("auth", `server rejected this machine's device token (HTTP ${res.status} \u2014 revoked?). Reconnect with: chat-recall login ${base3}`);
         }
         if (res.status === 402) {
           let detail = text;
@@ -20090,7 +20218,7 @@ async function syncToTargetInScope(cred, opts = {}) {
         const retryAfterS = Number(res.headers.get("retry-after"));
         const waitMs = res.status === 429 && retryAfterS > 0 ? retryAfterS * 1e3 : RETRY_DELAYS_MS[attempt];
         const why = res.status === 524 ? ` \u2014 the proxy cut the request at its time limit; the batch is too big for one request` : "";
-        console.error(`[sync] HTTP ${res.status} from ${base2}${why} \u2014 backing off ${Math.round(waitMs / 1e3)}s (attempt ${attempt + 1})`);
+        console.error(`[sync] HTTP ${res.status} from ${base3}${why} \u2014 backing off ${Math.round(waitMs / 1e3)}s (attempt ${attempt + 1})`);
         await sleep(waitMs);
         continue;
       } catch (err) {
@@ -20158,11 +20286,11 @@ async function syncToTargetInScope(cred, opts = {}) {
       }
     };
   };
-  const base2 = cred.serverUrl.replace(/\/$/, "");
-  const ledger = opts.useLedger ? getSyncedRows(base2) : null;
+  const base3 = cred.serverUrl.replace(/\/$/, "");
+  const ledger = opts.useLedger ? getSyncedRows(base3) : null;
   const convBatch = makeBatcher("conversations", 25, false, (rows) => {
     try {
-      markSynced(base2, rows.map((r) => {
+      markSynced(base3, rows.map((r) => {
         const off = typeof r.from_offset === "number" ? r.from_offset : 0;
         const hash = shippedHash.get(r.session_id);
         return off > 0 ? { id: r.session_id, mtime: r.mtime, offset: off, size: off, hash, acked: true } : { id: r.session_id, mtime: r.mtime, hash };
@@ -20177,7 +20305,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     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`, {
+      const res = await fetch(`${base3}/api/sync`, {
         method: "POST",
         headers,
         body: JSON.stringify({ conversations: convs }),
@@ -20188,10 +20316,10 @@ async function syncToTargetInScope(cred, opts = {}) {
       if (body.cli && body.cli.version) {
         const { planAutoUpdate: planAutoUpdate2, runAutoUpdate: runAutoUpdate2, sweepStaleStaging: sweepStaleStaging2 } = await Promise.resolve().then(() => (init_auto_update(), auto_update_exports));
         const authHeaders = cred.token ? { authorization: `Bearer ${cred.token}` } : {};
-        const plan = planAutoUpdate2(base2, { cli: body.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
+        const plan = planAutoUpdate2(base3, { cli: body.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
         sweepStaleStaging2();
         if (plan.update) {
-          void runAutoUpdate2(base2, authHeaders, ownVersion).catch(() => {
+          void runAutoUpdate2(base3, authHeaders, ownVersion).catch(() => {
           });
         }
       }
@@ -20199,7 +20327,7 @@ async function syncToTargetInScope(cred, opts = {}) {
       const acked = convs.filter((c) => !fullNeeded.has(c.session_id));
       if (acked.length > 0) {
         try {
-          markSynced(base2, acked.map((c) => ({
+          markSynced(base3, acked.map((c) => ({
             id: c.session_id,
             mtime: c.mtime,
             offset: c.from_offset,
@@ -20217,13 +20345,14 @@ async function syncToTargetInScope(cred, opts = {}) {
       clearTimeout(timer);
     }
   };
-  const postChunkedHead = async (conv, fileSize) => {
+  const postChunkedHead = async (head, fileSize) => {
+    const conv = { ...head, chunk_head: true };
     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`, {
+      const res = await fetch(`${base3}/api/sync`, {
         method: "POST",
         headers,
         body: JSON.stringify({ conversations: [conv] }),
@@ -20233,14 +20362,15 @@ async function syncToTargetInScope(cred, opts = {}) {
       const body = await res.json().catch(() => ({}));
       const id = conv.session_id;
       const guarded = (body.shrink_guarded ?? []).find((g) => g.session_id === id);
+      const staged = (body.rebuild_staged ?? []).includes(id);
       const mtime = conv.mtime;
       try {
-        if (!guarded) {
-          markSynced(base2, [{ id, mtime, offset: conv.from_offset, size: conv.from_offset, acked: true }]);
+        if (staged || !guarded) {
+          markSynced(base3, [{ 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 }]);
+          markSynced(base3, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true }]);
         } else {
-          markSynced(base2, [{ id, mtime }]);
+          markSynced(base3, [{ id, mtime }]);
         }
       } catch {
       }
@@ -20306,7 +20436,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     const m = process.memoryUsage();
     console.error(`[sync-trace] ${msg} \xB7 heap=${(m.heapUsed / 1048576).toFixed(0)}MB rss=${(m.rss / 1048576).toFixed(0)}MB`);
   } : null;
-  trace?.(`walk start: ${slice.length} ref(s) \u2192 ${base2}`);
+  trace?.(`walk start: ${slice.length} ref(s) \u2192 ${base3}`);
   if (upload.sessionMeta) {
     try {
       await reconcileFieldsForTarget(
@@ -20321,7 +20451,7 @@ async function syncToTargetInScope(cred, opts = {}) {
         { convRefs: slice }
       );
     } catch (e) {
-      console.error(`[sync] field reconcile (${base2}): ${e instanceof Error ? e.message : e}`);
+      console.error(`[sync] field reconcile (${base3}): ${e instanceof Error ? e.message : e}`);
     }
   }
   trace?.("field reconcile done");
@@ -20363,7 +20493,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   }
   trace?.("conversation walk start");
   const walkStartedAt = Date.now();
-  const firstWalk = (ledger ?? getSyncedRows(base2)).size === 0;
+  const firstWalk = (ledger ?? getSyncedRows(base3)).size === 0;
   reportWalkProgress({ done: 0, total: slice.length, startedAt: walkStartedAt, complete: false, first: firstWalk });
   walkProgressForUpload = { done: 0, total: slice.length, complete: false };
   let traceN = 0;
@@ -20403,7 +20533,7 @@ async function syncToTargetInScope(cred, opts = {}) {
           continue;
         } else {
           try {
-            markSynced(base2, [{ id: ref.prefixedId, mtime: ref.mtime }]);
+            markSynced(base3, [{ id: ref.prefixedId, mtime: ref.mtime }]);
           } catch {
           }
           skipped++;
@@ -20426,7 +20556,7 @@ async function syncToTargetInScope(cred, opts = {}) {
           const off = getBackendForId(ref.prefixedId)?.fileSize?.(ref.rawId) ?? 0;
           const priorCursor = ackRow?.s ?? 0;
           const safeToAck = off > 0 && off <= priorCursor;
-          markSynced(base2, [safeToAck ? { id: ref.prefixedId, mtime: ref.mtime, offset: off, size: off, hash: built.srcHash, acked: true } : { id: ref.prefixedId, mtime: ref.mtime, hash: built.srcHash }]);
+          markSynced(base3, [safeToAck ? { id: ref.prefixedId, mtime: ref.mtime, offset: off, size: off, hash: built.srcHash, acked: true } : { id: ref.prefixedId, mtime: ref.mtime, hash: built.srcHash }]);
         } catch {
         }
       }
@@ -20436,7 +20566,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     if (!built) {
       if (ledger) {
         try {
-          markSynced(base2, [{ id: ref.prefixedId, mtime: ref.mtime }]);
+          markSynced(base3, [{ id: ref.prefixedId, mtime: ref.mtime }]);
         } catch {
         }
       }
@@ -20493,7 +20623,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     walked++;
     if (walked % 250 === 0) console.error(`[sync] ${walked}/${slice.length} sessions\u2026`);
   }
-  const itemVersions = loadItemVersions(base2);
+  const itemVersions = loadItemVersions(base3);
   const seenTools = /* @__PURE__ */ new Set();
   const seenItemKeys = /* @__PURE__ */ new Map();
   const registry = buildSourceRegistry();
@@ -20587,7 +20717,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   await appendFlush();
   for (const id of appendResults.fullResyncNeeded) {
     try {
-      markFullResync(base2, id);
+      markFullResync(base3, id);
     } catch {
     }
   }
@@ -20600,7 +20730,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   await findingsBatch.drain();
   await drainInflight();
   {
-    const sentHashes = loadInventoryHashes(base2);
+    const sentHashes = loadInventoryHashes(base3);
     const entries = [];
     const hashes = {};
     for (const [sourceType, ids] of inventory) {
@@ -20614,7 +20744,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     if (entries.length > 0) {
       try {
         await post({ inventory: entries });
-        saveInventoryHashes(base2, hashes);
+        saveInventoryHashes(base3, hashes);
       } catch (err) {
         console.error(`[sync] toolkit inventory not sent (it is retried next sync): ${err instanceof Error ? err.message : err}`);
       }
@@ -20625,7 +20755,7 @@ async function syncToTargetInScope(cred, opts = {}) {
       const rec = {};
       for (const t of seenTools) rec[t] = extractorVersionForTool(t);
       for (const [k, v] of seenItemKeys) rec[k] = v;
-      saveItemVersions(base2, rec);
+      saveItemVersions(base3, rec);
     } catch {
     }
   }
@@ -20638,9 +20768,9 @@ async function syncToTargetInScope(cred, opts = {}) {
     }
     if (tombstones.length > 0) {
       await post({ tombstones });
-      const data = getLedgerData(base2);
+      const data = getLedgerData(base3);
       for (const t of tombstones) delete data[t.session_id];
-      persistLedgerData(base2, data);
+      persistLedgerData(base3, data);
     }
   }
   if (opts.prune) await post({ prune_empty_sessions: true });
@@ -20968,8 +21098,13 @@ 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, skippedBytes } = await backend.readFromOffset(ref.prefixedId, fromOffset, SYNC_CHUNK_BYTES);
+  const { text: tailText, newOffset, skippedBytes, baseLine } = await backend.readFromOffset(ref.prefixedId, fromOffset, SYNC_CHUNK_BYTES);
   if (newOffset <= fromOffset) return null;
+  const fileSize = backend.fileSize?.(ref.prefixedId) ?? 0;
+  const position = {
+    ...typeof baseLine === "number" ? { base_line: baseLine } : {},
+    final: fileSize > 0 && newOffset >= fileSize
+  };
   const messages = skippedBytes ? [] : parseTailMessages(ref.toolId, tailText);
   const textMessages = messages.filter((m) => m.role !== "summary" && m.content?.trim());
   const hasContent = textMessages.length > 0 || messages.some((m) => m.toolCalls?.length);
@@ -20982,6 +21117,7 @@ async function buildConversationTail(ref, fromOffset, opts = {}) {
         append: true,
         base_offset: fromOffset,
         from_offset: newOffset,
+        ...position,
         redacted_text: "",
         envelope: { v: TRANSCRIPT_VERSION, messages: [], subagents: [] },
         mtime: Math.floor(ref.mtime) || 0
@@ -21028,6 +21164,7 @@ async function buildConversationTail(ref, fromOffset, opts = {}) {
       // equals its stored synced-through offset.
       from_offset: newOffset,
       // where it ends → new synced-through offset.
+      ...position,
       redacted_text: redactedText,
       envelope,
       mtime: Math.floor(ref.mtime) || 0
@@ -21111,7 +21248,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.14";
+        if (true) ownVersion = "0.7.16";
       } catch {
       }
     }
@@ -21170,10 +21307,10 @@ function parseAgentText(content, format, fallbackName) {
   return { name: fm.name || fallbackName, description: fm.description || "", tools: fm.tools, body: body.trim() };
 }
 function readCommand(filePath, format) {
-  return parseCommandText(readFileSync36(filePath, "utf-8"), format, base(filePath));
+  return parseCommandText(readFileSync36(filePath, "utf-8"), format, base2(filePath));
 }
 function readAgent(filePath, format) {
-  return parseAgentText(readFileSync36(filePath, "utf-8"), format, base(filePath));
+  return parseAgentText(readFileSync36(filePath, "utf-8"), format, base2(filePath));
 }
 function readInstructions(filePath, name) {
   const content = readFileSync36(filePath, "utf-8");
@@ -21273,7 +21410,7 @@ function emit(type, art, toTool, projectPath) {
     content: stringifyFrontmatter({ name: art.name, description: art.description, ...art.tools ? { tools: art.tools } : {} }, art.body)
   };
 }
-function base(filePath) {
+function base2(filePath) {
   return basename21(filePath).replace(/\.(md|toml)$/, "");
 }
 var init_artifact_codec = __esm({
@@ -21711,11 +21848,11 @@ var init_toolkit_sync = __esm({
 });
 
 // ../engine/dist/core/which.js
-import { existsSync as existsSync44, statSync as statSync39, accessSync, constants } from "node:fs";
+import { existsSync as existsSync44, statSync as statSync40, 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 {
-    if (!statSync39(p).isFile())
+    if (!statSync40(p).isFile())
       return false;
   } catch {
     return false;
@@ -21778,11 +21915,11 @@ __export(toolkit_pull_exports, {
   platformRefusal: () => platformRefusal,
   portableCommand: () => portableCommand
 });
-import { existsSync as existsSync45, mkdirSync as mkdirSync13, statSync as statSync40, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync13, statSync as statSync41, 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 {
-    return statSync40(p).isFile();
+    return statSync41(p).isFile();
   } catch {
     return false;
   }
@@ -21796,9 +21933,9 @@ function portableCommand(cmd) {
   }
   if (isExecutableFile(cmd))
     return { command: cmd, rewritten: false };
-  const base2 = basename23(cmd);
-  if (onPath(base2))
-    return { command: base2, rewritten: true };
+  const base3 = basename23(cmd);
+  if (onPath(base3))
+    return { command: base3, rewritten: true };
   return { missing: cmd };
 }
 function entryFromSpec(spec) {
@@ -22315,7 +22452,7 @@ __export(shadow_prune_exports, {
   DEFAULT_MAX_TOTAL_BYTES: () => DEFAULT_MAX_TOTAL_BYTES,
   pruneShadow: () => pruneShadow
 });
-import { readdirSync as readdirSync32, statSync as statSync43, unlinkSync as unlinkSync3 } from "fs";
+import { readdirSync as readdirSync32, statSync as statSync44, unlinkSync as unlinkSync3 } from "fs";
 import { join as join50 } from "path";
 function listShadows(isFullyAcked) {
   const out = [];
@@ -22340,7 +22477,7 @@ function listShadows(isFullyAcked) {
       const path = join50(dir, name);
       let st;
       try {
-        st = statSync43(path);
+        st = statSync44(path);
       } catch {
         continue;
       }
@@ -22455,7 +22592,7 @@ var init_code_intel = __esm({
 });
 
 // ../engine/dist/core/companions.js
-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 { existsSync as existsSync48, mkdirSync as mkdirSync16, statSync as statSync45, 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";
@@ -22506,7 +22643,7 @@ function checkCodeindexStatus() {
     status.installed = true;
     status.path = foundPath;
     try {
-      status.size = statSync44(foundPath).size;
+      status.size = statSync45(foundPath).size;
     } catch {
     }
     try {
@@ -22846,17 +22983,17 @@ async function collectCode(opts) {
     return r;
   };
   log6(`indexing ${ws} + analyses \u2026`);
-  const base2 = await runMcp(bin, ws, [
+  const base3 = await runMcp(bin, ws, [
     call(1, "index_workspace", { path: ws }),
     call(2, "status"),
     call(3, "get_tree"),
     ...ANALYSES.map((a, i) => call(10 + i, "analyze", { analysis: a }))
   ]);
-  const st = parseJson(base2, 2, {});
-  const tree = parseJson(base2, 3, []);
+  const st = parseJson(base3, 2, {});
+  const tree = parseJson(base3, 3, []);
   const A = {};
   ANALYSES.forEach((a, i) => {
-    A[a] = parseJson(base2, 10 + i, {});
+    A[a] = parseJson(base3, 10 + i, {});
   });
   const { health, security: sec, duplication: dup, clones, literal_scan: lit, coupling: coup, cycles: cyc, dead_code: dead, unwrap_audit: unwrap, test_coverage: coverage, architecture: arch, crossref, type_drift: typeDrift, db_schema: dbSchema, migration_parity: migParity, manifest_compliance: manifest } = A;
   if (tree.length === 0) {
@@ -23949,7 +24086,7 @@ import { join as join48 } from "node:path";
 
 // src/project-tasks.ts
 init_http();
-import { existsSync as existsSync43, 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 statSync39 } from "node:fs";
 import { join as join45, dirname as dirname21 } from "node:path";
 import { homedir as homedir18 } from "node:os";
 
@@ -24042,14 +24179,14 @@ var FILE_KINDS = [
   { kind: "secret", filename: "SECURITY_TASKS.md", trackedPath: "/api/secrets/tasks/tracked", statusPath: "/api/secrets/tasks/status" },
   { kind: "code", filename: "CODE_TASKS.md", trackedPath: "/api/code/tasks/tracked", statusPath: "/api/code/tasks/status" }
 ];
-async function pushProjectTaskStatuses(base2, authHeaders, opts = {}) {
+async function pushProjectTaskStatuses(base3, authHeaders, opts = {}) {
   const out = { files: 0, pushedTasks: 0 };
   const ledger = readLedger();
   let ledgerDirty = false;
   for (const fk of FILE_KINDS) {
     let projects;
     try {
-      const res = await fetchWithTimeout(`${base2}${fk.trackedPath}`, { headers: authHeaders });
+      const res = await fetchWithTimeout(`${base3}${fk.trackedPath}`, { headers: authHeaders });
       if (!res.ok) continue;
       projects = (await res.json()).projects || [];
     } catch {
@@ -24060,7 +24197,7 @@ async function pushProjectTaskStatuses(base2, authHeaders, opts = {}) {
       if (!existsSync43(file)) continue;
       let mtime;
       try {
-        mtime = statSync38(file).mtimeMs;
+        mtime = statSync39(file).mtimeMs;
       } catch {
         continue;
       }
@@ -24077,7 +24214,7 @@ async function pushProjectTaskStatuses(base2, authHeaders, opts = {}) {
         continue;
       }
       try {
-        const res = await fetchWithTimeout(`${base2}${fk.statusPath}`, {
+        const res = await fetchWithTimeout(`${base3}${fk.statusPath}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeaders },
           body: JSON.stringify({ project, items: changed.map((t) => ({ id: t.id, status: t.intent })) })
@@ -24167,16 +24304,16 @@ ${block}`);
     return { status: "error", result: JSON.stringify({ error: e instanceof Error ? e.message : "failed" }) };
   }
 }
-async function runPull(base2, opts) {
+async function runPull(base3, opts) {
   const { executePull: executePull2 } = await Promise.resolve().then(() => (init_toolkit_pull(), toolkit_pull_exports));
   const { hostname: hostname3 } = await import("node:os");
-  const creds = loadAllCredentials().find((c) => c.serverUrl.replace(/\/+$/, "") === base2.replace(/\/+$/, ""));
+  const creds = loadAllCredentials().find((c) => c.serverUrl.replace(/\/+$/, "") === base3.replace(/\/+$/, ""));
   const headers = creds?.token ? { authorization: `Bearer ${creds.token}` } : {};
   const wanted = opts.types?.length ? opts.types : ["mcp", "skill", "command", "agent", "instructions"];
   const rows = [];
   for (const type of wanted) {
     try {
-      const res = await fetchWithTimeout(`${base2}/api/toolkit/browse/${type}?limit=1000`, { headers });
+      const res = await fetchWithTimeout(`${base3}/api/toolkit/browse/${type}?limit=1000`, { headers });
       if (!res.ok) continue;
       const body = await res.json();
       for (const it of body.items || []) rows.push(it);
@@ -24248,27 +24385,27 @@ try {
   ownVersion2 = JSON.parse(readFileSync39(join48(dir, "../package.json"), "utf-8")).version || ownVersion2;
 } catch {
   try {
-    if (true) ownVersion2 = "0.7.14";
+    if (true) ownVersion2 = "0.7.16";
   } catch {
   }
 }
 async function drainSyncIntents(opts = {}) {
   const out = { processed: 0, done: 0, errored: 0 };
   for (const cred of loadAllCredentials()) {
-    const base2 = cred.serverUrl.replace(/\/+$/, "");
+    const base3 = cred.serverUrl.replace(/\/+$/, "");
     const authHeaders = cred.token ? { authorization: `Bearer ${cred.token}` } : {};
     let pending;
     try {
-      const res = await fetchWithTimeout(`${base2}/api/sync-intents/pending`, { headers: authHeaders });
+      const res = await fetchWithTimeout(`${base3}/api/sync-intents/pending`, { headers: authHeaders });
       if (!res.ok) continue;
       const data = await res.json();
       pending = data.intents || [];
       if (data.cli && data.cli.version) {
         const { planAutoUpdate: planAutoUpdate2, runAutoUpdate: runAutoUpdate2, sweepStaleStaging: sweepStaleStaging2 } = await Promise.resolve().then(() => (init_auto_update(), auto_update_exports));
-        const plan = planAutoUpdate2(base2, { cli: data.cli }, ownVersion2, process.env.CHAT_RECALL_AUTO_UPDATE);
+        const plan = planAutoUpdate2(base3, { cli: data.cli }, ownVersion2, process.env.CHAT_RECALL_AUTO_UPDATE);
         sweepStaleStaging2();
         if (plan.update) {
-          void runAutoUpdate2(base2, authHeaders, ownVersion2).catch(() => {
+          void runAutoUpdate2(base3, authHeaders, ownVersion2).catch(() => {
           });
         }
       }
@@ -24276,7 +24413,7 @@ async function drainSyncIntents(opts = {}) {
       continue;
     }
     for (const intent of pending) {
-      const { status, result } = await runIntent(intent, { base: base2 });
+      const { status, result } = await runIntent(intent, { base: base3 });
       out.processed++;
       if (status === "done") out.done++;
       else out.errored++;
@@ -24285,7 +24422,7 @@ async function drainSyncIntents(opts = {}) {
         console.error(`[sync-intent] ${label}: ${status}`);
       }
       try {
-        await fetchWithTimeout(`${base2}/api/sync-intents/${intent.id}/ack`, {
+        await fetchWithTimeout(`${base3}/api/sync-intents/${intent.id}/ack`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeaders },
           body: JSON.stringify({ status, result })
@@ -24294,7 +24431,7 @@ async function drainSyncIntents(opts = {}) {
       }
     }
     try {
-      await pushProjectTaskStatuses(base2, authHeaders, { verbose: opts.verbose });
+      await pushProjectTaskStatuses(base3, authHeaders, { verbose: opts.verbose });
     } catch {
     }
   }
@@ -24313,7 +24450,7 @@ init_auto_update();
 
 // src/code-index-cursor.ts
 init_paths();
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, statSync as statSync41 } from "fs";
+import { readFileSync as readFileSync40, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, statSync as statSync42 } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
 import { createHash as createHash10 } from "crypto";
 import { join as join49, dirname as dirname24 } from "path";
@@ -24364,7 +24501,7 @@ function workspaceFingerprint(workspace, collectorVersion) {
       const rel = entry.slice(3);
       let stamp2 = "gone";
       try {
-        const s = statSync41(join49(workspace, rel));
+        const s = statSync42(join49(workspace, rel));
         stamp2 = `${s.size}:${Math.floor(s.mtimeMs)}`;
       } catch {
       }
@@ -24573,11 +24710,11 @@ function checkSelfRestart(opts) {
 }
 
 // src/log-rotate.ts
-import { statSync as statSync42, copyFileSync as copyFileSync3, truncateSync } from "fs";
+import { statSync as statSync43, copyFileSync as copyFileSync3, truncateSync } from "fs";
 var LOG_MAX_BYTES = 32 * 1024 * 1024;
 function rotateLogIfLarge(logPath, maxBytes = LOG_MAX_BYTES) {
   try {
-    const size = statSync42(logPath).size;
+    const size = statSync43(logPath).size;
     if (size < maxBytes) return { rotated: false, sizeBefore: 0 };
     copyFileSync3(logPath, `${logPath}.1`);
     truncateSync(logPath, 0);
@@ -24632,8 +24769,8 @@ async function runCollectorMigration(opts) {
 // auto-indexer/indexer.ts
 init_sync_ledger();
 init_collector_health();
-import { existsSync as existsSync50, readFileSync as readFileSync45, statSync as statSync45 } from "fs";
-var CLI_VERSION3 = true ? "0.7.14" : "0.0.0";
+import { existsSync as existsSync50, readFileSync as readFileSync45, statSync as statSync46 } from "fs";
+var CLI_VERSION3 = true ? "0.7.16" : "0.0.0";
 var DEBOUNCE_MS = 5e3;
 var PLANS_DIR = claudeBackend.plansDir();
 var TASKS_DIR = claudeBackend.tasksDir();
@@ -24738,7 +24875,7 @@ var CLAUDE_SESSION_ROOTS = claudeProjectDirs();
 var sessionWatcher = watchWithFallback("sessions", CLAUDE_SESSION_ROOTS.map((root) => `${root}/**/*.jsonl`), {
   ignored: (p, stats) => {
     if (/agent-/.test(p) || /^\./.test(basename25(p))) return true;
-    const st = stats ?? statSync45(p, { throwIfNoEntry: false });
+    const st = stats ?? statSync46(p, { throwIfNoEntry: false });
     if (!st || st.isDirectory()) return false;
     return st.mtimeMs < Date.now() - WATCH_WINDOW_MS;
   },
@@ -25108,10 +25245,10 @@ async function codeIndexTick() {
         continue;
       }
       for (const cred of creds) {
-        const base2 = cred.serverUrl.replace(/\/+$/, "");
+        const base3 = cred.serverUrl.replace(/\/+$/, "");
         const headers = { "content-type": "application/json", ...cred.token ? { authorization: `Bearer ${cred.token}` } : {} };
         try {
-          await fetchWithTimeout(`${base2}/api/code/index`, { method: "POST", headers, body: JSON.stringify(result) }, 6e4);
+          await fetchWithTimeout(`${base3}/api/code/index`, { method: "POST", headers, body: JSON.stringify(result) }, 6e4);
         } catch {
         }
       }
@@ -25134,12 +25271,12 @@ if (CODE_INDEX_ON) {
 }
 async function autoUpdateTick() {
   for (const cred of loadAllCredentials()) {
-    const base2 = cred.serverUrl.replace(/\/+$/, "");
+    const base3 = cred.serverUrl.replace(/\/+$/, "");
     const headers = cred.token ? { authorization: `Bearer ${cred.token}` } : {};
     try {
-      const r = await runAutoUpdate(base2, headers, CLI_VERSION3);
-      if (r.updated) daemonLog.info(`auto-update: ${r.reason} (${base2}) \u2014 restarting service`);
-      else if (!/already current|disabled|no CLI release/.test(r.reason)) daemonLog.info(`auto-update: ${r.reason} (${base2})`);
+      const r = await runAutoUpdate(base3, headers, CLI_VERSION3);
+      if (r.updated) daemonLog.info(`auto-update: ${r.reason} (${base3}) \u2014 restarting service`);
+      else if (!/already current|disabled|no CLI release/.test(r.reason)) daemonLog.info(`auto-update: ${r.reason} (${base3})`);
     } catch {
     }
   }
@@ -25166,20 +25303,20 @@ async function collectorMigrationOnce() {
     return;
   }
   for (const cred of creds) {
-    const base2 = cred.serverUrl.replace(/\/+$/, "");
+    const base3 = cred.serverUrl.replace(/\/+$/, "");
     const headers = { "content-type": "application/json", ...cred.token ? { authorization: `Bearer ${cred.token}` } : {} };
     const reindex = async (rootPath) => {
       try {
         const result = await collectCode2({ workspace: rootPath, binPath: bin });
-        const res = await fetchWithTimeout(`${base2}/api/code/index`, { method: "POST", headers, body: JSON.stringify(result) }, 6e4);
+        const res = await fetchWithTimeout(`${base3}/api/code/index`, { method: "POST", headers, body: JSON.stringify(result) }, 6e4);
         return res.ok;
       } catch {
         return false;
       }
     };
     try {
-      const r = await runCollectorMigration({ base: base2, authHeaders: headers, current: COLLECTOR_VERSION2, reindex, log: (m) => daemonLog.info(`${m}`) });
-      if (r.reindexed || r.failed || r.missing) daemonLog.info(`collector migration (${base2}): re-derived ${r.reindexed}, failed ${r.failed}, skipped-missing ${r.missing}`);
+      const r = await runCollectorMigration({ base: base3, authHeaders: headers, current: COLLECTOR_VERSION2, reindex, log: (m) => daemonLog.info(`${m}`) });
+      if (r.reindexed || r.failed || r.missing) daemonLog.info(`collector migration (${base3}): re-derived ${r.reindexed}, failed ${r.failed}, skipped-missing ${r.missing}`);
     } catch {
     }
   }