@indigoai-us/hq-cli 5.77.14 → 5.78.0

package/src/commands/cloud.pull-per-company.test.ts

@@ -1,188 +0,0 @@
-/**
- * Unit tests for `resolvePerCompanyPullPlan` — the helper extracted from the
- * `hq sync pull --company <slug>` action handler so the US-011 banner +
- * strict-refusal wiring can be exercised without commander / a real
- * VaultClient (US-011 fix, 2026-05-21).
- *
- * The action handler itself stays a thin orchestrator. These tests cover
- * the membership-resolution decision tree, which is the part that broke
- * on the pre-fix code path (banner silently never fired because the
- * handler never looked up the sync-config).
- *
- * Coverage:
- *   1. Undefined targetCompany short-circuits to no-op.
- *   2. Direct UID match returns mode + companyUid.
- *   3. Direct membershipKey match returns mode + companyUid.
- *   4. Slug match via entity.get returns mode + companyUid.
- *   5. listMyMemberships error degrades silently to no resolution.
- *   6. getMembershipSyncConfig error degrades to undefined mode but keeps companyUid.
- *   7. Slug iteration stops at first match (doesn't fan out to all entities).
- *   8. No matching membership returns no resolution.
- */
-
-import { describe, expect, it, vi } from "vitest";
-import {
-  resolvePerCompanyPullPlan,
-  type PerCompanyPullResolveClient,
-} from "./cloud.js";
-
-function makeClient(opts: {
-  memberships?: Array<{ companyUid: string; membershipKey: string }>;
-  syncConfigs?: Record<string, { syncMode: "shared" | "all" | "custom" }>;
-  entities?: Record<string, { slug?: string }>;
-  failListMemberships?: boolean;
-  failSyncConfigFor?: Set<string>;
-  failEntityFor?: Set<string>;
-}): PerCompanyPullResolveClient & {
-  _entityCalls: () => string[];
-} {
-  const entityCalls: string[] = [];
-  return {
-    listMyMemberships: vi.fn(async () => {
-      if (opts.failListMemberships) throw new Error("listMyMemberships boom");
-      return opts.memberships ?? [];
-    }),
-    getMembershipSyncConfig: vi.fn(async (key: string) => {
-      if (opts.failSyncConfigFor?.has(key))
-        throw new Error(`getMembershipSyncConfig boom for ${key}`);
-      const cfg = (opts.syncConfigs ?? {})[key];
-      if (!cfg) throw new Error(`no fake config for ${key}`);
-      return cfg;
-    }),
-    entity: {
-      get: vi.fn(async (uid: string) => {
-        entityCalls.push(uid);
-        if (opts.failEntityFor?.has(uid))
-          throw new Error(`entity.get boom for ${uid}`);
-        return (opts.entities ?? {})[uid] ?? {};
-      }),
-    },
-    _entityCalls: () => entityCalls,
-  };
-}
-
-describe("resolvePerCompanyPullPlan (US-011 per-company pull fix)", () => {
-  it("returns undefined+undefined when targetCompany is undefined", async () => {
-    const client = makeClient({});
-    const result = await resolvePerCompanyPullPlan(client, undefined);
-    expect(result.resolvedCompanyUid).toBeUndefined();
-    expect(result.resolvedMode).toBeUndefined();
-    // Should not call any API — short-circuit.
-    expect(client.listMyMemberships).not.toHaveBeenCalled();
-  });
-
-  it("matches by direct companyUid and returns the live syncMode", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_personal", membershipKey: "mbr_personal" },
-        { companyUid: "cmp_indigo", membershipKey: "mbr_indigo" },
-      ],
-      syncConfigs: {
-        mbr_personal: { syncMode: "all" },
-        mbr_indigo: { syncMode: "shared" },
-      },
-    });
-    const result = await resolvePerCompanyPullPlan(client, "cmp_indigo");
-    expect(result.resolvedCompanyUid).toBe("cmp_indigo");
-    expect(result.resolvedMode).toBe("shared");
-    // Slug-fallback loop must not fire — no entity calls.
-    expect(client._entityCalls()).toEqual([]);
-  });
-
-  it("matches by direct membershipKey", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_x", membershipKey: "mbr_special" },
-      ],
-      syncConfigs: { mbr_special: { syncMode: "custom" } },
-    });
-    const result = await resolvePerCompanyPullPlan(client, "mbr_special");
-    expect(result.resolvedCompanyUid).toBe("cmp_x");
-    expect(result.resolvedMode).toBe("custom");
-  });
-
-  it("matches by slug via entity.get fan-out", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_one", membershipKey: "mbr_one" },
-        { companyUid: "cmp_two", membershipKey: "mbr_two" },
-      ],
-      syncConfigs: { mbr_two: { syncMode: "all" } },
-      entities: {
-        cmp_one: { slug: "foo" },
-        cmp_two: { slug: "personal" },
-      },
-    });
-    const result = await resolvePerCompanyPullPlan(client, "personal");
-    expect(result.resolvedCompanyUid).toBe("cmp_two");
-    expect(result.resolvedMode).toBe("all");
-  });
-
-  it("stops slug iteration at the first match — does not fan out", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_a", membershipKey: "mbr_a" },
-        { companyUid: "cmp_b", membershipKey: "mbr_b" },
-        { companyUid: "cmp_c", membershipKey: "mbr_c" },
-      ],
-      syncConfigs: { mbr_b: { syncMode: "shared" } },
-      entities: {
-        cmp_a: { slug: "alpha" },
-        cmp_b: { slug: "beta" },
-        cmp_c: { slug: "gamma" },
-      },
-    });
-    const result = await resolvePerCompanyPullPlan(client, "beta");
-    expect(result.resolvedCompanyUid).toBe("cmp_b");
-    expect(result.resolvedMode).toBe("shared");
-    // cmp_a was probed, cmp_b matched, cmp_c never touched.
-    expect(client._entityCalls()).toEqual(["cmp_a", "cmp_b"]);
-  });
-
-  it("returns undefined for both when no matching membership/slug", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_x", membershipKey: "mbr_x" },
-      ],
-      entities: { cmp_x: { slug: "foo" } },
-    });
-    const result = await resolvePerCompanyPullPlan(client, "doesnotexist");
-    expect(result.resolvedCompanyUid).toBeUndefined();
-    expect(result.resolvedMode).toBeUndefined();
-  });
-
-  it("degrades silently when listMyMemberships fails — no banner, pull continues", async () => {
-    const client = makeClient({ failListMemberships: true });
-    const result = await resolvePerCompanyPullPlan(client, "personal");
-    expect(result.resolvedCompanyUid).toBeUndefined();
-    expect(result.resolvedMode).toBeUndefined();
-    // Sync-config never reached.
-    expect(client.getMembershipSyncConfig).not.toHaveBeenCalled();
-  });
-
-  it("on direct match, keeps companyUid even when getMembershipSyncConfig throws", async () => {
-    const client = makeClient({
-      memberships: [{ companyUid: "cmp_p", membershipKey: "mbr_p" }],
-      failSyncConfigFor: new Set(["mbr_p"]),
-    });
-    const result = await resolvePerCompanyPullPlan(client, "cmp_p");
-    expect(result.resolvedCompanyUid).toBe("cmp_p");
-    // Mode unknown — caller will skip banner emit (it only fires when mode='all').
-    expect(result.resolvedMode).toBeUndefined();
-  });
-
-  it("on slug-fallback match, skips broken entity rows and keeps looking", async () => {
-    const client = makeClient({
-      memberships: [
-        { companyUid: "cmp_broken", membershipKey: "mbr_broken" },
-        { companyUid: "cmp_good", membershipKey: "mbr_good" },
-      ],
-      syncConfigs: { mbr_good: { syncMode: "all" } },
-      entities: { cmp_good: { slug: "wanted" } },
-      failEntityFor: new Set(["cmp_broken"]),
-    });
-    const result = await resolvePerCompanyPullPlan(client, "wanted");
-    expect(result.resolvedCompanyUid).toBe("cmp_good");
-    expect(result.resolvedMode).toBe("all");
-  });
-});

package/src/commands/cloud.push-all.test.ts

@@ -1,485 +0,0 @@
-/**
- * Unit tests for `pushAll` — the orchestrator behind `hq sync push --all`.
- *
- * Mirrors the DI layout used in `cloud.pull-all.test.ts`: pushAll takes a
- * `VaultClient`-shaped adapter and a `share`-shaped function as deps, so
- * the tests can exercise the membership + canonical-person fanout without
- * touching the network or the real share() implementation.
- *
- * Personal paths are computed via the real `computePersonalVaultPaths` so
- * we verify the hqRoot scope on disk. Each test that exercises personal
- * uses an isolated tmpdir with known top-level entries.
- */
-
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-import {
-  pushAll,
-  type PushAllDeps,
-  type PullAllVaultClient,
-  type ShareCallOptions,
-  type ShareCallResult,
-} from "./cloud.js";
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-interface FakeMembership {
-  companyUid: string;
-}
-
-interface FakeEntity {
-  uid: string;
-  type: "person" | "company";
-  slug: string;
-  bucketName?: string;
-  createdAt: string;
-}
-
-function makeVaultClient(opts: {
-  memberships?: FakeMembership[];
-  persons?: FakeEntity[];
-  entitiesBySlug?: Record<string, { slug: string; name?: string }>;
-  failGetEntityFor?: Set<string>;
-}): PullAllVaultClient {
-  return {
-    listMyMemberships: vi
-      .fn<[], Promise<FakeMembership[]>>()
-      .mockResolvedValue(opts.memberships ?? []),
-    listPersonEntities: vi
-      .fn<[], Promise<FakeEntity[]>>()
-      .mockResolvedValue(opts.persons ?? []),
-    getEntity: vi
-      .fn<[string], Promise<{ slug?: string; name?: string } | null>>()
-      .mockImplementation(async (uid: string) => {
-        if (opts.failGetEntityFor?.has(uid)) {
-          throw new Error(`fake getEntity failure for ${uid}`);
-        }
-        return opts.entitiesBySlug?.[uid] ?? null;
-      }),
-  };
-}
-
-function makeShareSpy(
-  perCallOverrides: Record<string, Partial<ShareCallResult> | Error> = {},
-): {
-  fn: PushAllDeps["share"];
-  calls: ShareCallOptions[];
-} {
-  const calls: ShareCallOptions[] = [];
-  const fn: PushAllDeps["share"] = vi
-    .fn<[ShareCallOptions], Promise<ShareCallResult>>()
-    .mockImplementation(async (options: ShareCallOptions) => {
-      calls.push(options);
-      const override = perCallOverrides[options.company];
-      if (override instanceof Error) {
-        throw override;
-      }
-      return {
-        filesUploaded: 0,
-        bytesUploaded: 0,
-        filesSkipped: 0,
-        filesDeleted: 0,
-        filesExcludedByScope: 0,
-        conflictPaths: [],
-        aborted: false,
-        ...override,
-      };
-    });
-  return { fn, calls };
-}
-
-// Create a tmpdir hqRoot with a known set of top-level entries so the
-// personal-vault path computation produces a stable expected output.
-let tmpHqRoots: string[] = [];
-
-function makeHqRoot(topLevelEntries: string[]): string {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-pushall-test-"));
-  for (const name of topLevelEntries) {
-    fs.mkdirSync(path.join(root, name), { recursive: true });
-  }
-  tmpHqRoots.push(root);
-  return root;
-}
-
-beforeEach(() => {
-  tmpHqRoots = [];
-});
-
-afterEach(() => {
-  for (const root of tmpHqRoots) {
-    try {
-      fs.rmSync(root, { recursive: true, force: true });
-    } catch {
-      // Best-effort cleanup.
-    }
-  }
-});
-
-// ── 1. Happy path ───────────────────────────────────────────────────────────
-
-describe("pushAll", () => {
-  it("pushes every membership plus the canonical person entity", async () => {
-    const hqRoot = makeHqRoot([
-      ".git",
-      "companies",
-      "repos",
-      "workspace",
-      ".claude",
-      "knowledge",
-      "personal",
-    ]);
-    const vaultClient = makeVaultClient({
-      memberships: [
-        { companyUid: "cmp_acme" },
-        { companyUid: "cmp_globex" },
-      ],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          bucketName: "hq-vault-psn-alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-      entitiesBySlug: {
-        cmp_acme: { slug: "acme", name: "Acme" },
-        cmp_globex: { slug: "globex", name: "Globex" },
-      },
-    });
-    const share = makeShareSpy({
-      cmp_acme: { filesUploaded: 4, bytesUploaded: 400 },
-      cmp_globex: { filesUploaded: 1, bytesUploaded: 50 },
-      psn_alice: { filesUploaded: 9, bytesUploaded: 900 },
-    });
-
-    const result = await pushAll(
-      { hqRoot, onConflict: "abort" },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(share.calls).toHaveLength(3);
-    expect(share.calls[0]).toMatchObject({
-      company: "cmp_acme",
-      hqRoot,
-      paths: [path.join(hqRoot, "companies", "acme")],
-      onConflict: "abort",
-      skipUnchanged: true,
-      propagateDeletes: true,
-    });
-    expect(share.calls[1]).toMatchObject({
-      company: "cmp_globex",
-      paths: [path.join(hqRoot, "companies", "globex")],
-    });
-    expect(share.calls[2]).toMatchObject({
-      company: "psn_alice",
-      personalMode: true,
-      journalSlug: "__hq_personal_vault__",
-      skipUnchanged: true,
-      propagateDeletes: true,
-    });
-    // Personal paths excludes .git/companies/repos/workspace, keeps the rest.
-    expect(new Set(share.calls[2].paths)).toEqual(
-      new Set([
-        path.join(hqRoot, ".claude"),
-        path.join(hqRoot, "knowledge"),
-        path.join(hqRoot, "personal"),
-      ]),
-    );
-
-    expect(result.attempted).toBe(3);
-    expect(result.filesUploaded).toBe(14);
-    expect(result.bytesUploaded).toBe(1350);
-    expect(result.errors).toEqual([]);
-    expect(result.perCompany.map((row) => row.slug)).toEqual([
-      "acme",
-      "globex",
-      "personal",
-    ]);
-  });
-
-  // ── 2. Conflict + message passthrough ─────────────────────────────────────
-
-  it("forwards --on-conflict and --message to every share() call", async () => {
-    const hqRoot = makeHqRoot(["companies", ".claude"]);
-    const vaultClient = makeVaultClient({
-      memberships: [{ companyUid: "cmp_acme" }],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-    });
-    const share = makeShareSpy();
-
-    await pushAll(
-      { hqRoot, onConflict: "overwrite", message: "test broadcast" },
-      { vaultClient, share: share.fn },
-    );
-
-    for (const call of share.calls) {
-      expect(call.onConflict).toBe("overwrite");
-      expect(call.message).toBe("test broadcast");
-      expect(call.skipUnchanged).toBe(true);
-      expect(call.propagateDeletes).toBe(true);
-    }
-  });
-
-  // ── 3. Per-company error isolation ────────────────────────────────────────
-
-  it("continues past a per-company share failure and reports it in errors[]", async () => {
-    const hqRoot = makeHqRoot(["companies"]);
-    const vaultClient = makeVaultClient({
-      memberships: [
-        { companyUid: "cmp_acme" },
-        { companyUid: "cmp_globex" },
-      ],
-      persons: [],
-      entitiesBySlug: {
-        cmp_acme: { slug: "acme" },
-        cmp_globex: { slug: "globex" },
-      },
-    });
-    const share = makeShareSpy({
-      cmp_globex: new Error("STS denied"),
-    });
-
-    const result = await pushAll(
-      { hqRoot },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(share.calls.map((c) => c.company)).toEqual([
-      "cmp_acme",
-      "cmp_globex",
-    ]);
-    expect(result.attempted).toBe(2);
-    expect(result.errors).toEqual([
-      { company: "globex", message: "STS denied" },
-    ]);
-    const globexRow = result.perCompany.find((r) => r.slug === "globex");
-    expect(globexRow?.error).toBe("STS denied");
-    expect(globexRow?.result).toBeUndefined();
-  });
-
-  // ── 4. No person entity ────────────────────────────────────────────────────
-
-  it("omits the personal target when listPersonEntities returns []", async () => {
-    const hqRoot = makeHqRoot(["companies"]);
-    const vaultClient = makeVaultClient({
-      memberships: [{ companyUid: "cmp_acme" }],
-      persons: [],
-      entitiesBySlug: { cmp_acme: { slug: "acme" } },
-    });
-    const share = makeShareSpy();
-
-    const result = await pushAll(
-      { hqRoot },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(share.calls).toHaveLength(1);
-    expect(share.calls[0].company).toBe("cmp_acme");
-    expect(share.calls[0].personalMode).toBeUndefined();
-    expect(result.perCompany.map((r) => r.slug)).toEqual(["acme"]);
-  });
-
-  // ── 5. No memberships and no person entity ────────────────────────────────
-
-  it("returns cleanly with zero attempts when there is nothing to push", async () => {
-    const hqRoot = makeHqRoot([]);
-    const vaultClient = makeVaultClient({});
-    const share = makeShareSpy();
-
-    const result = await pushAll(
-      { hqRoot },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(share.calls).toEqual([]);
-    expect(result).toEqual({
-      attempted: 0,
-      filesUploaded: 0,
-      bytesUploaded: 0,
-      filesDeleted: 0,
-      filesExcludedByScope: 0,
-      errors: [],
-      perCompany: [],
-    });
-  });
-
-  // ── 6. Canonical-person tiebreak ──────────────────────────────────────────
-
-  it("picks the oldest person entity, breaking ties by uid", async () => {
-    const hqRoot = makeHqRoot(["docs"]);
-    const vaultClient = makeVaultClient({
-      memberships: [],
-      persons: [
-        {
-          uid: "psn_zzz",
-          type: "person",
-          slug: "alice-zzz",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-        {
-          uid: "psn_aaa",
-          type: "person",
-          slug: "alice-aaa",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-        {
-          uid: "psn_old",
-          type: "person",
-          slug: "alice-old",
-          createdAt: "2025-06-01T00:00:00Z",
-        },
-      ],
-    });
-    const share = makeShareSpy();
-
-    await pushAll({ hqRoot }, { vaultClient, share: share.fn });
-
-    expect(share.calls).toHaveLength(1);
-    expect(share.calls[0].company).toBe("psn_old");
-    expect(share.calls[0].personalMode).toBe(true);
-    expect(share.calls[0].journalSlug).toBe("__hq_personal_vault__");
-  });
-
-  // ── 7. Aggregate counts include deletes ───────────────────────────────────
-
-  it("aggregates filesDeleted across every successful target", async () => {
-    const hqRoot = makeHqRoot(["companies", "docs"]);
-    const vaultClient = makeVaultClient({
-      memberships: [{ companyUid: "cmp_acme" }],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-      entitiesBySlug: { cmp_acme: { slug: "acme" } },
-    });
-    const share = makeShareSpy({
-      cmp_acme: { filesUploaded: 2, filesDeleted: 1 },
-      psn_alice: { filesUploaded: 1, filesDeleted: 3 },
-    });
-
-    const result = await pushAll(
-      { hqRoot },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(result.filesUploaded).toBe(3);
-    expect(result.filesDeleted).toBe(4);
-  });
-
-  it("aggregates filesExcludedByScope across every successful target", async () => {
-    const hqRoot = makeHqRoot(["companies", "docs"]);
-    const vaultClient = makeVaultClient({
-      memberships: [{ companyUid: "cmp_acme" }],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-      entitiesBySlug: { cmp_acme: { slug: "acme" } },
-    });
-    const share = makeShareSpy({
-      cmp_acme: { filesExcludedByScope: 2 },
-      psn_alice: { filesExcludedByScope: 3 },
-    });
-
-    const result = await pushAll(
-      { hqRoot },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(result.filesExcludedByScope).toBe(5);
-  });
-
-  // ── skipPersonal — fanout omits the canonical-person leg ──────────────────
-  //
-  // Symmetric with the `pullAll` skipPersonal coverage in
-  // `cloud.pull-all.test.ts`. Wired through from `hq sync push --all
-  // --no-personal` (Commander's `--no-personal` is the auto-negation of the
-  // `--personal` single-target selector). Verifies (a) the personal leg is
-  // dropped even when a canonical person exists, and (b) the baseline
-  // behavior — no flag → personal stays in the plan.
-
-  it("skipPersonal=true omits the personal leg even when a person entity exists", async () => {
-    const hqRoot = makeHqRoot([".git", "companies", "repos", "workspace"]);
-    const vaultClient = makeVaultClient({
-      memberships: [
-        { companyUid: "cmp_acme" },
-        { companyUid: "cmp_globex" },
-      ],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          bucketName: "hq-vault-psn-alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-      entitiesBySlug: {
-        cmp_acme: { slug: "acme" },
-        cmp_globex: { slug: "globex" },
-      },
-    });
-    const share = makeShareSpy();
-
-    const result = await pushAll(
-      { hqRoot, skipPersonal: true },
-      { vaultClient, share: share.fn },
-    );
-
-    expect(share.calls.map((c) => c.company)).toEqual([
-      "cmp_acme",
-      "cmp_globex",
-    ]);
-    for (const call of share.calls) {
-      expect(call.personalMode).toBeUndefined();
-      expect(call.journalSlug).toBeUndefined();
-    }
-    expect(result.attempted).toBe(2);
-    expect(result.perCompany.map((r) => r.slug)).toEqual(["acme", "globex"]);
-  });
-
-  it("skipPersonal omitted keeps the personal leg in the plan (baseline)", async () => {
-    const hqRoot = makeHqRoot([".git", "companies", "repos", "workspace"]);
-    const vaultClient = makeVaultClient({
-      memberships: [{ companyUid: "cmp_acme" }],
-      persons: [
-        {
-          uid: "psn_alice",
-          type: "person",
-          slug: "alice",
-          createdAt: "2026-01-01T00:00:00Z",
-        },
-      ],
-      entitiesBySlug: { cmp_acme: { slug: "acme" } },
-    });
-    const share = makeShareSpy();
-
-    await pushAll({ hqRoot }, { vaultClient, share: share.fn });
-
-    expect(share.calls.map((c) => c.company)).toEqual([
-      "cmp_acme",
-      "psn_alice",
-    ]);
-    expect(share.calls[1].personalMode).toBe(true);
-    expect(share.calls[1].journalSlug).toBe("__hq_personal_vault__");
-  });
-});

package/src/commands/cloud.scope-excluded-warning.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { scopeExcludedWarning } from "./cloud.js";
-
-describe("scopeExcludedWarning", () => {
-  it("returns null for zero and negative counts", () => {
-    expect(scopeExcludedWarning(0)).toBeNull();
-    expect(scopeExcludedWarning(-1)).toBeNull();
-  });
-
-  it("returns a loud warning for positive counts", () => {
-    const warning = scopeExcludedWarning(3);
-
-    expect(warning).toBeTruthy();
-    expect(warning).toContain("3");
-    // The warning must loudly state the files did NOT reach the vault and
-    // explain why (outside the caller's write access) — without leaning on
-    // the jargon word "scope" in user-facing copy.
-    expect(warning).toContain("NOT uploaded");
-    expect(warning?.toLowerCase()).toContain("write access");
-  });
-});