@indigoai-us/hq-cloud 6.14.2 → 6.14.4

package/src/cli/reindex.test.ts

@@ -557,4 +557,166 @@ describe("reindex", () => {
       fs.lstatSync(path.join(root, ".claude/skills/core:demo/SKILL.md")).isSymbolicLink(),
     ).toBe(true);
   });
+
+  // --- multi-harness session-log capture into workspace/.session-logs/<harness>/
+  describe("session-log capture", () => {
+    let claudeDir: string; // CLAUDE_CONFIG_DIR
+    let codexHome: string; // CODEX_HOME
+    let grokHome: string; // GROK_HOME
+
+    // Per-harness cwd encodings the harnesses actually use.
+    const claudeSlug = (p: string): string => p.replace(/[^a-zA-Z0-9]/g, "-");
+    const grokKey = (p: string): string => encodeURIComponent(p);
+
+    const dest = (): string => path.join(root, "workspace", ".session-logs");
+
+    beforeEach(() => {
+      claudeDir = fs.mkdtempSync(path.join(os.tmpdir(), "ms-claude-"));
+      codexHome = fs.mkdtempSync(path.join(os.tmpdir(), "ms-codex-"));
+      grokHome = fs.mkdtempSync(path.join(os.tmpdir(), "ms-grok-"));
+      process.env.CLAUDE_CONFIG_DIR = claudeDir;
+      process.env.CODEX_HOME = codexHome;
+      process.env.GROK_HOME = grokHome;
+    });
+
+    afterEach(() => {
+      for (const d of [claudeDir, codexHome, grokHome]) {
+        fs.rmSync(d, { recursive: true, force: true });
+      }
+      delete process.env.CLAUDE_CONFIG_DIR;
+      delete process.env.CODEX_HOME;
+      delete process.env.GROK_HOME;
+    });
+
+    // Seed a Claude project folder for cwd `cwdPath`, return its dest dir name.
+    function seedClaude(cwdPath: string, body = "claude\n"): string {
+      const name = claudeSlug(cwdPath);
+      const projDir = path.join(claudeDir, "projects", name);
+      fs.mkdirSync(path.join(projDir, "tool-results"), { recursive: true });
+      fs.writeFileSync(path.join(projDir, "session.jsonl"), body);
+      fs.writeFileSync(path.join(projDir, "tool-results", "r.txt"), "res\n");
+      return name;
+    }
+
+    // Seed a Grok session folder for cwd `cwdPath`, return its dest dir name.
+    function seedGrok(cwdPath: string, body = "grok\n"): string {
+      const name = grokKey(cwdPath);
+      const sess = path.join(grokHome, "sessions", name, "uuid-1");
+      fs.mkdirSync(sess, { recursive: true });
+      fs.writeFileSync(path.join(sess, "chat_history.jsonl"), body);
+      return name;
+    }
+
+    // Seed a Codex rollout at YYYY/MM/DD/<file> whose session_meta records `cwd`.
+    function seedCodex(cwd: string, date: [string, string, string], file: string): string {
+      const [y, m, d] = date;
+      const dir = path.join(codexHome, "sessions", y, m, d);
+      fs.mkdirSync(dir, { recursive: true });
+      const meta = JSON.stringify({ type: "session_meta", payload: { cwd } });
+      const event = JSON.stringify({ type: "event_msg", payload: { text: "hi" } });
+      const abs = path.join(dir, file);
+      fs.writeFileSync(abs, `${meta}\n${event}\n`);
+      return abs;
+    }
+
+    // ── Claude ──────────────────────────────────────────────────────────────
+    it("claude: captures the HQ-root project AND descendant projects under claude/", () => {
+      const rootName = seedClaude(root);
+      const subName = seedClaude(path.join(root, "workspace", "worktrees", "x"));
+      // An unrelated project (different root) must NOT be captured.
+      seedClaude("/some/other/place");
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      const c = path.join(dest(), "claude");
+      expect(fs.readFileSync(path.join(c, rootName, "session.jsonl"), "utf8")).toBe("claude\n");
+      expect(fs.existsSync(path.join(c, subName, "session.jsonl"))).toBe(true);
+      expect(fs.existsSync(path.join(c, claudeSlug("/some/other/place")))).toBe(false);
+      // Namespaced: claude logs are NOT dumped at the .session-logs root anymore.
+      expect(fs.existsSync(path.join(dest(), "session.jsonl"))).toBe(false);
+    });
+
+    it("claude: overwrites an existing dest file but never prunes dest-only entries", () => {
+      const rootName = seedClaude(root, "fresh\n");
+      const c = path.join(dest(), "claude");
+      fs.mkdirSync(path.join(c, rootName), { recursive: true });
+      fs.writeFileSync(path.join(c, rootName, "session.jsonl"), "STALE\n");
+      fs.writeFileSync(path.join(dest(), "orphan.txt"), "keep\n");
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      expect(fs.readFileSync(path.join(c, rootName, "session.jsonl"), "utf8")).toBe("fresh\n");
+      expect(fs.readFileSync(path.join(dest(), "orphan.txt"), "utf8")).toBe("keep\n");
+    });
+
+    // ── Grok ────────────────────────────────────────────────────────────────
+    it("grok: captures the HQ-root and descendant cwd folders under grok/, excludes others", () => {
+      const rootName = seedGrok(root);
+      const subName = seedGrok(path.join(root, "repos", "private", "x"));
+      seedGrok("/tmp/benchmark"); // unrelated cwd → excluded
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      const g = path.join(dest(), "grok");
+      expect(fs.readFileSync(path.join(g, rootName, "uuid-1", "chat_history.jsonl"), "utf8")).toBe("grok\n");
+      expect(fs.existsSync(path.join(g, subName, "uuid-1", "chat_history.jsonl"))).toBe(true);
+      expect(fs.existsSync(path.join(g, grokKey("/tmp/benchmark")))).toBe(false);
+    });
+
+    // ── Codex ───────────────────────────────────────────────────────────────
+    it("codex: captures rollouts whose recorded cwd is the HQ tree, mirroring the date path", () => {
+      seedCodex(root, ["2026", "07", "13"], "rollout-root.jsonl");
+      seedCodex(path.join(root, "workspace", "worktrees", "y"), ["2026", "07", "13"], "rollout-sub.jsonl");
+      seedCodex("/elsewhere/repo", ["2026", "07", "13"], "rollout-other.jsonl");
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      const cx = path.join(dest(), "codex", "2026", "07", "13");
+      expect(fs.existsSync(path.join(cx, "rollout-root.jsonl"))).toBe(true);
+      expect(fs.existsSync(path.join(cx, "rollout-sub.jsonl"))).toBe(true);
+      // A rollout run from outside the HQ tree is never captured (tenant scope).
+      expect(fs.existsSync(path.join(cx, "rollout-other.jsonl"))).toBe(false);
+    });
+
+    it("codex: skips a rollout already captured and unchanged (mtime guard)", () => {
+      const src = seedCodex(root, ["2026", "07", "13"], "rollout-a.jsonl");
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      // Tamper the dest copy and push its mtime into the future; an unchanged
+      // src must be skipped, leaving the sentinel in place.
+      const destFile = path.join(dest(), "codex", "2026", "07", "13", "rollout-a.jsonl");
+      fs.writeFileSync(destFile, "SENTINEL\n");
+      const future = Date.now() / 1000 + 3600;
+      fs.utimesSync(destFile, future, future);
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+      expect(fs.readFileSync(destFile, "utf8")).toBe("SENTINEL\n");
+
+      // But when the src is newer, it IS re-copied (overwriting the sentinel).
+      fs.writeFileSync(src, `${JSON.stringify({ type: "session_meta", payload: { cwd: root } })}\nNEW\n`);
+      const soon = Date.now() / 1000 + 7200;
+      fs.utimesSync(src, soon, soon);
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+      expect(fs.readFileSync(destFile, "utf8")).toContain("NEW");
+    });
+
+    // ── Cross-harness ─────────────────────────────────────────────────────────
+    it("all three harnesses land side-by-side under their own subfolders", () => {
+      seedClaude(root);
+      seedGrok(root);
+      seedCodex(root, ["2026", "07", "14"], "rollout-z.jsonl");
+
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+
+      expect(fs.existsSync(path.join(dest(), "claude", claudeSlug(root), "session.jsonl"))).toBe(true);
+      expect(fs.existsSync(path.join(dest(), "grok", grokKey(root), "uuid-1", "chat_history.jsonl"))).toBe(true);
+      expect(fs.existsSync(path.join(dest(), "codex", "2026", "07", "14", "rollout-z.jsonl"))).toBe(true);
+    });
+
+    it("no-ops (still exit 0) when no harness has logs for this root", () => {
+      // Home dirs exist but are empty → nothing to capture, no dest created.
+      expect(reindex({ repoRoot: root }).status).toBe(0);
+      expect(fs.existsSync(path.join(root, "workspace", ".session-logs"))).toBe(false);
+    });
+  });
 });

package/src/cli/reindex.ts

@@ -2,8 +2,9 @@
  * hq reindex — surfaces namespaced skills as Claude Code skill wrappers under
  * .claude/skills/<ns>:<skill>/ (one symlink per source file), mirrors
  * personal/{knowledge,policies,workers,settings}/<entry> into core/<type>/,
- * prunes orphan wrappers + legacy command symlinks, and regenerates the
- * workers registry.
+ * prunes orphan wrappers + legacy command symlinks, captures this HQ tree's
+ * coding-harness session logs (Claude Code / Codex / Grok) into
+ * workspace/.session-logs/<harness>/, and regenerates the workers registry.
  *
  * The logic historically lived in a bundled bash script (scripts/reindex.sh)
  * that this module exec'd via `bash`. It is now implemented natively in
@@ -16,6 +17,7 @@
  */
 import { spawnSync } from "child_process";
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import {
   acquireOperationLock,
@@ -197,6 +199,216 @@ function safeSymlink(target: string, linkPath: string, label: string): boolean {
   }
 }
 
+// Capture the raw session transcripts of every supported coding harness for
+// this HQ tree into `workspace/.session-logs/<harness>/`, so they live inside
+// the HQ tree (where sync/search can see them) on each reindex.
+//
+// Scope — "this HQ tree" = the HQ root cwd OR any working directory UNDER it
+// (worktrees, repo subdirs). Harnesses key their logs by cwd differently, so
+// each helper re-derives the same scope in its own encoding.
+//
+// Contract (per the feature request), applied by every helper:
+//   - copies ALL matching files/folders into `.session-logs/<harness>/…`,
+//   - OVERWRITES existing dest files, and
+//   - NEVER deletes dest entries that lack a source counterpart — a one-way
+//     overlay, not a mirror, so anything already parked in `.session-logs`
+//     survives even after a harness rotates or prunes its own store.
+//
+// Best-effort throughout: any failure warns to stderr and is swallowed so it
+// can never fail the reindex. Each harness is independent — one failing must
+// not stop the others. Home dirs honor CLAUDE_CONFIG_DIR / CODEX_HOME /
+// GROK_HOME, else ~/.claude, ~/.codex, ~/.grok.
+function copySessionLogs(root: string): void {
+  const destBase = path.join(root, "workspace", ".session-logs");
+  for (const capture of [
+    copyClaudeSessionLogs,
+    copyCodexSessionLogs,
+    copyGrokSessionLogs,
+  ]) {
+    try {
+      capture(root, destBase);
+    } catch (err) {
+      warn(`reindex: session-log capture step failed (${(err as Error).message}); skipping.`);
+    }
+  }
+}
+
+/** `fs.statSync` without throwing (follows symlinks; null when missing). */
+function statOrNull(p: string): fs.Stats | null {
+  try {
+    return fs.statSync(p);
+  } catch {
+    return null;
+  }
+}
+
+// Overlay-copy a whole directory tree: mkdir dest, then recursive+force cpSync
+// (overwrite existing, never prune dest-only entries). Best-effort — warns and
+// returns on any failure. Shared by the Claude + Grok per-cwd-folder captures.
+function copyTreeOverlay(src: string, dest: string, label: string): void {
+  if (!safeMkdir(dest, `${label} directory`)) return;
+  try {
+    fs.cpSync(src, dest, { recursive: true, force: true });
+  } catch (err) {
+    warn(
+      `reindex: could not copy ${label} from '${src}' to '${dest}' ` +
+        `(${(err as NodeJS.ErrnoException).code ?? "error"}: ${(err as Error).message}); skipping.`,
+    );
+  }
+}
+
+// Claude Code: `<claude-config>/projects/<encoded-cwd>/…`, where the cwd is
+// encoded by replacing every non-alphanumeric char with '-'. Because that map
+// is per-character, a descendant cwd's dir name is exactly the root's encoded
+// name + '-' + <encoded-subpath> — so "this HQ tree" is the exact-root dir OR
+// any dir whose name starts with `<slug>-`. Copy each into `.session-logs/claude/`.
+function copyClaudeSessionLogs(root: string, destBase: string): void {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  const projectsDir = path.join(configDir, "projects");
+  if (!isDir(projectsDir)) return;
+
+  const slug = root.replace(/[^a-zA-Z0-9]/g, "-");
+  for (const entry of globEntries(projectsDir)) {
+    if (entry !== slug && !entry.startsWith(`${slug}-`)) continue;
+    const src = path.join(projectsDir, entry);
+    if (!isDir(src)) continue;
+    copyTreeOverlay(src, path.join(destBase, "claude", entry), "claude session logs");
+  }
+}
+
+// Grok: `<grok-home>/sessions/<url-encoded-cwd>/<session-uuid>/…`, where the cwd
+// is URL-encoded (encodeURIComponent: '/' -> '%2F'). A descendant cwd's key is
+// the root's key + '%2F' + <encoded-subpath>, so match the exact-root key OR
+// that prefix. Copy each matching cwd folder into `.session-logs/grok/`.
+function copyGrokSessionLogs(root: string, destBase: string): void {
+  const grokHome = process.env.GROK_HOME || path.join(os.homedir(), ".grok");
+  const sessionsDir = path.join(grokHome, "sessions");
+  if (!isDir(sessionsDir)) return;
+
+  const key = encodeURIComponent(root);
+  for (const entry of globEntries(sessionsDir)) {
+    if (entry !== key && !entry.startsWith(`${key}%2F`)) continue;
+    const src = path.join(sessionsDir, entry);
+    if (!isDir(src)) continue;
+    copyTreeOverlay(src, path.join(destBase, "grok", entry), "grok session logs");
+  }
+}
+
+// Codex: `<codex-home>/sessions/YYYY/MM/DD/rollout-*.jsonl` — a DATE tree, not
+// per-project. The working dir is only recorded inside each rollout's first
+// line (`session_meta`, at `payload.cwd`). Walk the tree and capture a rollout
+// iff its recorded cwd is the HQ root or under it, mirroring the date-relative
+// path under `.session-logs/codex/`. A rollout already copied and unchanged is
+// skipped by mtime, so a steady-state reindex only classifies newly-written
+// rollouts — the full-tree cwd scan is a one-time first-run cost.
+function copyCodexSessionLogs(root: string, destBase: string): void {
+  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  const sessionsDir = path.join(codexHome, "sessions");
+  if (!isDir(sessionsDir)) return;
+
+  const destDir = path.join(destBase, "codex");
+  const rootPrefix = root.endsWith(path.sep) ? root : root + path.sep;
+
+  for (const abs of walkFiles(sessionsDir)) {
+    if (!abs.endsWith(".jsonl")) continue;
+    const srcStat = statOrNull(abs);
+    if (!srcStat) continue;
+
+    const dest = path.join(destDir, path.relative(sessionsDir, abs));
+    // Cheap skip: already captured and unchanged since (dest mtime is the copy
+    // time, so it stays >= src mtime until the rollout is appended to again).
+    const destStat = statOrNull(dest);
+    if (destStat && destStat.mtimeMs >= srcStat.mtimeMs) continue;
+
+    const cwd = readCodexRolloutCwd(abs);
+    if (cwd === null) continue;
+    if (cwd !== root && !cwd.startsWith(rootPrefix)) continue;
+
+    if (!safeMkdir(path.dirname(dest), "codex session-log dir")) continue;
+    try {
+      fs.copyFileSync(abs, dest);
+    } catch (err) {
+      warn(
+        `reindex: could not copy codex session log '${abs}' -> '${dest}' ` +
+          `(${(err as NodeJS.ErrnoException).code ?? "error"}: ${(err as Error).message}); skipping.`,
+      );
+    }
+  }
+}
+
+// Recursively collect every regular file under `dir` (absolute paths). Symlinks
+// are not followed (lstat gate) so a stray link can't escape the tree or loop.
+// Missing/unreadable dirs yield []. Best-effort — mirrors globEntries' tolerance.
+function walkFiles(dir: string): string[] {
+  const out: string[] = [];
+  let names: string[];
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    const abs = path.join(dir, name);
+    const st = lstatOrNull(abs);
+    if (!st) continue;
+    if (st.isDirectory()) out.push(...walkFiles(abs));
+    else if (st.isFile()) out.push(abs);
+  }
+  return out;
+}
+
+// Extract `payload.cwd` (Codex ≥ the session_meta format; falls back to a
+// top-level `cwd`) from a rollout's first line, reading only that line. Codex
+// records cwd early, before the large `base_instructions` blob, but the line
+// can still be tens of KB — so read up to a generous cap and stop at the first
+// newline. Returns null on any parse/read failure (the rollout is then skipped).
+function readCodexRolloutCwd(file: string): string | null {
+  const line = readFirstLine(file, 4 * 1024 * 1024);
+  if (line === null) return null;
+  try {
+    const obj = JSON.parse(line) as { cwd?: unknown; payload?: { cwd?: unknown } };
+    const cwd = obj?.payload?.cwd ?? obj?.cwd;
+    return typeof cwd === "string" ? cwd : null;
+  } catch {
+    return null;
+  }
+}
+
+// Read the first line of `file` (up to `capBytes`), returning it WITHOUT the
+// trailing newline, or null on error / empty. Byte-accumulates and decodes once
+// so a multibyte char split across a read boundary can't corrupt the result.
+function readFirstLine(file: string, capBytes: number): string | null {
+  let fd: number | null = null;
+  try {
+    fd = fs.openSync(file, "r");
+    const chunks: Buffer[] = [];
+    const chunk = Buffer.allocUnsafe(65536);
+    let total = 0;
+    while (total < capBytes) {
+      const n = fs.readSync(fd, chunk, 0, chunk.length, total);
+      if (n <= 0) break;
+      const nl = chunk.indexOf(0x0a, 0);
+      if (nl !== -1 && nl < n) {
+        chunks.push(Buffer.from(chunk.subarray(0, nl)));
+        return Buffer.concat(chunks).toString("utf8");
+      }
+      chunks.push(Buffer.from(chunk.subarray(0, n)));
+      total += n;
+    }
+    return chunks.length ? Buffer.concat(chunks).toString("utf8") : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+}
+
 // --- legacy `.claude/commands/<ns>/<skill>.md` symlink matcher --------------
 // Mirrors the bash `case` patterns; `*` matches any chars (including `/`).
 function isLegacyCommandTarget(t: string): boolean {
@@ -549,6 +761,11 @@ export function reindex(opts: ReindexOptions = {}): ReindexResult {
     }
   }
 
+  // --- Session-log capture --------------------------------------------------
+  // Overlay this root's Claude Code session logs into workspace/.session-logs
+  // (copy-all, overwrite, never-prune). Best-effort; never fails the reindex.
+  copySessionLogs(root);
+
   // --- Workers registry regeneration ----------------------------------------
   // Source of truth: each worker.yaml. The registry is a derived index — the
   // generator (when present in the operated-on tree) keeps it in sync.

package/src/cli/sync.test.ts

@@ -3518,6 +3518,17 @@ describe("reportNewFilesToNotify chunking (server cap = 1000 files/report)", ()
     (fetchMock.mock.calls as Array<[string, RequestInit?]>)
       .filter(([u]) => String(u).includes("/v1/notify/file-added"))
       .map(([, init]) => JSON.parse(String(init!.body)).files.length);
+  const notificationTelemetryEvents = (
+    fetchMock: ReturnType<typeof vi.fn>,
+  ): Array<{ eventName: string; properties?: Record<string, unknown> }> =>
+    (fetchMock.mock.calls as Array<[string, RequestInit?]>)
+      .filter(([u]) => String(u).includes("/v1/telemetry/events"))
+      .flatMap(([, init]) =>
+        JSON.parse(String(init!.body)).events as Array<{
+          eventName: string;
+          properties?: Record<string, unknown>;
+        }>,
+      );
 
   afterEach(() => {
     vi.unstubAllGlobals();
@@ -3580,6 +3591,85 @@ describe("reportNewFilesToNotify chunking (server cap = 1000 files/report)", ()
     expect(notifyBatchSizes(fetchMock)).toEqual([1000, 1000, 1]);
   });
 
+  it("does not emit notification telemetry after a successful report", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        return { ok: true, status: 200, text: async () => "" };
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([]);
+  });
+
+  it("emits failure telemetry for a non-successful notification response", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        return { ok: false, status: 503, text: async () => "unavailable" };
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([
+      expect.objectContaining({
+        eventName: "new_files_notification_reported",
+        properties: {
+          status: "failure",
+          fileCount: 1,
+          batchIndex: 1,
+          batchCount: 1,
+          statusCode: 503,
+        },
+      }),
+    ]);
+  });
+
+  it("emits error-class telemetry when notification reporting throws", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        throw new TypeError("network down");
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([
+      expect.objectContaining({
+        eventName: "new_files_notification_reported",
+        properties: {
+          status: "failure",
+          fileCount: 1,
+          batchIndex: 1,
+          batchCount: 1,
+          errorClass: "TypeError",
+        },
+      }),
+    ]);
+  });
+
   it("no request at all when there are no new files", async () => {
     const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, text: async () => "" });
     vi.stubGlobal("fetch", fetchMock);

package/src/cli/sync.ts

@@ -722,18 +722,20 @@ export async function reportNewFilesToNotify(
         }),
         signal: controller.signal,
       });
-      void emitCloudTelemetry(telemetryClient, {
-        eventName: "new_files_notification_reported",
-        source: "hq-sync",
-        companyUid,
-        properties: {
-          result: response.ok ? "success" : "failure",
-          fileCount: batch.length,
-          batchIndex,
-          batchCount,
-          statusCode: response.status,
-        },
-      }, { claims: telemetryClaims });
+      if (!response.ok) {
+        void emitCloudTelemetry(telemetryClient, {
+          eventName: "new_files_notification_reported",
+          source: "hq-sync",
+          companyUid,
+          properties: {
+            status: "failure",
+            fileCount: batch.length,
+            batchIndex,
+            batchCount,
+            statusCode: response.status,
+          },
+        }, { claims: telemetryClaims });
+      }
     } catch (err) {
       // Best-effort per chunk: never let notification reporting affect the sync
       // result, and a failed chunk must not abort the remaining chunks.
@@ -743,11 +745,11 @@ export async function reportNewFilesToNotify(
         source: "hq-sync",
         companyUid,
         properties: {
-          result: "failure",
+          status: "failure",
           fileCount: batch.length,
           batchIndex,
           batchCount,
-          errorCode: safeErrorName(err),
+          errorClass: safeErrorName(err),
         },
       }, { claims: telemetryClaims });
     } finally {

package/src/index.ts

@@ -164,9 +164,11 @@ export {
   PERSONAL_VAULT_EXCLUDED_TOP_LEVEL,
   PERSONAL_VAULT_COMPANY_EXCLUDED_SLUGS,
   CONTINUITY_POINTER_REL,
+  SESSION_LOGS_SYNC_REL,
   computePersonalVaultPaths,
   computePersonalCompanySubdirs,
   computeContinuityPointerPaths,
+  computeSessionLogsSyncPaths,
 } from "./personal-vault.js";
 export type { PersonalVaultOptions } from "./personal-vault.js";
 

package/src/personal-vault.test.ts

@@ -25,6 +25,8 @@ import {
   CONTINUITY_POINTER_REL,
   computeAgencySyncPaths,
   AGENCY_SYNC_REL,
+  computeSessionLogsSyncPaths,
+  SESSION_LOGS_SYNC_REL,
   PERSONAL_VAULT_COMPANY_EXCLUDED_SLUGS,
   PERSONAL_VAULT_EXCLUDED_TOP_LEVEL,
 } from "./personal-vault.js";
@@ -628,3 +630,58 @@ describe("personal-vault: agency-workspace carve-out", () => {
     );
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────
+// Session-logs carve-out (workspace/.session-logs) — reindex-captured Claude
+// Code transcripts pierce the workspace/ exclusion and round-trip to the vault.
+// ─────────────────────────────────────────────────────────────────────────
+describe("personal-vault: session-logs carve-out", () => {
+  let hqRoot: string;
+  beforeEach(() => {
+    hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-sesslog-test-"));
+  });
+  afterEach(() => {
+    fs.rmSync(hqRoot, { recursive: true, force: true });
+  });
+  const relAll = (abs: string[]): string[] =>
+    abs.map((p) => path.relative(hqRoot, p)).sort();
+
+  it("constant: SESSION_LOGS_SYNC_REL is workspace/.session-logs", () => {
+    expect(SESSION_LOGS_SYNC_REL).toBe("workspace/.session-logs");
+  });
+
+  it("includes workspace/.session-logs when it exists", () => {
+    fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs", "tool-results"), {
+      recursive: true,
+    });
+    expect(relAll(computeSessionLogsSyncPaths(hqRoot))).toEqual([
+      path.join("workspace", ".session-logs"),
+    ]);
+  });
+
+  it("empty when workspace/.session-logs is absent (fail-soft)", () => {
+    fs.mkdirSync(path.join(hqRoot, "workspace"), { recursive: true });
+    expect(computeSessionLogsSyncPaths(hqRoot)).toEqual([]);
+  });
+
+  it("composes into computePersonalVaultPaths without broadening workspace/", () => {
+    fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs"), { recursive: true });
+    fs.writeFileSync(
+      path.join(hqRoot, "workspace", ".session-logs", "session.jsonl"),
+      "l\n",
+    );
+    // A sibling under workspace/ that must STAY local.
+    fs.mkdirSync(path.join(hqRoot, "workspace", "locks"), { recursive: true });
+    fs.writeFileSync(path.join(hqRoot, "workspace", "locks", "x.lock"), "1");
+    fs.mkdirSync(path.join(hqRoot, ".claude"), { recursive: true });
+
+    const out = relAll(computePersonalVaultPaths(hqRoot));
+    expect(out).toContain(path.join("workspace", ".session-logs"));
+    expect(out).toContain(".claude");
+    // The carve-out is exactly the .session-logs subtree — no other workspace/
+    // sibling is pulled in.
+    expect(out.some((p) => p.startsWith(path.join("workspace", "locks")))).toBe(
+      false,
+    );
+  });
+});