@indigoai-us/hq-cli 5.37.6 → 5.38.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [5.38.0]
+
+### Fixed
+
+- **`hq sync status` no longer reports "No sync journal yet" right after a
+  successful sync.** The command passed the HQ-root *path* where the engine
+  expects a journal *slug*, so it looked for `sync-journal._Users_<user>_hq.json`
+  — a slug the engine never writes — while the engine shards journals by slug
+  (`__hq_personal_vault__`, per-company). Status was blind to every real
+  journal. It now enumerates **all** shards via hq-cloud's `listJournals` and
+  prints a per-scope breakdown (personal vault + each company) plus an
+  all-scopes rollup; "No sync journal yet" appears only when none exist.
+  Tombstoned entries are excluded from tracked-file counts. Fixes
+  feedback_9fbf1f82 / DEV-1725 and feedback_46288b7b / DEV-1728.
+
+### Changed
+
+- Bumps `@indigoai-us/hq-cloud` to `^6.4.0` (was `^6.3.5`) for the new
+  `listJournals` / `getStateDir` enumeration API.
+
 ## [5.25.0] — 2026-05-26
 
 ### Added

package/dist/commands/cloud.js

@@ -13,11 +13,11 @@
  *   hq sync status            — show local journal summary
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="856084be-3bbb-50cd-8e3b-1e19ea13f4fb")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1164bdd1-84e4-5bc5-80a8-6888a6f4313c")}catch(e){}}();
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
-import { share, sync, readJournal, getJournalPath, loadCachedTokens, VaultClient, computePersonalVaultPaths, PERSONAL_VAULT_JOURNAL_SLUG, } from "@indigoai-us/hq-cloud";
+import { share, sync, getStateDir, listJournals, loadCachedTokens, VaultClient, computePersonalVaultPaths, PERSONAL_VAULT_JOURNAL_SLUG, } from "@indigoai-us/hq-cloud";
 import { DEFAULT_HQ_ROOT, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
 import { emitNarrowHint, isStrictRefusal, resolveBannerLevel, } from "../lib/narrow-hint-banner.js";
 /**
@@ -669,20 +669,20 @@ export function registerCloudCommands(program) {
         .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
         .action((options) => {
         try {
-            const journalPath = getJournalPath(options.hqRoot);
-            if (!fs.existsSync(journalPath)) {
-                console.log(chalk.dim("No sync journal yet — run `hq sync push` or `hq sync pull` to create one."));
-                console.log(chalk.dim(`  Expected at: ${journalPath}`));
+            // The engine SHARDS the journal by slug — the personal-vault fanout
+            // slot, one shard per cloud company, and the legacy "personal" shard.
+            // Enumerate EVERY shard the engine can write (via the engine's own
+            // `listJournals`) rather than reconstructing a single path: the old
+            // code passed the HQ-root PATH where a slug was expected, so it always
+            // looked at `sync-journal._Users_<user>_hq.json` — a slug the engine
+            // never writes — and printed "No sync journal yet" right after a
+            // successful sync (feedback_9fbf1f82 / feedback_46288b7b).
+            const journals = listJournals();
+            if (journals.length === 0) {
+                console.log(chalk.dim("No sync journal yet — run `hq sync now`, `hq sync push`, or `hq sync pull` to create one."));
+                console.log(chalk.dim(`  Looked in: ${getStateDir()} (sync-journal.*.json)`));
                 return;
             }
-            const journal = readJournal(options.hqRoot);
-            const entries = Object.entries(journal.files ?? {});
-            const lastSyncTimes = entries
-                .map(([, entry]) => entry.syncedAt)
-                .filter((t) => typeof t === "string")
-                .sort();
-            const lastSync = lastSyncTimes.at(-1) ?? "never";
-            const totalBytes = entries.reduce((acc, [, entry]) => acc + (entry.size ?? 0), 0);
             const configPath = path.join(options.hqRoot, ".hq", "config.json");
             let activeCompany;
             if (fs.existsSync(configPath)) {
@@ -694,13 +694,42 @@ export function registerCloudCommands(program) {
                     // ignore
                 }
             }
+            let grandFiles = 0;
+            let grandBytes = 0;
+            let grandLastSync = "";
             console.log(chalk.bold("\nHQ Sync — Status"));
             console.log(`  HQ root:        ${options.hqRoot}`);
             console.log(`  Active company: ${activeCompany ?? chalk.dim("(none)")}`);
-            console.log(`  Tracked files:  ${entries.length}`);
-            console.log(`  Total size:     ${formatBytes(totalBytes)}`);
-            console.log(`  Last sync:      ${lastSync}`);
-            console.log(`  Journal:        ${journalPath}`);
+            console.log(`  Journals:       ${journals.length}`);
+            for (const j of journals) {
+                const entries = Object.entries(j.journal.files ?? {});
+                // Tombstones record removed files — exclude them from "tracked".
+                const live = entries.filter(([, entry]) => !entry.removedAt);
+                const bytes = live.reduce((acc, [, entry]) => acc + (entry.size ?? 0), 0);
+                const lastSync = j.journal.lastSync ||
+                    live
+                        .map(([, entry]) => entry.syncedAt)
+                        .filter((t) => typeof t === "string")
+                        .sort()
+                        .at(-1) ||
+                    "never";
+                grandFiles += live.length;
+                grandBytes += bytes;
+                if (lastSync !== "never" && lastSync > grandLastSync) {
+                    grandLastSync = lastSync;
+                }
+                console.log(`\n  • ${scopeLabel(j.slug)}`);
+                console.log(`      Tracked files: ${live.length}`);
+                console.log(`      Total size:    ${formatBytes(bytes)}`);
+                console.log(`      Last sync:     ${lastSync}`);
+                console.log(chalk.dim(`      Journal:       ${j.path}`));
+            }
+            if (journals.length > 1) {
+                console.log(chalk.bold("\n  All scopes"));
+                console.log(`      Tracked files: ${grandFiles}`);
+                console.log(`      Total size:    ${formatBytes(grandBytes)}`);
+                console.log(`      Last sync:     ${grandLastSync || "never"}`);
+            }
         }
         catch (err) {
             console.error(chalk.red("✗ Status failed:"), err instanceof Error ? err.message : String(err));
@@ -1113,6 +1142,18 @@ function readActiveCompanySlug(hqRoot) {
         return undefined;
     }
 }
+/**
+ * Human-friendly label for a journal slug in `hq sync status`. The
+ * personal-vault fanout slot and the legacy `companies/personal` company both
+ * carry opaque slugs; everything else is a real company slug shown as-is.
+ */
+function scopeLabel(slug) {
+    if (slug === PERSONAL_VAULT_JOURNAL_SLUG)
+        return "personal vault";
+    if (slug === "personal")
+        return "personal (companies/personal)";
+    return slug;
+}
 function formatBytes(bytes) {
     if (bytes === 0)
         return "0 B";
@@ -1168,4 +1209,4 @@ function resolveUploadAuthorFromCache() {
     }
 }
 //# sourceMappingURL=cloud.js.map
-//# debugId=856084be-3bbb-50cd-8e3b-1e19ea13f4fb
+//# debugId=1164bdd1-84e4-5bc5-80a8-6888a6f4313c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.37.6",
+  "version": "5.38.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -15,7 +15,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@indigoai-us/hq-cloud": "^6.3.5",
+    "@indigoai-us/hq-cloud": "^6.4.0",
     "@indigoai-us/hq-onboarding": "^0.1.0",
     "@sentry/node": "^10.49.0",
     "chalk": "^5.3.0",

package/src/commands/cloud.status.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Regression tests for `hq sync status`.
+ *
+ * Bug (feedback_9fbf1f82 / DEV-1725, feedback_46288b7b / DEV-1728): status
+ * reported "No sync journal yet" immediately after a SUCCESSFUL sync. Root
+ * cause — the action passed the HQ-root PATH where the engine expects a journal
+ * SLUG, so it looked for `sync-journal._Users_<user>_hq.json`, a slug the
+ * engine never writes, while the engine shards journals by slug
+ * (`__hq_personal_vault__`, per-company). The fix enumerates EVERY shard via
+ * the engine's `listJournals` and only reports "no journal" when none exist.
+ *
+ * These tests drive the real registered `status` command against real journal
+ * shards under a temp `HQ_STATE_DIR`, capturing stdout.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Command } from "commander";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  writeJournal,
+  PERSONAL_VAULT_JOURNAL_SLUG,
+} from "@indigoai-us/hq-cloud";
+
+import { registerCloudCommands } from "./cloud.js";
+
+/** Build a fresh program with the cloud commands registered. */
+function makeProgram(): Command {
+  const program = new Command();
+  program.exitOverride(); // throw instead of process.exit on parse errors
+  registerCloudCommands(program);
+  return program;
+}
+
+/** Run `status` and return everything written to console.log. */
+async function runStatus(stateDir: string): Promise<string> {
+  const lines: string[] = [];
+  const spy = vi
+    .spyOn(console, "log")
+    .mockImplementation((...args: unknown[]) => {
+      lines.push(args.map(String).join(" "));
+    });
+  try {
+    await makeProgram().parseAsync(
+      ["status", "--hq-root", "/home/fake/hq"],
+      { from: "user" },
+    );
+  } finally {
+    spy.mockRestore();
+  }
+  return lines.join("\n");
+}
+
+describe("hq sync status", () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-status-test-"));
+    process.env.HQ_STATE_DIR = stateDir;
+  });
+
+  afterEach(() => {
+    fs.rmSync(stateDir, { recursive: true, force: true });
+    delete process.env.HQ_STATE_DIR;
+  });
+
+  function seed(slug: string, files: Record<string, unknown>): void {
+    writeJournal(slug, {
+      version: "2",
+      lastSync: "",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      files: files as any,
+      pulls: [],
+    });
+  }
+
+  it("reports 'No sync journal yet' only when no shard exists", async () => {
+    const out = await runStatus(stateDir);
+    expect(out).toContain("No sync journal yet");
+    expect(out).toContain("sync-journal.*.json");
+  });
+
+  it("REGRESSION: shows the personal-vault journal after a `--personal` sync", async () => {
+    // This is the exact scenario both reporters hit: a successful personal
+    // sync, then status. It must NOT say "No sync journal yet".
+    seed(PERSONAL_VAULT_JOURNAL_SLUG, {
+      ".claude/skills/x/SKILL.md": {
+        hash: "a",
+        size: 1234,
+        syncedAt: "2026-06-08T10:00:00.000Z",
+        direction: "up",
+      },
+    });
+
+    const out = await runStatus(stateDir);
+    expect(out).not.toContain("No sync journal yet");
+    expect(out).toContain("personal vault");
+    expect(out).toContain("Tracked files: 1");
+  });
+
+  it("enumerates every shard with a per-scope breakdown + rollup", async () => {
+    seed(PERSONAL_VAULT_JOURNAL_SLUG, {
+      ".claude/a": {
+        hash: "a",
+        size: 1000,
+        syncedAt: "2026-06-08T10:00:00.000Z",
+        direction: "up",
+      },
+    });
+    seed("marshalops", {
+      "k/a.md": {
+        hash: "b",
+        size: 5000,
+        syncedAt: "2026-06-08T11:00:00.000Z",
+        direction: "down",
+      },
+    });
+    seed("glazeymedia", {
+      "k/b.md": {
+        hash: "c",
+        size: 777,
+        syncedAt: "2026-06-09T09:30:00.000Z",
+        direction: "down",
+      },
+    });
+
+    const out = await runStatus(stateDir);
+    expect(out).toContain("Journals:       3");
+    expect(out).toContain("personal vault");
+    expect(out).toContain("marshalops");
+    expect(out).toContain("glazeymedia");
+    expect(out).toContain("All scopes");
+    // Rollup last-sync is the max across shards.
+    expect(out).toContain("2026-06-09T09:30:00.000Z");
+  });
+
+  it("excludes tombstoned entries from tracked counts", async () => {
+    seed("glazeymedia", {
+      "k/live.md": {
+        hash: "c",
+        size: 100,
+        syncedAt: "2026-06-09T09:30:00.000Z",
+        direction: "down",
+      },
+      "k/removed.md": {
+        hash: "old",
+        size: 999,
+        syncedAt: "2026-05-01T00:00:00.000Z",
+        direction: "down",
+        removedAt: "2026-05-02T00:00:00.000Z",
+        removedReason: "scope_shrink",
+      },
+    });
+
+    const out = await runStatus(stateDir);
+    // One live file, not two — the tombstone is not "tracked".
+    expect(out).toContain("Tracked files: 1");
+  });
+});

package/src/commands/cloud.ts

@@ -21,8 +21,8 @@ import * as path from "path";
 import {
   share,
   sync,
-  readJournal,
-  getJournalPath,
+  getStateDir,
+  listJournals,
   loadCachedTokens,
   VaultClient,
   computePersonalVaultPaths,
@@ -1102,25 +1102,28 @@ export function registerCloudCommands(program: Command): void {
     )
     .action((options: { hqRoot: string }) => {
       try {
-        const journalPath = getJournalPath(options.hqRoot);
-        if (!fs.existsSync(journalPath)) {
-          console.log(chalk.dim("No sync journal yet — run `hq sync push` or `hq sync pull` to create one."));
-          console.log(chalk.dim(`  Expected at: ${journalPath}`));
+        // The engine SHARDS the journal by slug — the personal-vault fanout
+        // slot, one shard per cloud company, and the legacy "personal" shard.
+        // Enumerate EVERY shard the engine can write (via the engine's own
+        // `listJournals`) rather than reconstructing a single path: the old
+        // code passed the HQ-root PATH where a slug was expected, so it always
+        // looked at `sync-journal._Users_<user>_hq.json` — a slug the engine
+        // never writes — and printed "No sync journal yet" right after a
+        // successful sync (feedback_9fbf1f82 / feedback_46288b7b).
+        const journals = listJournals();
+
+        if (journals.length === 0) {
+          console.log(
+            chalk.dim(
+              "No sync journal yet — run `hq sync now`, `hq sync push`, or `hq sync pull` to create one.",
+            ),
+          );
+          console.log(
+            chalk.dim(`  Looked in: ${getStateDir()} (sync-journal.*.json)`),
+          );
           return;
         }
 
-        const journal = readJournal(options.hqRoot);
-        const entries = Object.entries(journal.files ?? {});
-        const lastSyncTimes = entries
-          .map(([, entry]) => entry.syncedAt)
-          .filter((t): t is string => typeof t === "string")
-          .sort();
-        const lastSync = lastSyncTimes.at(-1) ?? "never";
-        const totalBytes = entries.reduce(
-          (acc, [, entry]) => acc + (entry.size ?? 0),
-          0,
-        );
-
         const configPath = path.join(options.hqRoot, ".hq", "config.json");
         let activeCompany: string | undefined;
         if (fs.existsSync(configPath)) {
@@ -1132,13 +1135,51 @@ export function registerCloudCommands(program: Command): void {
           }
         }
 
+        let grandFiles = 0;
+        let grandBytes = 0;
+        let grandLastSync = "";
+
         console.log(chalk.bold("\nHQ Sync — Status"));
         console.log(`  HQ root:        ${options.hqRoot}`);
         console.log(`  Active company: ${activeCompany ?? chalk.dim("(none)")}`);
-        console.log(`  Tracked files:  ${entries.length}`);
-        console.log(`  Total size:     ${formatBytes(totalBytes)}`);
-        console.log(`  Last sync:      ${lastSync}`);
-        console.log(`  Journal:        ${journalPath}`);
+        console.log(`  Journals:       ${journals.length}`);
+
+        for (const j of journals) {
+          const entries = Object.entries(j.journal.files ?? {});
+          // Tombstones record removed files — exclude them from "tracked".
+          const live = entries.filter(([, entry]) => !entry.removedAt);
+          const bytes = live.reduce(
+            (acc, [, entry]) => acc + (entry.size ?? 0),
+            0,
+          );
+          const lastSync =
+            j.journal.lastSync ||
+            live
+              .map(([, entry]) => entry.syncedAt)
+              .filter((t): t is string => typeof t === "string")
+              .sort()
+              .at(-1) ||
+            "never";
+
+          grandFiles += live.length;
+          grandBytes += bytes;
+          if (lastSync !== "never" && lastSync > grandLastSync) {
+            grandLastSync = lastSync;
+          }
+
+          console.log(`\n  • ${scopeLabel(j.slug)}`);
+          console.log(`      Tracked files: ${live.length}`);
+          console.log(`      Total size:    ${formatBytes(bytes)}`);
+          console.log(`      Last sync:     ${lastSync}`);
+          console.log(chalk.dim(`      Journal:       ${j.path}`));
+        }
+
+        if (journals.length > 1) {
+          console.log(chalk.bold("\n  All scopes"));
+          console.log(`      Tracked files: ${grandFiles}`);
+          console.log(`      Total size:    ${formatBytes(grandBytes)}`);
+          console.log(`      Last sync:     ${grandLastSync || "never"}`);
+        }
       } catch (err) {
         console.error(
           chalk.red("✗ Status failed:"),
@@ -1702,6 +1743,17 @@ function readActiveCompanySlug(hqRoot: string): string | undefined {
   }
 }
 
+/**
+ * Human-friendly label for a journal slug in `hq sync status`. The
+ * personal-vault fanout slot and the legacy `companies/personal` company both
+ * carry opaque slugs; everything else is a real company slug shown as-is.
+ */
+function scopeLabel(slug: string): string {
+  if (slug === PERSONAL_VAULT_JOURNAL_SLUG) return "personal vault";
+  if (slug === "personal") return "personal (companies/personal)";
+  return slug;
+}
+
 function formatBytes(bytes: number): string {
   if (bytes === 0) return "0 B";
   const units = ["B", "KB", "MB", "GB"];