@indigoai-us/hq-cloud 6.3.6 → 6.5.0

package/src/journal.test.ts

@@ -27,6 +27,7 @@ import {
   TOMBSTONE_TTL_MS,
   PERSONAL_VAULT_JOURNAL_SLUG,
   migratePersonalVaultJournal,
+  listJournals,
 } from "./journal.js";
 import type { SyncJournal, PullRecord } from "./types.js";
 
@@ -643,4 +644,123 @@ describe("journal", () => {
       expect(fs.existsSync(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG))).toBe(false);
     });
   });
+
+  // Regression: `hq sync status` reported "No sync journal yet" right after a
+  // successful sync because it read one path keyed off the HQ-ROOT, while the
+  // engine writes slug-sharded journals (personal vault + per-company).
+  // `listJournals` is the all-shard enumeration the status surface now uses.
+  describe("listJournals", () => {
+    function seed(slug: string, files: SyncJournal["files"]): void {
+      writeJournal(slug, {
+        version: "2",
+        lastSync: "",
+        files,
+        pulls: [],
+      });
+    }
+
+    it("returns [] when the state dir has no journals (truly-empty case)", () => {
+      expect(listJournals()).toEqual([]);
+    });
+
+    it("returns [] when the state dir does not exist at all", () => {
+      process.env.HQ_STATE_DIR = path.join(stateDir, "does-not-exist");
+      expect(listJournals()).toEqual([]);
+    });
+
+    it("enumerates the personal-vault shard written by a `--personal` sync", () => {
+      seed(PERSONAL_VAULT_JOURNAL_SLUG, {
+        ".claude/skills/x/SKILL.md": {
+          hash: "a",
+          size: 10,
+          syncedAt: "2026-06-08T10:00:00.000Z",
+          direction: "up",
+        },
+      });
+
+      const all = listJournals();
+      expect(all).toHaveLength(1);
+      expect(all[0]!.slug).toBe(PERSONAL_VAULT_JOURNAL_SLUG);
+      expect(all[0]!.path).toBe(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG));
+      expect(Object.keys(all[0]!.journal.files)).toContain(
+        ".claude/skills/x/SKILL.md",
+      );
+    });
+
+    it("enumerates a per-company shard written by a company sync", () => {
+      seed("marshalops", {
+        "knowledge/a.md": {
+          hash: "b",
+          size: 20,
+          syncedAt: "2026-06-08T11:00:00.000Z",
+          direction: "down",
+        },
+      });
+
+      const all = listJournals();
+      expect(all.map((j) => j.slug)).toEqual(["marshalops"]);
+    });
+
+    it("enumerates ALL shards together, sorted by slug", () => {
+      seed(PERSONAL_VAULT_JOURNAL_SLUG, {
+        ".claude/x": {
+          hash: "a",
+          size: 1,
+          syncedAt: "2026-06-08T10:00:00.000Z",
+          direction: "up",
+        },
+      });
+      seed("marshalops", {
+        "k/a": {
+          hash: "b",
+          size: 2,
+          syncedAt: "2026-06-08T11:00:00.000Z",
+          direction: "down",
+        },
+      });
+      seed("glazeymedia", {
+        "k/b": {
+          hash: "c",
+          size: 3,
+          syncedAt: "2026-06-08T12:00:00.000Z",
+          direction: "down",
+        },
+      });
+
+      const slugs = listJournals().map((j) => j.slug);
+      // Sorted: "__hq_personal_vault__" < "glazeymedia" < "marshalops".
+      expect(slugs).toEqual([
+        PERSONAL_VAULT_JOURNAL_SLUG,
+        "glazeymedia",
+        "marshalops",
+      ]);
+    });
+
+    it("skips a corrupt shard but still returns the healthy ones", () => {
+      seed("marshalops", {
+        "k/a": {
+          hash: "b",
+          size: 2,
+          syncedAt: "2026-06-08T11:00:00.000Z",
+          direction: "down",
+        },
+      });
+      fs.writeFileSync(
+        path.join(stateDir, "sync-journal.broken.json"),
+        "{ not valid json",
+      );
+
+      const all = listJournals();
+      expect(all.map((j) => j.slug)).toEqual(["marshalops"]);
+    });
+
+    it("ignores unrelated files in the state dir", () => {
+      seed("marshalops", {});
+      fs.writeFileSync(path.join(stateDir, "config.json"), "{}");
+      fs.writeFileSync(path.join(stateDir, "sync-journal.json"), "{}"); // no slug
+      fs.writeFileSync(path.join(stateDir, "notes.txt"), "hi");
+
+      expect(listJournals().map((j) => j.slug)).toEqual(["marshalops"]);
+    });
+  });
 });

package/src/journal.ts

@@ -135,6 +135,72 @@ export function readJournal(slug: string): SyncJournal {
   return { version: JOURNAL_VERSION_CURRENT, lastSync: "", files: {}, pulls: [] };
 }
 
+/** One enumerated journal shard: its recovered slug, on-disk path, contents. */
+export interface JournalSummary {
+  /**
+   * Slug recovered from the `sync-journal.<slug>.json` filename — the
+   * sanitized form the engine wrote (e.g. a company slug,
+   * `PERSONAL_VAULT_JOURNAL_SLUG`, or the legacy `"personal"`).
+   */
+  slug: string;
+  /** Absolute path to the journal file. */
+  path: string;
+  /** Parsed journal contents. */
+  journal: SyncJournal;
+}
+
+/**
+ * Enumerate every sync journal present in the state dir.
+ *
+ * The engine SHARDS journals by slug (ADR-0001 Phase 5): the personal-vault
+ * fanout slot under `PERSONAL_VAULT_JOURNAL_SLUG`, one shard per cloud company,
+ * and the legacy `"personal"` shard. A caller that reads a single fixed path
+ * therefore only ever sees one scope — and a caller that mistakes a non-slug
+ * value for a slug (e.g. `hq sync status` passing the HQ-root PATH, which
+ * `sanitizeSlug` mangles into `_Users_<user>_hq`) sees a slug the engine never
+ * writes, and reports "no journal" right after a successful sync. Any surface
+ * that wants the COMPLETE local sync picture must read ALL shards via this
+ * helper rather than reconstructing a path.
+ *
+ * Slugs are recovered from each filename. A shard that fails to read or parse
+ * is skipped rather than thrown — one corrupt shard must not blind the caller
+ * to the healthy ones. Results are sorted by slug for deterministic output.
+ */
+export function listJournals(): JournalSummary[] {
+  const dir = getStateDir();
+  let names: string[];
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return []; // state dir absent → no journals yet
+  }
+  const out: JournalSummary[] = [];
+  for (const name of names) {
+    if (
+      !name.startsWith(JOURNAL_FILE_PREFIX) ||
+      !name.endsWith(JOURNAL_FILE_SUFFIX)
+    ) {
+      continue;
+    }
+    const slug = name.slice(
+      JOURNAL_FILE_PREFIX.length,
+      name.length - JOURNAL_FILE_SUFFIX.length,
+    );
+    if (!slug) continue; // guard against a stray "sync-journal..json"
+    const filePath = path.join(dir, name);
+    try {
+      const journal = JSON.parse(
+        fs.readFileSync(filePath, "utf-8"),
+      ) as SyncJournal;
+      out.push({ slug, path: filePath, journal });
+    } catch {
+      // Corrupt/unreadable shard — skip; don't blind the caller to the rest.
+    }
+  }
+  out.sort((a, b) => a.slug.localeCompare(b.slug));
+  return out;
+}
+
 /**
  * Defuse the pre-5.47.2 Windows backslash-key landmine in a journal's `files`
  * map. Such clients stamped keys with the OS path separator ("\\"), e.g.