@indigoai-us/hq-cloud 6.14.3 → 6.14.5

package/src/bin/sync-runner.test.ts

@@ -1604,6 +1604,34 @@ describe("all-complete aggregate", () => {
     expect(deps.stderr.raw()).toContain("runner.telemetry.timeout");
   });
 
+  it("silences no-op completion and company-leg telemetry but retains session start", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const client: VaultClientSurface = {
+      ...makeVaultStub({
+        memberships: [{ companyUid: "cmp_a" }],
+        entityGet: (uid: string) =>
+          Promise.resolve({ uid, slug: "acme" } as unknown as EntityInfo),
+      }),
+      postTelemetryEvents: vi.fn(async (batch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const deps = makeDeps({ createVaultClient: () => client });
+
+    const code = await runRunner(["--companies"], deps);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(code).toBe(0);
+    const eventNames = posts
+      .flatMap((post) => post.events)
+      .map((event) => event.eventName);
+    expect(eventNames).toContain("sync_runner_session_started");
+    expect(eventNames).not.toContain("sync_runner_plan_built");
+    expect(eventNames).not.toContain("company_sync_leg_completed");
+    expect(eventNames).not.toContain("sync_runner_completed");
+  });
+
   it("emits action telemetry for completion and telemetry transport failure does not block completion", async () => {
     const posts: TelemetryEventsBatch[] = [];
     const client: VaultClientSurface = {
@@ -1626,11 +1654,25 @@ describe("all-complete aggregate", () => {
           defaultSyncResult({
             filesDownloaded: 2,
             bytesDownloaded: 300,
+            filesTombstoned: 3,
+            scopeOrphansRemoved: 4,
+            scopeOrphansBlocked: 5,
+          }),
+        ),
+      share: vi
+        .fn<(opts: ShareOptions) => Promise<ShareResult>>()
+        .mockResolvedValue(
+          defaultShareResult({
+            filesUploaded: 6,
+            bytesUploaded: 700,
+            filesDeleted: 7,
+            filesTombstoned: 8,
+            filesRefusedStale: 9,
           }),
         ),
     });
 
-    const code = await runRunner(["--companies"], deps);
+    const code = await runRunner(["--companies", "--direction", "both"], deps);
     await new Promise((resolve) => setTimeout(resolve, 0));
 
     expect(code).toBe(0);
@@ -1645,19 +1687,120 @@ describe("all-complete aggregate", () => {
       source: "sync-runner",
       schemaVersion: 1,
       properties: {
-        result: "completed",
+        status: "completed",
         attemptedCount: 1,
         companyCount: 1,
         errorCount: 0,
         filesDownloaded: 2,
         bytesDownloaded: 300,
-        filesUploaded: 0,
-        bytesUploaded: 0,
+        filesUploaded: 6,
+        bytesUploaded: 700,
+      },
+    });
+    const companyLeg = posts
+      .flatMap((post) => post.events)
+      .find((event) => event.eventName === "company_sync_leg_completed");
+    expect(companyLeg).toMatchObject({
+      properties: {
+        status: "complete",
+        deletedCount: 7,
+        tombstonedCount: 11,
+        scopeOrphansRemovedCount: 4,
+        refusedStaleCount: 9,
+        scopeOrphansBlockedCount: 5,
       },
     });
     expect(deps.stderr.raw()).toContain("runner.telemetry_events.nonfatal");
   });
 
+  it("retains terminal and company-leg telemetry for a partial sync", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const client: VaultClientSurface = {
+      ...makeVaultStub({
+        memberships: [{ companyUid: "cmp_a" }],
+        entityGet: (uid: string) =>
+          Promise.resolve({ uid, slug: "acme" } as unknown as EntityInfo),
+      }),
+      postTelemetryEvents: vi.fn(async (batch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const deps = makeDeps({
+      createVaultClient: () => client,
+      sync: vi
+        .fn<(opts: SyncOptions) => Promise<SyncResult>>()
+        .mockResolvedValue(defaultSyncResult({ aborted: true })),
+    });
+
+    const code = await runRunner(["--companies"], deps);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(code).toBe(0);
+    const events = posts.flatMap((post) => post.events);
+    expect(events.find((event) => event.eventName === "company_sync_leg_completed"))
+      .toMatchObject({ properties: { status: "aborted" } });
+    expect(events.find((event) => event.eventName === "sync_runner_completed"))
+      .toMatchObject({ properties: { status: "partial" } });
+  });
+
+  it("retains terminal and company-leg telemetry when a sync leg throws", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const client: VaultClientSurface = {
+      ...makeVaultStub({
+        memberships: [{ companyUid: "cmp_a" }],
+        entityGet: (uid: string) =>
+          Promise.resolve({ uid, slug: "acme" } as unknown as EntityInfo),
+      }),
+      postTelemetryEvents: vi.fn(async (batch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const deps = makeDeps({
+      createVaultClient: () => client,
+      sync: vi
+        .fn<(opts: SyncOptions) => Promise<SyncResult>>()
+        .mockRejectedValue(new Error("sync failed")),
+    });
+
+    const code = await runRunner(["--companies"], deps);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(code).toBe(PARTIAL_SYNC_EXIT);
+    const events = posts.flatMap((post) => post.events);
+    expect(events.find((event) => event.eventName === "company_sync_leg_completed"))
+      .toMatchObject({ properties: { status: "errored" } });
+    expect(events.find((event) => event.eventName === "sync_runner_completed"))
+      .toMatchObject({ properties: { status: "partial" } });
+  });
+
+  it("retains terminal failure telemetry when post-client discovery fails", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const client: VaultClientSurface = {
+      ...makeVaultStub({
+        memberships: [{ companyUid: "cmp_a" }],
+      }),
+      listMyMemberships: () => Promise.reject(new Error("network down")),
+      postTelemetryEvents: vi.fn(async (batch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const deps = makeDeps({ createVaultClient: () => client });
+
+    const code = await runRunner(["--companies"], deps);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(code).toBe(1);
+    expect(posts.flatMap((post) => post.events)).toContainEqual(
+      expect.objectContaining({
+        eventName: "sync_runner_completed",
+        properties: { status: "failed" },
+      }),
+    );
+  });
+
   it("sums filesDownloaded and bytesDownloaded across all companies", async () => {
     const slugs: Record<string, string> = { cmp_a: "acme", cmp_b: "beta" };
     const deps = makeDeps({

package/src/bin/sync-runner.ts

@@ -1166,6 +1166,37 @@ export async function runRunner(
     },
   );
 
+  const emitRunnerTerminalTelemetry = (properties: {
+    status: "completed" | "partial" | "failed";
+    attemptedCount?: number;
+    companyCount?: number;
+    errorCount?: number;
+    filesDownloaded?: number;
+    bytesDownloaded?: number;
+    filesUploaded?: number;
+    bytesUploaded?: number;
+  }): void => {
+    void emitCloudTelemetry(
+      client,
+      {
+        eventName: "sync_runner_completed",
+        source: "sync-runner",
+        sessionId: telemetrySessionId,
+        properties,
+      },
+      {
+        claims,
+        log: (message) =>
+          reportDiagnostic({
+            component: "telemetry-events",
+            event: "runner.telemetry_events.nonfatal",
+            message,
+            context: { source: "sync-runner" },
+          }),
+      },
+    );
+  };
+
   // ---- transport selection (presigned-URL for cmp_, direct-S3/STS for prs_) -
   // Company vaults ALWAYS use the presigned-URL transport now (HQ-59): the
   // STS-direct-S3 path for cmp_ is retired — no env override routes a company
@@ -1222,6 +1253,7 @@ export async function runRunner(
       message: err instanceof Error ? err.message : String(err),
       path: "(discovery)",
     });
+    emitRunnerTerminalTelemetry({ status: "failed" });
     // A transient network failure (offline, DNS blip, vault API briefly
     // unreachable) is NOT a crash — it self-heals on the next poll. Return the
     // retryable exit code so the watch loop stays alive instead of exiting and
@@ -1246,31 +1278,6 @@ export async function runRunner(
   }
   const plan = targetPlan.plan;
 
-  void emitCloudTelemetry(
-    client,
-    {
-      eventName: "sync_runner_plan_built",
-      source: "sync-runner",
-      sessionId: telemetrySessionId,
-      properties: {
-        direction: parsed.direction,
-        targetCount: plan.length,
-        companyCount: plan.filter((target) => target.personalMode !== true).length,
-        personalCount: plan.filter((target) => target.personalMode === true).length,
-      },
-    },
-    {
-      claims,
-      log: (message) =>
-        reportDiagnostic({
-          component: "telemetry-events",
-          event: "runner.telemetry_events.nonfatal",
-          message,
-          context: { source: "sync-runner" },
-        }),
-    },
-  );
-
   emitFanoutPlan(emit, plan);
 
   // One-time seed of the reserved personal-vault journal from the legacy
@@ -1301,7 +1308,7 @@ export async function runRunner(
     telemetryClaims: claims,
     telemetrySessionId,
   });
-  const { errors, allConflicts } = fanout;
+  const { errors, allConflicts, meaningfulOutcomeCount } = fanout;
   const rollup = rollupAllComplete(plan, fanout.stateByCompany);
 
   if (rollup.needsReindex) {
@@ -1414,34 +1421,22 @@ export async function runRunner(
     partial: rollup.partial,
     companies: rollup.companies,
   });
-  void emitCloudTelemetry(
-    client,
-    {
-      eventName: "sync_runner_completed",
-      source: "sync-runner",
-      sessionId: telemetrySessionId,
-      properties: {
-        result: rollup.partial ? "partial" : "completed",
-        attemptedCount: plan.length,
-        companyCount: rollup.companies.length,
-        errorCount: errors.length,
-        filesDownloaded: rollup.totalDownloaded,
-        bytesDownloaded: rollup.totalDownloadedBytes,
-        filesUploaded: rollup.totalUploaded,
-        bytesUploaded: rollup.totalUploadedBytes,
-      },
-    },
-    {
-      claims,
-      log: (message) =>
-        reportDiagnostic({
-          component: "telemetry-events",
-          event: "runner.telemetry_events.nonfatal",
-          message,
-          context: { source: "sync-runner" },
-        }),
-    },
-  );
+  if (
+    rollup.partial ||
+    errors.length > 0 ||
+    meaningfulOutcomeCount > 0
+  ) {
+    emitRunnerTerminalTelemetry({
+      status: rollup.partial || errors.length > 0 ? "partial" : "completed",
+      attemptedCount: plan.length,
+      companyCount: rollup.companies.length,
+      errorCount: errors.length,
+      filesDownloaded: rollup.totalDownloaded,
+      bytesDownloaded: rollup.totalDownloadedBytes,
+      filesUploaded: rollup.totalUploaded,
+      bytesUploaded: rollup.totalUploadedBytes,
+    });
+  }
 
   // Post-sync qmd reindex — runs AFTER `all-complete` is emitted so the
   // menubar/CLI already shows the sync as done; this is a best-effort tail

package/src/cli/reindex.test.ts

@@ -558,70 +558,163 @@ describe("reindex", () => {
     ).toBe(true);
   });
 
-  // --- session-log capture into workspace/.session-logs ---------------------
+  // --- multi-harness session-log capture into workspace/.session-logs/<harness>/
   describe("session-log capture", () => {
-    let claudeConfigDir: string;
-    // Claude Code encodes the project cwd into its projects-dir name by
-    // replacing every non-alphanumeric char with '-'; mirror that here.
-    const slugFor = (p: string): string => p.replace(/[^a-zA-Z0-9]/g, "-");
+    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(() => {
-      claudeConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "ms-claude-"));
-      process.env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+      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(() => {
-      fs.rmSync(claudeConfigDir, { recursive: true, force: true });
+      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;
     });
 
-    function seedProjectLogs(): string {
-      const projDir = path.join(claudeConfigDir, "projects", slugFor(root));
+    // 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"), "line-1\n");
-      fs.writeFileSync(path.join(projDir, "tool-results", "r.txt"), "result\n");
-      return projDir;
+      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;
     }
 
-    it("copies all files and folders from the projects dir into workspace/.session-logs", () => {
-      seedProjectLogs();
+    // ── 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 dest = path.join(root, "workspace", ".session-logs");
-      expect(fs.readFileSync(path.join(dest, "session.jsonl"), "utf8")).toBe("line-1\n");
-      expect(fs.readFileSync(path.join(dest, "tool-results", "r.txt"), "utf8")).toBe("result\n");
+      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("overwrites an existing dest file with the newer source copy", () => {
-      seedProjectLogs();
-      const dest = path.join(root, "workspace", ".session-logs");
-      fs.mkdirSync(dest, { recursive: true });
-      fs.writeFileSync(path.join(dest, "session.jsonl"), "STALE\n");
+    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");
 
-      expect(fs.readFileSync(path.join(dest, "session.jsonl"), "utf8")).toBe("line-1\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");
     });
 
-    it("never deletes dest entries that have no source counterpart", () => {
-      seedProjectLogs();
-      const dest = path.join(root, "workspace", ".session-logs");
-      fs.mkdirSync(path.join(dest, "old-run"), { recursive: true });
-      fs.writeFileSync(path.join(dest, "old-run", "keep.jsonl"), "keep\n");
-      fs.writeFileSync(path.join(dest, "orphan.txt"), "orphan\n");
+    // ── 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);
 
-      // Source content is present...
-      expect(fs.existsSync(path.join(dest, "session.jsonl"))).toBe(true);
-      // ...and the dest-only entries survived (no prune).
-      expect(fs.readFileSync(path.join(dest, "old-run", "keep.jsonl"), "utf8")).toBe("keep\n");
-      expect(fs.readFileSync(path.join(dest, "orphan.txt"), "utf8")).toBe("orphan\n");
+      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 there is no projects dir for this root", () => {
-      // No seedProjectLogs() → the source dir doesn't exist.
+    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);
     });