@indigoai-us/hq-cloud 6.14.2 → 6.14.4

package/src/personal-vault.ts

@@ -26,7 +26,12 @@
  *     the routing source-of-truth.)
  *   - `repos/`, `workspace/`: per user directive — heavy local-only
  *     content (cloned remotes, session threads) that has no business in
- *     the personal vault.
+ *     the personal vault. Three explicit sub-paths pierce this exclusion and
+ *     DO round-trip: `workspace/threads/handoff.json` (+ its active thread) via
+ *     {@link computeContinuityPointerPaths}, `workspace/agency/` via
+ *     {@link computeAgencySyncPaths}, and `workspace/.session-logs/` (the
+ *     reindex-captured Claude Code transcripts) via
+ *     {@link computeSessionLogsSyncPaths}.
  *
  * Note: `core/`, `data/`, and `personal/` were previously excluded but are
  * INCLUDED as of user directive 2026-05-13. `core/` ships the hq-core
@@ -134,7 +139,15 @@ export function computePersonalVaultPaths(
   );
   const continuity = computeContinuityPointerPaths(hqRoot);
   const agency = computeAgencySyncPaths(hqRoot);
-  return [...topLevel, ...manifest, ...companySubdirs, ...continuity, ...agency];
+  const sessionLogs = computeSessionLogsSyncPaths(hqRoot);
+  return [
+    ...topLevel,
+    ...manifest,
+    ...companySubdirs,
+    ...continuity,
+    ...agency,
+    ...sessionLogs,
+  ];
 }
 
 /**
@@ -261,6 +274,39 @@ export function computeAgencySyncPaths(hqRoot: string): string[] {
   return [];
 }
 
+/**
+ * Fixed relative path (forward-slash, hq-root-relative) of the session-logs
+ * subtree. See {@link computeSessionLogsSyncPaths}.
+ */
+export const SESSION_LOGS_SYNC_REL = "workspace/.session-logs";
+
+/**
+ * Compute the absolute path of the session-logs carve-out:
+ * `workspace/.session-logs/` (the whole subtree).
+ *
+ * `hq reindex` copies this HQ root's Claude Code session transcripts here (see
+ * reindex's copySessionLogs). Like the agency carve-out above, this pierces the
+ * `workspace/` top-level exclusion for ONE specific subtree so those raw
+ * transcripts round-trip to the personal vault / S3 — the operator's explicit
+ * directive is that the session logs travel with the vault. The rest of
+ * `workspace/` (session scratch, locks, reports, worktrees) stays machine-local.
+ *
+ * Returns the directory path when it exists; share()'s per-file walk handles
+ * recursion, and the nested personal-vault exclusions still apply to files
+ * inside it. Fail-soft: a missing or unreadable `workspace/.session-logs/`
+ * returns []. Callers tolerate empty arrays — same contract as the manifest,
+ * continuity, and agency special-cases.
+ */
+export function computeSessionLogsSyncPaths(hqRoot: string): string[] {
+  const sessionLogsDir = path.join(hqRoot, "workspace", ".session-logs");
+  try {
+    if (fs.statSync(sessionLogsDir).isDirectory()) return [sessionLogsDir];
+  } catch {
+    // No session logs captured on this machine yet — nothing to carry.
+  }
+  return [];
+}
+
 /**
  * Discover `companies/{slug}/` subdirs that should sync to the personal
  * bucket as a fallback for companies the operator has not designated as

package/src/watcher.test.ts

@@ -12,6 +12,7 @@ import {
 import { StaticFlagProvider } from "./sync/feature-flags.js";
 import type { PushEvent } from "./sync/push-event.js";
 import type { PushTransport } from "./sync/push-transport.js";
+import type { TelemetryEventsBatch } from "./vault-client.js";
 
 /**
  * US-001 — Phase 1 test harness: watch-triggered push seam + latency assertion.
@@ -371,6 +372,36 @@ describe("US-002: createWatchPathFilter — personal-vault exclusions", () => {
     expect(personal(path.join(ROOT, "workspace/worktrees/x/a.ts"))).toBe(false);
   });
 
+  // ── workspace/.session-logs subtree carve-out (personal mode) ────────────
+  // The personal push uploads workspace/.session-logs/** (reindex-captured
+  // Claude Code transcripts, computeSessionLogsSyncPaths), so the personal
+  // watcher must emit those changes event-driven. Mirrors the agency carve-out.
+  it("DOES emit for workspace/.session-logs files in personalMode (synced subtree)", () => {
+    expect(
+      personal(path.join(ROOT, "workspace/.session-logs/session.jsonl")),
+    ).toBe(true);
+    expect(
+      personal(path.join(ROOT, "workspace/.session-logs/tool-results/r.txt")),
+    ).toBe(true);
+    // The subtree root itself, as a file event, also emits.
+    expect(personal(path.join(ROOT, "workspace/.session-logs"))).toBe(true);
+  });
+
+  it("allows chokidar to DESCEND to workspace/.session-logs in personalMode (dir probes)", () => {
+    expect(personal(path.join(ROOT, "workspace"), true)).toBe(true);
+    expect(personal(path.join(ROOT, "workspace/.session-logs"), true)).toBe(true);
+    expect(
+      personal(path.join(ROOT, "workspace/.session-logs/tool-results"), true),
+    ).toBe(true);
+  });
+
+  it("session-logs carve-out is exact-segment (does NOT leak to a similarly-named sibling)", () => {
+    expect(
+      personal(path.join(ROOT, "workspace/.session-logs-old/foo.txt")),
+    ).toBe(false);
+    expect(personal(path.join(ROOT, "workspace/.session-logsX.md"))).toBe(false);
+  });
+
   it("does not apply the carve-out in non-personal mode", () => {
     // In non-personal mode the excluded-top-level layer never runs, so the
     // carve-out is irrelevant; handoff.json passes via the ordinary ignore
@@ -706,4 +737,62 @@ describe("PushEventEmitter — directory and delete tombstone handling", () => {
     expect(published[0]).not.toHaveProperty("contentHash");
     expect(published[0]).not.toHaveProperty("mtime");
   });
+
+  it("emits push telemetry only when publication fails", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const telemetryClient = {
+      postTelemetryEvents: vi.fn(async (batch: TelemetryEventsBatch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const changed = path.join(dir, "changed.md");
+    fs.writeFileSync(changed, "changed");
+    const success = new PushEventEmitter({
+      originTenantId: "tenant-indigo",
+      originDeviceId: "device-a",
+      transport: {
+        start: async () => {},
+        dispose: async () => {},
+        connected: true,
+        publish: async () => {},
+      },
+      flagProvider: new StaticFlagProvider(["tenant-indigo"]),
+      telemetryClient,
+    });
+
+    await success.emitForBatch({ paths: new Map([[changed, "changed.md"]]) });
+    await flushImmediate();
+    expect(posts).toEqual([]);
+
+    const failed = new PushEventEmitter({
+      originTenantId: "tenant-indigo",
+      originDeviceId: "device-a",
+      transport: {
+        start: async () => {},
+        dispose: async () => {},
+        connected: true,
+        publish: async () => {
+          throw new Error("network down");
+        },
+      },
+      flagProvider: new StaticFlagProvider(["tenant-indigo"]),
+      telemetryClient,
+      onError: vi.fn(),
+    });
+
+    await failed.emitForBatch({ paths: new Map([[changed, "changed.md"]]) });
+    await flushImmediate();
+    expect(posts.flatMap((post) => post.events)).toEqual([
+      expect.objectContaining({
+        eventName: "push_event_failed",
+        properties: {
+          kind: "upsert",
+          count: 1,
+          status: "failure",
+          stage: "publish",
+        },
+      }),
+    ]);
+  });
 });

package/src/watcher.ts

@@ -16,6 +16,7 @@ import { isPersonalVaultExcluded } from "./personal-vault-exclusions.js";
 import {
   AGENCY_SYNC_REL,
   CONTINUITY_POINTER_REL,
+  SESSION_LOGS_SYNC_REL,
   PERSONAL_VAULT_EXCLUDED_TOP_LEVEL,
 } from "./personal-vault.js";
 import type { PushEvent } from "./sync/push-event.js";
@@ -466,6 +467,22 @@ export function createWatchPathFilter(
       }
       if (isDir && AGENCY_SYNC_REL.startsWith(rel + "/")) return true;
 
+      // Session-logs carve-out: `workspace/.session-logs/` (the whole subtree)
+      // IS synced via computeSessionLogsSyncPaths (mirrored on the push side),
+      // so it must re-include BEFORE the top-level `workspace/` rejection below
+      // — identical shape to the agency carve-out just above. Without this, a
+      // `--personal --watch` runner never emits reindex-captured session-log
+      // changes and they wait for the 60s poll. Paths at/under it emit; the
+      // subtree root and its ancestor dir (`workspace`) return true for the dir
+      // probe so chokidar descends to reach them instead of pruning `workspace/`.
+      if (
+        rel === SESSION_LOGS_SYNC_REL ||
+        rel.startsWith(SESSION_LOGS_SYNC_REL + "/")
+      ) {
+        return true;
+      }
+      if (isDir && SESSION_LOGS_SYNC_REL.startsWith(rel + "/")) return true;
+
       // Layer 3: excluded top-level buckets (.git/companies/repos/workspace).
       const topLevel = rel.split("/")[0];
       if (excludedTopLevel.has(topLevel)) return false;
@@ -972,7 +989,7 @@ export class PushEventEmitter {
         this.onError(err instanceof Error ? err : new Error(String(err)), {
           relativePath,
         });
-        this.emitPublishTelemetry("push_event_failed", "unknown", "capture");
+        this.emitPublishFailureTelemetry("unknown", "capture");
         return;
       }
 
@@ -1008,31 +1025,29 @@ export class PushEventEmitter {
 
     try {
       await this.transport.publish(event);
-      this.emitPublishTelemetry("push_event_published", event.kind, "publish");
     } catch (err) {
       // Push failure (network / non-2xx / timeout). The cadence poll is the
       // safety net — log + continue, never throw.
       this.onError(err instanceof Error ? err : new Error(String(err)), {
         relativePath,
       });
-      this.emitPublishTelemetry("push_event_failed", event.kind, "publish");
+      this.emitPublishFailureTelemetry(event.kind, "publish");
     }
   }
 
-  private emitPublishTelemetry(
-    eventName: "push_event_published" | "push_event_failed",
+  private emitPublishFailureTelemetry(
     kind: string,
-    stage: string,
+    stage: "capture" | "publish",
   ): void {
     void emitCloudTelemetry(
       this.telemetryClient,
       {
-        eventName,
+        eventName: "push_event_failed",
         source: "watcher",
         properties: {
           kind,
           count: 1,
-          result: eventName === "push_event_published" ? "success" : "failure",
+          status: "failure",
           stage,
         },
       },