@indigoai-us/hq-cloud 6.14.18 → 6.14.20

package/src/bin/sync-runner.test.ts

@@ -33,9 +33,20 @@ import type {
   VaultClientSurface,
   WatcherSurface,
 } from "./sync-runner.js";
-import { FakeClock } from "../watcher.js";
-import { adaptivePollMs } from "./sync-runner-watch-loop.js";
-import { PERSONAL_VAULT_JOURNAL_SLUG } from "../journal.js";
+import {
+  FakeClock,
+  type LocalDeleteSnapshot,
+  type TreeChangeBatch,
+} from "../watcher.js";
+import {
+  adaptivePollMs,
+  journalEntriesForWatcherDelete,
+} from "./sync-runner-watch-loop.js";
+import {
+  PERSONAL_VAULT_JOURNAL_SLUG,
+  readJournal,
+  writeJournal,
+} from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
 import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
 import { TRANSIENT_NETWORK_EXIT } from "../lib/net-errors.js";
@@ -231,6 +242,9 @@ function makeDeps(overrides: Partial<RunnerDeps> = {}): TestDeps {
       updated: true,
       embedded: false,
       pendingDirty: false,
+      lockBusy: false,
+      timedOut: false,
+      corruptionQuarantined: false,
     })),
     reconcileManifest: vi
       .fn()
@@ -2159,6 +2173,9 @@ describe("all-complete aggregate", () => {
       updated: true,
       embedded: false,
       pendingDirty: false,
+      lockBusy: false,
+      timedOut: false,
+      corruptionQuarantined: false,
     }));
     const deps = makeDeps({
       createVaultClient: () =>
@@ -5577,13 +5594,13 @@ describe("runRunnerWithLoop — operation lock", () => {
 // pass (events must never announce bytes that are not in S3 yet).
 
 interface BatchWatcherStub extends WatcherSurface {
-  emit(changedRelPath?: string, batch?: { paths: Map<string, string> }): void;
+  emit(changedRelPath?: string, batch?: TreeChangeBatch): void;
   disposed: boolean;
 }
 
 function makeBatchWatcherStub(): BatchWatcherStub {
   const listeners = new Set<
-    (p?: string, b?: { paths: Map<string, string> }) => void
+    (p?: string, b?: TreeChangeBatch) => void
   >();
   return {
     disposed: false,
@@ -5597,7 +5614,7 @@ function makeBatchWatcherStub(): BatchWatcherStub {
       this.disposed = true;
       listeners.clear();
     },
-    emit(changedRelPath?: string, batch?: { paths: Map<string, string> }) {
+    emit(changedRelPath?: string, batch?: TreeChangeBatch) {
       for (const l of [...listeners]) l(changedRelPath, batch);
     },
   };
@@ -5774,6 +5791,94 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
     await loop;
   });
 
+  it("does not publish an exit-zero deletion that the scoped push refused", async () => {
+    const publishBatch = vi.fn();
+    const startEventSync = vi.fn().mockResolvedValue({
+      publishBatch,
+      receiver: { start: async () => {}, dispose: async () => {}, connected: true },
+      ownDeviceId: "dev-test",
+      dispose: vi.fn().mockResolvedValue(undefined),
+    });
+    const runPass = vi
+      .fn()
+      .mockResolvedValueOnce(0)
+      .mockResolvedValueOnce({
+        exitCode: 0,
+        result: {
+          pushPathResults: [{
+            relativePath: "companies/indigo/deleted.md",
+            status: "refused",
+            operation: "delete",
+            reason: "missing-delete-intent",
+          }],
+        },
+      })
+      .mockResolvedValue(0);
+    const { loop, watcher, tick, shutdown } = runLoop({
+      claims: ENROLLED_CLAIMS,
+      startEventSync,
+      runPass,
+    });
+    await microtasks();
+    watcher.emit("companies/indigo/deleted.md", {
+      paths: new Map([[
+        "/tmp/hq/companies/indigo/deleted.md",
+        "companies/indigo/deleted.md",
+      ]]),
+    });
+    tick();
+    await microtasks();
+
+    expect(publishBatch).not.toHaveBeenCalled();
+    shutdown();
+    await loop;
+  });
+
+  it("does not publish unlinkDir when a covered descendant delete was refused", async () => {
+    const publishBatch = vi.fn();
+    const startEventSync = vi.fn().mockResolvedValue({
+      publishBatch,
+      receiver: { start: async () => {}, dispose: async () => {}, connected: true },
+      ownDeviceId: "dev-test",
+      dispose: vi.fn().mockResolvedValue(undefined),
+    });
+    const runPass = vi
+      .fn()
+      .mockResolvedValueOnce(0)
+      .mockResolvedValueOnce({
+        exitCode: 0,
+        result: {
+          pushPathResults: [{
+            relativePath: "companies/indigo/archive/deleted.md",
+            status: "refused",
+            operation: "delete",
+            reason: "missing-delete-intent",
+          }],
+        },
+      })
+      .mockResolvedValue(0);
+    const { loop, watcher, tick, shutdown } = runLoop({
+      claims: ENROLLED_CLAIMS,
+      startEventSync,
+      runPass,
+    });
+    await microtasks();
+    const absolutePath = "/tmp/hq/companies/indigo/archive";
+    watcher.emit("companies/indigo/archive", {
+      paths: new Map([[
+        absolutePath,
+        "companies/indigo/archive",
+      ]]),
+      changes: new Map([[absolutePath, { kind: "unlinkDir" }]]),
+    });
+    tick();
+    await microtasks();
+
+    expect(publishBatch).not.toHaveBeenCalled();
+    shutdown();
+    await loop;
+  });
+
   it("F04: mixed-route watcher batches publish only routes that were pushed", async () => {
     const publishBatch = vi.fn();
     const startEventSync = vi.fn().mockResolvedValue({
@@ -6354,6 +6459,77 @@ describe("US-004 — --personal for an AGENT machine identity (HARD GATE)", () =
     "custom:entityUid": AGENT_UID,
   };
 
+  it("uses the newly minted machine ID token for --personal claims when no cache claims are available", async () => {
+    const machineIdToken = `header.${Buffer.from(JSON.stringify(agentClaims)).toString("base64url")}.signature`;
+    const listByType = vi.fn((type: string) =>
+      Promise.resolve(type === "agent" ? [agentSelfEntity] : []),
+    );
+    const syncSpy = vi.fn().mockResolvedValue(defaultSyncResult());
+    const deps = makeDeps({
+      getAccessToken: vi.fn().mockResolvedValue(machineIdToken),
+      // Simulate a newly minted token before any cache read is available.
+      getIdTokenClaims: () => null,
+      sync: syncSpy as unknown as RunnerDeps["sync"],
+      createVaultClient: () => ({
+        ...makeVaultStub(),
+        entity: { get: () => Promise.resolve(undefined as never), listByType },
+      }),
+    });
+
+    expect(await runRunner(["--personal"], deps)).toBe(0);
+    expect(listByType).toHaveBeenCalledWith("agent");
+    expect(syncSpy).toHaveBeenCalledTimes(1);
+    expect(deps.stderr.events().some((event) => event.type === "auth-error")).toBe(false);
+  });
+
+  it("uses the freshly authenticated machine claims over a stale human cache for --companies", async () => {
+    const machineIdToken = `header.${Buffer.from(JSON.stringify(agentClaims)).toString("base64url")}.signature`;
+    const listByType = vi.fn((type: string) =>
+      Promise.resolve(type === "agent" ? [agentSelfEntity] : []),
+    );
+    const syncSpy = vi.fn().mockResolvedValue(defaultSyncResult());
+    const deps = makeDeps({
+      getAccessToken: vi.fn().mockResolvedValue(machineIdToken),
+      // A pre-bootstrap human token must not make this machine run select a
+      // person vault (or drop its own personal target altogether).
+      getIdTokenClaims: () => ({ sub: "human-sub" }),
+      sync: syncSpy as unknown as RunnerDeps["sync"],
+      createVaultClient: () => ({
+        ...makeVaultStub({ memberships: [{ companyUid: "cmp_team" }] }),
+        entity: {
+          get: (uid: string) =>
+            Promise.resolve(
+              uid === "cmp_team"
+                ? ({
+                    uid,
+                    type: "company",
+                    slug: "team",
+                    bucketName: "hq-vault-cmp-team",
+                    status: "active",
+                  } as EntityInfo)
+                : (undefined as never),
+            ),
+          listByType,
+        },
+      }),
+    });
+
+    expect(await runRunner(["--companies"], deps)).toBe(0);
+    expect(listByType).toHaveBeenCalledWith("agent");
+    expect(syncSpy).toHaveBeenCalledTimes(2);
+    const plan = deps.stdout.events().find((event) => event.type === "fanout-plan") as Extract<
+      RunnerEvent,
+      { type: "fanout-plan" }
+    >;
+    expect(plan.companies).toContainEqual(
+      expect.objectContaining({
+        uid: AGENT_UID,
+        slug: "personal",
+        personalMode: true,
+      }),
+    );
+  });
+
   // -----------------------------------------------------------------------
   // (1) RESOLUTION — UNBLOCKED by US-013.
   //
@@ -7001,3 +7177,483 @@ describe("US-002 — manifest reconciliation wiring", () => {
     expect(deps.stderr.raw()).not.toContain("manifest-reconciled");
   });
 });
+
+describe("watcher delete intents without pre-seeded authorization", () => {
+  function startDeleteHarness(
+    keys: string[],
+    options: { gateInitialPull?: boolean } = {},
+  ) {
+    const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-watch-delete-"));
+    const companyRoot = path.join(hqRoot, "companies", "indigo");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const remote = new Map<string, string>();
+    const files: Record<string, {
+      hash: string; size: number; syncedAt: string; direction: "down";
+      remoteEtag: string; kind: "file";
+    }> = {};
+    for (const key of keys) {
+      const absolutePath = path.join(companyRoot, key);
+      const content = `synced:${key}`;
+      fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+      fs.writeFileSync(absolutePath, content);
+      remote.set(key, content);
+      files[key] = {
+        hash: `hash:${key}`,
+        size: Buffer.byteLength(content),
+        syncedAt: new Date().toISOString(),
+        direction: "down",
+        remoteEtag: `etag:${key}`,
+        kind: "file",
+      };
+    }
+    writeJournal("indigo", {
+      version: "2", lastSync: new Date().toISOString(), files, pulls: [],
+    });
+
+    const watcher = makeBatchWatcherStub();
+    const sleep = makeSteppableSleep();
+    let capture: ((
+      relativePath: string,
+      kind: "unlink" | "unlinkDir",
+    ) => LocalDeleteSnapshot[]) | undefined;
+    let triggerShutdown = () => {};
+    let downloads = 0;
+    let releaseInitialPull = () => {};
+    const initialPullGate = new Promise<void>((resolve) => {
+      releaseInitialPull = resolve;
+    });
+    let initialPullGated = options.gateInitialPull === true;
+    const runPass = vi.fn(async (argv: string[]) => {
+      const direction = argv[argv.indexOf("--direction") + 1];
+      if (direction === "push") {
+        const journal = readJournal("indigo");
+        const pathResults: Array<{
+          relativePath: string; status: "accepted" | "refused";
+          operation: "delete"; reason?: string;
+        }> = [];
+        const scopes = argv.flatMap((value, index) =>
+          argv[index - 1] === "--scope-path" ? [value] : [],
+        );
+        for (const scope of scopes) {
+          for (const key of Object.keys(journal.files)) {
+            if (key !== scope && !key.startsWith(`${scope}/`)) continue;
+            const absolutePath = path.join(companyRoot, key);
+            const entry = journal.files[key];
+            if (fs.existsSync(absolutePath)) {
+              remote.set(key, fs.readFileSync(absolutePath, "utf8"));
+              continue;
+            }
+            const intent = entry.localDeleteIntent;
+            const current =
+              intent?.remoteEtag === entry.remoteEtag &&
+              intent?.localHash === entry.hash &&
+              intent?.localKind === entry.kind;
+            if (current) {
+              remote.delete(key);
+              delete journal.files[key];
+              pathResults.push({
+                relativePath: `companies/indigo/${key}`,
+                status: "accepted",
+                operation: "delete",
+              });
+            } else {
+              pathResults.push({
+                relativePath: `companies/indigo/${key}`,
+                status: "refused",
+                operation: "delete",
+                reason: "missing-delete-intent",
+              });
+            }
+          }
+          const added = path.join(companyRoot, scope);
+          if (fs.existsSync(added) && fs.lstatSync(added).isFile()) {
+            remote.set(scope, fs.readFileSync(added, "utf8"));
+          }
+        }
+        writeJournal("indigo", journal);
+        return { exitCode: 0, result: { pushPathResults: pathResults } };
+      }
+      if (direction === "pull" || direction === "both") {
+        if (initialPullGated) {
+          initialPullGated = false;
+          await initialPullGate;
+        }
+        const journal = readJournal("indigo");
+        for (const [key, content] of remote) {
+          const absolutePath = path.join(companyRoot, key);
+          if (fs.existsSync(absolutePath)) continue;
+          const entry = journal.files[key];
+          const intent = entry?.localDeleteIntent;
+          const currentIntent =
+            intent?.remoteEtag === entry?.remoteEtag &&
+            intent?.localHash === entry?.hash &&
+            intent?.localKind === entry?.kind;
+          if (currentIntent) continue;
+          fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+          fs.writeFileSync(absolutePath, content);
+          downloads++;
+        }
+      }
+      return 0;
+    });
+    const loop = runRunnerWithLoop(
+      [
+        "--companies", "--watch", "--event-push", "--direction", "both",
+        "--hq-root", hqRoot, "--poll-remote-ms", "60000",
+      ],
+      {
+        runPass,
+        createWatcher: (opts) => {
+          capture = opts.captureLocalDeleteSnapshots;
+          return watcher;
+        },
+        sleep: sleep.sleep,
+        onShutdownSignal: (handler) => {
+          triggerShutdown = handler;
+          return () => {};
+        },
+      },
+    );
+    return {
+      hqRoot, companyRoot, remote, watcher, loop, tick: sleep.tick,
+      capture: () => capture!, downloads: () => downloads,
+      releaseInitialPull,
+      shutdown: () => triggerShutdown(),
+    };
+  }
+
+  async function settle(): Promise<void> {
+    await flushLoopMicrotasks(12);
+  }
+
+  async function stopHarness(h: ReturnType<typeof startDeleteHarness>) {
+    h.shutdown();
+    h.tick();
+    await h.loop;
+    fs.rmSync(h.hqRoot, { recursive: true, force: true });
+  }
+
+  it("live unlink binds the pre-delete revision, deletes remote, and survives immediate plus later full pulls", async () => {
+    const h = startDeleteHarness(["knowledge/gone.md"]);
+    await settle();
+    const absolutePath = path.join(h.companyRoot, "knowledge/gone.md");
+    fs.unlinkSync(absolutePath);
+    const snapshots = h.capture()(
+      "companies/indigo/knowledge/gone.md", "unlink",
+    );
+    expect(snapshots).toHaveLength(1);
+    expect(readJournal("indigo").files["knowledge/gone.md"]?.localDeleteIntent)
+      .toMatchObject({
+        remoteEtag: "etag:knowledge/gone.md",
+        localHash: "hash:knowledge/gone.md",
+        localKind: "file",
+      });
+    h.watcher.emit("companies/indigo/knowledge/gone.md", {
+      paths: new Map([[absolutePath, "companies/indigo/knowledge/gone.md"]]),
+      changes: new Map([
+        [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+      ]),
+    } as TreeChangeBatch);
+    h.tick();
+    await settle();
+    expect(h.remote.has("knowledge/gone.md")).toBe(false);
+    expect(fs.existsSync(absolutePath)).toBe(false);
+    expect(h.downloads()).toBe(0);
+
+    for (let i = 0; i < 8; i++) {
+      h.tick();
+      await settle();
+    }
+    expect(fs.existsSync(absolutePath)).toBe(false);
+    expect(h.downloads()).toBe(0);
+    await stopHarness(h);
+  });
+
+  it("persists the intent before an in-flight pull plans the missing path", async () => {
+    const h = startDeleteHarness(
+      ["knowledge/in-flight.md"],
+      { gateInitialPull: true },
+    );
+    await settle();
+    const relativePath = "companies/indigo/knowledge/in-flight.md";
+    const absolutePath = path.join(
+      h.companyRoot,
+      "knowledge/in-flight.md",
+    );
+    fs.unlinkSync(absolutePath);
+    const snapshots = h.capture()(relativePath, "unlink");
+
+    expect(snapshots).toHaveLength(1);
+    expect(
+      readJournal("indigo").files["knowledge/in-flight.md"]
+        ?.localDeleteIntent,
+    ).toBeDefined();
+
+    h.watcher.emit(relativePath, {
+      paths: new Map([[absolutePath, relativePath]]),
+      changes: new Map([
+        [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+      ]),
+    } as TreeChangeBatch);
+    h.releaseInitialPull();
+    await settle();
+
+    expect(h.downloads()).toBe(0);
+    expect(fs.existsSync(absolutePath)).toBe(false);
+
+    h.tick();
+    await settle();
+    expect(h.remote.has("knowledge/in-flight.md")).toBe(false);
+    expect(h.downloads()).toBe(0);
+    await stopHarness(h);
+  });
+
+  it("uses direct journal-key lookup for file unlink snapshots", () => {
+    const exactEntry = {
+      hash: "hash",
+      size: 4,
+      syncedAt: new Date().toISOString(),
+      direction: "down" as const,
+      remoteEtag: "etag",
+      kind: "file" as const,
+    };
+    const files = new Proxy(
+      { "knowledge/exact.md": exactEntry },
+      {
+        ownKeys: () => {
+          throw new Error("file unlink must not enumerate the journal");
+        },
+      },
+    );
+
+    expect(
+      journalEntriesForWatcherDelete(
+        files,
+        "knowledge/exact.md",
+        "unlink",
+      ),
+    ).toEqual([["knowledge/exact.md", exactEntry]]);
+  });
+
+  it("keeps a deleted top-level personal file in the scoped push delete roots", async () => {
+    const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-personal-delete-"));
+    const key = "personal-note.md";
+    const absolutePath = path.join(hqRoot, key);
+    fs.writeFileSync(absolutePath, "personal content");
+    const remote = new Map([[key, "personal content"]]);
+    writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, {
+      version: "2",
+      lastSync: new Date().toISOString(),
+      pulls: [],
+      files: {
+        [key]: {
+          hash: "personal-hash",
+          size: 16,
+          syncedAt: new Date().toISOString(),
+          direction: "down",
+          remoteEtag: "personal-etag",
+          kind: "file",
+        },
+      },
+    });
+
+    const shareSpy = vi.fn(async (options: ShareOptions) => {
+      const journal = readJournal(PERSONAL_VAULT_JOURNAL_SLUG);
+      const entry = journal.files[key];
+      const intent = entry?.localDeleteIntent;
+      const currentIntent =
+        intent?.remoteEtag === entry?.remoteEtag &&
+        intent?.localHash === entry?.hash &&
+        intent?.localKind === entry?.kind;
+      if (
+        !fs.existsSync(absolutePath) &&
+        options.deleteScopeRoots?.includes(key) &&
+        currentIntent
+      ) {
+        remote.delete(key);
+        delete journal.files[key];
+        writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, journal);
+        return defaultShareResult({
+          filesDeleted: 1,
+          pathResults: [
+            { path: key, status: "accepted", operation: "delete" },
+          ],
+        });
+      }
+      return defaultShareResult();
+    });
+    let downloads = 0;
+    const syncSpy = vi.fn(async () => {
+      if (remote.has(key) && !fs.existsSync(absolutePath)) {
+        const entry =
+          readJournal(PERSONAL_VAULT_JOURNAL_SLUG).files[key];
+        const intent = entry?.localDeleteIntent;
+        const currentIntent =
+          intent?.remoteEtag === entry?.remoteEtag &&
+          intent?.localHash === entry?.hash &&
+          intent?.localKind === entry?.kind;
+        if (!currentIntent) {
+          fs.writeFileSync(absolutePath, remote.get(key)!);
+          downloads++;
+        }
+      }
+      return defaultSyncResult();
+    });
+    const runnerDeps = makeDeps({
+      share: shareSpy,
+      sync: syncSpy,
+      createVaultClient: () =>
+        makeVaultStub({
+          listPersons: () =>
+            Promise.resolve([
+              {
+                uid: "prs_personal",
+                type: "person",
+                bucketName: "hq-vault-personal",
+                status: "active",
+              } as unknown as EntityInfo,
+            ]),
+        }),
+      operationLockAlreadyHeld: true,
+    });
+    const watcher = makeBatchWatcherStub();
+    const sleep = makeSteppableSleep();
+    let capture: ((
+      relativePath: string,
+      kind: "unlink" | "unlinkDir",
+    ) => LocalDeleteSnapshot[]) | undefined;
+    let triggerShutdown = () => {};
+    const loop = runRunnerWithLoop(
+      [
+        "--personal",
+        "--watch",
+        "--event-push",
+        "--direction",
+        "both",
+        "--hq-root",
+        hqRoot,
+        "--poll-remote-ms",
+        "60000",
+      ],
+      {
+        runPass: (passArgv) => runRunner(passArgv, runnerDeps),
+        createWatcher: (options) => {
+          capture = options.captureLocalDeleteSnapshots;
+          return watcher;
+        },
+        sleep: sleep.sleep,
+        onShutdownSignal: (handler) => {
+          triggerShutdown = handler;
+          return () => {};
+        },
+      },
+    );
+    await vi.waitFor(() => expect(syncSpy).toHaveBeenCalled());
+    await settle();
+    shareSpy.mockClear();
+
+    fs.unlinkSync(absolutePath);
+    const snapshots = capture!(key, "unlink");
+    expect(snapshots).toHaveLength(1);
+    expect(snapshots[0].deleteScopeRoot).toBe(key);
+    expect(
+      readJournal(PERSONAL_VAULT_JOURNAL_SLUG).files[key]
+        ?.localDeleteIntent,
+    ).toBeDefined();
+    watcher.emit(key, {
+      paths: new Map([[absolutePath, key]]),
+      changes: new Map([
+        [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+      ]),
+    } as TreeChangeBatch);
+    sleep.tick();
+    await settle();
+
+    expect(remote.has(key)).toBe(false);
+    expect(downloads).toBe(0);
+    expect(fs.existsSync(absolutePath)).toBe(false);
+    const scopedShareOptions = shareSpy.mock.calls.at(-1)?.[0];
+    expect(scopedShareOptions?.paths).not.toContain(absolutePath);
+    expect(scopedShareOptions?.deleteScopeRoots).toEqual([key]);
+
+    triggerShutdown();
+    await loop;
+    fs.rmSync(hqRoot, { recursive: true, force: true });
+  });
+
+  it("rename uploads the new path, deletes the old path, and neither resurrects", async () => {
+    const h = startDeleteHarness(["knowledge/old.md"]);
+    await settle();
+    const oldPath = path.join(h.companyRoot, "knowledge/old.md");
+    const newPath = path.join(h.companyRoot, "knowledge/new.md");
+    const snapshots = h.capture()(
+      "companies/indigo/knowledge/old.md", "unlink",
+    );
+    fs.renameSync(oldPath, newPath);
+    h.watcher.emit("companies/indigo/knowledge/old.md", {
+      paths: new Map([
+        [oldPath, "companies/indigo/knowledge/old.md"],
+        [newPath, "companies/indigo/knowledge/new.md"],
+      ]),
+      changes: new Map([
+        [oldPath, { kind: "unlink", deleteSnapshots: snapshots }],
+        [newPath, { kind: "add" }],
+      ]),
+    } as TreeChangeBatch);
+    h.tick();
+    await settle();
+    expect(h.remote.has("knowledge/old.md")).toBe(false);
+    expect(h.remote.get("knowledge/new.md")).toBe("synced:knowledge/old.md");
+    expect(fs.existsSync(oldPath)).toBe(false);
+    expect(fs.existsSync(newPath)).toBe(true);
+    await stopHarness(h);
+  });
+
+  it("unlinkDir records every tracked descendant across a 12-file breaker-sized subtree", async () => {
+    const keys = Array.from(
+      { length: 12 }, (_, i) => `knowledge/moved/f-${i}.md`,
+    );
+    const h = startDeleteHarness(keys);
+    await settle();
+    const subtree = path.join(h.companyRoot, "knowledge/moved");
+    const snapshots = h.capture()(
+      "companies/indigo/knowledge/moved", "unlinkDir",
+    );
+    expect(snapshots).toHaveLength(12);
+    fs.rmSync(subtree, { recursive: true, force: true });
+    h.watcher.emit("companies/indigo/knowledge/moved", {
+      paths: new Map([[subtree, "companies/indigo/knowledge/moved"]]),
+      changes: new Map([
+        [subtree, { kind: "unlinkDir", deleteSnapshots: snapshots }],
+      ]),
+    } as TreeChangeBatch);
+    h.tick();
+    await settle();
+    expect(h.remote.size).toBe(0);
+    expect(Object.keys(readJournal("indigo").files)).toHaveLength(0);
+    await stopHarness(h);
+  });
+
+  it("concurrent recreation before delete execution invalidates the observation and preserves remote", async () => {
+    const h = startDeleteHarness(["knowledge/race.md"]);
+    await settle();
+    const absolutePath = path.join(h.companyRoot, "knowledge/race.md");
+    fs.unlinkSync(absolutePath);
+    const snapshots = h.capture()(
+      "companies/indigo/knowledge/race.md", "unlink",
+    );
+    h.watcher.emit("companies/indigo/knowledge/race.md", {
+      paths: new Map([[absolutePath, "companies/indigo/knowledge/race.md"]]),
+      changes: new Map([
+        [absolutePath, { kind: "unlink", deleteSnapshots: snapshots }],
+      ]),
+    } as TreeChangeBatch);
+    fs.writeFileSync(absolutePath, "concurrent recreation");
+    h.tick();
+    await settle();
+    expect(h.remote.has("knowledge/race.md")).toBe(true);
+    expect(readJournal("indigo").files["knowledge/race.md"]?.localDeleteIntent)
+      .toBeUndefined();
+    await stopHarness(h);
+  });
+});