@indigoai-us/hq-cloud 6.14.1 → 6.14.3

package/src/cli/share.test.ts

@@ -1265,8 +1265,8 @@ describe("share", () => {
   });
 
   it("a file over the size limit is a benign skip-size-limit event, NEVER an error (HQ-SYNC-4 exit-2 flood)", async () => {
-    // Regression for the fleet-wide "auto-sync watcher exited unexpectedly
-    // (code=Some(2))" flood (HQ-SYNC-4, ~93k events across 60+ machines). An
+    // Regression for the "auto-sync watcher exited unexpectedly
+    // (code=Some(2))" flood (HQ-SYNC-4, ~93k events across 60+ user machines). An
     // oversized file is a permanent, benign skip — it exceeds the 50 MB cap on
     // EVERY pass, forever. Emitting it as `type: "error"` pushed it into the
     // runner's `errors[]`, so the pass returned exit 2, which the menubar
@@ -4992,3 +4992,140 @@ describe("currency-gated: journal version 2 fixtures", () => {
     });
   });
 });
+
+describe("scope-invalid key hardening on push (doubled companies/ tree — incident 2026-07-11)", () => {
+  let tmpDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    clearContextCache();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-share-poison-test-"));
+    stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-state-poison-test-"));
+    process.env.HQ_STATE_DIR = stateDir;
+    setupFetchMock();
+    // Earlier describes in this file don't all clear call history; reset it
+    // here so uploaded-key assertions below are order-independent.
+    vi.mocked(uploadFile).mockClear();
+    vi.mocked(uploadSymlink).mockClear();
+    vi.mocked(headRemoteFile).mockClear();
+    vi.mocked(deleteRemoteFile).mockClear();
+    vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
+    vi.mocked(uploadSymlink).mockResolvedValue({ etag: '"upload-symlink-etag"' });
+    vi.mocked(headRemoteFile).mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+    vi.mocked(uploadFile).mockResolvedValue({ etag: '"upload-etag"' });
+    vi.mocked(uploadSymlink).mockResolvedValue({ etag: '"upload-symlink-etag"' });
+    vi.mocked(headRemoteFile).mockResolvedValue(null);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(stateDir, { recursive: true, force: true });
+    delete process.env.HQ_STATE_DIR;
+  });
+
+  it("refuses to upload doubled-tree companies/ keys in company mode — clear per-key warning, never an error", async () => {
+    // The incident writer: a stale doubled local tree
+    // companies/acme/companies/acme/… would push literal `companies/…` keys
+    // via the direct-S3 STS transport, poisoning the bucket with keys the
+    // presign download API rejects (INVALID_KEY_COMPANIES_SCOPED) for every
+    // other machine. The push planner must refuse them up front.
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    const doubled = path.join(companyRoot, "companies", "acme", "knowledge");
+    fs.mkdirSync(doubled, { recursive: true });
+    fs.writeFileSync(path.join(doubled, "poison.md"), "poison");
+    fs.mkdirSync(path.join(companyRoot, "docs"), { recursive: true });
+    fs.writeFileSync(path.join(companyRoot, "docs", "good.md"), "good");
+
+    const events: Array<{ type?: string; path?: string }> = [];
+    const result = await share({
+      paths: [companyRoot],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      onEvent: (e) => events.push(e as { type?: string }),
+    });
+
+    expect(result.aborted).toBe(false);
+    expect(result.filesUploaded).toBe(1);
+    const uploadedKeys = vi.mocked(uploadFile).mock.calls.map((c) => c[2]);
+    expect(uploadedKeys).toEqual(["docs/good.md"]);
+
+    // Per-key warning on the existing event channel, never type:"error"
+    // (an error event flips the runner pass to exit 2 — the flood class).
+    const skipEvents = events.filter((e) => e.type === "skip-invalid-scoped-key");
+    expect(skipEvents.map((e) => e.path)).toEqual([
+      "companies/acme/knowledge/poison.md",
+    ]);
+    expect(events.some((e) => e.type === "error")).toBe(false);
+  });
+
+  it("tombstones (journal drop, no remote HEAD/DELETE) a companies/ journal key in company mode instead of re-uploading", async () => {
+    // Delete-propagation on a poisoned journal entry: HEAD/DeleteObject on a
+    // companies/-prefixed key would be rejected by the presign transport's
+    // server validator, so the delete plan must route it straight to
+    // toTombstone — journal entry drained, no remote call, no re-upload.
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const journalPath = path.join(stateDir, "sync-journal.acme.json");
+    fs.writeFileSync(
+      journalPath,
+      JSON.stringify({
+        version: "1",
+        lastSync: new Date().toISOString(),
+        files: {
+          "companies/acme/knowledge/poison.md": {
+            hash: "poison-hash",
+            size: 6,
+            syncedAt: new Date().toISOString(),
+            direction: "up",
+            remoteEtag: "poison-etag",
+          },
+        },
+      }),
+    );
+
+    const result = await share({
+      paths: [companyRoot],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      skipUnchanged: true,
+      propagateDeletes: true,
+      propagateDeletePolicy: "currency-gated",
+    });
+
+    expect(result.aborted).toBe(false);
+    // Tombstoned: journal entry dropped without any remote HEAD or DELETE.
+    expect(result.filesTombstoned).toBe(1);
+    expect(result.filesDeleted).toBe(0);
+    expect(headRemoteFile).not.toHaveBeenCalled();
+    expect(deleteRemoteFile).not.toHaveBeenCalled();
+    expect(uploadFile).not.toHaveBeenCalled();
+    const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+    expect(journal.files["companies/acme/knowledge/poison.md"]).toBeUndefined();
+  });
+
+  it("personal-mode push still uploads companies/{slug}/ keys (local non-cloud companies are legitimate)", async () => {
+    const localCo = path.join(tmpDir, "companies", "localco");
+    fs.mkdirSync(localCo, { recursive: true });
+    fs.writeFileSync(path.join(localCo, "notes.md"), "n");
+
+    const events: Array<{ type?: string }> = [];
+    const result = await share({
+      paths: [localCo],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      personalMode: true,
+      journalSlug: "personal-vault",
+      onEvent: (e) => events.push(e as { type?: string }),
+    });
+
+    expect(result.aborted).toBe(false);
+    const uploadedKeys = vi.mocked(uploadFile).mock.calls.map((c) => c[2]);
+    expect(uploadedKeys).toContain("companies/localco/notes.md");
+    expect(events.filter((e) => e.type === "skip-invalid-scoped-key")).toEqual([]);
+  });
+});

package/src/cli/share.ts

@@ -1047,12 +1047,34 @@ function createShareCounters(): ShareCounters {
 }
 
 async function buildSharePlans(run: PushRunContext): Promise<SharePlans> {
-  const filesToShare = collectFiles(
+  const collected = collectFiles(
     run.paths,
     run.hqRoot,
     run.syncRoot,
     run.shouldSync,
   );
+  // Scope-invalid key filter (incident 2026-07-11). In company mode the sync
+  // root IS the company folder, so a local entry whose vault key starts with
+  // `companies/` can only come from a stale doubled local tree
+  // (companies/{slug}/companies/{slug}/…). Uploading it poisons the bucket
+  // with keys the server validator rejects (INVALID_KEY_COMPANIES_SCOPED) —
+  // the direct-S3 STS transport bypasses server validation. Refuse them here
+  // with a per-key warning; uploadFile/uploadSymlink's validateVaultUploadKey
+  // is the belt-and-suspenders backstop. The pull leg's journal-tombstone
+  // path then CLEANS the doubled tree (local delete + journal drop) instead
+  // of this leg ever re-uploading it. Personal vaults legitimately carry
+  // `companies/{slug}/…` keys, so this only applies in company mode.
+  const filesToShare =
+    run.options.personalMode === true
+      ? collected
+      : collected.filter((entry) => {
+          if (!entry.relativePath.startsWith("companies/")) return true;
+          run.emit({
+            type: "skip-invalid-scoped-key",
+            path: entry.relativePath,
+          });
+          return false;
+        });
   const pushPlan = computePushPlan(
     filesToShare,
     run.journal,
@@ -1069,6 +1091,7 @@ async function buildSharePlans(run: PushRunContext): Promise<SharePlans> {
         run.shouldSync,
         run.propagateDeletePolicy,
         run.ctx,
+        run.options.personalMode !== true,
       )
     : { toDelete: [], toTombstone: [], refusedStale: [] };
   const decommissionPlan =
@@ -1139,7 +1162,7 @@ async function executeUploads(
       // Emitting it as `type: "error"` pushed it into the runner's `errors[]`,
       // so every watch pass returned exit 2 and the menubar reported an
       // "auto-sync watcher exited unexpectedly (code=Some(2))" crash on every
-      // tick (the fleet-wide HQ-SYNC-4 flood). Surface it for visibility, but
+      // tick (the HQ-SYNC-4 flood across user machines). Surface it for visibility, but
       // do not let it flip the pass to a non-zero exit.
       let bytes = 0;
       try {
@@ -1676,6 +1699,10 @@ function defaultConsoleLogger(event: SyncProgressEvent): void {
       `    Sample refused paths: ${event.samplePaths.slice(0, 5).join(", ")}${event.samplePaths.length > 5 ? ", …" : ""}\n` +
       `    To proceed anyway: re-run with HQ_SYNC_DELETE_BULK_OVERRIDE=1 (or propagateDeletePolicy:"all").`,
     );
+  } else if (event.type === "skip-invalid-scoped-key") {
+    console.warn(
+      `  ! ${event.path} skipped — 'companies/'-prefixed key is invalid in a company-scoped vault (stale doubled local tree? remove the inner companies/<slug> copy)`,
+    );
   } else if (event.type === "ignore-excluded") {
     // The "not silent" surface: an ignore rule dropped content that doesn't
     // look like expected build/VCS/cache noise, so it never reached the vault.
@@ -2178,6 +2205,11 @@ async function computeDeletePlan(
   shouldSync: (filePath: string, isDir?: boolean) => boolean,
   policy: "currency-gated" | "owned-only" | "all",
   ctx: EntityContext,
+  // True for a COMPANY-scoped push (personalMode !== true): the sync root is
+  // the company folder and journal keys are bucket-relative, so a literal
+  // `companies/…` key is scope-invalid (see the poisoned-key branch below).
+  // Personal-vault pushes legitimately journal `companies/{slug}/…` keys.
+  companyScoped: boolean = true,
 ): Promise<DeletePlan> {
   const plan: DeletePlan = { toDelete: [], toTombstone: [], refusedStale: [] };
   if (scopeRoots.length === 0) return plan;
@@ -2249,6 +2281,20 @@ async function computeDeletePlan(
       continue;
     }
 
+    // Scope-invalid journal keys (incident 2026-07-11): in a COMPANY-scoped
+    // context, a journal entry at a literal `companies/…` key records a
+    // doubled-tree poisoning upload. HEAD/DeleteObject on such a key via the
+    // presign transport is rejected by the server validator
+    // (INVALID_KEY_COMPANIES_SCOPED) and would error the push, so route it
+    // straight to `toTombstone` (journal drop, no remote call) — the local
+    // journal entry drains; server-side cleanup of any poisoned object is an
+    // operator action. Personal-vault pushes (personalMode) carry legitimate
+    // `companies/{slug}/…` keys and are unaffected (companyScoped=false).
+    if (companyScoped && relativeKey.startsWith("companies/")) {
+      plan.toTombstone.push(relativeKey);
+      continue;
+    }
+
     if (!shouldSync(localPath, false) && !shouldSync(localPath, true)) continue;
     // Ephemeral artifacts (conflict mirrors) never propagate-delete via the
     // normal path — see EPHEMERAL_PATH_PATTERN doc. NOTE: this is a no-op

package/src/cli/sync-scope.test.ts

@@ -461,4 +461,94 @@ describe("sync — scope-aware download (US-005)", () => {
     expect(second.scopeOrphansRemoved).toBe(0);
     expect(second.scopeOrphansBlocked).toBe(0);
   });
+
+  // ── US-006: sessions prefix push-only pull-scope exclusion ─────────────────
+  // The sessions prefix is PUSH-ONLY: pushed into the vault but never
+  // auto-pulled onto grantee laptops in ANY mode (including `all`, which
+  // otherwise pulls the whole bucket). The engine expresses this as
+  // `excludePrefixes`, applied to the DOWNLOAD filter only — never to
+  // scope-shrink, so an authored/pinned session is never orphaned.
+  describe("sessions push-only exclusion (US-006)", () => {
+    const withSession = () => {
+      REMOTE.current = [
+        { key: "knowledge/readme.md", size: 100, lastModified: new Date(), etag: '"def456"' },
+        { key: "sessions/prs_1/2026-07-11T10-00-00.json", size: 50, lastModified: new Date(), etag: '"sess1"' },
+      ];
+    };
+    const sessionPath = "sessions/prs_1/2026-07-11T10-00-00.json";
+
+    it("AC4: `all` mode subtracts excludePrefixes — a sessions key is skip-out-of-scope; non-session downloads", async () => {
+      withSession();
+      const result = await sync({
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        syncMode: "all",
+        excludePrefixes: ["sessions/"],
+      });
+      // `all` normally pulls everything; the exclusion carves sessions out.
+      expect(result.filesDownloaded).toBe(1);
+      expect(result.filesOutOfScope).toBe(1);
+      expect(fs.existsSync(companyRel("knowledge/readme.md"))).toBe(true);
+      expect(fs.existsSync(companyRel(sessionPath))).toBe(false);
+    });
+
+    it("AC4: excludePrefixes is NOT fed to scope-shrink — a previously-pulled session file is never orphaned", async () => {
+      withSession();
+      // 1. Full pull WITHOUT the exclusion: the session materializes and journals
+      //    as a pulled (direction:"down") entry under an `all`-mode PullRecord.
+      const first = await sync({
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        syncMode: "all",
+      });
+      expect(first.filesDownloaded).toBe(2);
+      expect(fs.existsSync(companyRel(sessionPath))).toBe(true);
+
+      // 2. Full pull WITH the sessions exclusion. The session is now
+      //    skip-out-of-scope (not re-pulled) but MUST NOT be pruned: the exclude
+      //    set never reaches scope-shrink, whose currentPrefixSet stays `[""]`
+      //    (covers everything). If it WERE fed in, the file would be orphaned.
+      const second = await sync({
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        syncMode: "all",
+        excludePrefixes: ["sessions/"],
+      });
+      expect(second.filesOutOfScope).toBe(1);
+      expect(second.scopeOrphansRemoved).toBe(0);
+      expect(second.scopeOrphansBlocked).toBe(0);
+      expect(fs.existsSync(companyRel(sessionPath))).toBe(true);
+    });
+
+    it("AC6: a pinned/in-scope session survives scope-shrink even though excludePrefixes skips its re-pull", async () => {
+      withSession();
+      // Materialize both under all-mode (knowledge sync + an on-demand session get).
+      await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, syncMode: "all" });
+      expect(fs.existsSync(companyRel(sessionPath))).toBe(true);
+
+      // A scoped shared pull whose inclusion prefixSet includes the pinned
+      // session key (as resolvePullScope would after `hq files get` pins it),
+      // plus the push-only sessions exclusion. The session is NOT re-pulled
+      // (exclusion), but the pin keeps it in scope-shrink's currentPrefixSet, so
+      // it is retained rather than orphaned.
+      const scoped = await sync({
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        syncMode: "shared",
+        prefixSet: ["knowledge/", sessionPath],
+        excludePrefixes: ["sessions/"],
+      });
+      expect(scoped.scopeOrphansRemoved).toBe(0);
+      expect(scoped.scopeOrphansBlocked).toBe(0);
+      // Session is not re-downloaded (excluded) but survives on disk...
+      expect(scoped.filesOutOfScope).toBe(1);
+      expect(fs.existsSync(companyRel(sessionPath))).toBe(true);
+      // ...and the in-scope knowledge file is retained too.
+      expect(fs.existsSync(companyRel("knowledge/readme.md"))).toBe(true);
+    });
+  });
 });

package/src/cli/sync.test.ts

@@ -3589,3 +3589,157 @@ describe("reportNewFilesToNotify chunking (server cap = 1000 files/report)", ()
     expect(fetchMock).not.toHaveBeenCalled();
   });
 });
+
+describe("scope-invalid key hardening (companies/ prefix in a company vault — incident 2026-07-11)", () => {
+  let tmpDir: string;
+  let stateDir: string;
+  let journalPath: string;
+
+  beforeEach(() => {
+    clearContextCache();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-sync-poison-test-"));
+    stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-state-poison-test-"));
+    process.env.HQ_STATE_DIR = stateDir;
+    journalPath = path.join(stateDir, "sync-journal.acme.json");
+    setupFetchMock();
+    // Earlier tests in this file replace the downloadFile implementation with
+    // throwing probes; vi.clearAllMocks() keeps implementations, so restore
+    // the default writer here to keep these tests order-independent.
+    vi.mocked(s3Module.downloadFile).mockReset();
+    vi.mocked(s3Module.downloadFile).mockImplementation(
+      async (_ctx: unknown, _key: string, localPath: string) => {
+        fs.mkdirSync(path.dirname(localPath), { recursive: true });
+        fs.writeFileSync(localPath, "mock file content");
+        return { metadata: {} };
+      },
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(stateDir, { recursive: true, force: true });
+    delete process.env.HQ_STATE_DIR;
+  });
+
+  it("skips a companies/-prefixed remote key instead of erroring the whole company sync", async () => {
+    // The incident shape: 25 poisoned `companies/indigo/…` objects in the
+    // company bucket; the presign download API rejects them
+    // (INVALID_KEY_COMPANIES_SCOPED), so attempting to download errored the
+    // whole company sync and gated heartbeat toolset refreshes fleet-wide.
+    // One bad object must never take down a company sync.
+    vi.mocked(s3Module.listRemoteFiles).mockReset();
+    vi.mocked(s3Module.listRemoteFiles).mockResolvedValue([
+      { key: "companies/acme/knowledge/poison.md", size: 10, lastModified: new Date(), etag: '"p1"' },
+      { key: "docs/good.md", size: 5, lastModified: new Date(), etag: '"g1"' },
+    ]);
+    const events: Array<{ type: string; [k: string]: unknown }> = [];
+    const result = await sync({
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      onEvent: (e) => events.push(e as never),
+    });
+
+    // The good file syncs; the poisoned key is never downloaded.
+    expect(result.aborted).toBe(false);
+    expect(result.filesDownloaded).toBe(1);
+    expect(
+      fs.existsSync(path.join(tmpDir, "companies", "acme", "docs", "good.md")),
+    ).toBe(true);
+    expect(
+      fs.existsSync(
+        path.join(tmpDir, "companies", "acme", "companies", "acme", "knowledge", "poison.md"),
+      ),
+    ).toBe(false);
+    const downloadedKeys = vi
+      .mocked(s3Module.downloadFile)
+      .mock.calls.map((c) => c[1]);
+    expect(downloadedKeys).not.toContain("companies/acme/knowledge/poison.md");
+
+    // Counted as policy-excluded, surfaced as a benign per-key warning event —
+    // deliberately NOT type:"error" (an error event flips the runner to exit 2).
+    expect(result.filesExcludedByPolicy).toBeGreaterThanOrEqual(1);
+    const skipEvents = events.filter((e) => e.type === "skip-invalid-scoped-key");
+    expect(skipEvents).toEqual([
+      { type: "skip-invalid-scoped-key", path: "companies/acme/knowledge/poison.md" },
+    ]);
+    expect(events.filter((e) => e.type === "error")).toEqual([]);
+  });
+
+  it("cleans a doubled-tree journal entry via tombstone (local delete + journal drop) without HEAD-verifying the invalid key", async () => {
+    // A doubled local tree (companies/acme/companies/acme/…) previously
+    // poisoned the bucket; the poisoned objects were deleted server-side.
+    // The journal entry at the invalid key must drain as a tombstone —
+    // local copy removed, journal entry dropped — and must NOT be
+    // HEAD-verified (the presign transport rejects the key, which would
+    // defer the tombstone forever) and must NOT be re-uploaded.
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    const doubled = path.join(companyRoot, "companies", "acme", "knowledge");
+    fs.mkdirSync(doubled, { recursive: true });
+    fs.writeFileSync(path.join(doubled, "poison.md"), "poison content");
+    const crypto = await import("node:crypto");
+    const baseline = crypto
+      .createHash("sha256")
+      .update("poison content")
+      .digest("hex");
+    fs.writeFileSync(
+      journalPath,
+      JSON.stringify({
+        version: "1",
+        lastSync: new Date(Date.now() - 60_000).toISOString(),
+        files: {
+          "companies/acme/knowledge/poison.md": {
+            hash: baseline,
+            size: 14,
+            syncedAt: new Date(Date.now() - 60_000).toISOString(),
+            direction: "up",
+            remoteEtag: "poison-etag",
+          },
+        },
+      }),
+    );
+    // Remote LIST no longer contains the poisoned key (manual cleanup done).
+    vi.mocked(s3Module.listRemoteFiles).mockReset();
+    vi.mocked(s3Module.listRemoteFiles).mockResolvedValue([]);
+
+    const result = await sync({
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+    });
+
+    // Cleaned, not re-uploaded: local doubled-tree copy gone, journal dropped.
+    expect(fs.existsSync(path.join(doubled, "poison.md"))).toBe(false);
+    expect(result.filesTombstoned).toBeGreaterThanOrEqual(1);
+    const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+    expect(journal.files["companies/acme/knowledge/poison.md"]).toBeUndefined();
+    // No HEAD verify against the invalid key — the server validator would
+    // reject it (INVALID_KEY_COMPANIES_SCOPED) and defer the cleanup forever.
+    const headKeys = vi
+      .mocked(s3Module.headRemoteFile)
+      .mock.calls.map((c) => c[1]);
+    expect(headKeys).not.toContain("companies/acme/knowledge/poison.md");
+    // Never re-uploaded.
+    expect(vi.mocked(s3Module.uploadFile)).not.toHaveBeenCalled();
+  });
+
+  it("personal-mode pull still downloads companies/{slug}/ keys (local non-cloud companies are legitimate)", async () => {
+    vi.mocked(s3Module.listRemoteFiles).mockReset();
+    vi.mocked(s3Module.listRemoteFiles).mockResolvedValue([
+      { key: "companies/localco/notes.md", size: 4, lastModified: new Date(), etag: '"n1"' },
+    ]);
+    const events: Array<{ type: string }> = [];
+    const result = await sync({
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      personalMode: true,
+      onEvent: (e) => events.push(e as never),
+    });
+    expect(result.filesDownloaded).toBe(1);
+    expect(events.filter((e) => e.type === "skip-invalid-scoped-key")).toEqual([]);
+    expect(fs.existsSync(path.join(tmpDir, "companies", "localco", "notes.md"))).toBe(true);
+  });
+});