@rubytech/create-realagent-code 0.1.603 → 0.1.605

package/payload/platform/plugins/scheduling/mcp/dist/tools/__tests__/scheduling-gate.test.js

@@ -5,7 +5,7 @@
 // that only ever ran all four together could not tell a working check from an
 // always-true one riding on a sibling.
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync, symlinkSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 /** Records the mocked neo4j session returns. Empty for every test but the mail
@@ -17,7 +17,7 @@ vi.mock("../../lib/neo4j.js", () => ({
         close: vi.fn(async () => { }),
     }),
 }));
-import { runSchedulingGate, advanceGateMark, watermarkPath, readWatermarks, readWatermarksChecked, foldMailWatermarks, parseD1Count, digestBusy, slotKey, slotPosition, slotsIn, promoteSlot, } from "../scheduling-gate.js";
+import { runSchedulingGate, advanceGateMark, watermarkPath, readWatermarks, readWatermarksChecked, foldMailWatermarks, parseD1Count, digestBusy, digestSweepState, slotKey, slotPosition, slotsIn, promoteSlot, UNFLAGGED_ID_CAP, } from "../scheduling-gate.js";
 const ACCOUNT = "20028fb5-0000-4000-8000-000000000000";
 const EVENT = "65ef758c-0000-4000-8000-000000000000";
 let platformRoot;
@@ -37,6 +37,20 @@ function quietSources(over = {}) {
         // Task 2681 — "quiet" for the graph arm is an account whose graph holds no
         // appointment activity at all.
         graphActivity: async () => ({ newestActivityAt: null }),
+        // Task 2684 — "quiet" for the unflagged arm is a label holding nothing this
+        // routine has not already flagged.
+        graphUnflagged: async () => ({ ids: [] }),
+        // Task 2688 — "quiet" for the connector arm is an account that registered
+        // no queue of the requested kind, which is what every install answers until
+        // an operator describes one.
+        connectorQueues: async () => ({ pluginPresent: true, bindings: [] }),
+        connectorQueueRead: async () => ({ status: 200, items: 0, truncated: false }),
+        // Task 2689 — "quiet" for the sweep arm is a sweep that ran just now with
+        // both review queues empty.
+        sweepState: async () => ({ newestReportAt: new Date().toISOString(), orphans: 0, citations: 0 }),
+        // Task 2689 — "quiet" for the filesystem arm is an account directory that
+        // has not grown since the stored measurement.
+        filesystemBytes: async () => ({ bytes: 0, capped: false }),
         ...over,
     };
 }
@@ -1037,7 +1051,7 @@ describe("unrecognised check type", () => {
             errored: [
                 {
                     kind: "nonsense",
-                    detail: 'unknown check type "nonsense" — accepted: mail, d1, whatsapp, calendar, telegram, graph',
+                    detail: 'unknown check type "nonsense" — accepted: mail, d1, whatsapp, calendar, telegram, graph, graph-unflagged, connector, sweep, filesystem',
                 },
             ],
         });
@@ -1061,7 +1075,7 @@ describe("unrecognised check type", () => {
             errored: [
                 {
                     kind: "nonsense",
-                    detail: 'unknown check type "nonsense" — accepted: mail, d1, whatsapp, calendar, telegram, graph',
+                    detail: 'unknown check type "nonsense" — accepted: mail, d1, whatsapp, calendar, telegram, graph, graph-unflagged, connector, sweep, filesystem',
                 },
             ],
         });
@@ -1173,7 +1187,14 @@ describe("mail check — outlook provider", () => {
     it("records no position for an empty folder rather than advancing onto nothing", async () => {
         const sources = quietSources({ mailOutlook: async () => ({ newestReceivedAt: null }) });
         const gate = await run([CHECK], sources);
-        expect(gate).toEqual({ hasWork: false, genuineWork: false, reasons: [], errored: [], observed: {} });
+        expect(gate).toEqual({
+            hasWork: false,
+            genuineWork: false,
+            reasons: [],
+            errored: [],
+            observed: {},
+            unflagged: [],
+        });
         expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual([]);
     });
     it("keys the folder segment lower-cased, so two spellings address one entry", async () => {
@@ -1437,4 +1458,413 @@ describe("REAL_SOURCES.graphActivity", () => {
         await expect(S.graphActivity(ACCOUNT, "appointments")).rejects.toThrow(/expected an ISO string/);
     });
 });
+// Task 2684 — the unflagged-node check. Where every check above compares a
+// source against ONE stored position, this one asks which nodes are outstanding
+// for this routine, which is an exact set: a node that arrives between the probe
+// and the flag write is simply still unflagged on the next fire.
+describe("graph-unflagged check", () => {
+    const SECTIONS = { type: "graph-unflagged", label: "Section" };
+    const unflagged = (ids) => ({
+        graphUnflagged: async () => ({ ids }),
+    });
+    it("is false when the label holds nothing outstanding for this routine", async () => {
+        expect(await run([SECTIONS], quietSources(unflagged([])))).toMatchObject({
+            hasWork: false,
+            reasons: [],
+            errored: [],
+            unflagged: [],
+        });
+    });
+    it("is true when one node of the label is unflagged, and hands its id over", async () => {
+        expect(await run([SECTIONS], quietSources(unflagged(["4:abc:1"])))).toMatchObject({
+            hasWork: true,
+            reasons: ["graph-unflagged"],
+            errored: [],
+            unflagged: [{ label: "Section", ids: ["4:abc:1"] }],
+        });
+    });
+    it("records no watermark position — its state is the flag, not a stored mark", async () => {
+        const result = await run([SECTIONS], quietSources(unflagged(["4:abc:1"])));
+        expect(result.observed).toEqual({});
+    });
+    it("probes under this routine's own event id, so another routine's flag still counts", async () => {
+        const keys = [];
+        await run([SECTIONS], quietSources({
+            graphUnflagged: async (_a, _l, flagKey) => {
+                keys.push(flagKey);
+                return { ids: [] };
+            },
+        }));
+        expect(keys).toEqual([EVENT]);
+    });
+    it("caps the handed set, so a backlog drains over fires rather than being skipped", async () => {
+        const limits = [];
+        await run([SECTIONS], quietSources({
+            graphUnflagged: async (_a, _l, _k, limit) => {
+                limits.push(limit);
+                return { ids: [] };
+            },
+        }));
+        expect(limits).toEqual([UNFLAGGED_ID_CAP]);
+    });
+    it("carries one entry per check, so two labels in one gate flag separately", async () => {
+        const result = await run([SECTIONS, { type: "graph-unflagged", label: "ConversationArchive" }], quietSources({
+            graphUnflagged: async (_a, label) => ({ ids: [`${label}-1`] }),
+        }));
+        expect(result.unflagged).toEqual([
+            { label: "Section", ids: ["Section-1"] },
+            { label: "ConversationArchive", ids: ["ConversationArchive-1"] },
+        ]);
+    });
+    it("hands nothing over when the source throws, and counts the throw as work", async () => {
+        const result = await run([SECTIONS], quietSources({
+            graphUnflagged: async () => {
+                throw new Error("neo4j down");
+            },
+        }));
+        expect(result.hasWork).toBe(true);
+        expect(result.errored.map((e) => e.kind)).toContain("graph-unflagged");
+        // A check that threw knows nothing about its source, so flagging on it would
+        // mark processed what no turn ever saw.
+        expect(result.unflagged).toEqual([]);
+    });
+    it("refuses a label it cannot probe, and counts that as work rather than quiet", async () => {
+        const result = await run([{ type: "graph-unflagged", label: "Person" }], quietSources(unflagged([])));
+        expect(result.hasWork).toBe(true);
+        expect(result.errored[0].detail).toMatch(/unknown graph-unflagged label/);
+        expect(result.unflagged).toEqual([]);
+    });
+    it("names the label in its source, so two labels are distinguishable in the log", async () => {
+        const result = await run([SECTIONS], quietSources({
+            graphUnflagged: async () => {
+                throw new Error("neo4j down");
+            },
+        }));
+        expect(result.errored[0].source).toBe("graph:Section");
+    });
+});
+describe("REAL_SOURCES.graphUnflagged", () => {
+    it("returns the ids the label holds outstanding for this routine", async () => {
+        neo4jRecords = [
+            { get: (k) => (k === "id" ? "4:abc:1" : null) },
+            { get: (k) => (k === "id" ? "4:abc:2" : null) },
+        ];
+        const { REAL_SOURCES: S } = await import("../scheduling-gate.js");
+        expect(await S.graphUnflagged(ACCOUNT, "Section", EVENT, 500)).toEqual({
+            ids: ["4:abc:1", "4:abc:2"],
+        });
+    });
+    it("throws on a non-string id rather than dropping it from the handed set", async () => {
+        neo4jRecords = [{ get: (k) => (k === "id" ? 17 : null) }];
+        const { REAL_SOURCES: S } = await import("../scheduling-gate.js");
+        await expect(S.graphUnflagged(ACCOUNT, "Section", EVENT, 500)).rejects.toThrow(/expected a string/);
+    });
+});
+// Task 2688 — the connector queue arm.
+//
+// The three quiet cases are asserted apart from the error cases on purpose:
+// this is the only check whose source can fail and still answer "no work", so a
+// suite that ran them together could not tell an unauthorised connector from an
+// unreachable one, which is exactly the distinction the arm exists to make.
+describe("connector check", () => {
+    const CHECK = { type: "connector", scope: "operational" };
+    const QUEUE = {
+        kind: "operational",
+        path: "/v2/jobs/changed",
+        changedSinceParam: "updatedSince",
+        itemsField: "items",
+    };
+    const BINDING = { name: "jobs", queue: QUEUE };
+    const AT = "2026-08-14T06:00:00.000Z";
+    const YESTERDAY = "2026-08-13T06:00:00.000Z";
+    const bound = (over = {}) => quietSources({
+        connectorQueues: async () => ({ pluginPresent: true, bindings: [BINDING] }),
+        ...over,
+    });
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date(AT));
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it("reports work and records the probe instant on a first run, without calling the queue", async () => {
+        let called = 0;
+        const res = await run([CHECK], bound({
+            connectorQueueRead: async () => {
+                called++;
+                return { status: 200, items: 0, truncated: false };
+            },
+        }));
+        // An unfiltered read of a queue that has never been filtered is the body
+        // connector-call caps, and a capped body cannot be counted.
+        expect(called).toBe(0);
+        expect(res).toMatchObject({ hasWork: true, genuineWork: true, reasons: ["connector"] });
+        expect(res.observed.connector).toEqual({ jobs: { changedSince: AT } });
+    });
+    it("reports work when the queue holds records above the stored position", async () => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound({ connectorQueueRead: async () => ({ status: 200, items: 3, truncated: false }) }));
+        expect(res).toMatchObject({ hasWork: true, reasons: ["connector"], errored: [] });
+        expect(res.observed.connector).toEqual({ jobs: { changedSince: AT } });
+    });
+    it("reports no work on an empty queue, and still records the position", async () => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound());
+        expect(res).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+        expect(res.observed.connector).toEqual({ jobs: { changedSince: AT } });
+    });
+    it("passes the stored position as the changed-since argument", async () => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const seen = [];
+        await run([CHECK], bound({
+            connectorQueueRead: async (_a, _b, changedSince) => {
+                seen.push(changedSince);
+                return { status: 200, items: 0, truncated: false };
+            },
+        }));
+        expect(seen).toEqual([YESTERDAY]);
+    });
+    it("asks only for the queues whose kind matches the scope", async () => {
+        const asked = [];
+        await run([{ type: "connector", scope: "accounting" }], quietSources({
+            connectorQueues: async (_a, kind) => {
+                asked.push(kind);
+                return { pluginPresent: true, bindings: [] };
+            },
+        }));
+        expect(asked).toEqual(["accounting"]);
+    });
+    it("answers quiet when the connector plugin is not installed", async () => {
+        const res = await run([CHECK], quietSources({ connectorQueues: async () => ({ pluginPresent: false, bindings: [] }) }));
+        expect(res).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+        expect(res.observed.connector).toBeUndefined();
+    });
+    it("answers quiet when no registered queue carries that kind", async () => {
+        const res = await run([CHECK], quietSources());
+        expect(res).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+        expect(res.observed.connector).toBeUndefined();
+    });
+    it.each([401, 403])("answers quiet on %i and records no position", async (status) => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound({ connectorQueueRead: async () => ({ status, items: 0, truncated: false }) }));
+        expect(res).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+        // No position: an unauthorised connector was never read, so advancing past
+        // it would skip whatever arrived while the credential was dead.
+        expect(res.observed.connector).toBeUndefined();
+    });
+    it("counts any other non-2xx as work, so an outage still fires", async () => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound({ connectorQueueRead: async () => ({ status: 500, items: 0, truncated: false }) }));
+        expect(res).toMatchObject({ hasWork: true, genuineWork: false, reasons: ["connector"] });
+        expect(res.errored[0]).toMatchObject({ kind: "connector", source: "connector:operational" });
+        expect(res.observed.connector).toBeUndefined();
+    });
+    it("treats a truncated body as work AND records the position, so the window narrows", async () => {
+        // A body the connector capped cannot be counted, but it is proof the queue
+        // moved. Recording nothing would leave the same window on the next fire,
+        // which would truncate again: the routine would then wake the model on
+        // every fire for ever, with no way back to quiet.
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound({ connectorQueueRead: async () => ({ status: 200, items: 0, truncated: true }) }));
+        expect(res).toMatchObject({ hasWork: true, genuineWork: true, reasons: ["connector"], errored: [] });
+        expect(res.observed.connector).toEqual({ jobs: { changedSince: AT } });
+    });
+    it("counts a transport failure as work", async () => {
+        seedWatermarks({ connector: { jobs: { changedSince: YESTERDAY } } });
+        const res = await run([CHECK], bound({
+            connectorQueueRead: async () => {
+                throw new Error("ETIMEDOUT");
+            },
+        }));
+        expect(res).toMatchObject({ hasWork: true, genuineWork: false });
+        expect(res.errored).toEqual([
+            { kind: "connector", detail: "ETIMEDOUT", source: "connector:operational" },
+        ]);
+    });
+    it("holds one position per connector under a single check", async () => {
+        seedWatermarks({
+            connector: {
+                jobs: { changedSince: YESTERDAY },
+                crm: { changedSince: "2026-08-12T06:00:00.000Z" },
+            },
+        });
+        const res = await run([CHECK], quietSources({
+            connectorQueues: async () => ({
+                pluginPresent: true,
+                bindings: [BINDING, { name: "crm", queue: QUEUE }],
+            }),
+            connectorQueueRead: async (_a, binding) => ({
+                status: 200,
+                items: binding.name === "crm" ? 2 : 0,
+                truncated: false,
+            }),
+        }));
+        expect(res).toMatchObject({ hasWork: true, reasons: ["connector"] });
+        expect(res.observed.connector).toEqual({
+            jobs: { changedSince: AT },
+            crm: { changedSince: AT },
+        });
+    });
+    it("names each connector slot in the watermark helpers", () => {
+        const marks = { connector: { jobs: { changedSince: AT } } };
+        expect(slotsIn(marks)).toEqual([{ kind: "connector", key: "jobs" }]);
+        expect(slotKey({ kind: "connector", key: "jobs" })).toBe("connector:jobs");
+        expect(slotPosition({ kind: "connector", key: "jobs" }, marks)).toBe(AT);
+        const into = {};
+        expect(promoteSlot({ kind: "connector", key: "jobs" }, marks, into)).toBe(true);
+        expect(into.connector).toEqual({ jobs: { changedSince: AT } });
+    });
+});
+// Task 2689 — the health-delta checks.
+describe("sweep check", () => {
+    const CHECK = { type: "sweep" };
+    const FRESH = { newestReportAt: new Date().toISOString(), orphans: 2, citations: 1 };
+    it("is false when the digest matches the stored one", async () => {
+        seedWatermarks({ sweep: { digest: digestSweepState(FRESH, Date.now()) } });
+        const sources = quietSources({ sweepState: async () => FRESH });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+    });
+    it("is true when a review queue moved", async () => {
+        seedWatermarks({ sweep: { digest: digestSweepState(FRESH, Date.now()) } });
+        const sources = quietSources({ sweepState: async () => ({ ...FRESH, orphans: 3 }) });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["sweep"] });
+    });
+    it("is true on a first run, when no digest is stored", async () => {
+        const sources = quietSources({ sweepState: async () => FRESH });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["sweep"] });
+    });
+    it("reports work rather than an error when the source is unreachable", async () => {
+        const sources = quietSources({
+            sweepState: async () => {
+                throw new Error("neo4j unreachable");
+            },
+        });
+        expect(await run([CHECK], sources)).toMatchObject({
+            hasWork: true,
+            reasons: ["sweep"],
+            errored: [{ kind: "sweep", source: "sweep", detail: "neo4j unreachable" }],
+        });
+    });
+    it("changes once when the sweep goes stale, then settles", () => {
+        const now = Date.parse("2026-08-14T12:00:00.000Z");
+        const state = { newestReportAt: "2026-08-14T11:00:00.000Z", orphans: 0, citations: 0 };
+        const healthy = digestSweepState(state, now);
+        const stale = digestSweepState(state, now + 27 * 60 * 60 * 1000);
+        expect(stale).not.toBe(healthy);
+        expect(digestSweepState(state, now + 30 * 60 * 60 * 1000)).toBe(stale);
+    });
+    it("treats a sweep that has never run as stale", () => {
+        const now = Date.parse("2026-08-14T12:00:00.000Z");
+        const absent = { newestReportAt: null, orphans: 0, citations: 0 };
+        const old = { newestReportAt: "2026-08-12T12:00:00.000Z", orphans: 0, citations: 0 };
+        expect(digestSweepState(absent, now)).toBe(digestSweepState(old, now));
+    });
+    it("does not move on the sweep merely running again", () => {
+        const now = Date.parse("2026-08-14T12:00:00.000Z");
+        const before = { newestReportAt: "2026-08-14T10:00:00.000Z", orphans: 4, citations: 2 };
+        const after = { newestReportAt: "2026-08-14T11:00:00.000Z", orphans: 4, citations: 2 };
+        expect(digestSweepState(after, now)).toBe(digestSweepState(before, now));
+    });
+    it("records its digest as a promotable slot", async () => {
+        const sources = quietSources({ sweepState: async () => FRESH });
+        const res = await run([CHECK], sources);
+        expect(slotsIn(res.observed)).toEqual([{ kind: "sweep" }]);
+        const into = {};
+        expect(promoteSlot({ kind: "sweep" }, res.observed, into)).toBe(true);
+        expect(into.sweep?.digest).toBe(res.observed.sweep?.digest);
+        expect(slotKey({ kind: "sweep" })).toBe("sweep");
+        expect(slotPosition({ kind: "sweep" }, into)).toBe(res.observed.sweep.digest.slice(0, 8));
+    });
+});
+describe("filesystem check", () => {
+    const CHECK = { type: "filesystem", minGrowthBytes: 1_000 };
+    it("is false when growth is below the threshold", async () => {
+        seedWatermarks({ filesystem: { bytes: 10_000 } });
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 10_999, capped: false }) });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: false, reasons: [], errored: [] });
+    });
+    it("is true when growth reaches the threshold", async () => {
+        seedWatermarks({ filesystem: { bytes: 10_000 } });
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 11_000, capped: false }) });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["filesystem"] });
+    });
+    it("is false when the directory shrank", async () => {
+        seedWatermarks({ filesystem: { bytes: 10_000 } });
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 4_000, capped: false }) });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: false, reasons: [] });
+    });
+    it("is true on a first run, when no size is stored", async () => {
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 1, capped: false }) });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["filesystem"] });
+    });
+    it("reports work and records no position when the walk hit its cap", async () => {
+        seedWatermarks({ filesystem: { bytes: 10_000 } });
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 10_001, capped: true }) });
+        const res = await run([CHECK], sources);
+        expect(res).toMatchObject({ hasWork: true, reasons: ["filesystem"] });
+        expect(res.observed.filesystem).toBeUndefined();
+    });
+    it("refuses a non-positive threshold rather than passing on every fire", async () => {
+        const res = await run([{ type: "filesystem", minGrowthBytes: 0 }], quietSources());
+        expect(res).toMatchObject({ hasWork: true, errored: [{ kind: "filesystem" }] });
+    });
+    it("reports work rather than an error when the source is unreachable", async () => {
+        const sources = quietSources({
+            filesystemBytes: async () => {
+                throw new Error("ENOENT: no account directory");
+            },
+        });
+        expect(await run([CHECK], sources)).toMatchObject({
+            hasWork: true,
+            reasons: ["filesystem"],
+            errored: [{ kind: "filesystem", source: "filesystem" }],
+        });
+    });
+    it("records its size as a promotable slot", async () => {
+        const sources = quietSources({ filesystemBytes: async () => ({ bytes: 77, capped: false }) });
+        const res = await run([CHECK], sources);
+        expect(slotsIn(res.observed)).toEqual([{ kind: "filesystem" }]);
+        const into = {};
+        expect(promoteSlot({ kind: "filesystem" }, res.observed, into)).toBe(true);
+        expect(into.filesystem?.bytes).toBe(77);
+        expect(slotKey({ kind: "filesystem" })).toBe("filesystem");
+        expect(slotPosition({ kind: "filesystem" }, into)).toBe("77");
+    });
+});
+describe("measureAccountBytes", () => {
+    it("sums nested regular files and never follows a symlink", async () => {
+        const { measureAccountBytes } = await import("../scheduling-gate.js");
+        const root = mkdtempSync(join(tmpdir(), "fs-measure-"));
+        mkdirSync(join(root, "nested"), { recursive: true });
+        writeFileSync(join(root, "a.txt"), "12345");
+        writeFileSync(join(root, "nested", "b.txt"), "678");
+        const outside = mkdtempSync(join(tmpdir(), "fs-outside-"));
+        writeFileSync(join(outside, "big.txt"), "x".repeat(5000));
+        symlinkSync(outside, join(root, "link"));
+        expect(measureAccountBytes(root, 1000)).toEqual({ bytes: 8, capped: false });
+    });
+    it("stops at the cap and says so", async () => {
+        const { measureAccountBytes } = await import("../scheduling-gate.js");
+        const root = mkdtempSync(join(tmpdir(), "fs-cap-"));
+        for (let i = 0; i < 5; i++)
+            writeFileSync(join(root, `f${i}.txt`), "ab");
+        expect(measureAccountBytes(root, 3)).toMatchObject({ capped: true });
+    });
+    it("throws on a missing root rather than reading zero", async () => {
+        const { measureAccountBytes } = await import("../scheduling-gate.js");
+        expect(() => measureAccountBytes(join(tmpdir(), "fs-absent-000"), 10)).toThrow();
+    });
+});
+describe("measureAccountBytes cap covers directories too", () => {
+    it("stops on a tree that is wide in directories and holds no file", async () => {
+        const { measureAccountBytes } = await import("../scheduling-gate.js");
+        const root = mkdtempSync(join(tmpdir(), "fs-dirs-"));
+        for (let i = 0; i < 6; i++)
+            mkdirSync(join(root, `d${i}`));
+        // Files alone would never reach a cap here, so a file-only counter would
+        // walk the whole tree however wide it got.
+        expect(measureAccountBytes(root, 4)).toMatchObject({ capped: true });
+    });
+});
 //# sourceMappingURL=scheduling-gate.test.js.map