chat-recall 0.7.14 → 0.7.16

package/dist/mcp.js

@@ -4259,7 +4259,7 @@ var require_pino = __commonJS({
         messageKey,
         errorKey,
         nestedKey,
-        base,
+        base: base2,
         name,
         level: level2,
         customLevels,
@@ -4298,11 +4298,11 @@ var require_pino = __commonJS({
         [formattersSym]: allFormatters
       });
       let chindings = "";
-      if (base !== null) {
+      if (base2 !== null) {
         if (name === void 0) {
-          chindings = coreChindings(base);
+          chindings = coreChindings(base2);
         } else {
-          chindings = coreChindings(Object.assign({}, base, { name }));
+          chindings = coreChindings(Object.assign({}, base2, { name }));
         }
       }
       const time2 = timestamp instanceof Function ? timestamp : timestamp ? epochTime : nullTime;
@@ -5271,57 +5271,57 @@ function freshDefaults() {
     team: defaultTeam()
   };
 }
-function mergeSources(base, partial) {
+function mergeSources(base2, partial) {
   if (!partial)
-    return base;
+    return base2;
   const legacyGemini = partial.enabled?.gemini;
   const inherited = legacyGemini && typeof legacyGemini === "object" ? (({ sessions: _s, plans: _p, ...rest }) => rest)(legacyGemini) : {};
   const enabled = {
-    claude: { ...base.enabled.claude, ...partial.enabled?.claude ?? {} },
-    opencode: { ...base.enabled.opencode, ...partial.enabled?.opencode ?? {} },
-    codex: { ...base.enabled.codex, ...partial.enabled?.codex ?? {} },
-    agy: { ...base.enabled.agy, ...inherited, ...partial.enabled?.agy ?? {} },
-    cursor: { ...base.enabled.cursor, ...partial.enabled?.cursor ?? {} },
-    shared: { ...base.enabled.shared, ...partial.enabled?.shared ?? {} },
-    common: { ...base.enabled.common, ...partial.enabled?.common ?? {} }
+    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 ?? {} }
   };
   return {
-    claudeHome: partial.claudeHome ?? base.claudeHome,
-    geminiHome: partial.geminiHome ?? base.geminiHome,
-    codexHome: partial.codexHome ?? base.codexHome,
-    opencodeDbPath: partial.opencodeDbPath ?? base.opencodeDbPath,
-    agyHome: partial.agyHome ?? base.agyHome,
-    cursorHome: partial.cursorHome ?? base.cursorHome,
-    cursorIdeHome: partial.cursorIdeHome ?? base.cursorIdeHome,
-    extraClaudeHomes: partial.extraClaudeHomes ?? base.extraClaudeHomes,
-    approvedHomes: partial.approvedHomes ?? base.approvedHomes,
-    declinedHomes: partial.declinedHomes ?? base.declinedHomes,
-    homesGrandfathered: partial.homesGrandfathered ?? base.homesGrandfathered,
+    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,
     enabled
   };
 }
-function mergePrivacy(base, partial) {
+function mergePrivacy(base2, partial) {
   if (!partial)
-    return base;
-  return { ...base, ...partial };
+    return base2;
+  return { ...base2, ...partial };
 }
-function mergeSync(base, partial) {
+function mergeSync(base2, partial) {
   if (!partial)
-    return base;
+    return base2;
   return {
-    ...base,
+    ...base2,
     ...partial,
-    upload: { ...base.upload, ...partial.upload ?? {} }
+    upload: { ...base2.upload, ...partial.upload ?? {} }
   };
 }
-function mergeTeam(base, partial) {
+function mergeTeam(base2, partial) {
   if (!partial)
-    return base;
+    return base2;
   return {
-    ...base,
+    ...base2,
     ...partial,
-    publishAllowed: { ...base.publishAllowed, ...partial.publishAllowed ?? {} },
-    vault: { ...base.vault, ...partial.vault ?? {} }
+    publishAllowed: { ...base2.publishAllowed, ...partial.publishAllowed ?? {} },
+    vault: { ...base2.vault, ...partial.vault ?? {} }
   };
 }
 function settingsFilePath() {
@@ -5439,15 +5439,15 @@ function loadSettings() {
   }
   try {
     const parsed = JSON.parse(readFileSync3(path2, "utf-8"));
-    const base = freshDefaults();
+    const base2 = freshDefaults();
     const result = {
       v: SCHEMA_VERSION,
-      embedding: { ...base.embedding, ...parsed.embedding ?? {} },
-      summary: { ...base.summary, ...parsed.summary ?? {} },
-      sources: mergeSources(base.sources, parsed.sources),
-      privacy: mergePrivacy(base.privacy, parsed.privacy),
-      sync: mergeSync(base.sync, parsed.sync),
-      team: mergeTeam(base.team, parsed.team)
+      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)
     };
     if (mtimeMs >= 0)
       _settingsCache = { mtimeMs, size, value: structuredClone(result) };
@@ -5643,10 +5643,10 @@ function legacyAutoSyncedHomes() {
     { base: join6(home, ".local", "share", "opencode"), marker: "opencode.db" },
     { base: join6(home, ".cursor"), marker: "chats" }
   ];
-  for (const { base, marker } of bases) {
-    add(base, marker);
-    const parent = dirname5(base);
-    const leaf = base.slice(parent.length + 1);
+  for (const { base: base2, marker } of bases) {
+    add(base2, marker);
+    const parent = dirname5(base2);
+    const leaf = base2.slice(parent.length + 1);
     try {
       for (const e of readdirSync4(parent, { withFileTypes: true })) {
         if (!e.isDirectory())
@@ -5827,17 +5827,17 @@ function cursorHomeDir() {
 function cursorIdeHomeDir() {
   return process.env.CHAT_RECALL_CURSOR_IDE_HOME || sources().cursorIdeHome || (process.platform === "darwin" ? join7(homedir3(), "Library", "Application Support", "Cursor") : join7(homedir3(), ".config", "Cursor"));
 }
-function siblingHomes(base, overridden, suffix) {
+function siblingHomes(base2, overridden, suffix) {
   const roots = [];
   const add = (home) => {
     const root = suffix ? join7(home, suffix) : home;
     if (existsSync5(root) && !roots.includes(root))
       roots.push(root);
   };
-  add(base);
+  add(base2);
   if (!overridden) {
-    const parent = dirname6(base);
-    const leaf = basename3(base);
+    const parent = dirname6(base2);
+    const leaf = basename3(base2);
     try {
       for (const entry of readdirSync5(parent, { withFileTypes: true })) {
         if (!entry.isDirectory())
@@ -7108,7 +7108,64 @@ var init_opencode = __esm({
 });
 
 // ../engine/dist/core/backends/tail-read.js
-import { openSync, readSync, closeSync, statSync as statSync6 } from "node:fs";
+import { openSync, readSync, closeSync, 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 = readSync(fd, buf, got, len - got, pos + got);
+    if (n <= 0)
+      break;
+    got += n;
+  }
+  return buf.subarray(0, got);
+}
+function linesBeforeOffset(path2, offset) {
+  if (offset <= 0)
+    return 0;
+  let fd = null;
+  try {
+    fd = openSync(path2, "r");
+    const ino = fstatSync(fd).ino;
+    const known = lineCounts.get(path2);
+    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 = readSync(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(path2)) {
+      const oldest = lineCounts.keys().next().value;
+      if (oldest !== void 0)
+        lineCounts.delete(oldest);
+    }
+    lineCounts.set(path2, { offset, lines, ino, edge });
+    return lines;
+  } catch {
+    return void 0;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
 function readTailFromOffset(path2, offset, maxBytes = TAIL_READ_MAX_BYTES) {
   let size = 0;
   try {
@@ -7136,7 +7193,7 @@ function readTailFromOffset(path2, 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(path2, offset) };
     }
     if (offset + got >= size)
       return { text: "", newOffset: offset };
@@ -7169,12 +7226,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;
   }
 });
 
@@ -11019,9 +11079,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);
@@ -13290,8 +13350,8 @@ function serverRulePackVersion() {
   return serverPack ? serverPack.version || "unversioned" : null;
 }
 function activeRules() {
-  const base = settingsView().rules;
-  return serverPack && serverPack.rules.length > 0 ? [...base, ...serverPack.rules] : base;
+  const base2 = settingsView().rules;
+  return serverPack && serverPack.rules.length > 0 ? [...base2, ...serverPack.rules] : base2;
 }
 function isRedactionEnabled() {
   const env = isEnvRedactionRequested();
@@ -14154,17 +14214,17 @@ async function collectCode(opts) {
     return r;
   };
   log6(`indexing ${ws} + analyses \u2026`);
-  const base = await runMcp(bin, ws, [
+  const base2 = 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(base, 2, {});
-  const tree = parseJson(base, 3, []);
+  const st = parseJson(base2, 2, {});
+  const tree = parseJson(base2, 3, []);
   const A = {};
   ANALYSES.forEach((a, i) => {
-    A[a] = parseJson(base, 10 + i, {});
+    A[a] = parseJson(base2, 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) {
@@ -19452,38 +19512,100 @@ var init_extractor_version = __esm({
 });
 
 // src/sync-ledger.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync7, renameSync as renameSync5, mkdirSync as mkdirSync10 } from "node:fs";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync7, renameSync as renameSync5, mkdirSync as mkdirSync10, statSync as statSync40 } from "node:fs";
 import { join as join46, dirname as dirname17 } from "node:path";
 function toRow(entry) {
   if (entry === void 0) return void 0;
   return typeof entry === "number" ? { m: entry, v: 0 } : entry;
 }
-function load() {
-  if (cache3) return cache3;
+function stampOf(path2) {
   try {
-    const parsed = JSON.parse(readFileSync34(ledgerPath(), "utf-8"));
-    cache3 = parsed && typeof parsed === "object" ? parsed : {};
+    const st = statSync40(path2);
+    return `${st.mtimeMs}:${st.size}`;
   } catch {
-    cache3 = {};
+    return null;
   }
+}
+function readDisk(path2) {
+  try {
+    const parsed = JSON.parse(readFileSync34(path2, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    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 path2 = ledgerPath();
+  const stamp = stampOf(path2);
+  if (cache3 && stamp === diskStamp) return cache3;
+  const disk = readDisk(path2);
+  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 = stamp;
   return cache3;
 }
-function persistNow(data) {
+function persistNow() {
   const path2 = ledgerPath();
   mkdirSync10(dirname17(path2), { recursive: true });
-  const tmp = `${path2}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(data));
+  load();
+  const tmp = `${path2}.tmp-${process.pid}`;
+  writeFileSync7(tmp, JSON.stringify(cache3 ?? {}));
   renameSync5(tmp, path2);
+  base = snapshot(cache3 ?? {});
+  diskStamp = stampOf(path2);
   pendingWrite = false;
 }
-function persist(data) {
+function persist(_data) {
   pendingWrite = true;
   if (flushTimer) return;
   flushTimer = setTimeout(() => {
     flushTimer = null;
     if (pendingWrite) {
       try {
-        persistNow(data);
+        persistNow();
       } catch {
       }
     }
@@ -19517,7 +19639,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() {
@@ -19526,7 +19648,7 @@ function flushLedger() {
     flushTimer = null;
   }
   if (!pendingWrite || !cache3) return;
-  persistNow(cache3);
+  persistNow();
 }
 function loadItemVersionsAll() {
   if (itemVersionsCache) return itemVersionsCache;
@@ -19586,6 +19708,7 @@ function persistLedgerData(server, serverData) {
   const data = load();
   data[server] = serverData;
   persist(data);
+  flushLedger();
 }
 function markSynced(server, rows) {
   if (rows.length === 0) return;
@@ -19602,13 +19725,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 base = prevF ? { m: Math.floor(r.mtime), v: ev, f: prevF } : { m: Math.floor(r.mtime), v: ev };
+    const base2 = prevF ? { m: Math.floor(r.mtime), v: ev, f: prevF } : { m: Math.floor(r.mtime), v: ev };
     if (o > 0 || s > 0) {
-      base.o = o;
-      base.s = s;
+      base2.o = o;
+      base2.s = s;
     }
-    if (r.hash !== void 0) base.h = r.hash;
-    forServer[r.id] = base;
+    if (r.hash !== void 0) base2.h = r.hash;
+    forServer[r.id] = base2;
   }
   persist(data);
 }
@@ -19683,7 +19806,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";
@@ -19691,6 +19814,9 @@ var init_sync_ledger = __esm({
     init_extractor_version();
     ledgerPath = () => join46(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;
@@ -19729,7 +19855,7 @@ var init_sync_fields = __esm({
 });
 
 // ../engine/dist/core/index-lock.js
-import { existsSync as existsSync43, mkdirSync as mkdirSync11, openSync as openSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync35, rmSync as rmSync4, statSync as statSync40, closeSync as closeSync9 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync11, openSync as openSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync35, rmSync as rmSync4, statSync as statSync41, closeSync as closeSync9 } from "fs";
 import { dirname as dirname18, join as join47 } from "path";
 function acquireIndexLock(opts) {
   const lockPath = lockFilePath(opts.file);
@@ -19779,7 +19905,7 @@ function lockFilePath(file = ".compact.lock") {
 }
 function stealStaleLock(lockPath, staleAfterMs) {
   try {
-    const s = statSync40(lockPath);
+    const s = statSync41(lockPath);
     const age = Date.now() - s.mtimeMs;
     let payload;
     try {
@@ -19845,7 +19971,7 @@ var init_http = __esm({
       CLI_VERSION = JSON.parse(readFileSync36(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 {
       }
     }
@@ -20343,7 +20469,7 @@ var init_telemetry = __esm({
     init_sync_client();
     cliVersion2 = () => {
       try {
-        return true ? "0.7.14" : "dev";
+        return true ? "0.7.16" : "dev";
       } catch {
         return "dev";
       }
@@ -20366,11 +20492,11 @@ __export(server_probe_exports, {
 function probeOk(r) {
   return r.kind === "ok" && r.apiVersion >= 2;
 }
-async function probeServer(base, opts = {}) {
+async function probeServer(base2, opts = {}) {
   const f = opts.fetchImpl || fetch;
   let res;
   try {
-    res = await f(`${base.replace(/\/+$/, "")}/api/capabilities`, {
+    res = await f(`${base2.replace(/\/+$/, "")}/api/capabilities`, {
       signal: AbortSignal.timeout(opts.timeoutMs ?? 1e4)
     });
   } catch (err) {
@@ -20407,34 +20533,34 @@ async function probeServer(base, opts = {}) {
     raw: parsed
   };
 }
-function probeAdvice(r, base) {
+function probeAdvice(r, base2) {
   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 ${base}. If the host moved, re-point it: \`chat-recall login <new-server-url>\``;
+      return `HTTP ${r.status} \u2014 nothing is served at ${base2}. If the host moved, re-point it: \`chat-recall login <new-server-url>\``;
     case "unauthorized":
-      return `HTTP ${r.status} \u2014 ${base} rejected the credential. Re-login: \`chat-recall login ` + base + "`";
+      return `HTTP ${r.status} \u2014 ${base2} rejected the credential. Re-login: \`chat-recall login ` + base2 + "`";
     case "server_error":
-      return `HTTP ${r.status} \u2014 ${base} is up but failing. Nothing to fix locally; check the server.`;
+      return `HTTP ${r.status} \u2014 ${base2} is up but failing. Nothing to fix locally; check the server.`;
     case "not_api":
-      return `${base} 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 `${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`;
     case "unreachable":
       switch (r.reason) {
         case "dns":
-          return `cannot resolve the host in ${base} (${r.error}) \u2014 check the URL for a typo, and your DNS or VPN`;
+          return `cannot resolve the host in ${base2} (${r.error}) \u2014 check the URL for a typo, and your DNS or VPN`;
         case "refused":
-          return `${base} resolves but refused the connection (${r.error}) \u2014 the server is not running, or the port is wrong`;
+          return `${base2} 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 ${base} 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 ${base2} 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 `${base} did not answer in time (${r.error}) \u2014 a firewall or proxy that drops traffic silently looks exactly like this`;
+          return `${base2} 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 ${base} was cut (${r.error}) \u2014 often a proxy or a captive portal`;
+          return `the connection to ${base2} was cut (${r.error}) \u2014 often a proxy or a captive portal`;
         case "bad_port":
-          return `${base} names a port that Node and every browser refuse to open (the WHATWG bad-port list) \u2014 use the server's real 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`;
         default:
-          return `no HTTP response from ${base} (${r.error}) \u2014 check the URL, DNS, or that the server is running`;
+          return `no HTTP response from ${base2} (${r.error}) \u2014 check the URL, DNS, or that the server is running`;
       }
   }
 }
@@ -20467,8 +20593,8 @@ function describeCause(err) {
     const code = e.code;
     if (typeof code === "string" && code && !parts.includes(code)) parts.push(code);
   }
-  const base = err instanceof Error ? err.message : String(err);
-  return parts.length ? `${base}: ${parts.join(" \u2192 ")}` : base;
+  const base2 = err instanceof Error ? err.message : String(err);
+  return parts.length ? `${base2}: ${parts.join(" \u2192 ")}` : base2;
 }
 function describeUnreachable(err) {
   const reason = classifyUnreachable(err);
@@ -20516,7 +20642,7 @@ __export(auto_update_exports, {
 import { execSync as execSync4, execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync37, existsSync as existsSync45 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { writeFileSync as writeFileSync9, mkdtempSync as mkdtempSync3, rmSync as rmSync5, readdirSync as readdirSync31, statSync as statSync41, mkdirSync as mkdirSync12 } from "node:fs";
+import { writeFileSync as writeFileSync9, mkdtempSync as mkdtempSync3, rmSync as rmSync5, readdirSync as readdirSync31, statSync as statSync42, mkdirSync as mkdirSync12 } from "node:fs";
 import { join as join48, dirname as dirname19, sep as sep3, posix as pathPosix, win32 as pathWin32 } from "node:path";
 import { tmpdir as tmpdir3, homedir as homedir17 } from "node:os";
 import { createHash as createHash10 } from "node:crypto";
@@ -20548,12 +20674,12 @@ function installedVersion() {
     return null;
   }
 }
-function planAutoUpdate(base, caps, ownVersion2, flag) {
+function planAutoUpdate(base2, caps, ownVersion2, 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, ownVersion2) <= 0) return { update: false, reason: `already current (own ${ownVersion2} >= server ${rel.version})` };
-  return { update: true, reason: `server ${rel.version} > own ${ownVersion2}`, url: tarballUrl(base, rel.version), fallbackUrl: tarballUrl(base), sha256: rel.sha256, from: ownVersion2, to: rel.version };
+  return { update: true, reason: `server ${rel.version} > own ${ownVersion2}`, url: tarballUrl(base2, rel.version), fallbackUrl: tarballUrl(base2), sha256: rel.sha256, from: ownVersion2, to: rel.version };
 }
 function sweepStaleStaging(root = tmpdir3(), now = Date.now()) {
   const MKDTEMP_SUFFIX = /^cr-update-.{6}$/s;
@@ -20569,7 +20695,7 @@ function sweepStaleStaging(root = tmpdir3(), now = Date.now()) {
     if (!MKDTEMP_SUFFIX.test(name)) continue;
     const dir = join48(root, name);
     try {
-      const st = statSync41(dir);
+      const st = statSync42(dir);
       if (!st.isDirectory() || now - st.mtimeMs < COLD_MS) continue;
       const inside = readdirSync31(dir);
       if (inside.length > 1 || inside.length === 1 && inside[0] !== "chat-recall.tgz") continue;
@@ -20733,20 +20859,20 @@ function clearUpdateFailures() {
 function stopAutoUpdates() {
   stopRequested = true;
 }
-async function runAutoUpdate(base, authHeaders, ownVersion2, deps) {
+async function runAutoUpdate(base2, authHeaders, ownVersion2, deps) {
   let caps;
   try {
-    const res = await fetchWithTimeout(`${base.replace(/\/+$/, "")}/api/capabilities`, { headers: authHeaders });
+    const res = await fetchWithTimeout(`${base2.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(ownVersion2, installedVersion());
-  const plan = planAutoUpdate(base, caps, effectiveOwn, process.env.CHAT_RECALL_AUTO_UPDATE);
+  const plan = planAutoUpdate(base2, caps, effectiveOwn, process.env.CHAT_RECALL_AUTO_UPDATE);
   if (!plan.update) {
-    if (/disabled|no CLI release/.test(plan.reason) && !reportedStandingSkip.has(base)) {
-      reportedStandingSkip.add(base);
+    if (/disabled|no CLI release/.test(plan.reason) && !reportedStandingSkip.has(base2)) {
+      reportedStandingSkip.add(base2);
       try {
         const { reportClientEvent: reportClientEvent3 } = await Promise.resolve().then(() => (init_client_events(), client_events_exports));
         reportClientEvent3("auto_update_skipped", { message: `${plan.reason} (server offers ${caps.cli?.version ?? "?"}, this device runs ${effectiveOwn})` });
@@ -20802,7 +20928,7 @@ var init_auto_update = __esm({
     "use strict";
     init_http();
     init_index_lock();
-    tarballUrl = (base, version2) => `${base.replace(/\/+$/, "")}/install/${version2 ? `chat-recall-${version2}.tgz` : "chat-recall.tgz"}`;
+    tarballUrl = (base2, version2) => `${base2.replace(/\/+$/, "")}/install/${version2 ? `chat-recall-${version2}.tgz` : "chat-recall.tgz"}`;
     GIVE_UP_AFTER = 3;
     reportedStandingSkip = /* @__PURE__ */ new Set();
     STOPPING_REASON = "not installed: this process is shutting down";
@@ -20847,7 +20973,7 @@ __export(sync_client_exports, {
   syncSessions: () => syncSessions
 });
 import { join as join49, dirname as dirname20, basename as basename22 } from "node:path";
-import { readFileSync as readFileSync38, writeFileSync as writeFileSync10, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync4, rmSync as rmSync6, chmodSync as chmodSync6, unlinkSync as unlinkSync3, readdirSync as readdirSync32, statSync as statSync42 } from "node:fs";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync10, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync4, rmSync as rmSync6, chmodSync as chmodSync6, unlinkSync as unlinkSync3, readdirSync as readdirSync32, statSync as statSync43 } from "node:fs";
 import { tmpdir as tmpdir4, hostname as hostname2 } from "node:os";
 import { createHash as createHash11 } from "node:crypto";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -20910,15 +21036,15 @@ function loadAllCredentials() {
   return [];
 }
 async function fetchTenantSecurityConfig(cred) {
-  const base = cred.serverUrl.replace(/\/+$/, "");
-  const cached = _securityConfigCache.get(base);
+  const base2 = cred.serverUrl.replace(/\/+$/, "");
+  const cached = _securityConfigCache.get(base2);
   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(`${base}/api/secrets/rules`, { headers }),
-      fetchWithTimeout(`${base}/api/teams/security-config`, { headers }).catch(() => null)
+      fetchWithTimeout(`${base2}/api/secrets/rules`, { headers }),
+      fetchWithTimeout(`${base2}/api/teams/security-config`, { headers }).catch(() => null)
     ]);
     let tenantRules = [];
     let rulePackVersion = null;
@@ -20943,18 +21069,18 @@ async function fetchTenantSecurityConfig(cred) {
       const body2 = await settingsRes.json().catch(() => ({}));
       if (typeof body2.verifySecrets === "boolean") verifySecrets = body2.verifySecrets;
       if (typeof body2.telemetry === "boolean") {
-        setTelemetryEligible(base, body2.telemetry);
+        setTelemetryEligible(base2, body2.telemetry);
         try {
           const prior = readCollectorHealth()?.telemetryEligible ?? {};
           updateCollectorHealth({
-            telemetryEligible: { ...prior, [base]: { allowed: body2.telemetry, at: Date.now() } }
+            telemetryEligible: { ...prior, [base2]: { allowed: body2.telemetry, at: Date.now() } }
           });
         } catch {
         }
       }
     }
     const config2 = { tenantRules, verifySecrets, rulePackVersion };
-    _securityConfigCache.set(base, { fetchedAt: Date.now(), config: config2 });
+    _securityConfigCache.set(base2, { fetchedAt: Date.now(), config: config2 });
     return config2;
   } catch {
     return { tenantRules: [], verifySecrets: true, rulePackVersion: null };
@@ -20973,18 +21099,18 @@ function readPersistedSyncConfigs() {
     return {};
   }
 }
-function persistSyncConfig(base, config2) {
+function persistSyncConfig(base2, config2) {
   try {
     const all = readPersistedSyncConfigs();
-    all[base] = { fetchedAt: Date.now(), config: config2 };
+    all[base2] = { fetchedAt: Date.now(), config: config2 };
     mkdirSync13(dirname20(syncConfigCachePath()), { recursive: true });
     writeFileSync10(syncConfigCachePath(), JSON.stringify(all, null, 2));
   } catch {
   }
 }
 async function fetchTenantSyncConfig(cred) {
-  const base = cred.serverUrl.replace(/\/+$/, "");
-  const cached = _syncConfigCache.get(base);
+  const base2 = cred.serverUrl.replace(/\/+$/, "");
+  const cached = _syncConfigCache.get(base2);
   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}`;
@@ -20992,7 +21118,7 @@ async function fetchTenantSyncConfig(cred) {
     try {
       const sources2 = discoverSessionSources();
       if (sources2.length > 0) {
-        await fetchWithTimeout(`${base}/api/sync-config/sources`, {
+        await fetchWithTimeout(`${base2}/api/sync-config/sources`, {
           method: "POST",
           headers,
           body: JSON.stringify({ device: deviceLabel(), sources: sources2 })
@@ -21000,12 +21126,12 @@ async function fetchTenantSyncConfig(cred) {
       }
     } catch {
     }
-    const res = await fetchWithTimeout(`${base}/api/sync-config`, { headers });
+    const res = await fetchWithTimeout(`${base2}/api/sync-config`, { headers });
     if (res.status === 404) {
-      _syncConfigCache.set(base, { fetchedAt: Date.now(), config: EMPTY_SYNC_CONFIG });
+      _syncConfigCache.set(base2, { fetchedAt: Date.now(), config: EMPTY_SYNC_CONFIG });
       return EMPTY_SYNC_CONFIG;
     }
-    if (!res.ok) return lastKnownSyncConfig(base, `HTTP ${res.status}`);
+    if (!res.ok) return lastKnownSyncConfig(base2, `HTTP ${res.status}`);
     const body2 = await res.json().catch(() => ({}));
     const config2 = {
       excludeTools: Array.isArray(body2.excludeTools) ? body2.excludeTools.filter((t) => typeof t === "string") : [],
@@ -21042,22 +21168,22 @@ async function fetchTenantSyncConfig(cred) {
       if (decided > 0) console.error(`[sync] applied ${decided} folder decision(s) from the dashboard`);
     } catch {
     }
-    _syncConfigCache.set(base, { fetchedAt: Date.now(), config: config2 });
-    persistSyncConfig(base, config2);
+    _syncConfigCache.set(base2, { fetchedAt: Date.now(), config: config2 });
+    persistSyncConfig(base2, config2);
     return config2;
   } catch (err) {
     if (isSyncRulesRefusal(err)) throw err;
-    return lastKnownSyncConfig(base, err instanceof Error ? err.message : "request failed");
+    return lastKnownSyncConfig(base2, err instanceof Error ? err.message : "request failed");
   }
 }
-function lastKnownSyncConfig(base, reason) {
-  const remembered = _syncConfigCache.get(base) ?? readPersistedSyncConfigs()[base];
+function lastKnownSyncConfig(base2, reason) {
+  const remembered = _syncConfigCache.get(base2) ?? readPersistedSyncConfigs()[base2];
   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 ${base} (${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 ${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.`
   );
   refusal[SYNC_RULES_REFUSAL] = true;
   throw refusal;
@@ -21178,25 +21304,25 @@ async function syncSessions(opts = {}) {
   ${errors.join("\n  ")}`);
   return { ...agg, perTarget };
 }
-async function postFieldBatch(base, token, rows) {
+async function postFieldBatch(base2, 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(`${base}/api/sync`, { method: "POST", headers, body: JSON.stringify({ fields: rows }) }, 6e4);
+    const res = await fetchWithTimeout(`${base2}/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(`${base}: fields batch HTTP ${res.status} ${await res.text().catch(() => "")}`);
+    if (!retryable || attempt >= 5) throw new Error(`${base2}: 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 base = cred.serverUrl.replace(/\/+$/, "");
-  const ledger = getSyncedRows(base);
+  const base2 = cred.serverUrl.replace(/\/+$/, "");
+  const ledger = getSyncedRows(base2);
   let pushed = 0, absent = 0, scanned = 0;
   for (const field of SYNC_FIELDS) {
-    const needFull = !!opts.force || fieldNeedsFullPass(base, field);
+    const needFull = !!opts.force || fieldNeedsFullPass(base2, field);
     const candidates2 = needFull ? fullRefs() : opts.convRefs ?? fullRefs();
     const send = [];
     const mtimeById = /* @__PURE__ */ new Map();
@@ -21212,15 +21338,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(base, cred.token, chunk);
-      markFieldCoverage(base, field, chunk.map((r) => ({ id: r.session_id, present: true, mtime: mtimeById.get(r.session_id) ?? 0 })));
+      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 })));
       pushed += chunk.length;
     }
     if (absentIds.length) {
-      markFieldCoverage(base, field, absentIds.map((id) => ({ id, present: false, mtime: mtimeById.get(id) ?? 0 })));
+      markFieldCoverage(base2, field, absentIds.map((id) => ({ id, present: false, mtime: mtimeById.get(id) ?? 0 })));
       absent += absentIds.length;
     }
-    if (needFull) markFieldFullPassDone(base, field);
+    if (needFull) markFieldFullPassDone(base2, field);
   }
   return { pushed, absent, scanned };
 }
@@ -21258,7 +21384,7 @@ function reapStaleScanDirs(dir = tmpdir4(), maxAgeMs = 6 * 36e5, now = Date.now(
     if (!name.startsWith("cr-batchscan-")) continue;
     const p = join49(dir, name);
     try {
-      if (now - statSync42(p).mtimeMs < maxAgeMs) continue;
+      if (now - statSync43(p).mtimeMs < maxAgeMs) continue;
       rmSync6(p, { recursive: true, force: true });
       reaped++;
     } catch {
@@ -21337,25 +21463,25 @@ function serverIngestConcurrency(serverUrl) {
   return advertisedIngestConc.get(serverUrl.replace(/\/$/, "")) ?? null;
 }
 async function verifyServerApi(serverUrl, minApi) {
-  const base = serverUrl.replace(/\/$/, "");
-  const seen = capsOk.get(base);
+  const base2 = serverUrl.replace(/\/$/, "");
+  const seen = capsOk.get(base2);
   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(base, {
+  const probe = await probeServer2(base2, {
     fetchImpl: ((url, init) => fetchWithTimeout(String(url), init ?? {}))
   });
-  if (probe.kind !== "ok") throw new Error(probeAdvice2(probe, base));
+  if (probe.kind !== "ok") throw new Error(probeAdvice2(probe, base2));
   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(base, Math.floor(adv));
+    advertisedIngestConc.set(base2, Math.floor(adv));
   }
-  if (caps.limits?.acceptsGzipBody === true) advertisedGzipBody.add(base);
-  else advertisedGzipBody.delete(base);
-  capsOk.set(base, Date.now());
+  if (caps.limits?.acceptsGzipBody === true) advertisedGzipBody.add(base2);
+  else advertisedGzipBody.delete(base2);
+  capsOk.set(base2, Date.now());
   return true;
 }
 async function syncToTarget(cred, opts = {}) {
@@ -21420,7 +21546,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(`${base}/api/sync`, {
+        const res = await fetch(`${base2}/api/sync`, {
           method: "POST",
           // No token ⇒ no auth header: a no-auth local server (AUTH_PROVIDER=none)
           // accepts it as the single 'default' tenant.
@@ -21436,26 +21562,26 @@ async function syncToTargetInScope(cred, opts = {}) {
           acceptedUploads.set(cred.serverUrl, (acceptedUploads.get(cred.serverUrl) ?? 0) + 1);
           const body3 = await res.json().catch(() => ({}));
           if (typeof body3.telemetry === "boolean") {
-            setTelemetryEligible(base, body3.telemetry);
+            setTelemetryEligible(base2, body3.telemetry);
             try {
               const prior = readCollectorHealth()?.telemetryEligible ?? {};
               updateCollectorHealth({
-                telemetryEligible: { ...prior, [base]: { allowed: body3.telemetry, at: Date.now() } }
+                telemetryEligible: { ...prior, [base2]: { allowed: body3.telemetry, at: Date.now() } }
               });
             } catch {
             }
           }
           const adv = body3.limits?.ingestConcurrencyPerTenant;
           if (typeof adv === "number" && Number.isFinite(adv) && adv >= 1) {
-            setServerIngestConcurrency(base, Math.floor(adv));
+            setServerIngestConcurrency(base2, Math.floor(adv));
           }
           if (body3.cli && body3.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(base, { cli: body3.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
+            const plan = planAutoUpdate2(base2, { cli: body3.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
             sweepStaleStaging2();
             if (plan.update) {
-              void runAutoUpdate2(base, authHeaders, ownVersion).catch(() => {
+              void runAutoUpdate2(base2, authHeaders, ownVersion).catch(() => {
               });
             }
           }
@@ -21464,7 +21590,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 ${base}`);
+          throw classedError("auth", `server rejected this machine's device token (HTTP ${res.status} \u2014 revoked?). Reconnect with: chat-recall login ${base2}`);
         }
         if (res.status === 402) {
           let detail = text;
@@ -21485,7 +21611,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 ${base}${why} \u2014 backing off ${Math.round(waitMs / 1e3)}s (attempt ${attempt + 1})`);
+        console.error(`[sync] HTTP ${res.status} from ${base2}${why} \u2014 backing off ${Math.round(waitMs / 1e3)}s (attempt ${attempt + 1})`);
         await sleep(waitMs);
         continue;
       } catch (err) {
@@ -21553,11 +21679,11 @@ async function syncToTargetInScope(cred, opts = {}) {
       }
     };
   };
-  const base = cred.serverUrl.replace(/\/$/, "");
-  const ledger = opts.useLedger ? getSyncedRows(base) : null;
+  const base2 = cred.serverUrl.replace(/\/$/, "");
+  const ledger = opts.useLedger ? getSyncedRows(base2) : null;
   const convBatch = makeBatcher("conversations", 25, false, (rows) => {
     try {
-      markSynced(base, rows.map((r) => {
+      markSynced(base2, 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 };
@@ -21572,7 +21698,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(`${base}/api/sync`, {
+      const res = await fetch(`${base2}/api/sync`, {
         method: "POST",
         headers,
         body: JSON.stringify({ conversations: convs }),
@@ -21583,10 +21709,10 @@ async function syncToTargetInScope(cred, opts = {}) {
       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(base, { cli: body2.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
+        const plan = planAutoUpdate2(base2, { cli: body2.cli }, ownVersion, process.env.CHAT_RECALL_AUTO_UPDATE);
         sweepStaleStaging2();
         if (plan.update) {
-          void runAutoUpdate2(base, authHeaders, ownVersion).catch(() => {
+          void runAutoUpdate2(base2, authHeaders, ownVersion).catch(() => {
           });
         }
       }
@@ -21594,7 +21720,7 @@ async function syncToTargetInScope(cred, opts = {}) {
       const acked = convs.filter((c) => !fullNeeded.has(c.session_id));
       if (acked.length > 0) {
         try {
-          markSynced(base, acked.map((c) => ({
+          markSynced(base2, acked.map((c) => ({
             id: c.session_id,
             mtime: c.mtime,
             offset: c.from_offset,
@@ -21612,13 +21738,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(`${base}/api/sync`, {
+      const res = await fetch(`${base2}/api/sync`, {
         method: "POST",
         headers,
         body: JSON.stringify({ conversations: [conv] }),
@@ -21628,14 +21755,15 @@ async function syncToTargetInScope(cred, opts = {}) {
       const body2 = await res.json().catch(() => ({}));
       const id = conv.session_id;
       const guarded = (body2.shrink_guarded ?? []).find((g) => g.session_id === id);
+      const staged = (body2.rebuild_staged ?? []).includes(id);
       const mtime = conv.mtime;
       try {
-        if (!guarded) {
-          markSynced(base, [{ id, mtime, offset: conv.from_offset, size: conv.from_offset, acked: true }]);
+        if (staged || !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(base, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true }]);
+          markSynced(base2, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true }]);
         } else {
-          markSynced(base, [{ id, mtime }]);
+          markSynced(base2, [{ id, mtime }]);
         }
       } catch {
       }
@@ -21701,7 +21829,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 ${base}`);
+  trace?.(`walk start: ${slice.length} ref(s) \u2192 ${base2}`);
   if (upload.sessionMeta) {
     try {
       await reconcileFieldsForTarget(
@@ -21716,7 +21844,7 @@ async function syncToTargetInScope(cred, opts = {}) {
         { convRefs: slice }
       );
     } catch (e) {
-      console.error(`[sync] field reconcile (${base}): ${e instanceof Error ? e.message : e}`);
+      console.error(`[sync] field reconcile (${base2}): ${e instanceof Error ? e.message : e}`);
     }
   }
   trace?.("field reconcile done");
@@ -21758,7 +21886,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   }
   trace?.("conversation walk start");
   const walkStartedAt = Date.now();
-  const firstWalk = (ledger ?? getSyncedRows(base)).size === 0;
+  const firstWalk = (ledger ?? getSyncedRows(base2)).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;
@@ -21798,7 +21926,7 @@ async function syncToTargetInScope(cred, opts = {}) {
           continue;
         } else {
           try {
-            markSynced(base, [{ id: ref.prefixedId, mtime: ref.mtime }]);
+            markSynced(base2, [{ id: ref.prefixedId, mtime: ref.mtime }]);
           } catch {
           }
           skipped++;
@@ -21821,7 +21949,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(base, [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(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 }]);
         } catch {
         }
       }
@@ -21831,7 +21959,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     if (!built) {
       if (ledger) {
         try {
-          markSynced(base, [{ id: ref.prefixedId, mtime: ref.mtime }]);
+          markSynced(base2, [{ id: ref.prefixedId, mtime: ref.mtime }]);
         } catch {
         }
       }
@@ -21888,7 +22016,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     walked++;
     if (walked % 250 === 0) console.error(`[sync] ${walked}/${slice.length} sessions\u2026`);
   }
-  const itemVersions = loadItemVersions(base);
+  const itemVersions = loadItemVersions(base2);
   const seenTools = /* @__PURE__ */ new Set();
   const seenItemKeys = /* @__PURE__ */ new Map();
   const registry = buildSourceRegistry();
@@ -21982,7 +22110,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   await appendFlush();
   for (const id of appendResults.fullResyncNeeded) {
     try {
-      markFullResync(base, id);
+      markFullResync(base2, id);
     } catch {
     }
   }
@@ -21995,7 +22123,7 @@ async function syncToTargetInScope(cred, opts = {}) {
   await findingsBatch.drain();
   await drainInflight();
   {
-    const sentHashes = loadInventoryHashes(base);
+    const sentHashes = loadInventoryHashes(base2);
     const entries = [];
     const hashes = {};
     for (const [sourceType, ids] of inventory) {
@@ -22009,7 +22137,7 @@ async function syncToTargetInScope(cred, opts = {}) {
     if (entries.length > 0) {
       try {
         await post({ inventory: entries });
-        saveInventoryHashes(base, hashes);
+        saveInventoryHashes(base2, hashes);
       } catch (err) {
         console.error(`[sync] toolkit inventory not sent (it is retried next sync): ${err instanceof Error ? err.message : err}`);
       }
@@ -22020,7 +22148,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(base, rec);
+      saveItemVersions(base2, rec);
     } catch {
     }
   }
@@ -22033,9 +22161,9 @@ async function syncToTargetInScope(cred, opts = {}) {
     }
     if (tombstones.length > 0) {
       await post({ tombstones });
-      const data = getLedgerData(base);
+      const data = getLedgerData(base2);
       for (const t of tombstones) delete data[t.session_id];
-      persistLedgerData(base, data);
+      persistLedgerData(base2, data);
     }
   }
   if (opts.prune) await post({ prune_empty_sessions: true });
@@ -22363,8 +22491,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);
@@ -22377,6 +22510,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
@@ -22423,6 +22557,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
@@ -22506,7 +22641,7 @@ var init_sync_client = __esm({
       ownVersion = JSON.parse(readFileSync38(join49(dir, "../package.json"), "utf-8")).version || ownVersion;
     } catch {
       try {
-        if (true) ownVersion = "0.7.14";
+        if (true) ownVersion = "0.7.16";
       } catch {
       }
     }
@@ -22665,9 +22800,9 @@ async function refreshUpdateCheck(force = false) {
     const { loadAllCredentials: loadAllCredentials2 } = await Promise.resolve().then(() => (init_sync_client(), sync_client_exports));
     for (const cred of loadAllCredentials2()) {
       if (!cred.serverUrl) continue;
-      const base = cred.serverUrl.replace(/\/+$/, "");
+      const base2 = cred.serverUrl.replace(/\/+$/, "");
       try {
-        const res = await fetchWithTimeout(`${base}/api/capabilities`, {
+        const res = await fetchWithTimeout(`${base2}/api/capabilities`, {
           headers: cred.token ? { authorization: `Bearer ${cred.token}` } : {}
         }, 5e3);
         if (!res.ok) continue;
@@ -23056,7 +23191,7 @@ __export(install_skills_exports, {
   skillsSourceDir: () => skillsSourceDir,
   uninstallSkills: () => uninstallSkills
 });
-import { readdirSync as readdirSync33, existsSync as existsSync47, mkdirSync as mkdirSync15, rmSync as rmSync8, cpSync, writeFileSync as writeFileSync13, readFileSync as readFileSync42, statSync as statSync43, realpathSync as realpathSync4 } from "fs";
+import { readdirSync as readdirSync33, existsSync as existsSync47, mkdirSync as mkdirSync15, rmSync as rmSync8, cpSync, writeFileSync as writeFileSync13, readFileSync as readFileSync42, statSync as statSync44, realpathSync as realpathSync4 } from "fs";
 import { createHash as createHash12 } from "crypto";
 import { join as join52, basename as basename23 } from "path";
 function skillsSourceDir() {
@@ -23297,18 +23432,18 @@ function usableDir(dir) {
   if (!isDir(dir)) {
     const missing = [];
     let cur = dir;
-    let base = false;
+    let base2 = false;
     while (missing.length < MAX_MISSING_LEVELS) {
       const parent = dirname(cur);
       if (parent === cur) break;
       missing.push(cur);
       if (isDir(parent)) {
-        base = true;
+        base2 = true;
         break;
       }
       cur = parent;
     }
-    if (!base) return false;
+    if (!base2) return false;
     for (let i = missing.length - 1; i >= 0; i--) {
       try {
         mkdirSync(missing[i]);
@@ -29497,7 +29632,7 @@ function installCrashGuards() {
     reportClientEvent2("mcp_crash", { message: err.stack || err.message });
   });
 }
-var RELAY_VERSION = true ? "0.7.14" : "0.0.0";
+var RELAY_VERSION = true ? "0.7.16" : "0.0.0";
 function daemonIdleSecs() {
   const raw = process.env.CHAT_RECALL_DAEMON_IDLE_SECS;
   if (raw === void 0) return 900;