chat-recall 0.7.18 → 0.7.19

package/dist/mcp.js

@@ -5023,6 +5023,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;
@@ -5206,6 +5208,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 }
   };
@@ -5282,6 +5285,7 @@ function mergeSources(base2, partial) {
     codex: { ...base2.enabled.codex, ...partial.enabled?.codex ?? {} },
     agy: { ...base2.enabled.agy, ...inherited, ...partial.enabled?.agy ?? {} },
     cursor: { ...base2.enabled.cursor, ...partial.enabled?.cursor ?? {} },
+    hermes: { ...base2.enabled.hermes, ...partial.enabled?.hermes ?? {} },
     shared: { ...base2.enabled.shared, ...partial.enabled?.shared ?? {} },
     common: { ...base2.enabled.common, ...partial.enabled?.common ?? {} }
   };
@@ -5293,6 +5297,7 @@ function mergeSources(base2, partial) {
     agyHome: partial.agyHome ?? base2.agyHome,
     cursorHome: partial.cursorHome ?? base2.cursorHome,
     cursorIdeHome: partial.cursorIdeHome ?? base2.cursorIdeHome,
+    hermesHome: partial.hermesHome ?? base2.hermesHome,
     extraClaudeHomes: partial.extraClaudeHomes ?? base2.extraClaudeHomes,
     approvedHomes: partial.approvedHomes ?? base2.approvedHomes,
     declinedHomes: partial.declinedHomes ?? base2.declinedHomes,
@@ -5689,6 +5694,13 @@ function grandfatherLegacyHomes() {
   }
   return { seeded };
 }
+function defaultHermesHome() {
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA?.trim() || join6(homedir2(), "AppData", "Local");
+    return join6(local, "hermes");
+  }
+  return join6(homedir2(), ".hermes");
+}
 function primaryHomes() {
   const home = homedir2();
   const env = process.env;
@@ -5705,7 +5717,8 @@ function primaryHomes() {
     env.CHAT_RECALL_CODEX_HOME || s?.codexHome || join6(home, ".codex"),
     env.CHAT_RECALL_AGY_HOME || s?.agyHome || join6(home, ".gemini", "antigravity-cli"),
     env.CHAT_RECALL_CURSOR_HOME || s?.cursorHome || join6(home, ".cursor"),
-    dirOf(opencodeDb)
+    dirOf(opencodeDb),
+    env.CHAT_RECALL_HERMES_HOME || s?.hermesHome || env.HERMES_HOME?.trim() || defaultHermesHome()
   ];
   return candidates2.map(normalizeHomePath);
 }
@@ -5815,6 +5828,9 @@ function geminiHomeDir() {
 function opencodeDbPath() {
   return process.env.CHAT_RECALL_OPENCODE_DB || sources().opencodeDbPath || join7(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 || join7(homedir3(), ".codex");
 }
@@ -5916,6 +5932,22 @@ function opencodeDbPaths(opts = {}) {
     dbs.push(primary);
   return applyExclusions(dbs, opts.includeExcluded);
 }
+function hermesDbPaths(opts = {}) {
+  const root = hermesHomeDir();
+  const dbs = [join7(root, "state.db")];
+  try {
+    const profiles = join7(root, "profiles");
+    for (const entry of readdirSync5(profiles, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      const p = join7(profiles, entry.name, "state.db");
+      if (existsSync5(p))
+        dbs.push(p);
+    }
+  } catch {
+  }
+  return applyExclusions(dbs, opts.includeExcluded);
+}
 function extraClaudeHomeDirs() {
   const extras = sources().extraClaudeHomes ?? [];
   const primary = claudeHomeDir();
@@ -7212,6 +7244,71 @@ function readTailFromOffset(path2, 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 path2 = paths[i];
+    let size = 0;
+    try {
+      size = statSync6(path2).size;
+    } catch {
+      size = 0;
+    }
+    const last = i === paths.length - 1;
+    if (!last && offset >= start + size) {
+      const lines = linesBeforeOffset(path2, size);
+      if (lines === void 0)
+        return { text: "", newOffset: offset };
+      linesBefore += lines + (size > 0 && !endsWithNewline(path2, size) ? 1 : 0);
+      start += size;
+      continue;
+    }
+    const local = offset - start;
+    const read = readTailFromOffset(path2, 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(path2, "r");
+      const text = readAt(fd, local, size - local).toString("utf-8");
+      return shift({ text, newOffset: size, baseLine: linesBeforeOffset(path2, local) });
+    } catch {
+      return { text: "", newOffset: offset };
+    } finally {
+      if (fd !== null) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
+  }
+  return { text: "", newOffset: offset };
+}
+function endsWithNewline(path2, size) {
+  let fd = null;
+  try {
+    fd = openSync(path2, "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;
@@ -9690,6 +9787,473 @@ var init_cursor = __esm({
   }
 });
 
+// ../engine/dist/core/backends/hermes.js
+import { existsSync as existsSync12 } 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 call2 of parseToolCalls(r.tool_calls)) {
+        const toolName = call2.function?.name ?? "";
+        const toolInput = parseArguments(call2.function?.arguments);
+        const command = toolName === "terminal" && typeof toolInput?.command === "string" ? toolInput.command : void 0;
+        events.push({
+          kind: "tool_use",
+          ts,
+          tsIso,
+          line,
+          toolName,
+          toolUseId: call2.id || call2.call_id || `${r.id}:${toolName}`,
+          toolInput,
+          ...command ? { command } : {}
+        });
+      }
+      continue;
+    }
+    if (r.role === "tool") {
+      const body2 = r.content ?? "";
+      const { exitCode, isError } = toolResultStatus(body2);
+      events.push({
+        kind: "tool_result",
+        ts,
+        tsIso,
+        line,
+        toolUseId: r.tool_call_id ?? void 0,
+        toolName: r.tool_name ?? void 0,
+        resultBody: body2,
+        resultIsError: isError,
+        ...exitCode !== void 0 ? { resultExitCode: exitCode } : {},
+        resultBytes: Buffer.byteLength(body2)
+      });
+    }
+  }
+  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(body2) {
+  if (!body2.startsWith("{"))
+    return { isError: false };
+  try {
+    const r = JSON.parse(body2);
+    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) => existsSync12(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 path2 of this.dbPaths()) {
+          const db = openSqliteReadonly(path2);
+          if (!db)
+            continue;
+          try {
+            if (db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(rawId)) {
+              this._dbForSession.set(rawId, path2);
+              return path2;
+            }
+          } 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 path2 = this.dbPathFor(rawId);
+        if (!path2)
+          return null;
+        const db = openSqliteReadonly(path2);
+        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: path2,
+            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 (!existsSync12(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 path2 = this.dbPathFor(this.toRawId(rawId));
+        if (!path2)
+          return null;
+        const db = openSqliteReadonly(path2);
+        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 path2 = this.dbPathFor(id);
+        if (!path2)
+          return [];
+        const db = openSqliteReadonly(path2);
+        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 path2 = this.dbPathFor(rawId);
+        if (!path2)
+          return null;
+        const db = openSqliteReadonly(path2);
+        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);
@@ -9697,6 +10261,7 @@ function bootstrapBackends() {
   registerBackend(codexBackend);
   registerBackend(agyBackend);
   registerBackend(cursorBackend);
+  registerBackend(hermesBackend);
 }
 var init_backends = __esm({
   "../engine/dist/core/backends/index.js"() {
@@ -9707,6 +10272,7 @@ var init_backends = __esm({
     init_codex();
     init_agy();
     init_cursor();
+    init_hermes();
     init_tool_backend();
     _setRegistryBootstrapper(bootstrapBackends);
   }
@@ -9919,7 +10485,7 @@ var init_session_outcome = __esm({
 });
 
 // ../engine/dist/core/first-prompt.js
-import { createReadStream, existsSync as existsSync12, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
+import { createReadStream, existsSync as existsSync13, openSync as openSync3, readSync as readSync3, closeSync as closeSync3 } from "fs";
 import { StringDecoder } from "string_decoder";
 function stripBanners(s) {
   let out = s;
@@ -10088,7 +10654,7 @@ var init_project_dir_name = __esm({
 });
 
 // ../engine/dist/core/backends/claude.js
-import { existsSync as existsSync13, readdirSync as readdirSync11, readFileSync as readFileSync9, statSync as statSync12, openSync as openSync4, readSync as readSync4, closeSync as closeSync4 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync11, readFileSync as readFileSync9, statSync as statSync12, openSync as openSync4, readSync as readSync4, closeSync as closeSync4 } from "fs";
 import { join as join14, basename as basename8 } from "path";
 function stripReminders(text) {
   return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
@@ -10158,7 +10724,7 @@ var init_claude = __esm({
         return join14(this.homeDir(), "history.jsonl");
       }
       isAvailable() {
-        return existsSync13(this.projectsDir());
+        return existsSync14(this.projectsDir());
       }
       // ── ID handling ────────────────────────────────────────────────
       /**
@@ -10264,7 +10830,7 @@ var init_claude = __esm({
             prior.modified = ref.modified;
           }
         };
-        if (!existsSync13(root))
+        if (!existsSync14(root))
           return;
         for (const proj of readdirSync11(root, { withFileTypes: true })) {
           if (!proj.isDirectory())
@@ -10275,12 +10841,12 @@ var init_claude = __esm({
           const projectPath = resolveProjectDirName(proj.name);
           const indexPath = join14(projPath, "sessions-index.json");
           const indexed = /* @__PURE__ */ new Set();
-          if (existsSync13(indexPath)) {
+          if (existsSync14(indexPath)) {
             try {
               const indexData = JSON.parse(readFileSync9(indexPath, "utf-8"));
               const entries = indexData.entries || [];
               for (const entry of entries) {
-                if (!entry.fullPath || !existsSync13(entry.fullPath))
+                if (!entry.fullPath || !existsSync14(entry.fullPath))
                   continue;
                 indexed.add(entry.sessionId);
                 add({
@@ -10605,7 +11171,7 @@ var init_claude = __esm({
       collectRecentEdits(opts) {
         const candidates2 = [];
         for (const root of claudeProjectDirs()) {
-          if (!existsSync13(root))
+          if (!existsSync14(root))
             continue;
           for (const projEntry of readdirSync11(root, { withFileTypes: true })) {
             if (!projEntry.isDirectory())
@@ -10627,7 +11193,7 @@ var init_claude = __esm({
                 const st = statSync12(fp);
                 let mtime = st.mtimeMs;
                 const subDir = join14(projPath, f.slice(0, -6), "subagents");
-                if (existsSync13(subDir)) {
+                if (existsSync14(subDir)) {
                   for (const sub of readdirSync11(subDir)) {
                     try {
                       const subSt = statSync12(join14(subDir, sub));
@@ -10704,27 +11270,45 @@ var init_claude = __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 = statSync12(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();
@@ -10902,7 +11486,7 @@ var init_model_pricing = __esm({
 });
 
 // ../engine/dist/parsers/session.js
-import { createReadStream as createReadStream2, existsSync as existsSync14, readdirSync as readdirSync12, readFileSync as readFileSync10, statSync as statSync13, openSync as openSync5, readSync as readSync5, closeSync as closeSync5 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync15, readdirSync as readdirSync12, readFileSync as readFileSync10, statSync as statSync13, openSync as openSync5, readSync as readSync5, closeSync as closeSync5 } from "fs";
 import { createInterface } from "readline";
 import { join as join15, basename as basename9 } from "path";
 function removeCodeBlocks(text) {
@@ -10951,17 +11535,17 @@ function isValuableToolResult(content, toolName = "") {
 }
 function hasSubagentsDir(sessionPath) {
   const dir = sessionPath.slice(0, -6);
-  return existsSync14(join15(dir, "subagents"));
+  return existsSync15(join15(dir, "subagents"));
 }
 function getSubagentPaths(sessionPath) {
   const subagentsDir = join15(sessionPath.slice(0, -6), "subagents");
-  if (!existsSync14(subagentsDir))
+  if (!existsSync15(subagentsDir))
     return [];
   return readdirSync12(subagentsDir).filter((f) => f.endsWith(".jsonl")).sort().map((f) => join15(subagentsDir, f));
 }
 function readCwdFromJsonl(sessionPath) {
   try {
-    if (!existsSync14(sessionPath))
+    if (!existsSync15(sessionPath))
       return "";
     let text;
     const fd = openSync5(sessionPath, "r");
@@ -11018,7 +11602,7 @@ async function parseSessionFile(sessionPath, maxMessages = 50) {
   };
   const modelsUsed = /* @__PURE__ */ new Set();
   const filesModified = /* @__PURE__ */ new Set();
-  if (!existsSync14(sessionPath)) {
+  if (!existsSync15(sessionPath)) {
     return content;
   }
   const filesToParse = hasSubagentsDir(sessionPath) ? [sessionPath, ...getSubagentPaths(sessionPath)] : [sessionPath];
@@ -11637,7 +12221,7 @@ function canonicalEventsToMessages(events) {
     switch (e.kind) {
       case "user":
         cur = null;
-        messages.push({ line: e.line, role: "user", content: e.text ?? "", timestamp: e.tsIso });
+        messages.push({ line: e.line, role: "user", content: e.text ?? "", timestamp: e.tsIso, ...e.origin ? { origin: e.origin } : {} });
         break;
       case "assistant_text":
         cur = { line: e.line, role: "assistant", content: e.text ?? "", timestamp: e.tsIso };
@@ -12048,7 +12632,7 @@ var init_raw = __esm({
 // ../engine/dist/transcript/shadow.js
 import { gzipSync as gzipSync2, gunzipSync as gunzipSync2 } from "zlib";
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync2, renameSync as renameSync2, statSync as statSync14, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync2, renameSync as renameSync2, statSync as statSync14, openSync as openSync6, readSync as readSync6, closeSync as closeSync6 } from "fs";
 import { dirname as dirname14, join as join18 } from "path";
 function shadowRoot() {
   return join18(getDataDir(), "shadow");
@@ -12059,7 +12643,7 @@ function shadowFileFor(tool, rawId) {
 }
 function readShadowContainer(tool, rawId) {
   const path2 = shadowFileFor(tool, rawId);
-  if (!existsSync15(path2))
+  if (!existsSync16(path2))
     return null;
   try {
     const c = JSON.parse(gunzipSync2(readFileSync11(path2)).toString("utf-8"));
@@ -12261,7 +12845,7 @@ var init_shadow = __esm({
 });
 
 // ../engine/dist/core/live-session-scan.js
-import { existsSync as existsSync16, readdirSync as readdirSync13, readFileSync as readFileSync12, statSync as statSync15, openSync as openSync7, readSync as readSync7, closeSync as closeSync7 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync13, readFileSync as readFileSync12, statSync as statSync15, openSync as openSync7, readSync as readSync7, closeSync as closeSync7 } from "fs";
 import { join as join19, basename as basename12 } from "path";
 function detectTool(sessionId) {
   return getBackendForId(sessionId)?.id ?? "claude";
@@ -12318,7 +12902,7 @@ function sessionFileIndex() {
     return p;
   };
   for (const root of roots) {
-    if (seenRoots.has(root) || !existsSync16(root))
+    if (seenRoots.has(root) || !existsSync17(root))
       continue;
     seenRoots.add(root);
     dirs.set(root, dirMtime(root));
@@ -12444,7 +13028,7 @@ function resolveSessionContentPaths(sessionFile) {
   if (!hasSubagentsDir(sessionFile))
     return [sessionFile];
   const subDir = join19(sessionFile.slice(0, -6), "subagents");
-  if (!existsSync16(subDir))
+  if (!existsSync17(subDir))
     return [sessionFile];
   const subPaths = readdirSync13(subDir).filter((f) => f.endsWith(".jsonl")).sort().map((f) => join19(subDir, f));
   return [sessionFile, ...subPaths];
@@ -12461,7 +13045,7 @@ function findCodexSessionFile(sessionId) {
   return null;
 }
 function findCodexSessionFileIn(root, sessionId) {
-  if (!existsSync16(root))
+  if (!existsSync17(root))
     return null;
   for (const year of readdirSync13(root, { withFileTypes: true })) {
     if (!year.isDirectory())
@@ -12554,10 +13138,10 @@ var init_types = __esm({
 
 // ../engine/dist/transcript/opencode.js
 async function parseOpenCodeSubagents(parentSessionId) {
-  const { existsSync: existsSync48 } = await import("fs");
+  const { existsSync: existsSync49 } = await import("fs");
   const { opencodeBackend: opencodeBackend2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
   const dbPath = opencodeBackend2.dbPath();
-  if (!existsSync48(dbPath))
+  if (!existsSync49(dbPath))
     return [];
   const realParent = parentSessionId.replace("opencode_", "");
   const db = openSqliteReadonlyOrThrow(dbPath);
@@ -12598,10 +13182,10 @@ async function parseOpenCodeSubagents(parentSessionId) {
   }
 }
 async function parseOpenCodeTranscript(sessionId) {
-  const { existsSync: existsSync48 } = await import("fs");
+  const { existsSync: existsSync49 } = await import("fs");
   const { opencodeBackend: opencodeBackend2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
   const dbPath = opencodeBackend2.dbPath();
-  if (!existsSync48(dbPath))
+  if (!existsSync49(dbPath))
     return [];
   const realId = sessionId.replace("opencode_", "");
   const db = openSqliteReadonlyOrThrow(dbPath);
@@ -12875,7 +13459,7 @@ var init_credentials_env = __esm({
 });
 
 // ../engine/dist/core/which.js
-import { existsSync as existsSync18, statSync as statSync17, accessSync as accessSync2, constants as constants2 } from "node:fs";
+import { existsSync as existsSync19, statSync as statSync17, accessSync as accessSync2, constants as constants2 } from "node:fs";
 import { join as join21, isAbsolute as isAbsolute2, delimiter as delimiter2, sep as sep2 } from "node:path";
 function executable(p) {
   try {
@@ -12916,7 +13500,7 @@ function resolveOnPath(name) {
       continue;
     for (const c of candidates(name)) {
       const full = join21(dir, c);
-      if (existsSync18(full) && executable(full))
+      if (existsSync19(full) && executable(full))
         return full;
     }
   }
@@ -13080,7 +13664,7 @@ var init_code_intel = __esm({
 });
 
 // ../engine/dist/core/companions.js
-import { existsSync as existsSync19, mkdirSync as mkdirSync7, statSync as statSync18, chmodSync as chmodSync4, unlinkSync, renameSync as renameSync3, createWriteStream, readFileSync as readFileSync14, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync7, statSync as statSync18, chmodSync as chmodSync4, unlinkSync, renameSync as renameSync3, createWriteStream, readFileSync as readFileSync14, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join23 } from "node:path";
 import { execSync as execSync2 } from "node:child_process";
@@ -13203,7 +13787,7 @@ Refusing to install. The release may have been re-uploaded, or something is serv
     renameSync3(tmpPath, CODEINDEX_BIN_PATH);
   } catch (err) {
     try {
-      if (existsSync19(tmpPath))
+      if (existsSync20(tmpPath))
         unlinkSync(tmpPath);
     } catch {
     }
@@ -13640,7 +14224,7 @@ var init_secret_redactor = __esm({
 
 // ../engine/dist/core/detector-install.js
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync20, mkdirSync as mkdirSync8, mkdtempSync, chmodSync as chmodSync5, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync5, readFileSync as readFileSync15, statSync as statSync20, copyFileSync as copyFileSync2 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync8, mkdtempSync, chmodSync as chmodSync5, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync5, readFileSync as readFileSync15, statSync as statSync20, copyFileSync as copyFileSync2 } from "fs";
 import { join as join24 } from "path";
 function managedDetectorPath(name) {
   return join24(getDetectorBinDir(), name + exeSuffix());
@@ -13680,7 +14264,7 @@ function resolveDetector(name) {
   const dir = configuredDir();
   if (dir) {
     const p2 = join24(dir, name + exeSuffix());
-    if (existsSync20(p2))
+    if (existsSync21(p2))
       return { path: p2, version: "operator-supplied", source: "configured" };
     return { error: "not-installed" };
   }
@@ -13688,7 +14272,7 @@ function resolveDetector(name) {
   if (!spec.assets[platformKey()])
     return { error: "unsupported-platform" };
   const p = managedDetectorPath(name);
-  if (!existsSync20(p))
+  if (!existsSync21(p))
     return { error: "not-installed" };
   const receipt = readReceipt(name);
   if (!receipt)
@@ -13744,7 +14328,7 @@ var init_detector_install = __esm({
 
 // ../engine/dist/core/secret-scanner.js
 import { spawnSync } from "child_process";
-import { existsSync as existsSync21, unlinkSync as unlinkSync2, readFileSync as readFileSync16, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync22, unlinkSync as unlinkSync2, readFileSync as readFileSync16, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join25 } from "path";
 function mask(s) {
@@ -13910,7 +14494,7 @@ function runTrufflehogDir(binary, dir, opts = {}) {
   return out;
 }
 function scanDirForSecrets(dir, opts = {}) {
-  if (!existsSync21(dir))
+  if (!existsSync22(dir))
     return [];
   const gitleaks = whichDetector("gitleaks");
   const trufflehog = whichDetector("trufflehog");
@@ -13947,7 +14531,7 @@ function scanTenantRules(text, tenantRules) {
   return out;
 }
 function scanFileForSecrets(filePath, opts = {}) {
-  if (!existsSync21(filePath))
+  if (!existsSync22(filePath))
     return [];
   const gitleaks = whichDetector("gitleaks");
   const trufflehog = whichDetector("trufflehog");
@@ -15026,7 +15610,7 @@ var init_collector = __esm({
 
 // ../engine/dist/core/source-discovery.js
 import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync23, readdirSync as readdirSync14, statSync as statSync22 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync14, statSync as statSync22 } from "fs";
 import { join as join28 } from "path";
 function sourceId(path2) {
   return "src_" + createHash8("sha256").update(path2).digest("hex").slice(0, 12);
@@ -15085,7 +15669,7 @@ function countTranscripts(root, tool) {
   walk(root, 0);
   return { sessions, newestMtime };
 }
-function countOpencodeSessions(dbPath) {
+function countDbSessions(dbPath) {
   try {
     const st = statSync22(dbPath);
     return { sessions: 0, newestMtime: st.mtimeMs };
@@ -15103,18 +15687,24 @@ function discoverSessionSources() {
   ];
   for (const [tool, dirs] of dirTools) {
     for (const [i, path2] of dirs.entries()) {
-      if (!existsSync23(path2))
+      if (!existsSync24(path2))
         continue;
       const { sessions, newestMtime } = countTranscripts(path2, tool);
       out.push({ id: sourceId(path2), tool, path: path2, sessions, newestMtime, isPrimary: i === 0 });
     }
   }
   for (const [i, path2] of opencodeDbPaths({ includeExcluded: true }).entries()) {
-    if (!existsSync23(path2))
+    if (!existsSync24(path2))
       continue;
-    const { sessions, newestMtime } = countOpencodeSessions(path2);
+    const { sessions, newestMtime } = countDbSessions(path2);
     out.push({ id: sourceId(path2), tool: "opencode", path: path2, sessions, newestMtime, isPrimary: i === 0 });
   }
+  for (const [i, path2] of hermesDbPaths({ includeExcluded: true }).entries()) {
+    if (!existsSync24(path2))
+      continue;
+    const { sessions, newestMtime } = countDbSessions(path2);
+    out.push({ id: sourceId(path2), tool: "hermes", path: path2, sessions, newestMtime, isPrimary: i === 0 });
+  }
   return out;
 }
 var excludedIds, SOURCE_ID_RE, MAX_DEPTH;
@@ -15130,7 +15720,7 @@ var init_source_discovery = __esm({
 
 // ../engine/dist/core/home-discovery.js
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync24, readdirSync as readdirSync15, readFileSync as readFileSync19, realpathSync as realpathSync3, statSync as statSync23 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync15, readFileSync as readFileSync19, realpathSync as realpathSync3, statSync as statSync23 } from "fs";
 import { homedir as homedir7, platform as osPlatform } from "os";
 import { join as join29 } from "path";
 function candidateRoots(plat = osPlatform(), env = process.env) {
@@ -15151,10 +15741,10 @@ function candidateRoots(plat = osPlatform(), env = process.env) {
     add(env.XDG_CONFIG_HOME || join29(home, ".config"));
     add(env.XDG_DATA_HOME || join29(home, ".local", "share"));
   }
-  return roots.filter((r) => existsSync24(r));
+  return roots.filter((r) => existsSync25(r));
 }
 function identifyHome(dir) {
-  const has = (...parts) => existsSync24(join29(dir, ...parts));
+  const has = (...parts) => existsSync25(join29(dir, ...parts));
   if (has("projects") && dirHasTranscript(join29(dir, "projects"), (f) => f.endsWith(".jsonl"), 2))
     return "claude";
   if (has("sessions") && dirHasTranscript(join29(dir, "sessions"), (f) => f.startsWith("rollout-") && f.endsWith(".jsonl"), 4))
@@ -15165,6 +15755,8 @@ function identifyHome(dir) {
     return "cursor";
   if (has("opencode.db"))
     return "opencode";
+  if (has("state.db") && has("SOUL.md"))
+    return "hermes";
   return null;
 }
 function dirHasTranscript(root, match, depth) {
@@ -15192,7 +15784,8 @@ function countSessions(dir, tool) {
     codex: { sub: "sessions", depth: 4, match: (f) => f.startsWith("rollout-") && f.endsWith(".jsonl") },
     agy: { sub: "brain", depth: 4, match: (f) => f.endsWith(".jsonl") },
     cursor: { sub: "chats", depth: 3, match: (f) => f === "store.db" },
-    opencode: { sub: "", depth: 0, match: () => false }
+    opencode: { sub: "", depth: 0, match: () => false },
+    hermes: { sub: "", depth: 0, match: () => false }
   };
   const s = spec[tool];
   if (!s.sub)
@@ -15235,6 +15828,8 @@ function declaredHomes(env = process.env, plat = osPlatform()) {
   add(env.CHAT_RECALL_AGY_HOME);
   add(env.CHAT_RECALL_CURSOR_HOME);
   add(env.CHAT_RECALL_CURSOR_IDE_HOME);
+  add(env.CHAT_RECALL_HERMES_HOME);
+  add(env.HERMES_HOME);
   for (const d of (env.CLAUDE_DIRS || "").split(","))
     add(d);
   if (plat === "win32") {
@@ -15334,6 +15929,15 @@ function discoverHomes(opts = {}) {
     if (prior && !(via === "declared" && prior.via !== "declared"))
       return;
     found.set(real, { tool, path: real, via, sessions: countSessions(real, tool) });
+    if (tool === "hermes") {
+      try {
+        for (const e of readdirSync15(join29(real, "profiles"), { withFileTypes: true })) {
+          if (e.isDirectory())
+            consider(join29(real, "profiles", e.name), via);
+        }
+      } catch {
+      }
+    }
   };
   for (const d of declaredHomes(env, plat))
     consider(d, "declared");
@@ -16001,7 +16605,7 @@ var init_source_policy = __esm({
     init_project_path_match();
     init_settings();
     cache2 = null;
-    TOOLS = ["claude", "opencode", "codex", "agy", "cursor"];
+    TOOLS = ["claude", "opencode", "codex", "agy", "cursor", "hermes"];
   }
 });
 
@@ -16096,7 +16700,7 @@ var init_source_registry = __esm({
 });
 
 // ../engine/dist/core/utils.js
-import { existsSync as existsSync25, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync16 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join30 } from "path";
 function splitByHeaders(markdown) {
@@ -16132,7 +16736,7 @@ function getClaudeDirs() {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (dir) => {
-    if (!seen.has(dir) && existsSync25(dir)) {
+    if (!seen.has(dir) && existsSync26(dir)) {
       seen.add(dir);
       dirs.push(dir);
     }
@@ -16151,7 +16755,7 @@ function getClaudeDirs() {
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith(".claude-") && entry.name !== ".claude-code") {
         const candidate = join30(home, entry.name);
-        if (existsSync25(join30(candidate, "projects"))) {
+        if (existsSync26(join30(candidate, "projects"))) {
           add(candidate);
         }
       }
@@ -16164,7 +16768,7 @@ function discoverSubdirs(subdir) {
   const result = [];
   for (const claudeDir of getClaudeDirs()) {
     const path2 = join30(claudeDir, subdir);
-    if (existsSync25(path2)) {
+    if (existsSync26(path2)) {
       result.push(path2);
     }
   }
@@ -16177,7 +16781,7 @@ var init_utils = __esm({
 });
 
 // ../engine/dist/parsers/plan-source.js
-import { existsSync as existsSync26, readdirSync as readdirSync17, readFileSync as readFileSync20, statSync as statSync25 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync17, readFileSync as readFileSync20, statSync as statSync25 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join31, basename as basename14 } from "path";
 function parseFrontmatter(content) {
@@ -16235,7 +16839,7 @@ var init_plan_source = __esm({
           return this._knownProjectDirs;
         const projectsDir = claudeBackend.projectsDir();
         this._knownProjectDirs = [];
-        if (!existsSync26(projectsDir))
+        if (!existsSync27(projectsDir))
           return this._knownProjectDirs;
         try {
           const entries = readdirSync17(projectsDir, { withFileTypes: true });
@@ -16243,7 +16847,7 @@ var init_plan_source = __esm({
             if (!entry.isDirectory() || entry.name.startsWith("."))
               continue;
             const projectPath = resolveProjectDirName(entry.name);
-            if (existsSync26(projectPath)) {
+            if (existsSync27(projectPath)) {
               this._knownProjectDirs.push(projectPath);
             }
           }
@@ -16267,7 +16871,7 @@ var init_plan_source = __esm({
       async *discoverClaudePlans() {
         const seenClaude = /* @__PURE__ */ new Set();
         for (const plansDir of this.plansDirs) {
-          if (!existsSync26(plansDir))
+          if (!existsSync27(plansDir))
             continue;
           const files = readdirSync17(plansDir).filter((f) => f.endsWith(".md"));
           for (const file of files) {
@@ -16309,7 +16913,7 @@ var init_plan_source = __esm({
       }
       async *discoverOpenCodePlans() {
         const plansDir = opencodeBackend.plansDir();
-        if (!existsSync26(plansDir))
+        if (!existsSync27(plansDir))
           return;
         let files;
         try {
@@ -16396,7 +17000,7 @@ var init_plan_source = __esm({
         return "";
       }
       async parse(item) {
-        if (!existsSync26(item.filePath))
+        if (!existsSync27(item.filePath))
           return [];
         const content = readFileSync20(item.filePath, "utf-8");
         const chunks = [];
@@ -16437,7 +17041,7 @@ var init_plan_source = __esm({
           const projPath = join31(root, proj);
           for (const sessionEntry of safeReaddir(projPath)) {
             const subDir = join31(projPath, sessionEntry, "subagents");
-            if (!existsSync26(subDir))
+            if (!existsSync27(subDir))
               continue;
             for (const f of safeReaddir(subDir)) {
               const m = f.match(/^agent-([a-z0-9_-]+)\.jsonl$/i);
@@ -16512,7 +17116,7 @@ var init_plan_source = __esm({
       }
       async *discoverAgyPlans() {
         const brainDir = join31(agyBackend.homeDir(), "brain");
-        if (!existsSync26(brainDir))
+        if (!existsSync27(brainDir))
           return;
         let sessionDirs;
         try {
@@ -16567,7 +17171,7 @@ var init_plan_source = __esm({
 });
 
 // ../engine/dist/parsers/task-source.js
-import { existsSync as existsSync27, readdirSync as readdirSync18, readFileSync as readFileSync21, statSync as statSync26 } from "fs";
+import { existsSync as existsSync28, readdirSync as readdirSync18, readFileSync as readFileSync21, statSync as statSync26 } from "fs";
 import { join as join32 } from "path";
 var MAX_CHUNK_CHARS2, TaskSource;
 var init_task_source = __esm({
@@ -16597,7 +17201,7 @@ var init_task_source = __esm({
       }
       async *discoverClaudeTodos() {
         const todosDir = claudeBackend.todosDir();
-        if (!existsSync27(todosDir))
+        if (!existsSync28(todosDir))
           return;
         let files;
         try {
@@ -16648,7 +17252,7 @@ var init_task_source = __esm({
         }
       }
       async *discoverInDir(tasksDir) {
-        if (!existsSync27(tasksDir))
+        if (!existsSync28(tasksDir))
           return;
         const entries = readdirSync18(tasksDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -16690,7 +17294,7 @@ var init_task_source = __esm({
           return this.parseAgentTodo(item);
         }
         const taskDir = item.filePath;
-        if (!existsSync27(taskDir))
+        if (!existsSync28(taskDir))
           return [];
         const taskFiles = readdirSync18(taskDir).filter((f) => f.endsWith(".json"));
         const tasks = this.readTasks(taskDir, taskFiles);
@@ -16751,7 +17355,7 @@ ${task.description}`.slice(0, MAX_CHUNK_CHARS2);
         }];
       }
       async parseAgentTodo(item) {
-        if (!existsSync27(item.filePath))
+        if (!existsSync28(item.filePath))
           return [];
         let parsed;
         try {
@@ -16803,7 +17407,7 @@ ${task.description}`.slice(0, MAX_CHUNK_CHARS2);
 });
 
 // ../engine/dist/parsers/claude-md-source.js
-import { existsSync as existsSync28, readFileSync as readFileSync22, readdirSync as readdirSync19, statSync as statSync27 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync22, readdirSync as readdirSync19, statSync as statSync27 } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join33, basename as basename15, dirname as dirname16 } from "path";
 import { createHash as createHash9 } from "crypto";
@@ -16811,13 +17415,13 @@ function discoverProjectDirs(claudeDir) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const addProject = (path2) => {
-    if (!seen.has(path2) && existsSync28(path2)) {
+    if (!seen.has(path2) && existsSync29(path2)) {
       seen.add(path2);
       dirs.push(path2);
     }
   };
   const scanProjectsDir = (projectsDir) => {
-    if (!existsSync28(projectsDir))
+    if (!existsSync29(projectsDir))
       return;
     try {
       const entries = readdirSync19(projectsDir, { withFileTypes: true });
@@ -16845,7 +17449,7 @@ function discoverProjectDirs(claudeDir) {
   } catch {
   }
   const gemProjects = agyBackend.sharedProjectsJson();
-  if (existsSync28(gemProjects)) {
+  if (existsSync29(gemProjects)) {
     try {
       const data = JSON.parse(readFileSync22(gemProjects, "utf-8"));
       for (const path2 of Object.keys(data.projects || {}))
@@ -16854,7 +17458,7 @@ function discoverProjectDirs(claudeDir) {
     }
   }
   const ocDb = opencodeBackend.dbPath();
-  if (existsSync28(ocDb)) {
+  if (existsSync29(ocDb)) {
     try {
       const db = openSqliteReadonlyOrThrow(ocDb);
       try {
@@ -16905,7 +17509,7 @@ var init_claude_md_source = __esm({
         for (const note of NOTE_FILES) {
           const p = join33(homedir10(), note.filename);
           const key2 = seenKey(p, note.tool);
-          if (existsSync28(p) && !seen.has(key2)) {
+          if (existsSync29(p) && !seen.has(key2)) {
             seen.add(key2);
             const item = this.fileToItem(p, note.filename, note.tool);
             if (item)
@@ -16917,7 +17521,7 @@ var init_claude_md_source = __esm({
           for (const note of NOTE_FILES) {
             const p = join33(projectDir, note.filename);
             const key2 = seenKey(p, note.tool);
-            if (existsSync28(p) && !seen.has(key2)) {
+            if (existsSync29(p) && !seen.has(key2)) {
               seen.add(key2);
               const item = this.fileToItem(p, note.filename, note.tool);
               if (item)
@@ -16926,12 +17530,12 @@ var init_claude_md_source = __esm({
           }
         }
         for (const searchDir of this.searchDirs) {
-          if (!existsSync28(searchDir))
+          if (!existsSync29(searchDir))
             continue;
           for (const note of NOTE_FILES) {
             const directPath = join33(searchDir, note.filename);
             const key2 = seenKey(directPath, note.tool);
-            if (existsSync28(directPath) && !seen.has(key2)) {
+            if (existsSync29(directPath) && !seen.has(key2)) {
               seen.add(key2);
               const item = this.fileToItem(directPath, note.filename, note.tool);
               if (item)
@@ -16946,7 +17550,7 @@ var init_claude_md_source = __esm({
               for (const note of NOTE_FILES) {
                 const p = join33(searchDir, entry.name, note.filename);
                 const key2 = seenKey(p, note.tool);
-                if (existsSync28(p) && !seen.has(key2)) {
+                if (existsSync29(p) && !seen.has(key2)) {
                   seen.add(key2);
                   const item = this.fileToItem(p, note.filename, note.tool);
                   if (item)
@@ -16960,7 +17564,7 @@ var init_claude_md_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync28(item.filePath))
+        if (!existsSync29(item.filePath))
           return [];
         const content = readFileSync22(item.filePath, "utf-8");
         const chunks = [];
@@ -17029,7 +17633,7 @@ var init_claude_md_source = __esm({
 });
 
 // ../engine/dist/parsers/agent-memory-source.js
-import { existsSync as existsSync29, readFileSync as readFileSync23, readdirSync as readdirSync20, statSync as statSync28 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync23, readdirSync as readdirSync20, statSync as statSync28 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join34, basename as basename16 } from "path";
 function parseFrontmatter2(content) {
@@ -17063,7 +17667,7 @@ function discoverMemoryDirs() {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (memoryDir, projectHash) => {
-    if (!seen.has(memoryDir) && existsSync29(memoryDir)) {
+    if (!seen.has(memoryDir) && existsSync30(memoryDir)) {
       seen.add(memoryDir);
       out.push({ memoryDir, projectHash });
     }
@@ -17079,7 +17683,7 @@ function discoverMemoryDirs() {
   } catch {
   }
   for (const projectsDir of claudeRoots) {
-    if (!existsSync29(projectsDir))
+    if (!existsSync30(projectsDir))
       continue;
     try {
       for (const entry of readdirSync20(projectsDir, { withFileTypes: true })) {
@@ -17128,7 +17732,7 @@ var init_agent_memory_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync29(item.filePath))
+        if (!existsSync30(item.filePath))
           return [];
         const content = readFileSync23(item.filePath, "utf-8");
         const { body: body2 } = parseFrontmatter2(content);
@@ -17214,7 +17818,7 @@ var init_agent_memory_source = __esm({
 });
 
 // ../engine/dist/parsers/history-source.js
-import { existsSync as existsSync30, readdirSync as readdirSync21, statSync as statSync29 } from "fs";
+import { existsSync as existsSync31, readdirSync as readdirSync21, statSync as statSync29 } from "fs";
 import { createReadStream as createReadStream3 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 import { homedir as homedir12 } from "os";
@@ -17236,7 +17840,7 @@ var init_history_source = __esm({
           const home = homedir12();
           const paths = [];
           const tryAdd = (p) => {
-            if (existsSync30(p) && !paths.includes(p))
+            if (existsSync31(p) && !paths.includes(p))
               paths.push(p);
           };
           tryAdd(claudeBackend.historyFile());
@@ -17254,7 +17858,7 @@ var init_history_source = __esm({
       async *discover() {
         if (!isSourceEnabled("claude", "history"))
           return;
-        const historyPath = this.historyPaths.find((p) => existsSync30(p));
+        const historyPath = this.historyPaths.find((p) => existsSync31(p));
         if (!historyPath)
           return;
         const stat3 = statSync29(historyPath);
@@ -17350,7 +17954,7 @@ var init_history_source = __esm({
       async groupByProject() {
         const groups = /* @__PURE__ */ new Map();
         for (const historyPath of this.historyPaths) {
-          if (!existsSync30(historyPath))
+          if (!existsSync31(historyPath))
             continue;
           const rl = createInterface2({
             input: createReadStream3(historyPath),
@@ -17398,7 +18002,7 @@ var init_history_source = __esm({
 });
 
 // ../engine/dist/parsers/paste-source.js
-import { existsSync as existsSync31, readdirSync as readdirSync22, readFileSync as readFileSync24, statSync as statSync30 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync22, readFileSync as readFileSync24, statSync as statSync30 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join36, basename as basename17 } from "path";
 var MAX_CHUNK_CHARS6, MAX_FILE_SIZE, PasteSource;
@@ -17419,7 +18023,7 @@ var init_paste_source = __esm({
           const home = homedir13();
           const dirs = [];
           const tryAdd = (p) => {
-            if (existsSync31(p) && !dirs.includes(p))
+            if (existsSync32(p) && !dirs.includes(p))
               dirs.push(p);
           };
           tryAdd(claudeBackend.pasteCacheDir());
@@ -17439,7 +18043,7 @@ var init_paste_source = __esm({
           return;
         const seen = /* @__PURE__ */ new Set();
         for (const cacheDir of this.cacheDirs) {
-          if (!existsSync31(cacheDir))
+          if (!existsSync32(cacheDir))
             continue;
           const files = readdirSync22(cacheDir).filter((f) => f.endsWith(".txt"));
           for (const file of files) {
@@ -17473,7 +18077,7 @@ var init_paste_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync31(item.filePath))
+        if (!existsSync32(item.filePath))
           return [];
         const content = readFileSync24(item.filePath, "utf-8");
         if (content.trim().length < 20)
@@ -17498,7 +18102,7 @@ var init_paste_source = __esm({
 });
 
 // ../engine/dist/parsers/antigravity-brain-source.js
-import { existsSync as existsSync32, readdirSync as readdirSync23, readFileSync as readFileSync25, statSync as statSync31 } from "fs";
+import { existsSync as existsSync33, readdirSync as readdirSync23, readFileSync as readFileSync25, statSync as statSync31 } from "fs";
 import { join as join37 } from "path";
 var MAX_CHUNK_CHARS7, AntigravityBrainSource;
 var init_antigravity_brain_source = __esm({
@@ -17517,7 +18121,7 @@ var init_antigravity_brain_source = __esm({
       async *discover() {
         if (!isSourceEnabled("agy", "brain"))
           return;
-        if (!existsSync32(this.brainDir))
+        if (!existsSync33(this.brainDir))
           return;
         const sessions = readdirSync23(this.brainDir, { withFileTypes: true });
         for (const entry of sessions) {
@@ -17536,7 +18140,7 @@ var init_antigravity_brain_source = __esm({
               const heading = content.split("\n").find((l) => l.startsWith("#"))?.replace(/^#+\s*/, "").trim() || file;
               const metaPath = `${filePath}.metadata.json`;
               let metaSummary = "";
-              if (existsSync32(metaPath)) {
+              if (existsSync33(metaPath)) {
                 try {
                   const meta = JSON.parse(readFileSync25(metaPath, "utf-8"));
                   metaSummary = meta.summary || "";
@@ -17567,7 +18171,7 @@ var init_antigravity_brain_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync32(item.filePath))
+        if (!existsSync33(item.filePath))
           return [];
         const content = readFileSync25(item.filePath, "utf-8");
         const chunks = [];
@@ -17610,7 +18214,7 @@ var init_antigravity_brain_source = __esm({
 });
 
 // ../engine/dist/parsers/opencode-source.js
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 var MAX_CHUNK_CHARS8, OpenCodeSource;
 var init_opencode_source = __esm({
   "../engine/dist/parsers/opencode-source.js"() {
@@ -17628,7 +18232,7 @@ var init_opencode_source = __esm({
       async *discover() {
         if (!isSourceEnabled("opencode", "sessions"))
           return;
-        if (!existsSync33(this.dbPath))
+        if (!existsSync34(this.dbPath))
           return;
         let db;
         try {
@@ -17726,7 +18330,7 @@ var init_opencode_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync33(this.dbPath))
+        if (!existsSync34(this.dbPath))
           return [];
         const sessionId = item.id.replace("opencode_", "");
         const db = openSqliteReadonlyOrThrow(this.dbPath);
@@ -17798,7 +18402,7 @@ var init_opencode_source = __esm({
 });
 
 // ../engine/dist/parsers/opencode-todo-source.js
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 var OpenCodeTodoSource;
 var init_opencode_todo_source = __esm({
   "../engine/dist/parsers/opencode-todo-source.js"() {
@@ -17815,7 +18419,7 @@ var init_opencode_todo_source = __esm({
       async *discover() {
         if (!isSourceEnabled("opencode", "todos"))
           return;
-        if (!existsSync34(this.dbPath))
+        if (!existsSync35(this.dbPath))
           return;
         let db;
         try {
@@ -17864,7 +18468,7 @@ var init_opencode_todo_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync34(this.dbPath))
+        if (!existsSync35(this.dbPath))
           return [];
         const sessionId = item.extra?.sessionId || item.id.replace(`${opencodeBackend.idPrefix}todo_`, "");
         const db = openSqliteReadonlyOrThrow(this.dbPath);
@@ -17912,7 +18516,7 @@ var init_opencode_todo_source = __esm({
 });
 
 // ../engine/dist/parsers/codex-session-source.js
-import { existsSync as existsSync35, readdirSync as readdirSync24, readFileSync as readFileSync26, statSync as statSync32 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync24, readFileSync as readFileSync26, statSync as statSync32 } from "fs";
 import { join as join38, basename as basename18 } from "path";
 function getCodexSessionsDir() {
   return codexBackend.sessionsDir();
@@ -17969,7 +18573,7 @@ var init_codex_session_source = __esm({
       async *discover() {
         if (!isSourceEnabled("codex", "sessions"))
           return;
-        if (!existsSync35(this.sessionsDir))
+        if (!existsSync36(this.sessionsDir))
           return;
         const jsonlFiles = this.collectJsonlFiles(this.sessionsDir);
         for (const filePath of jsonlFiles) {
@@ -18028,7 +18632,7 @@ var init_codex_session_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync35(item.filePath))
+        if (!existsSync36(item.filePath))
           return [];
         const events = readJsonlLines(item.filePath);
         const chunks = [];
@@ -18131,7 +18735,7 @@ var init_codex_session_source = __esm({
       }
       collectJsonlFiles(dir) {
         const results = [];
-        if (!existsSync35(dir))
+        if (!existsSync36(dir))
           return results;
         for (const entry of readdirSync24(dir, { withFileTypes: true })) {
           const fullPath = join38(dir, entry.name);
@@ -18148,7 +18752,7 @@ var init_codex_session_source = __esm({
 });
 
 // ../engine/dist/parsers/diary-source.js
-import { existsSync as existsSync36, mkdirSync as mkdirSync9, readdirSync as readdirSync25, readFileSync as readFileSync27, writeFileSync as writeFileSync6, statSync as statSync33 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync9, readdirSync as readdirSync25, readFileSync as readFileSync27, writeFileSync as writeFileSync6, statSync as statSync33 } from "fs";
 import { join as join39, basename as basename19 } from "path";
 var MAX_CHUNK_CHARS10, DiarySource;
 var init_diary_source = __esm({
@@ -18164,7 +18768,7 @@ var init_diary_source = __esm({
       }
       /** Discover all diary entries across all agents. */
       async *discover() {
-        if (!existsSync36(this.diaryDir))
+        if (!existsSync37(this.diaryDir))
           return;
         const agents = readdirSync25(this.diaryDir, { withFileTypes: true }).filter((d) => d.isDirectory());
         for (const agentDir of agents) {
@@ -18199,7 +18803,7 @@ var init_diary_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync36(item.filePath))
+        if (!existsSync37(item.filePath))
           return [];
         const raw = readFileSync27(item.filePath, "utf-8");
         const entry = JSON.parse(raw);
@@ -18239,7 +18843,7 @@ var init_diary_source = __esm({
       static write(entry, diaryDir) {
         const dir = diaryDir || getDiaryDir();
         const agentDir = join39(dir, entry.agent.toLowerCase().replace(/[^a-z0-9_-]/g, "_"));
-        if (!existsSync36(agentDir)) {
+        if (!existsSync37(agentDir)) {
           mkdirSync9(agentDir, { recursive: true });
         }
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -18258,7 +18862,7 @@ var init_diary_source = __esm({
       static read(agentName, lastN = 10, diaryDir) {
         const dir = diaryDir || getDiaryDir();
         const agentDir = join39(dir, agentName.toLowerCase().replace(/[^a-z0-9_-]/g, "_"));
-        if (!existsSync36(agentDir))
+        if (!existsSync37(agentDir))
           return [];
         const files = readdirSync25(agentDir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, lastN);
         const entries = [];
@@ -18309,7 +18913,7 @@ var init_redact_inline = __esm({
 });
 
 // ../engine/dist/parsers/skills-source.js
-import { existsSync as existsSync37, readdirSync as readdirSync26, readFileSync as readFileSync28, statSync as statSync34 } from "fs";
+import { existsSync as existsSync38, readdirSync as readdirSync26, readFileSync as readFileSync28, statSync as statSync34 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join40 } from "path";
 function rebuildBody(content) {
@@ -18349,7 +18953,7 @@ function resolveRoots() {
     all.push({ path: join40(cursorHomeDir(), "skills"), tool: "cursor" });
     all.push({ path: join40(cursorHomeDir(), "skills-cursor"), tool: "cursor", readonly: true });
   }
-  return all.filter((r) => existsSync37(r.path));
+  return all.filter((r) => existsSync38(r.path));
 }
 function parseFrontmatter3(text) {
   const m = text.match(/^---\n([\s\S]*?)\n---/);
@@ -18391,7 +18995,7 @@ var init_skills_source = __esm({
           return;
         for (const { name: pluginName, dir } of codexBackend.installedPluginDirs()) {
           const skillsDir = join40(dir, "skills");
-          if (!existsSync37(skillsDir))
+          if (!existsSync38(skillsDir))
             continue;
           yield* this.fromSkillRoot({ path: skillsDir, tool: "codex" }, pluginName);
         }
@@ -18416,7 +19020,7 @@ var init_skills_source = __esm({
           if (!st.isDirectory())
             continue;
           const skillMd = join40(skillDir, "SKILL.md");
-          if (!existsSync37(skillMd))
+          if (!existsSync38(skillMd))
             continue;
           let content;
           try {
@@ -18481,7 +19085,7 @@ var init_skills_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync37(item.filePath))
+        if (!existsSync38(item.filePath))
           return [];
         const content = readFileSync28(item.filePath, "utf-8");
         if (!content.trim())
@@ -18506,11 +19110,11 @@ var init_skills_source = __esm({
 });
 
 // ../engine/dist/parsers/mcps-source.js
-import { existsSync as existsSync38, readFileSync as readFileSync29, statSync as statSync35 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync29, statSync as statSync35 } from "fs";
 import { homedir as homedir15 } from "os";
 import { join as join41 } from "path";
 function readJson(path2) {
-  if (!existsSync38(path2))
+  if (!existsSync39(path2))
     return null;
   try {
     const raw = readFileSync29(path2, "utf-8");
@@ -18673,7 +19277,7 @@ var init_mcps_source = __esm({
         }
       }
       async *fromCodexToml(path2) {
-        if (!existsSync38(path2))
+        if (!existsSync39(path2))
           return;
         let content;
         try {
@@ -18829,7 +19433,7 @@ var init_toolkit_format = __esm({
 });
 
 // ../engine/dist/parsers/slash-commands-source.js
-import { existsSync as existsSync39, readdirSync as readdirSync27, readFileSync as readFileSync30, statSync as statSync36 } from "fs";
+import { existsSync as existsSync40, readdirSync as readdirSync27, readFileSync as readFileSync30, statSync as statSync36 } from "fs";
 import { join as join42, basename as basename20 } from "path";
 function rebuildBody2(content) {
   const { text, redacted } = redactInlineSecrets(content);
@@ -18882,14 +19486,14 @@ var init_slash_commands_source = __esm({
         if (isSourceEnabled("claude", "commands")) {
           roots.push({ path: claudeBackend.commandsDir(), tool: "claude", scope: "user", projectPath: "", format: "md" });
           const projectsRoot = claudeBackend.projectsDir();
-          if (existsSync39(projectsRoot)) {
+          if (existsSync40(projectsRoot)) {
             try {
               for (const entry of readdirSync27(projectsRoot, { withFileTypes: true })) {
                 if (!entry.isDirectory() || entry.name.startsWith("."))
                   continue;
                 const projectPath = resolveProjectDirName(entry.name);
                 const cmdDir = join42(projectPath, ".claude", "commands");
-                if (existsSync39(cmdDir))
+                if (existsSync40(cmdDir))
                   roots.push({ path: cmdDir, tool: "claude", scope: "project", projectPath, format: "md" });
               }
             } catch {
@@ -18951,7 +19555,7 @@ var init_slash_commands_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync39(item.filePath))
+        if (!existsSync40(item.filePath))
           return [];
         const content = readFileSync30(item.filePath, "utf-8");
         if (!content.trim())
@@ -18976,7 +19580,7 @@ var init_slash_commands_source = __esm({
 });
 
 // ../engine/dist/parsers/subagents-source.js
-import { existsSync as existsSync40, readdirSync as readdirSync28, readFileSync as readFileSync31, statSync as statSync37 } from "fs";
+import { existsSync as existsSync41, readdirSync as readdirSync28, readFileSync as readFileSync31, statSync as statSync37 } from "fs";
 import { join as join43, basename as basename21 } from "path";
 function rebuildBody3(content) {
   const { text, redacted } = redactInlineSecrets(content);
@@ -19031,14 +19635,14 @@ var init_subagents_source = __esm({
         if (isSourceEnabled("claude", "agents")) {
           roots.push({ path: claudeBackend.agentsDir(), tool: "claude", scope: "user", projectPath: "", format: "md" });
           const projectsRoot = claudeBackend.projectsDir();
-          if (existsSync40(projectsRoot)) {
+          if (existsSync41(projectsRoot)) {
             try {
               for (const entry of readdirSync28(projectsRoot, { withFileTypes: true })) {
                 if (!entry.isDirectory() || entry.name.startsWith("."))
                   continue;
                 const projectPath = resolveProjectDirName(entry.name);
                 const agentDir = join43(projectPath, ".claude", "agents");
-                if (existsSync40(agentDir))
+                if (existsSync41(agentDir))
                   roots.push({ path: agentDir, tool: "claude", scope: "project", projectPath, format: "md" });
               }
             } catch {
@@ -19101,7 +19705,7 @@ var init_subagents_source = __esm({
         }
       }
       async parse(item) {
-        if (!existsSync40(item.filePath))
+        if (!existsSync41(item.filePath))
           return [];
         const content = readFileSync31(item.filePath, "utf-8");
         if (!content.trim())
@@ -19126,10 +19730,10 @@ var init_subagents_source = __esm({
 });
 
 // ../engine/dist/parsers/hooks-source.js
-import { existsSync as existsSync41, readFileSync as readFileSync32, readdirSync as readdirSync29, statSync as statSync38 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync32, readdirSync as readdirSync29, statSync as statSync38 } from "fs";
 import { join as join44 } from "path";
 function readJson2(path2) {
-  if (!existsSync41(path2))
+  if (!existsSync42(path2))
     return null;
   try {
     return JSON.parse(readFileSync32(path2, "utf-8"));
@@ -19151,14 +19755,14 @@ var init_hooks_source = __esm({
           return;
         yield* this.fromSettings(claudeBackend.settingsFile(), "user", "");
         const projectsRoot = claudeBackend.projectsDir();
-        if (existsSync41(projectsRoot)) {
+        if (existsSync42(projectsRoot)) {
           try {
             for (const entry of readdirSync29(projectsRoot, { withFileTypes: true })) {
               if (!entry.isDirectory() || entry.name.startsWith("."))
                 continue;
               const projectPath = resolveProjectDirName(entry.name);
               const settingsPath2 = join44(projectPath, ".claude", "settings.json");
-              if (existsSync41(settingsPath2)) {
+              if (existsSync42(settingsPath2)) {
                 yield* this.fromSettings(settingsPath2, "project", projectPath);
               }
             }
@@ -19249,11 +19853,11 @@ var init_hooks_source = __esm({
 });
 
 // ../engine/dist/parsers/plugins-source.js
-import { existsSync as existsSync42, readFileSync as readFileSync33, readdirSync as readdirSync30, statSync as statSync39 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync33, readdirSync as readdirSync30, statSync as statSync39 } from "fs";
 import { homedir as homedir16 } from "os";
 import { join as join45 } from "path";
 function readJson3(path2) {
-  if (!existsSync42(path2))
+  if (!existsSync43(path2))
     return null;
   try {
     return JSON.parse(readFileSync33(path2, "utf-8"));
@@ -19308,7 +19912,7 @@ var init_plugins_source = __esm({
           }
         }
         const gemRoot = agyBackend.sharedExtensionsDir();
-        if (isSourceEnabled("agy", "extensions") && existsSync42(gemRoot)) {
+        if (isSourceEnabled("agy", "extensions") && existsSync43(gemRoot)) {
           let entries;
           try {
             entries = readdirSync30(gemRoot);
@@ -19484,6 +20088,8 @@ function toolOfId(id) {
     return "codex";
   if (id.startsWith("cursor_"))
     return "cursor";
+  if (id.startsWith("hermes_"))
+    return "hermes";
   return "claude";
 }
 function extractorVersionForTool(tool) {
@@ -19741,6 +20347,8 @@ function markSynced(server, rows) {
     else if (prev?.F !== void 0) base2.F = prev.F;
     if (cursorFromCaller && r.chunkedHead) base2.k = 1;
     else if (prev?.k && !completesChunked && !(cursorFromCaller && r.full)) base2.k = 1;
+    const layout = cursorFromCaller ? r.layout : prev?.L;
+    if (layout) base2.L = layout;
     forServer[r.id] = base2;
   }
   persist(data);
@@ -19881,12 +20489,12 @@ 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 statSync41, closeSync as closeSync9 } from "fs";
+import { existsSync as existsSync44, 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);
   mkdirSync11(dirname18(lockPath), { recursive: true });
-  if (existsSync43(lockPath)) {
+  if (existsSync44(lockPath)) {
     if (!stealStaleLock(lockPath, opts.staleAfterMs ?? 10 * 6e4)) {
       return null;
     }
@@ -19997,7 +20605,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.18";
+        if (true) CLI_VERSION = "0.7.19";
       } catch {
       }
     }
@@ -20094,7 +20702,7 @@ var init_derived = __esm({
 
 // src/scan-pool.ts
 import { Worker } from "node:worker_threads";
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync45 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { cpus } from "node:os";
 function poolSize() {
@@ -20109,7 +20717,7 @@ function workerScript() {
   for (const rel of ["./scan-worker.js", "../dist/scan-worker.js"]) {
     try {
       const p = fileURLToPath(new URL(rel, import.meta.url));
-      if (existsSync44(p)) return p;
+      if (existsSync45(p)) return p;
     } catch {
     }
   }
@@ -20495,7 +21103,7 @@ var init_telemetry = __esm({
     init_sync_client();
     cliVersion2 = () => {
       try {
-        return true ? "0.7.18" : "dev";
+        return true ? "0.7.19" : "dev";
       } catch {
         return "dev";
       }
@@ -20810,7 +21418,7 @@ __export(auto_update_exports, {
   tarballUrl: () => tarballUrl
 });
 import { execSync as execSync4, execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync38, existsSync as existsSync45 } from "node:fs";
+import { readFileSync as readFileSync38, existsSync as existsSync46 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { writeFileSync as writeFileSync9, mkdtempSync as mkdtempSync3, rmSync as rmSync6, readdirSync as readdirSync31, statSync as statSync43, mkdirSync as mkdirSync12 } from "node:fs";
 import { join as join49, dirname as dirname19, sep as sep3, posix as pathPosix, win32 as pathWin32 } from "node:path";
@@ -20971,7 +21579,7 @@ function resolveNpm(loc) {
 }
 function realInstall(tgz) {
   const prefix = runningPrefix();
-  const npm = resolveNpm({ execPath: process.execPath, prefix, platform: process.platform, env: process.env, exists: existsSync45 });
+  const npm = resolveNpm({ execPath: process.execPath, prefix, platform: process.platform, env: process.env, exists: existsSync46 });
   if (prefix) {
     npmInstall(npm, ["install", "-g", "--prefix", prefix, tgz]);
     return;
@@ -21824,6 +22432,11 @@ async function syncToTargetInScope(cred, opts = {}) {
   };
   const localSessionIds = /* @__PURE__ */ new Set();
   const shippedHash = /* @__PURE__ */ new Map();
+  const shippedLayout = /* @__PURE__ */ new Map();
+  const layoutOf = (id) => {
+    const layout = shippedLayout.get(id);
+    return layout ? { layout } : {};
+  };
   const makeBatcher = (field, maxItems, flatten = false, onFlush, barrier) => {
     let batch = [];
     let batchBytes = 0;
@@ -21856,7 +22469,7 @@ async function syncToTargetInScope(cred, opts = {}) {
       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, full: true } : { id: r.session_id, mtime: r.mtime, hash };
+        return off > 0 ? { id: r.session_id, mtime: r.mtime, offset: off, size: off, hash, acked: true, full: true, ...layoutOf(r.session_id) } : { id: r.session_id, mtime: r.mtime, hash };
       }));
     } catch {
     }
@@ -21899,8 +22512,9 @@ async function syncToTargetInScope(cred, opts = {}) {
             // size = new offset (file grew to here)
             acked: true,
             // server merged this tail
-            chunkFinal: c.final === true
+            chunkFinal: c.final === true,
             // completes a chunked full sync
+            ...layoutOf(c.session_id)
           })));
         } catch {
         }
@@ -21932,9 +22546,9 @@ async function syncToTargetInScope(cred, opts = {}) {
       const mtime = conv.mtime;
       try {
         if (staged || !guarded) {
-          markSynced(base2, [{ id, mtime, offset: conv.from_offset, size: conv.from_offset, acked: true, chunkedHead: true }]);
+          markSynced(base2, [{ id, mtime, offset: conv.from_offset, size: conv.from_offset, acked: true, chunkedHead: true, ...layoutOf(id) }]);
         } else if (typeof guarded.o === "number" && guarded.o > 0 && guarded.o <= fileSize) {
-          markSynced(base2, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true, chunkedHead: true }]);
+          markSynced(base2, [{ id, mtime, offset: guarded.o, size: guarded.o, acked: true, chunkedHead: true, ...layoutOf(id) }]);
         } else {
           markSynced(base2, [{ id, mtime }]);
         }
@@ -22029,8 +22643,8 @@ async function syncToTargetInScope(cred, opts = {}) {
     if (!ledger) return ref.mtime >= (opts.sinceMs ?? 0) ? "full" : "skip";
     const ack = ledger.get(ref.prefixedId);
     const backend = backendFor(ref);
-    const split = !!backend?.spansMultipleSources?.(ref.prefixedId);
-    const isAO = !!backend?.isAppendOnly?.() && !split;
+    const sameLayout = (ack?.L ?? "") === (backend?.sourceLayout?.(ref.prefixedId) ?? "");
+    const isAO = !!backend?.isAppendOnly?.() && sameLayout;
     const size = isAO ? backend?.fileSize?.(ref.prefixedId) ?? 0 : 0;
     return syncMode(ack, ref.mtime, size, extractorVersionForTool(ref.toolId), isAO);
   };
@@ -22077,6 +22691,9 @@ async function syncToTargetInScope(cred, opts = {}) {
       skipped++;
       continue;
     }
+    const layout = backendFor(ref)?.sourceLayout?.(ref.prefixedId) ?? "";
+    if (layout) shippedLayout.set(ref.prefixedId, layout);
+    else shippedLayout.delete(ref.prefixedId);
     trace?.(`build (${mode}) ${ref.prefixedId} \xB7 ${(sessionFileBytes(ref) / 1048576).toFixed(1)}MB`);
     let promotedForFindings = false;
     if (mode === "append" && ledger) {
@@ -22122,7 +22739,7 @@ async function syncToTargetInScope(cred, opts = {}) {
           const off = getBackendForId(ref.prefixedId)?.fileSize?.(ref.rawId) ?? 0;
           const priorCursor = ackRow?.s ?? 0;
           const safeToAck = off > 0 && off <= priorCursor;
-          markSynced(base2, [safeToAck ? { id: ref.prefixedId, mtime: ref.mtime, offset: off, size: off, hash: built.srcHash, acked: true } : { id: ref.prefixedId, mtime: ref.mtime, hash: built.srcHash }]);
+          markSynced(base2, [safeToAck ? { id: ref.prefixedId, mtime: ref.mtime, offset: off, size: off, hash: built.srcHash, acked: true, ...layoutOf(ref.prefixedId) } : { id: ref.prefixedId, mtime: ref.mtime, hash: built.srcHash }]);
         } catch {
         }
       }
@@ -22877,7 +23494,7 @@ var init_sync_client = __esm({
       ownVersion = JSON.parse(readFileSync39(join50(dir, "../package.json"), "utf-8")).version || ownVersion;
     } catch {
       try {
-        if (true) ownVersion = "0.7.18";
+        if (true) ownVersion = "0.7.19";
       } catch {
       }
     }
@@ -23159,7 +23776,7 @@ __export(service_installer_exports, {
   uninstallService: () => uninstallService
 });
 import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync46, mkdirSync as mkdirSync14, readFileSync as readFileSync42, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync47, mkdirSync as mkdirSync14, readFileSync as readFileSync42, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir18 } from "os";
 import { join as join52 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -23195,7 +23812,7 @@ function refreshServiceDefinition() {
   try {
     const { watchJs, node, logFile } = resolveDaemonPaths();
     const unitPath = join52(homedir18(), ".config", "systemd", "user", "chat-recall-watch.service");
-    if (!existsSync46(unitPath)) return false;
+    if (!existsSync47(unitPath)) return false;
     const current = readFileSync42(unitPath, "utf8");
     if (!current.includes(watchJs)) return false;
     const wanted = renderSystemdUnit(watchJs, node, logFile);
@@ -23363,7 +23980,7 @@ function uninstallService() {
     } catch {
     }
     const unitPath = join52(homedir18(), ".config", "systemd", "user", "chat-recall-watch.service");
-    if (existsSync46(unitPath)) {
+    if (existsSync47(unitPath)) {
       rmSync8(unitPath, { force: true });
       removed = true;
     }
@@ -23380,7 +23997,7 @@ function uninstallService() {
     } catch {
     }
     let removed = false;
-    if (existsSync46(plistPath)) {
+    if (existsSync47(plistPath)) {
       rmSync8(plistPath, { force: true });
       removed = true;
     }
@@ -23427,7 +24044,7 @@ __export(install_skills_exports, {
   skillsSourceDir: () => skillsSourceDir,
   uninstallSkills: () => uninstallSkills
 });
-import { readdirSync as readdirSync33, existsSync as existsSync47, mkdirSync as mkdirSync15, rmSync as rmSync9, cpSync, writeFileSync as writeFileSync13, readFileSync as readFileSync43, statSync as statSync45, realpathSync as realpathSync4 } from "fs";
+import { readdirSync as readdirSync33, existsSync as existsSync48, mkdirSync as mkdirSync15, rmSync as rmSync9, cpSync, writeFileSync as writeFileSync13, readFileSync as readFileSync43, statSync as statSync45, realpathSync as realpathSync4 } from "fs";
 import { createHash as createHash12 } from "crypto";
 import { join as join53, basename as basename23 } from "path";
 function skillsSourceDir() {
@@ -23466,8 +24083,8 @@ function skillStamp() {
 }
 function bundledSkillNames() {
   const src = skillsSourceDir();
-  if (!existsSync47(src)) return [];
-  return readdirSync33(src, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync47(join53(src, e.name, "SKILL.md"))).map((e) => e.name).sort();
+  if (!existsSync48(src)) return [];
+  return readdirSync33(src, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync48(join53(src, e.name, "SKILL.md"))).map((e) => e.name).sort();
 }
 function realPathOrSelf(p) {
   try {
@@ -23491,7 +24108,7 @@ function claudeSkillTargets() {
       dir,
       // Judge each profile on ITS OWN transcripts, not the primary's: a home
       // with no projects/ is a directory someone made, not a Claude install.
-      available: existsSync47(join53(home, "projects"))
+      available: existsSync48(join53(home, "projects"))
     });
   }
   if (targets.length === 0) {
@@ -23515,7 +24132,7 @@ function skillTargets() {
   ];
 }
 function isManaged(dir) {
-  return existsSync47(join53(dir, MARKER));
+  return existsSync48(join53(dir, MARKER));
 }
 function installSkills(opts = {}) {
   const onlyAvailable = opts.onlyAvailable ?? true;
@@ -23533,7 +24150,7 @@ function installSkills(opts = {}) {
     }
     for (const name of names) {
       const dest = join53(t.dir, name);
-      if (existsSync47(dest) && !isManaged(dest)) {
+      if (existsSync48(dest) && !isManaged(dest)) {
         skippedUserOwned.push(name);
         continue;
       }
@@ -23553,7 +24170,7 @@ function uninstallSkills() {
   const perTarget = [];
   for (const t of skillTargets()) {
     const removed = [];
-    if (!existsSync47(t.dir)) {
+    if (!existsSync48(t.dir)) {
       perTarget.push({ id: t.id, label: t.label, removed });
       continue;
     }
@@ -23577,7 +24194,7 @@ function skillsNeedRefresh() {
     if (!t.available) continue;
     for (const name of names) {
       const marker = join53(t.dir, name, MARKER);
-      if (!existsSync47(marker)) return true;
+      if (!existsSync48(marker)) return true;
       try {
         if (readFileSync43(marker, "utf-8").trim() !== cur) return true;
       } catch {
@@ -23595,7 +24212,7 @@ function skillStatus() {
     let ver = null;
     for (const name of names) {
       const marker = join53(t.dir, name, MARKER);
-      if (existsSync47(marker)) {
+      if (existsSync48(marker)) {
         installed++;
         try {
           ver = readFileSync43(marker, "utf-8").trim();
@@ -23855,6 +24472,7 @@ var SESSION_ID_PREFIXES = {
   opencode: "opencode_",
   agy: "agy_",
   cursor: "cursor_",
+  hermes: "hermes_",
   gemini: "gemini_"
 };
 function toolOfSessionId(sessionId) {
@@ -23883,6 +24501,8 @@ function resumeCommandFor(sessionId, tool) {
     // available answer for either.
     case "cursor":
       return `cursor-agent --resume ${raw("cursor_")}`;
+    case "hermes":
+      return `hermes --resume ${raw("hermes_")}`;
     // Gemini's `--resume` takes an index or "latest", never a session id.
     default:
       return null;
@@ -24872,7 +25492,7 @@ function isMultiTenant() {
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { existsSync as existsSync22, readFileSync as readFileSync18, statSync as statSync21 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync18, statSync as statSync21 } from "fs";
 import { join as join27 } from "path";
 
 // ../engine/dist/core/context.js
@@ -25020,7 +25640,7 @@ function sanitizeQuery(query) {
 
 // ../engine/dist/core/write-ahead-log.js
 init_paths();
-import { existsSync as existsSync17, mkdirSync as mkdirSync5, appendFileSync, openSync as openSync8, closeSync as closeSync8, chmodSync as chmodSync3 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, appendFileSync, openSync as openSync8, closeSync as closeSync8, chmodSync as chmodSync3 } from "fs";
 import { join as join20 } from "path";
 var REDACT_KEYS = /* @__PURE__ */ new Set([
   "content",
@@ -25037,7 +25657,7 @@ var WriteAheadLog = class {
   walPath;
   constructor(walDir) {
     const dir = walDir || getWalDir();
-    if (!existsSync17(dir)) {
+    if (!existsSync18(dir)) {
       mkdirSync5(dir, { recursive: true });
       try {
         chmodSync3(dir, 448);
@@ -25045,7 +25665,7 @@ var WriteAheadLog = class {
       }
     }
     this.walPath = join20(dir, "write_log.jsonl");
-    if (!existsSync17(this.walPath)) {
+    if (!existsSync18(this.walPath)) {
       const fd = openSync8(this.walPath, "w", 384);
       closeSync8(fd);
     }
@@ -25406,7 +26026,7 @@ var RecallEditsTimelineSchema = z.object({
   pattern: z.string().optional().describe("Optional substring filter on file path"),
   project_filter: z.string().optional().describe("Filter by project name (matched against the encoded project directory name)"),
   include_reads: z.boolean().optional().default(false).describe("Include read-type tool calls in addition to write/edit ones"),
-  tools: z.array(z.enum(["claude", "opencode", "codex", "agy", "cursor"])).optional().describe("Restrict to a subset of AI tools. Default: every tool this machine has."),
+  tools: z.array(z.enum(["claude", "opencode", "codex", "agy", "cursor", "hermes"])).optional().describe("Restrict to a subset of AI tools. Default: every tool this machine has."),
   group_by_repo: z.boolean().optional().default(false).describe("Group output by detected git repo root instead of returning a flat list. Useful when a single session touched multiple repos."),
   view: z.enum(["timeline", "summary"]).optional().default("timeline").describe("timeline = the chronological edit rows; summary = an aggregated rollup over the same window"),
   group_by: z.enum(["session"]).optional().describe('"session" = aggregate edits per session instead of a flat timeline \u2014 answers "which sessions touched files matching X?" (pass `pattern` + a wide `since_hours`, e.g. 720 for 30 days).')
@@ -26118,7 +26738,7 @@ aggregate per session instead \u2014 "which sessions edited auth.rs in the last
             include_reads: { type: "boolean", default: false, description: "Include Read tool_uses too" },
             tools: {
               type: "array",
-              items: { type: "string", enum: ["claude", "opencode", "codex", "agy", "cursor"] },
+              items: { type: "string", enum: ["claude", "opencode", "codex", "agy", "cursor", "hermes"] },
               description: "Restrict to specific AI tools. Default: every tool this machine has."
             },
             group_by_repo: { type: "boolean", default: false, description: "Group results by detected git repo root." },
@@ -28079,7 +28699,7 @@ _Edits stayed local or window was off \u2014 try increasing buffer_minutes._` }]
       }
       case "recall_project_context": {
         const params = RecallProjectContextSchema.parse(args);
-        const target = existsSync22(params.project_path) && statSync21(params.project_path).isDirectory() ? resolveProjectId(params.project_path).id : params.project_path;
+        const target = existsSync23(params.project_path) && statSync21(params.project_path).isDirectory() ? resolveProjectId(params.project_path).id : params.project_path;
         const dossier = await remoteGetQS(`/api/projects/${encodeURIComponent(target)}/dossier`, { sessions: params.limit, tasks: params.tasks, plans: params.plans });
         return { content: [{ type: "text", text: dossier.markdown }] };
       }
@@ -29039,7 +29659,7 @@ Subject: ${params.subject}`;
         const start = resolve2(p.path ?? process.cwd());
         let root = start;
         for (let dir = start, last = ""; dir && dir !== last; last = dir, dir = resolve2(dir, "..")) {
-          if (existsSync22(join27(dir, ".git"))) {
+          if (existsSync23(join27(dir, ".git"))) {
             root = dir;
             break;
           }
@@ -29196,7 +29816,7 @@ ${row.value}`
         let identity = params.identity ?? "AI coding assistant";
         if (!params.identity && !isMultiTenant()) {
           const idFile = getIdentityFilePath();
-          if (existsSync22(idFile)) {
+          if (existsSync23(idFile)) {
             try {
               identity = readFileSync18(idFile, "utf-8").trim() || identity;
             } catch {
@@ -29868,7 +30488,7 @@ function installCrashGuards() {
     reportClientEvent2("mcp_crash", { message: err.stack || err.message });
   });
 }
-var RELAY_VERSION = true ? "0.7.18" : "0.0.0";
+var RELAY_VERSION = true ? "0.7.19" : "0.0.0";
 function daemonIdleSecs() {
   const raw = process.env.CHAT_RECALL_DAEMON_IDLE_SECS;
   if (raw === void 0) return 900;