chat-recall 0.7.17 → 0.7.19

package/dist/scan-worker.js

@@ -4524,6 +4524,7 @@ function defaultSourcesEnabled() {
       commands: true
     },
     cursor: { sessions: true, skills: true, agents: true, commands: true },
+    hermes: { sessions: true },
     shared: { skills: true },
     common: { mcps: true, agentMd: true }
   };
@@ -4594,6 +4595,7 @@ function mergeSources(base, partial) {
     codex: { ...base.enabled.codex, ...partial.enabled?.codex ?? {} },
     agy: { ...base.enabled.agy, ...inherited, ...partial.enabled?.agy ?? {} },
     cursor: { ...base.enabled.cursor, ...partial.enabled?.cursor ?? {} },
+    hermes: { ...base.enabled.hermes, ...partial.enabled?.hermes ?? {} },
     shared: { ...base.enabled.shared, ...partial.enabled?.shared ?? {} },
     common: { ...base.enabled.common, ...partial.enabled?.common ?? {} }
   };
@@ -4605,6 +4607,7 @@ function mergeSources(base, partial) {
     agyHome: partial.agyHome ?? base.agyHome,
     cursorHome: partial.cursorHome ?? base.cursorHome,
     cursorIdeHome: partial.cursorIdeHome ?? base.cursorIdeHome,
+    hermesHome: partial.hermesHome ?? base.hermesHome,
     extraClaudeHomes: partial.extraClaudeHomes ?? base.extraClaudeHomes,
     approvedHomes: partial.approvedHomes ?? base.approvedHomes,
     declinedHomes: partial.declinedHomes ?? base.declinedHomes,
@@ -5284,6 +5287,8 @@ function declaredOrigin(value) {
 function userRecordOrigin(obj, text) {
   if (obj.isSidechain === true)
     return "subagent";
+  if (obj.isCompactSummary === true)
+    return "compact-summary";
   const declared = declaredOrigin(obj.origin);
   if (declared && declared !== "human")
     return declared;
@@ -5430,6 +5435,7 @@ function redactContainer(c, redact) {
     }))
   };
 }
+var RAW_PARSE_MAX_BYTES;
 var init_raw = __esm({
   "../engine/dist/transcript/raw.js"() {
     "use strict";
@@ -5437,6 +5443,7 @@ var init_raw = __esm({
     init_claude();
     init_codex();
     init_from_events();
+    RAW_PARSE_MAX_BYTES = 40 * 1024 * 1024;
   }
 });
 
@@ -5524,6 +5531,13 @@ function grandfatherLegacyHomes() {
   }
   return { seeded };
 }
+function defaultHermesHome() {
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA?.trim() || join3(homedir2(), "AppData", "Local");
+    return join3(local, "hermes");
+  }
+  return join3(homedir2(), ".hermes");
+}
 function primaryHomes() {
   const home = homedir2();
   const env = process.env;
@@ -5540,7 +5554,8 @@ function primaryHomes() {
     env.CHAT_RECALL_CODEX_HOME || s?.codexHome || join3(home, ".codex"),
     env.CHAT_RECALL_AGY_HOME || s?.agyHome || join3(home, ".gemini", "antigravity-cli"),
     env.CHAT_RECALL_CURSOR_HOME || s?.cursorHome || join3(home, ".cursor"),
-    dirOf(opencodeDb)
+    dirOf(opencodeDb),
+    env.CHAT_RECALL_HERMES_HOME || s?.hermesHome || env.HERMES_HOME?.trim() || defaultHermesHome()
   ];
   return candidates.map(normalizeHomePath);
 }
@@ -5619,6 +5634,9 @@ function geminiHomeDir() {
 function opencodeDbPath() {
   return process.env.CHAT_RECALL_OPENCODE_DB || sources().opencodeDbPath || join4(homedir3(), ".local", "share", "opencode", "opencode.db");
 }
+function hermesHomeDir() {
+  return process.env.CHAT_RECALL_HERMES_HOME || sources().hermesHome || process.env.HERMES_HOME?.trim() || defaultHermesHome();
+}
 function codexHomeDir() {
   return process.env.CHAT_RECALL_CODEX_HOME || sources().codexHome || join4(homedir3(), ".codex");
 }
@@ -5724,6 +5742,22 @@ function opencodeDbPaths(opts = {}) {
     dbs.push(primary);
   return applyExclusions(dbs, opts.includeExcluded);
 }
+function hermesDbPaths(opts = {}) {
+  const root = hermesHomeDir();
+  const dbs = [join4(root, "state.db")];
+  try {
+    const profiles = join4(root, "profiles");
+    for (const entry of readdirSync2(profiles, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      const p = join4(profiles, entry.name, "state.db");
+      if (existsSync3(p))
+        dbs.push(p);
+    }
+  } catch {
+  }
+  return applyExclusions(dbs, opts.includeExcluded);
+}
 var sources, _sourceExclusionFilter;
 var init_tool_paths = __esm({
   "../engine/dist/core/tool-paths.js"() {
@@ -7001,6 +7035,71 @@ function readTailFromOffset(path, offset, maxBytes = TAIL_READ_MAX_BYTES) {
     }
   }
 }
+function readSourcesFromOffset(paths, offset, maxBytes = TAIL_READ_MAX_BYTES) {
+  let start = 0;
+  let linesBefore = 0;
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    let size = 0;
+    try {
+      size = statSync3(path).size;
+    } catch {
+      size = 0;
+    }
+    const last = i === paths.length - 1;
+    if (!last && offset >= start + size) {
+      const lines = linesBeforeOffset(path, size);
+      if (lines === void 0)
+        return { text: "", newOffset: offset };
+      linesBefore += lines + (size > 0 && !endsWithNewline(path, size) ? 1 : 0);
+      start += size;
+      continue;
+    }
+    const local = offset - start;
+    const read = readTailFromOffset(path, local, maxBytes);
+    const shift = (r) => ({
+      ...r,
+      newOffset: start + r.newOffset,
+      ...r.baseLine !== void 0 ? { baseLine: linesBefore + r.baseLine } : {}
+    });
+    if (last || read.newOffset > local || local >= size)
+      return shift(read);
+    if (size - local > maxBytes)
+      return { text: "", newOffset: start + size, skippedBytes: size - local };
+    let fd = null;
+    try {
+      fd = openSync(path, "r");
+      const text = readAt(fd, local, size - local).toString("utf-8");
+      return shift({ text, newOffset: size, baseLine: linesBeforeOffset(path, local) });
+    } catch {
+      return { text: "", newOffset: offset };
+    } finally {
+      if (fd !== null) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
+  }
+  return { text: "", newOffset: offset };
+}
+function endsWithNewline(path, size) {
+  let fd = null;
+  try {
+    fd = openSync(path, "r");
+    return readAt(fd, size - 1, 1)[0] === 10;
+  } catch {
+    return true;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
 function findNewline(fd, from, size) {
   const block = Buffer.allocUnsafe(SKIP_SCAN_BYTES);
   let pos = from;
@@ -9479,6 +9578,473 @@ var init_cursor = __esm({
   }
 });
 
+// ../engine/dist/core/backends/hermes.js
+import { existsSync as existsSync10 } from "fs";
+function firstUserPrompt(db, sessionId) {
+  try {
+    const row = db.prepare(`
+      SELECT substr(content, 1, 400) AS text FROM messages
+      WHERE session_id = ? AND role = 'user' AND active = 1 AND _compressed_summary = 0
+        AND (display_kind IS NULL OR display_kind = 'steer')
+        AND length(trim(content)) > 0
+      ORDER BY id LIMIT 1
+    `).get(sessionId);
+    return row?.text ? flatString(row.text.slice(0, 200)) : "";
+  } catch {
+    return "";
+  }
+}
+function messageRowsToEvents(rows) {
+  const events = [];
+  let line = 0;
+  for (const r of rows) {
+    line++;
+    if (r.active === 0)
+      continue;
+    if (r.display_kind === "failed_turn" || r.display_kind === "hidden")
+      continue;
+    const ts = Math.round((r.timestamp || 0) * 1e3);
+    const tsIso = ts ? new Date(ts).toISOString() : void 0;
+    const text = (r.content ?? "").trim();
+    if (r._compressed_summary === 1) {
+      if (text)
+        events.push({ kind: "summary", ts, tsIso, line, text });
+      continue;
+    }
+    if (r.role === "user") {
+      if (!text)
+        continue;
+      events.push({
+        kind: "user",
+        ts,
+        tsIso,
+        line,
+        text,
+        ...r.display_kind === "process_complete" ? { origin: "task-notification" } : {}
+      });
+      continue;
+    }
+    if (r.role === "assistant") {
+      if (text)
+        events.push({ kind: "assistant_text", ts, tsIso, line, text });
+      for (const call of parseToolCalls(r.tool_calls)) {
+        const toolName = call.function?.name ?? "";
+        const toolInput = parseArguments(call.function?.arguments);
+        const command = toolName === "terminal" && typeof toolInput?.command === "string" ? toolInput.command : void 0;
+        events.push({
+          kind: "tool_use",
+          ts,
+          tsIso,
+          line,
+          toolName,
+          toolUseId: call.id || call.call_id || `${r.id}:${toolName}`,
+          toolInput,
+          ...command ? { command } : {}
+        });
+      }
+      continue;
+    }
+    if (r.role === "tool") {
+      const body = r.content ?? "";
+      const { exitCode, isError } = toolResultStatus(body);
+      events.push({
+        kind: "tool_result",
+        ts,
+        tsIso,
+        line,
+        toolUseId: r.tool_call_id ?? void 0,
+        toolName: r.tool_name ?? void 0,
+        resultBody: body,
+        resultIsError: isError,
+        ...exitCode !== void 0 ? { resultExitCode: exitCode } : {},
+        resultBytes: Buffer.byteLength(body)
+      });
+    }
+  }
+  return events;
+}
+function parseToolCalls(json) {
+  if (!json)
+    return [];
+  try {
+    const calls = JSON.parse(json);
+    return Array.isArray(calls) ? calls : [];
+  } catch {
+    return [];
+  }
+}
+function parseArguments(args) {
+  if (typeof args !== "string")
+    return args ?? {};
+  try {
+    return JSON.parse(args);
+  } catch {
+    return { raw: args };
+  }
+}
+function toolResultStatus(body) {
+  if (!body.startsWith("{"))
+    return { isError: false };
+  try {
+    const r = JSON.parse(body);
+    const exitCode = typeof r.exit_code === "number" ? r.exit_code : void 0;
+    const hasError = r.error !== void 0 && r.error !== null && r.error !== "";
+    return { exitCode, isError: hasError || exitCode !== void 0 && exitCode !== 0 };
+  } catch {
+    return { isError: false };
+  }
+}
+var PREFIX5, MESSAGE_COLUMNS, ARCHIVED_SESSION_COLUMNS, SESSION_MTIME_SQL, HermesBackend, hermesBackend;
+var init_hermes = __esm({
+  "../engine/dist/core/backends/hermes.js"() {
+    "use strict";
+    init_sqlite_reader();
+    init_tool_paths();
+    init_session_outcome();
+    init_session_git();
+    init_generic_engine();
+    init_flat_string();
+    PREFIX5 = "hermes_";
+    MESSAGE_COLUMNS = "id, role, content, tool_calls, tool_call_id, tool_name, timestamp, display_kind, active, _compressed_summary";
+    ARCHIVED_SESSION_COLUMNS = [
+      "id",
+      "source",
+      "title",
+      "model",
+      "cwd",
+      "git_branch",
+      "git_repo_root",
+      "parent_session_id",
+      "started_at",
+      "ended_at",
+      "end_reason",
+      "message_count",
+      "tool_call_count",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_write_tokens",
+      "reasoning_tokens",
+      "estimated_cost_usd",
+      "actual_cost_usd"
+    ];
+    SESSION_MTIME_SQL = `MAX(
+  s.started_at,
+  COALESCE(s.ended_at, 0),
+  COALESCE(s.last_activity_at, 0),
+  COALESCE((SELECT MAX(m.timestamp) FROM messages m WHERE m.session_id = s.id), 0)
+)`;
+    HermesBackend = class {
+      id = "hermes";
+      idPrefix = PREFIX5;
+      displayName = "Hermes";
+      homeDir() {
+        return hermesHomeDir();
+      }
+      /** Every Hermes database on this machine, the root profile first. */
+      dbPaths() {
+        return hermesDbPaths();
+      }
+      isAvailable() {
+        return this.dbPaths().some((p) => existsSync10(p));
+      }
+      /** The database that holds this session. A session id is unique within a
+       *  database, and each named profile has its own. */
+      dbPathFor(rawId) {
+        const cached = this._dbForSession.get(rawId);
+        if (cached)
+          return cached;
+        for (const path of this.dbPaths()) {
+          const db = openSqliteReadonly(path);
+          if (!db)
+            continue;
+          try {
+            if (db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(rawId)) {
+              this._dbForSession.set(rawId, path);
+              return path;
+            }
+          } catch {
+          } finally {
+            db.close();
+          }
+        }
+        return null;
+      }
+      _dbForSession = /* @__PURE__ */ new Map();
+      /** Tests, and anything that adds a profile mid-process. */
+      _clearDbRouting() {
+        this._dbForSession.clear();
+      }
+      // ── ID handling ────────────────────────────────────────────────
+      matchesId(id) {
+        return id.startsWith(PREFIX5);
+      }
+      toRawId(id) {
+        return id.startsWith(PREFIX5) ? id.slice(PREFIX5.length) : id;
+      }
+      toPrefixedId(rawId) {
+        return rawId.startsWith(PREFIX5) ? rawId : PREFIX5 + rawId;
+      }
+      // ── Location ───────────────────────────────────────────────────
+      findSession(id) {
+        const rawId = this.toRawId(id);
+        const path = this.dbPathFor(rawId);
+        if (!path)
+          return null;
+        const db = openSqliteReadonly(path);
+        if (!db)
+          return null;
+        try {
+          const row = db.prepare(`
+        SELECT s.cwd, s.git_repo_root, ${SESSION_MTIME_SQL} AS mtime
+        FROM sessions s WHERE s.id = ?
+      `).get(rawId);
+          if (!row)
+            return null;
+          return {
+            path,
+            format: "sqlite",
+            projectDir: "",
+            projectPath: row.git_repo_root || row.cwd || "",
+            mtime: Math.round((row.mtime || 0) * 1e3)
+          };
+        } catch {
+          return null;
+        } finally {
+          db.close();
+        }
+      }
+      listSessions(opts = {}) {
+        const byId = /* @__PURE__ */ new Map();
+        for (const dbPath of this.dbPaths()) {
+          if (!existsSync10(dbPath))
+            continue;
+          for (const ref of this.listSessionsInDb(dbPath, opts)) {
+            const prior = byId.get(ref.rawId);
+            if (!prior || ref.mtime > prior.mtime)
+              byId.set(ref.rawId, ref);
+          }
+        }
+        const all = [...byId.values()].sort((a, b) => b.mtime - a.mtime);
+        return opts.limit ? all.slice(0, opts.limit) : all;
+      }
+      listSessionsInDb(dbPath, opts) {
+        const cutoffSec = (opts.sinceMs ?? 0) / 1e3;
+        const filter = opts.projectFilter?.toLowerCase();
+        const db = openSqliteReadonly(dbPath);
+        if (!db)
+          return [];
+        try {
+          const rows = db.prepare(`
+        SELECT * FROM (
+          SELECT s.id, s.cwd, s.git_repo_root, s.started_at, s.message_count,
+                 ${SESSION_MTIME_SQL} AS mtime
+          FROM sessions s
+        ) WHERE mtime >= ? ORDER BY mtime DESC
+      `).all(cutoffSec);
+          const out = [];
+          for (const row of rows) {
+            const projectPath = row.git_repo_root || row.cwd || "";
+            if (filter && !projectPath.toLowerCase().includes(filter))
+              continue;
+            const mtime = Math.round(row.mtime * 1e3);
+            this._dbForSession.set(row.id, dbPath);
+            out.push({
+              toolId: "hermes",
+              rawId: row.id,
+              prefixedId: this.toPrefixedId(row.id),
+              projectPath,
+              projectDir: "",
+              fullPath: dbPath,
+              created: new Date(Math.round(row.started_at * 1e3)).toISOString(),
+              modified: new Date(mtime).toISOString(),
+              mtime,
+              firstPrompt: opts.previews === false ? "" : firstUserPrompt(db, row.id),
+              messageCount: opts.previews === false ? 0 : row.message_count ?? 0
+            });
+            if (opts.limit && out.length >= opts.limit)
+              break;
+          }
+          return out;
+        } catch {
+          return [];
+        } finally {
+          db.close();
+        }
+      }
+      /** Hermes writes a title for each session (a model-written one, or the
+       *  first prompt for a one-shot run). */
+      getNativeTitle(rawId) {
+        const path = this.dbPathFor(this.toRawId(rawId));
+        if (!path)
+          return null;
+        const db = openSqliteReadonly(path);
+        if (!db)
+          return null;
+        try {
+          const row = db.prepare("SELECT title FROM sessions WHERE id = ?").get(this.toRawId(rawId));
+          const t = row?.title?.trim();
+          return t ? t.slice(0, 200) : null;
+        } catch {
+          return null;
+        } finally {
+          db.close();
+        }
+      }
+      // ── Generic-engine inputs ───────────────────────────────────────
+      fileToolMap = {
+        write_file: "write",
+        patch: "edit",
+        read_file: "read"
+      };
+      /**
+       * `write_file` carries `{ path, content }`. `patch` carries
+       * `{ mode: 'replace', path, old_string, new_string }`; its other mode,
+       * `patch`, is a multi-file V4A patch with no single before and after.
+       */
+      extractEditDelta(toolName, input) {
+        if (input == null || typeof input !== "object")
+          return null;
+        const inp = input;
+        if (toolName === "write_file") {
+          return { before: "", after: typeof inp.content === "string" ? inp.content : null };
+        }
+        if (toolName === "patch" && (inp.mode === void 0 || inp.mode === "replace")) {
+          const before = typeof inp.old_string === "string" ? inp.old_string : null;
+          const after = typeof inp.new_string === "string" ? inp.new_string : null;
+          if (before === null && after === null)
+            return null;
+          return { before, after };
+        }
+        return null;
+      }
+      readEvents(rawId) {
+        const id = this.toRawId(rawId);
+        const path = this.dbPathFor(id);
+        if (!path)
+          return [];
+        const db = openSqliteReadonly(path);
+        if (!db)
+          return [];
+        try {
+          const rows = db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE session_id = ? ORDER BY id`).all(id);
+          return messageRowsToEvents(rows);
+        } catch {
+          return [];
+        } finally {
+          db.close();
+        }
+      }
+      /**
+       * Events from the dump `exportRawSession` writes, for a session rebuilt from
+       * the server's archive. The archive joins the lines of every dump it got, so
+       * a row that changed (a rewind sets `active` to 0) is there more than once.
+       * The last copy of each row id is the newest.
+       */
+      readEventsFromText(text) {
+        const rows = /* @__PURE__ */ new Map();
+        for (const line of text.split("\n")) {
+          if (!line.trim())
+            continue;
+          try {
+            const rec = JSON.parse(line);
+            if (rec.kind === "message" && rec.row) {
+              rows.delete(rec.row.id);
+              rows.set(rec.row.id, rec.row);
+            }
+          } catch {
+          }
+        }
+        return messageRowsToEvents([...rows.values()].sort((a, b) => a.id - b.id));
+      }
+      // ── Per-session operations — all delegate to the generic engine ─
+      extractTurns(id, opts = {}) {
+        return extractTurnsFromEvents(this.toPrefixedId(id), this.readEvents(id), opts);
+      }
+      liveScanEdits(id) {
+        const located = this.findSession(id);
+        if (!located) {
+          return { found: false, projectPath: "", projectDir: "", edits: [], fileMtime: 0, tool: "hermes" };
+        }
+        return liveScanEditsFromEvents(this.readEvents(id), this.fileToolMap, {
+          sessionId: this.toPrefixedId(id),
+          tool: "hermes",
+          projectPath: located.projectPath,
+          projectDir: located.projectDir,
+          fileMtime: located.mtime,
+          found: true
+        });
+      }
+      replay(id) {
+        const located = this.findSession(id);
+        if (!located) {
+          return { sessionId: this.toPrefixedId(id), found: false, projectPath: "", files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+        }
+        return replayFromEvents(this.toPrefixedId(id), this.readEvents(id), this.fileToolMap, this.extractEditDelta.bind(this), {
+          projectPath: located.projectPath,
+          found: true
+        });
+      }
+      computeOutcome(id, opts) {
+        return computeOutcome(this.toPrefixedId(id), opts);
+      }
+      /** File edits since `sinceMs` across the sessions active since then. */
+      collectRecentEdits(opts) {
+        const refs = this.listSessions({ sinceMs: opts.sinceMs, projectFilter: opts.projectFilter, previews: false });
+        const edits = [];
+        for (const ref of opts.limitSessions ? refs.slice(0, opts.limitSessions) : refs) {
+          for (const e of this.liveScanEdits(ref.rawId).edits) {
+            if (e.ts >= opts.sinceMs)
+              edits.push(e);
+          }
+        }
+        return edits.sort((a, b) => b.ts - a.ts);
+      }
+      getCommits(id, files, startMs, endMs, bufferMinutes) {
+        return getSessionCommits(this.toPrefixedId(id), files, startMs, endMs, bufferMinutes);
+      }
+      /**
+       * The session row and its messages as JSONL, one row per line in id order.
+       * Hermes rewrites and compacts its database, so the archive keeps the rows
+       * as they were synced.
+       */
+      exportRawSession(id) {
+        const rawId = this.toRawId(id);
+        const path = this.dbPathFor(rawId);
+        if (!path)
+          return null;
+        const db = openSqliteReadonly(path);
+        if (!db)
+          return null;
+        try {
+          const have = new Set(db.prepare(`SELECT name FROM pragma_table_info('sessions')`).all().map((c) => c.name));
+          const cols = ARCHIVED_SESSION_COLUMNS.filter((c) => have.has(c)).map((c) => `s.${c}`);
+          const session = db.prepare(`
+        SELECT ${[...cols, `${SESSION_MTIME_SQL} AS mtime`].join(", ")}
+        FROM sessions s WHERE s.id = ?
+      `).get(rawId);
+          if (!session)
+            return null;
+          const rows = db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE session_id = ? ORDER BY id`).all(rawId);
+          const lines = [JSON.stringify({ kind: "session", row: session })];
+          for (const r of rows)
+            lines.push(JSON.stringify({ kind: "message", row: r }));
+          return {
+            tool: "hermes",
+            mtime: Math.round(Number(session.mtime || 0) * 1e3),
+            files: [{ name: `${rawId}.dump.jsonl`, bytes: Buffer.from(lines.join("\n") + "\n", "utf-8") }]
+          };
+        } catch {
+          return null;
+        } finally {
+          db.close();
+        }
+      }
+    };
+    hermesBackend = new HermesBackend();
+  }
+});
+
 // ../engine/dist/core/backends/index.js
 function bootstrapBackends() {
   registerBackend(claudeBackend);
@@ -9486,6 +10052,7 @@ function bootstrapBackends() {
   registerBackend(codexBackend);
   registerBackend(agyBackend);
   registerBackend(cursorBackend);
+  registerBackend(hermesBackend);
 }
 var init_backends = __esm({
   "../engine/dist/core/backends/index.js"() {
@@ -9496,6 +10063,7 @@ var init_backends = __esm({
     init_codex2();
     init_agy();
     init_cursor();
+    init_hermes();
     init_tool_backend();
     _setRegistryBootstrapper(bootstrapBackends);
   }
@@ -9708,7 +10276,7 @@ var init_session_outcome = __esm({
 });
 
 // ../engine/dist/core/first-prompt.js
-import { createReadStream, existsSync as existsSync10, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
+import { createReadStream, existsSync as existsSync11, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
 import { StringDecoder } from "string_decoder";
 function stripBanners(s) {
   let out = s;
@@ -9877,7 +10445,7 @@ var init_project_dir_name = __esm({
 });
 
 // ../engine/dist/core/backends/claude.js
-import { existsSync as existsSync11, readdirSync as readdirSync8, readFileSync as readFileSync7, statSync as statSync9, openSync as openSync4, readSync as readSync4, closeSync as closeSync4 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync8, readFileSync as readFileSync7, statSync as statSync9, openSync as openSync4, readSync as readSync4, closeSync as closeSync4 } from "fs";
 import { join as join11, basename as basename6 } from "path";
 function stripReminders(text) {
   return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
@@ -9947,7 +10515,7 @@ var init_claude2 = __esm({
         return join11(this.homeDir(), "history.jsonl");
       }
       isAvailable() {
-        return existsSync11(this.projectsDir());
+        return existsSync12(this.projectsDir());
       }
       // ── ID handling ────────────────────────────────────────────────
       /**
@@ -10053,7 +10621,7 @@ var init_claude2 = __esm({
             prior.modified = ref.modified;
           }
         };
-        if (!existsSync11(root))
+        if (!existsSync12(root))
           return;
         for (const proj of readdirSync8(root, { withFileTypes: true })) {
           if (!proj.isDirectory())
@@ -10064,12 +10632,12 @@ var init_claude2 = __esm({
           const projectPath = resolveProjectDirName(proj.name);
           const indexPath = join11(projPath, "sessions-index.json");
           const indexed = /* @__PURE__ */ new Set();
-          if (existsSync11(indexPath)) {
+          if (existsSync12(indexPath)) {
             try {
               const indexData = JSON.parse(readFileSync7(indexPath, "utf-8"));
               const entries = indexData.entries || [];
               for (const entry of entries) {
-                if (!entry.fullPath || !existsSync11(entry.fullPath))
+                if (!entry.fullPath || !existsSync12(entry.fullPath))
                   continue;
                 indexed.add(entry.sessionId);
                 add({
@@ -10394,7 +10962,7 @@ var init_claude2 = __esm({
       collectRecentEdits(opts) {
         const candidates = [];
         for (const root of claudeProjectDirs()) {
-          if (!existsSync11(root))
+          if (!existsSync12(root))
             continue;
           for (const projEntry of readdirSync8(root, { withFileTypes: true })) {
             if (!projEntry.isDirectory())
@@ -10416,7 +10984,7 @@ var init_claude2 = __esm({
                 const st = statSync9(fp);
                 let mtime = st.mtimeMs;
                 const subDir = join11(projPath, f.slice(0, -6), "subagents");
-                if (existsSync11(subDir)) {
+                if (existsSync12(subDir)) {
                   for (const sub of readdirSync8(subDir)) {
                     try {
                       const subSt = statSync9(join11(subDir, sub));
@@ -10493,27 +11061,45 @@ var init_claude2 = __esm({
       /**
        * True when this session exists in MORE THAN ONE home.
        *
-       * Such a session cannot be tail-appended: `fileSize()` is the SUM across
-       * copies while a byte offset addresses ONE file, so the two disagree by
-       * construction and the "tail" is either empty or the wrong bytes. The caller
-       * uses this to force a FULL sync, which ships the unioned container and is
-       * correct regardless of how the halves are arranged.
-       *
        * Measured on ec05f266: ~/.claude 1715 records, ~/.claude-work 205 records,
-       * zero overlap. An offset-based append against a 5846662-byte "size" that no
-       * single file has could only ever ship nonsense.
+       * zero overlap. `fileSize()` is the sum across the copies, and
+       * `readFromOffset()` reads them joined end to end, primary first.
        */
       spansMultipleSources(prefixedId) {
         return findSessionFiles(this.toRawId(prefixedId)).length > 1;
       }
+      /**
+       * The copies before the last one, each with its size. Claude Code writes to
+       * the home of the profile that runs the session, so the live copy can grow,
+       * appear, vanish or merge back into the primary. Each of those moves bytes
+       * under an offset into the joined copies; this key changes with all of them.
+       */
+      sourceLayout(prefixedId) {
+        const copies = findSessionFiles(this.toRawId(prefixedId));
+        if (copies.length < 2)
+          return "";
+        return copies.slice(0, -1).map((c) => {
+          let size = -1;
+          try {
+            size = statSync9(c.path).size;
+          } catch {
+          }
+          return `${c.path}:${size}`;
+        }).join("|");
+      }
+      /**
+       * Session 8de13d0a had 31 MB in ~/.claude and 2 MB in ~/.claude-work. Over
+       * the 24 MB build ceiling a sync ships the transcript in chunks read here,
+       * and this returned no text for a session in two homes. Each sync shipped
+       * nothing, and the server stayed three hours behind.
+       */
       async readFromOffset(prefixedId, offset, maxBytes) {
-        const rawId = this.toRawId(prefixedId);
-        const copies = findSessionFiles(rawId);
+        const copies = findSessionFiles(this.toRawId(prefixedId));
         if (copies.length === 0)
           return { text: "", newOffset: offset };
-        if (copies.length > 1)
-          return { text: "", newOffset: offset };
-        return readTailFromOffset(copies[0].path, offset, maxBytes);
+        if (copies.length === 1)
+          return readTailFromOffset(copies[0].path, offset, maxBytes);
+        return readSourcesFromOffset(copies.map((c) => c.path), offset, maxBytes);
       }
     };
     claudeBackend = new ClaudeBackend();
@@ -10528,11 +11114,11 @@ var init_model_pricing = __esm({
 });
 
 // ../engine/dist/parsers/session.js
-import { createReadStream as createReadStream2, existsSync as existsSync12, readdirSync as readdirSync9, readFileSync as readFileSync8, statSync as statSync10, openSync as openSync5, readSync as readSync5, closeSync as closeSync5 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync13, readdirSync as readdirSync9, readFileSync as readFileSync8, statSync as statSync10, openSync as openSync5, readSync as readSync5, closeSync as closeSync5 } from "fs";
 import { join as join12, basename as basename7 } from "path";
 function hasSubagentsDir(sessionPath) {
   const dir = sessionPath.slice(0, -6);
-  return existsSync12(join12(dir, "subagents"));
+  return existsSync13(join12(dir, "subagents"));
 }
 var init_session = __esm({
   "../engine/dist/parsers/session.js"() {
@@ -10631,7 +11217,7 @@ __export(live_session_scan_exports, {
   withSessionReadCache: () => withSessionReadCache,
   withSessionScanScope: () => withSessionScanScope
 });
-import { existsSync as existsSync13, readdirSync as readdirSync10, readFileSync as readFileSync9, statSync as statSync11, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync10, readFileSync as readFileSync9, statSync as statSync11, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
 import { join as join13, basename as basename8 } from "path";
 import { createHash as createHash2 } from "crypto";
 function lazyGeminiProjectsJson() {
@@ -10692,7 +11278,7 @@ function sessionFileIndex() {
     return p;
   };
   for (const root of roots) {
-    if (seenRoots.has(root) || !existsSync13(root))
+    if (seenRoots.has(root) || !existsSync14(root))
       continue;
     seenRoots.add(root);
     dirs.set(root, dirMtime(root));
@@ -10818,7 +11404,7 @@ function resolveSessionContentPaths(sessionFile) {
   if (!hasSubagentsDir(sessionFile))
     return [sessionFile];
   const subDir = join13(sessionFile.slice(0, -6), "subagents");
-  if (!existsSync13(subDir))
+  if (!existsSync14(subDir))
     return [sessionFile];
   const subPaths = readdirSync10(subDir).filter((f) => f.endsWith(".jsonl")).sort().map((f) => join13(subDir, f));
   return [sessionFile, ...subPaths];
@@ -10835,7 +11421,7 @@ function loadGeminiProjectMap() {
     return geminiProjectMapCache;
   const map = /* @__PURE__ */ new Map();
   const projectsPath = lazyGeminiProjectsJson();
-  if (existsSync13(projectsPath)) {
+  if (existsSync14(projectsPath)) {
     try {
       const data = JSON.parse(readFileSync9(projectsPath, "utf-8"));
       for (const path of Object.keys(data.projects || {})) {
@@ -10871,7 +11457,7 @@ function geminiIndex() {
   const projMap = loadGeminiProjectMap();
   const isGeminiChat = (f) => f.startsWith("session-") && (f.endsWith(".json") || f.endsWith(".jsonl"));
   for (const tmpRoot of geminiTmpDirs()) {
-    if (!existsSync13(tmpRoot))
+    if (!existsSync14(tmpRoot))
       continue;
     let projs;
     try {
@@ -10883,7 +11469,7 @@ function geminiIndex() {
       if (!proj.isDirectory())
         continue;
       const chats = join13(tmpRoot, proj.name, "chats");
-      if (!existsSync13(chats))
+      if (!existsSync14(chats))
         continue;
       let files;
       try {
@@ -11004,7 +11590,7 @@ function findCodexSessionFile(sessionId) {
   return null;
 }
 function findCodexSessionFileIn(root, sessionId) {
-  if (!existsSync13(root))
+  if (!existsSync14(root))
     return null;
   for (const year of readdirSync10(root, { withFileTypes: true })) {
     if (!year.isDirectory())