@rubytech/create-realagent-code 0.1.591 → 0.1.593

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

@@ -17,7 +17,7 @@ vi.mock("../../lib/neo4j.js", () => ({
         close: vi.fn(async () => { }),
     }),
 }));
-import { runSchedulingGate, watermarkPath, observationPath, readWatermarks, foldMailWatermarks, parseD1Count, digestBusy, } from "../scheduling-gate.js";
+import { runSchedulingGate, advanceGateMark, watermarkPath, readWatermarks, readWatermarksChecked, foldMailWatermarks, parseD1Count, digestBusy, } from "../scheduling-gate.js";
 const ACCOUNT = "20028fb5-0000-4000-8000-000000000000";
 const EVENT = "65ef758c-0000-4000-8000-000000000000";
 let platformRoot;
@@ -58,14 +58,14 @@ afterEach(() => {
     vi.doUnmock("imapflow");
     delete process.env.PLATFORM_PORT;
 });
-const run = (checks, sources, commit = false) => runSchedulingGate({ eventId: EVENT, checks, commit }, ACCOUNT, platformRoot, sources);
+const run = (checks, sources) => runSchedulingGate({ eventId: EVENT, checks }, ACCOUNT, platformRoot, sources);
 describe("d1 check", () => {
     const CHECK = { type: "d1", database: "bookings", sql: "SELECT count(*) FROM b" };
     it("is false on a zero count", async () => {
-        expect(await run([CHECK], quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([CHECK], quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("is true on one row", async () => {
-        expect(await run([CHECK], quietSources({ d1: async () => 1 }))).toEqual({
+        expect(await run([CHECK], quietSources({ d1: async () => 1 }))).toMatchObject({
             hasWork: true,
             reasons: ["d1"],
             errored: [],
@@ -77,7 +77,7 @@ describe("d1 check", () => {
                 throw new Error("no cloudflare credentials");
             },
         });
-        expect(await run([CHECK], sources)).toEqual({
+        expect(await run([CHECK], sources)).toMatchObject({
             hasWork: true,
             reasons: ["d1"],
             errored: [{ kind: "d1", detail: "no cloudflare credentials" }],
@@ -88,14 +88,14 @@ describe("mail check", () => {
     const CHECK = { type: "mail", mailbox: "ops@example.com" };
     it("is false when nothing sits above the watermark", async () => {
         seedWatermarks({ mail: { "ops@example.com|INBOX": { uid: 100, uidValidity: 1 } } });
-        expect(await run([CHECK], quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([CHECK], quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("is true when a UID above the watermark matches", async () => {
         seedWatermarks({ mail: { "ops@example.com|INBOX": { uid: 100, uidValidity: 1 } } });
         const sources = quietSources({
             mail: async () => ({ matched: true, highestUid: 104, uidValidity: 1 }),
         });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
     });
     it("probes from UID 0 on a first run, so nothing already there is missed", async () => {
         const seen = [];
@@ -113,7 +113,7 @@ describe("mail check", () => {
         const sources = quietSources({
             mail: async () => ({ matched: false, highestUid: 100, uidValidity: 7 }),
         });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
     });
     it("keys the watermark by folder, so two folders of one mailbox never collide", async () => {
         seedWatermarks({ mail: { "ops@example.com|Archive": { uid: 100, uidValidity: 1 } } });
@@ -131,12 +131,12 @@ describe("mail check", () => {
 describe("whatsapp check", () => {
     it("status is false while connected", async () => {
         const check = { type: "whatsapp", scope: "status" };
-        expect(await run([check], quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([check], quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("status is true while disconnected", async () => {
         const check = { type: "whatsapp", scope: "status" };
         const sources = quietSources({ whatsappStatus: async () => ({ connected: false }) });
-        expect(await run([check], sources)).toEqual({ hasWork: true, reasons: ["whatsapp"], errored: [] });
+        expect(await run([check], sources)).toMatchObject({ hasWork: true, reasons: ["whatsapp"], errored: [] });
     });
     it("inbound is true only on a message received since the watermark", async () => {
         const check = { type: "whatsapp", scope: "inbound" };
@@ -144,7 +144,7 @@ describe("whatsapp check", () => {
         const sources = quietSources({
             whatsappInbound: async () => ({ latest: 1_754_000_900, newer: true }),
         });
-        expect(await run([check], sources)).toEqual({ hasWork: true, reasons: ["whatsapp"], errored: [] });
+        expect(await run([check], sources)).toMatchObject({ hasWork: true, reasons: ["whatsapp"], errored: [] });
     });
     it("inbound passes the stored watermark to the source", async () => {
         const check = { type: "whatsapp", scope: "inbound" };
@@ -164,15 +164,15 @@ describe("calendar check", () => {
     const CHECK = { type: "calendar", connector: "google" };
     it("is false on an unchanged digest", async () => {
         seedWatermarks({ calendar: { digest: "DIGEST-A" } });
-        expect(await run([CHECK], quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([CHECK], quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("is true on a changed digest", async () => {
         seedWatermarks({ calendar: { digest: "DIGEST-A" } });
         const sources = quietSources({ calendarDigest: async () => "DIGEST-B" });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["calendar"], errored: [] });
     });
     it("is true on a first run, when nothing has been committed yet", async () => {
-        expect(await run([CHECK], quietSources())).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
+        expect(await run([CHECK], quietSources())).toMatchObject({ hasWork: true, reasons: ["calendar"], errored: [] });
     });
 });
 describe("digestBusy", () => {
@@ -229,48 +229,49 @@ describe("all four together", () => {
             mail: { "ops@example.com|INBOX": { uid: 100, uidValidity: 1 } },
             calendar: { digest: "DIGEST-A" },
         });
-        expect(await run(ALL, quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run(ALL, quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("one noisy source is enough, and names only itself", async () => {
         seedWatermarks({
             mail: { "ops@example.com|INBOX": { uid: 100, uidValidity: 1 } },
             calendar: { digest: "DIGEST-A" },
         });
-        expect(await run(ALL, quietSources({ d1: async () => 2 }))).toEqual({
+        expect(await run(ALL, quietSources({ d1: async () => 2 }))).toMatchObject({
             hasWork: true,
             reasons: ["d1"],
             errored: [],
         });
     });
 });
-describe("commit", () => {
+// Task 2663 — the advance is the dispatcher's, so it is tested through
+// `advanceGateMark` against the readings a real gate call returned. The old
+// `commit` describe drove the same ground through a parameter the agent set.
+describe("advanceGateMark", () => {
     const ALL = [
         { type: "mail", mailbox: "ops@example.com" },
         { type: "d1", database: "bookings", sql: "SELECT count(*) FROM b" },
         { type: "whatsapp", scope: "inbound" },
         { type: "calendar", connector: "google" },
     ];
-    it("a plain call leaves the file bytes unchanged", async () => {
+    it("the gate itself leaves the file bytes unchanged", async () => {
         seedWatermarks({ calendar: { digest: "DIGEST-A" } });
         const path = watermarkPath(EVENT, platformRoot);
         const before = readFileSync(path);
         await run(ALL, quietSources({ calendarDigest: async () => "DIGEST-B" }));
         expect(readFileSync(path).equals(before)).toBe(true);
     });
-    it("a plain call on a first run writes no file at all", async () => {
+    it("the gate on a first run writes no file at all", async () => {
         await run(ALL, quietSources());
         expect(existsSync(watermarkPath(EVENT, platformRoot))).toBe(false);
     });
-    it("advances every watermark named in checks", async () => {
+    it("advances every watermark the gate read", async () => {
         const sources = quietSources({
             mail: async () => ({ matched: true, highestUid: 250, uidValidity: 9 }),
             whatsappInbound: async () => ({ latest: 1_754_009_999, newer: true }),
             calendarDigest: async () => "DIGEST-Z",
         });
-        // Task 2654 — the commit promotes what the gate read, so the gate call is
-        // part of the sequence. A bare commit advances nothing, by design.
-        await run(ALL, sources);
-        const result = await run(ALL, sources, true);
+        const gate = await run(ALL, sources);
+        const { advanced } = advanceGateMark(EVENT, platformRoot, gate.observed);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(marks.mail["ops@example.com|inbox"]).toEqual({ uid: 250, uidValidity: 9 });
         expect(marks.whatsapp.inbound).toBe(1_754_009_999);
@@ -278,77 +279,79 @@ describe("commit", () => {
         expect(marks.lastCommitAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
         // d1 has no watermark: its answer is a property of the present, not a
         // position in a stream.
-        expect(result.advanced).toEqual(["ops@example.com|inbox", "whatsapp", "calendar"]);
+        expect(advanced).toEqual(["ops@example.com|inbox", "whatsapp", "calendar"]);
+    });
+    it("names the position it wrote per advanced key", async () => {
+        const gate = await run([{ type: "calendar", connector: "google" }], quietSources({ calendarDigest: async () => "DIGEST-Z" }));
+        const { positions } = advanceGateMark(EVENT, platformRoot, gate.observed);
+        expect(positions).toEqual(["calendar:DIGEST-Z"]);
+    });
+    it("stamps lastCommitAt only when something moved", async () => {
+        // Stamping it on every accepted wake would make `auditGateMarkStalled`,
+        // which counts accepted wakes SINCE this instant, read 0 or 1 for ever — the
+        // check built to catch a mark that stopped moving could then never fire, and
+        // `auditGateWatermarkAge` would go permanently green for the same reason.
+        const { advanced } = advanceGateMark(EVENT, platformRoot, {});
+        expect(advanced).toEqual([]);
+        expect(existsSync(watermarkPath(EVENT, platformRoot))).toBe(false);
     });
-    it("a commit whose sources are quiet still stamps lastCommitAt", async () => {
-        // Otherwise a routine that ran and found nothing would look, to the
-        // watermark-age audit, exactly like one whose commits had stopped.
-        await run(ALL, quietSources(), true);
-        const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
-        expect(marks.lastCommitAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    it("leaves an existing file untouched when nothing moved", async () => {
+        seedWatermarks({ calendar: { digest: "DIGEST-A" }, lastCommitAt: "2026-08-10T10:00:00.000Z" });
+        const before = readFileSync(watermarkPath(EVENT, platformRoot));
+        advanceGateMark(EVENT, platformRoot, {});
+        expect(readFileSync(watermarkPath(EVENT, platformRoot)).equals(before)).toBe(true);
     });
-    it("a committed watermark makes the next plain call quiet", async () => {
+    it("an advanced watermark makes the next gate call quiet", async () => {
         const sources = quietSources({ calendarDigest: async () => "DIGEST-Z" });
         const checks = [{ type: "calendar", connector: "google" }];
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
-        await run(checks, sources, true);
-        expect(await run(checks, sources)).toEqual({ hasWork: false, reasons: [], errored: [] });
+        const first = await run(checks, sources);
+        expect(first).toMatchObject({ hasWork: true, reasons: ["calendar"], errored: [] });
+        advanceGateMark(EVENT, platformRoot, first.observed);
+        expect(await run(checks, sources)).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
-    it("a check that errors is not committed, so its work is not marked consumed", async () => {
+    it("a check that errored is not advanced, so its work is not marked consumed", async () => {
         const checks = [{ type: "calendar", connector: "google" }];
         const sources = quietSources({
             calendarDigest: async () => {
                 throw new Error("neo4j down");
             },
         });
-        const result = await run(checks, sources, true);
-        expect(result).toMatchObject({ hasWork: true, reasons: ["calendar"], advanced: [] });
-        const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
-        expect(marks.calendar).toBeUndefined();
+        const gate = await run(checks, sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["calendar"], observed: {} });
+        const { advanced } = advanceGateMark(EVENT, platformRoot, gate.observed);
+        expect(advanced).toEqual([]);
+        expect(existsSync(watermarkPath(EVENT, platformRoot))).toBe(false);
     });
-    // Task 2633 — the agent that raised it read `advanced: []` from a commit over
-    // four d1 checks, inferred a broken watermark, reported an unfixable platform
-    // fault, and deleted all four checks.
-    it("names the checks that hold no watermark, instead of omitting them in silence", async () => {
-        const checks = [
-            { type: "mail", mailbox: "ops@example.com" },
-            { type: "d1", database: "bookings", sql: "SELECT count(*) FROM b" },
-        ];
-        // Task 2654 — the gate call records the position the commit promotes.
-        await run(checks, quietSources());
-        const result = await run(checks, quietSources(), true);
-        // Task 2635 folds the folder segment to lower case on write.
-        expect(result.advanced).toEqual(["ops@example.com|inbox"]);
-        expect(result.skipped).toEqual(["d1"]);
-    });
-    it("counts every skipped check, not every skipped kind", async () => {
-        const checks = [
+    it("a check holding no position contributes no key, so nothing advances for it", async () => {
+        // Task 2633 — an agent read an empty `advanced` over four d1 checks,
+        // inferred a broken watermark and deleted all four. `d1` and `whatsapp` in
+        // `status` scope read a current value; there is no position to record.
+        const gate = await run([
             { type: "d1", database: "bookings", sql: "SELECT max(id) FROM b" },
             { type: "d1", database: "leads", sql: "SELECT max(id) FROM l" },
             { type: "whatsapp", scope: "status" },
-        ];
-        const result = await run(checks, quietSources(), true);
-        expect(result.skipped).toEqual(["d1", "d1", "whatsapp"]);
+        ], quietSources());
+        expect(gate.observed).toEqual({});
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual([]);
+    });
+    // Task 2664 — the destructive half. `readWatermarks` returned `{}` for a file
+    // it could not parse, this function promoted into that empty object and wrote
+    // it, and the file's real positions were destroyed rather than repaired.
+    it("does not overwrite a file it could not parse", async () => {
+        const path = watermarkPath(EVENT, platformRoot);
+        mkdirSync(join(path, ".."), { recursive: true });
+        writeFileSync(path, "{ not json");
+        const before = readFileSync(path);
+        const gate = await run([{ type: "calendar", connector: "google" }], quietSources({ calendarDigest: async () => "DIGEST-Z" }));
+        const { advanced, unreadable } = advanceGateMark(EVENT, platformRoot, gate.observed);
+        expect({ advanced, unreadable }).toEqual({ advanced: [], unreadable: true });
+        expect(readFileSync(path).equals(before)).toBe(true);
     });
-    it("a plain call reports no skipped array at all", async () => {
-        const checks = [
-            { type: "d1", database: "bookings", sql: "SELECT count(*) FROM b" },
-        ];
-        expect(await run(checks, quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
-    });
-    it("a check that errored is neither advanced nor skipped, because its state is unknown", async () => {
-        const checks = [
-            { type: "d1", database: "bookings", sql: "SELECT count(*) FROM b" },
-            { type: "calendar", connector: "google" },
-        ];
-        const sources = quietSources({
-            calendarDigest: async () => {
-                throw new Error("neo4j down");
-            },
-        });
-        const result = await run(checks, sources, true);
-        expect(result.advanced).toEqual([]);
-        expect(result.skipped).toEqual(["d1"]);
+    it("still writes a first fire, which has no file at all", async () => {
+        const gate = await run([{ type: "calendar", connector: "google" }], quietSources({ calendarDigest: async () => "DIGEST-Z" }));
+        const { advanced, unreadable } = advanceGateMark(EVENT, platformRoot, gate.observed);
+        expect({ advanced, unreadable }).toEqual({ advanced: ["calendar"], unreadable: false });
+        expect(existsSync(watermarkPath(EVENT, platformRoot))).toBe(true);
     });
 });
 describe("watermark location", () => {
@@ -599,14 +602,16 @@ describe("watermark folder-case fold", () => {
         const sources = quietSources({
             mail: async (_c, since) => ({ matched: false, highestUid: since + 1, uidValidity: 1 }),
         });
-        // Task 2654 — each commit promotes what its own gate call read, so both
+        // Task 2663 — each advance promotes what its own gate call read, so both
         // fires run the real two-step sequence.
-        await run([lower], sources);
-        const first = await run([lower], sources, true);
-        expect(first.advanced).toEqual(["ops@example.com|inbox"]);
-        await run([upper], sources);
-        const second = await run([upper], sources, true);
-        expect(second.advanced).toEqual(["ops@example.com|inbox"]);
+        const firstGate = await run([lower], sources);
+        expect(advanceGateMark(EVENT, platformRoot, firstGate.observed).advanced).toEqual([
+            "ops@example.com|inbox",
+        ]);
+        const secondGate = await run([upper], sources);
+        expect(advanceGateMark(EVENT, platformRoot, secondGate.observed).advanced).toEqual([
+            "ops@example.com|inbox",
+        ]);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(Object.keys(marks.mail)).toEqual(["ops@example.com|inbox"]);
         // The second call read the first call's position rather than restarting at 0.
@@ -628,6 +633,111 @@ describe("watermark folder-case fold", () => {
         await run([check], sources);
         expect(seen).toEqual([106]);
     });
+    // Task 2664 — a file that is present and unusable is a third state. Today it
+    // reads identically to a healthy first fire: `{}` and no line.
+    describe("readWatermarksChecked", () => {
+        /** The lines console.error saw, with the suite's default silencer replaced. */
+        function captureErrors() {
+            const lines = [];
+            vi.spyOn(console, "error").mockImplementation((...a) => void lines.push(a.join(" ")));
+            return lines;
+        }
+        function writeRaw(body) {
+            const path = watermarkPath(EVENT, platformRoot);
+            mkdirSync(join(path, ".."), { recursive: true });
+            writeFileSync(path, body);
+        }
+        it("is silent on a missing file and does not call it unreadable", () => {
+            const lines = captureErrors();
+            expect(readWatermarksChecked(EVENT, platformRoot)).toEqual({ marks: {}, unreadable: false });
+            expect(lines.filter((l) => l.includes("op=watermark-unreadable"))).toEqual([]);
+        });
+        it("names a file that does not parse, by its id8", () => {
+            writeRaw("{ not json");
+            const lines = captureErrors();
+            const { marks, unreadable } = readWatermarksChecked(EVENT, platformRoot);
+            expect({ marks, unreadable }).toEqual({ marks: {}, unreadable: true });
+            expect(lines.join("\n")).toContain(`[scheduling-gate] op=watermark-unreadable eventId=${EVENT.slice(0, 8)} reason=`);
+        });
+        it("names a file that parses to a non-object", () => {
+            writeRaw('"a string"');
+            const lines = captureErrors();
+            expect(readWatermarksChecked(EVENT, platformRoot)).toEqual({ marks: {}, unreadable: true });
+            expect(lines.join("\n")).toContain("op=watermark-unreadable");
+            expect(lines.join("\n")).toContain("reason=not an object");
+        });
+        // Task 2667 — an array is an object to `typeof`, so it passed the guard
+        // above. `foldMailWatermarks` returned it unchanged (`marks.mail` is
+        // undefined), `advanceGateMark` promoted into it, and `JSON.stringify`
+        // dropped every non-index property on the way to disk, so the file was
+        // written back as `[]` while `op=mark-advanced` named the positions it had
+        // just lost.
+        it("names a file that parses to an array, by its shape", () => {
+            writeRaw("[]");
+            const lines = captureErrors();
+            expect(readWatermarksChecked(EVENT, platformRoot)).toEqual({ marks: {}, unreadable: true });
+            expect(lines.join("\n")).toContain(`[scheduling-gate] op=watermark-unreadable eventId=${EVENT.slice(0, 8)} ` +
+                `reason=an array, not a watermark object`);
+        });
+        it("leaves an array file byte-identical across an advance that observed a position", async () => {
+            // An array holding an element, written compactly. A bare `[]` cannot tell
+            // the two behaviours apart: the promoted properties are dropped by
+            // `JSON.stringify`, so the destructive write reproduces `[]` byte for byte
+            // and the assertion passes while the file is being rewritten on every fire.
+            writeRaw('["a stray element"]');
+            captureErrors();
+            const path = watermarkPath(EVENT, platformRoot);
+            const before = readFileSync(path);
+            const gate = await run([{ type: "calendar", connector: "google" }], quietSources());
+            // The advance has something to promote, which is what made this destructive.
+            expect(gate.observed.calendar?.digest).toBeDefined();
+            const { advanced, unreadable } = advanceGateMark(EVENT, platformRoot, gate.observed);
+            // The bytes first: the defect is the WRITE, and asserting the return value
+            // first would leave the emptied file unobserved on a red run.
+            expect(readFileSync(path).equals(before)).toBe(true);
+            expect({ advanced, unreadable }).toEqual({ advanced: [], unreadable: true });
+        });
+        it("a gate over an array file still reports work", async () => {
+            writeRaw("[]");
+            captureErrors();
+            const gate = await run([{ type: "calendar", connector: "google" }], quietSources());
+            expect(gate).toMatchObject({ hasWork: true, reasons: ["calendar"] });
+        });
+        it("names a read error that is not a missing file", () => {
+            // A directory where the file should be: present, and unreadable for a
+            // reason that is not ENOENT.
+            mkdirSync(watermarkPath(EVENT, platformRoot), { recursive: true });
+            const lines = captureErrors();
+            expect(readWatermarksChecked(EVENT, platformRoot)).toEqual({ marks: {}, unreadable: true });
+            expect(lines.join("\n")).toContain("op=watermark-unreadable");
+        });
+        it("emits on EVERY read, so it repeats until the file is fixed", () => {
+            writeRaw("{ not json");
+            const lines = captureErrors();
+            readWatermarksChecked(EVENT, platformRoot);
+            readWatermarksChecked(EVENT, platformRoot);
+            expect(lines.filter((l) => l.includes("op=watermark-unreadable"))).toHaveLength(2);
+        });
+        it("reports a readable file as readable and folds it", () => {
+            seedWatermarks({ mail: { "a@b.com|INBOX": { uid: 106, uidValidity: 11 } } });
+            const lines = captureErrors();
+            const { marks, unreadable } = readWatermarksChecked(EVENT, platformRoot);
+            expect(unreadable).toBe(false);
+            expect(marks.mail).toEqual({ "a@b.com|inbox": { uid: 106, uidValidity: 11 } });
+            expect(lines.filter((l) => l.includes("op=watermark-unreadable"))).toEqual([]);
+        });
+        it("readWatermarks still returns just the marks, so its callers are untouched", () => {
+            writeRaw("{ not json");
+            captureErrors();
+            expect(readWatermarks(EVENT, platformRoot)).toEqual({});
+        });
+        it("a gate over an unreadable file still reports work", async () => {
+            writeRaw("{ not json");
+            captureErrors();
+            const gate = await run([{ type: "calendar", connector: "google" }], quietSources());
+            expect(gate).toMatchObject({ hasWork: true, reasons: ["calendar"] });
+        });
+    });
     it("readWatermarks writes nothing, so the audit path stays read-only", () => {
         // schedule-audit.ts:218 reads every gated event's file and never writes.
         seedWatermarks({
@@ -664,11 +774,11 @@ describe("telegram check", () => {
     };
     const measured = (lines) => lines.every((l) => !l.includes("op=check-error"));
     it("is false when the account holds no inbound message at all", async () => {
-        expect(await run([CHECK], quietSources())).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([CHECK], quietSources())).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("is false when nothing arrived after the watermark", async () => {
         seedWatermarks({ telegram: { inbound: "2026-08-05T10:00:00.000Z" } });
-        expect(await run([CHECK], quietSources(at("2026-08-05T09:00:00.000Z")))).toEqual({
+        expect(await run([CHECK], quietSources(at("2026-08-05T09:00:00.000Z")))).toMatchObject({
             hasWork: false,
             reasons: [],
             errored: [],
@@ -677,7 +787,7 @@ describe("telegram check", () => {
     it("is true when a message arrived after the watermark", async () => {
         seedWatermarks({ telegram: { inbound: "2026-08-05T10:00:00.000Z" } });
         const lines = linesFrom();
-        expect(await run([CHECK], quietSources(at("2026-08-05T11:00:00.000Z")))).toEqual({
+        expect(await run([CHECK], quietSources(at("2026-08-05T11:00:00.000Z")))).toMatchObject({
             hasWork: true,
             reasons: ["telegram"],
             errored: [],
@@ -688,7 +798,7 @@ describe("telegram check", () => {
         // The boundary is `>`, not `>=`. A `>=` would re-report the last handled
         // message on every fire and the gate could never go quiet.
         seedWatermarks({ telegram: { inbound: "2026-08-05T10:00:00.000Z" } });
-        expect(await run([CHECK], quietSources(at("2026-08-05T10:00:00.000Z")))).toEqual({
+        expect(await run([CHECK], quietSources(at("2026-08-05T10:00:00.000Z")))).toMatchObject({
             hasWork: false,
             reasons: [],
             errored: [],
@@ -696,7 +806,7 @@ describe("telegram check", () => {
     });
     it("is true on a first run, so nothing already waiting is missed", async () => {
         const lines = linesFrom();
-        expect(await run([CHECK], quietSources(at("2026-08-05T09:00:00.000Z")))).toEqual({
+        expect(await run([CHECK], quietSources(at("2026-08-05T09:00:00.000Z")))).toMatchObject({
             hasWork: true,
             reasons: ["telegram"],
             errored: [],
@@ -710,7 +820,7 @@ describe("telegram check", () => {
                 throw new Error("HTTP 500 on GET /api/telegram-reader/gate-probe");
             },
         });
-        expect(await run([CHECK], sources)).toEqual({
+        expect(await run([CHECK], sources)).toMatchObject({
             hasWork: true,
             reasons: ["telegram"],
             errored: [{ kind: "telegram", detail: "HTTP 500 on GET /api/telegram-reader/gate-probe" }],
@@ -724,13 +834,9 @@ describe("telegram check", () => {
         expect(line).toContain("kind=telegram");
         expect(line).toContain("/api/telegram-reader/gate-probe");
     });
-    it("a commit advances the watermark to what the gate's probe read", async () => {
-        // Task 2654 — the gate's probe, not the commit's. The commit runs at the end
-        // of the turn, so its own reading already includes anything that arrived
-        // while the turn ran.
-        await run([CHECK], quietSources(at("2026-08-05T11:00:00.000Z")));
-        const result = await run([CHECK], quietSources(at("2026-08-05T11:00:00.000Z")), true);
-        expect(result.advanced).toEqual(["telegram"]);
+    it("the advance writes the watermark to what the gate's probe read", async () => {
+        const gate = await run([CHECK], quietSources(at("2026-08-05T11:00:00.000Z")));
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual(["telegram"]);
         const marks = readWatermarks(EVENT, platformRoot);
         expect(marks.telegram).toEqual({ inbound: "2026-08-05T11:00:00.000Z" });
     });
@@ -770,21 +876,18 @@ describe("telegram check", () => {
         // nobody has read. That is the mute direction, and it loses a booking.
         seedWatermarks({ telegram: { inbound: "2026-08-05T18:00:00.000Z" } });
         const check = { type: "telegram", scope: "inbound", botId: "111" };
-        expect(await run([check], quietSources(at("2026-08-05T12:00:00.000Z")))).toEqual({
+        expect(await run([check], quietSources(at("2026-08-05T12:00:00.000Z")))).toMatchObject({
             hasWork: true,
             reasons: ["telegram"],
             errored: [],
         });
     });
-    it("a scoped commit writes under the bot, leaving the account-wide mark alone", async () => {
+    it("a scoped advance writes under the bot, leaving the account-wide mark alone", async () => {
         seedWatermarks({ telegram: { inbound: "2026-08-05T18:00:00.000Z" } });
         const check = { type: "telegram", scope: "inbound", botId: "111" };
         const sources = quietSources(at("2026-08-05T12:00:00.000Z"));
-        // Task 2654 — the commit promotes what the GATE read, so the gate call is
-        // part of the sequence. A bare commit advances nothing, by design.
-        await run([check], sources);
-        const result = await run([check], sources, true);
-        expect(result.advanced).toEqual(["telegram:111"]);
+        const gate = await run([check], sources);
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual(["telegram:111"]);
         const marks = readWatermarks(EVENT, platformRoot);
         expect(marks.telegram?.inbound).toBe("2026-08-05T18:00:00.000Z");
         expect(marks.telegram?.byBot).toEqual({ "111": "2026-08-05T12:00:00.000Z" });
@@ -828,14 +931,15 @@ describe("telegram check", () => {
         expect(line).toContain("kind=telegram");
         expect(line).toContain("0000000000");
     });
-    it("a commit on a quiet account is skipped, not advanced onto nothing", async () => {
+    it("a quiet account records no position, so nothing advances onto nothing", async () => {
         // A null probe is "nothing to measure from", not "position zero". There is
-        // no position to record, so the check reports as `skipped` exactly as `d1`
-        // does, and the stored mark is left alone. Writing null would drop the mark
-        // and re-report every stored message on the next fire.
+        // no position to record, so the check contributes no key and the stored mark
+        // is left alone. Writing null would drop the mark and re-report every stored
+        // message on the next fire.
         seedWatermarks({ telegram: { inbound: "2026-08-05T10:00:00.000Z" } });
-        const result = await run([CHECK], quietSources(), true);
-        expect(result).toMatchObject({ hasWork: false, advanced: [], skipped: ["telegram"] });
+        const gate = await run([CHECK], quietSources());
+        expect(gate).toMatchObject({ hasWork: false, observed: {} });
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual([]);
         expect(readWatermarks(EVENT, platformRoot).telegram).toEqual({
             inbound: "2026-08-05T10:00:00.000Z",
         });
@@ -849,7 +953,7 @@ describe("telegram check", () => {
 describe("unrecognised check type", () => {
     const CHECK = { type: "nonsense" };
     it("resolves rather than throwing, and counts the unknown type as work", async () => {
-        expect(await run([CHECK], quietSources())).toEqual({
+        expect(await run([CHECK], quietSources())).toMatchObject({
             hasWork: true,
             reasons: ["nonsense"],
             errored: [
@@ -873,7 +977,7 @@ describe("unrecognised check type", () => {
     });
     it("still runs the sibling checks — one bad type does not abort the gate", async () => {
         const checks = [CHECK, { type: "d1", database: "b", sql: "SELECT 1" }];
-        expect(await run(checks, quietSources())).toEqual({
+        expect(await run(checks, quietSources())).toMatchObject({
             hasWork: true,
             reasons: ["nonsense"],
             errored: [
@@ -938,8 +1042,8 @@ describe("errored", () => {
             { kind: "calendar", detail: "calendar down" },
         ]);
     });
-    it("is present on a commit too", async () => {
-        const res = await run([D1], quietSources(), true);
+    it("is present and empty when every check answered", async () => {
+        const res = await run([D1], quietSources());
         expect(res.errored).toEqual([]);
     });
 });
@@ -959,23 +1063,16 @@ describe("mail check — outlook provider", () => {
         const sources = quietSources({
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:00:00Z" }),
         });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
-    it("is true on a message above the watermark, and advances that key on commit", async () => {
+    it("is true on a message above the watermark, and the advance writes that key", async () => {
         seedWatermarks({ mailOutlook: { [KEY]: { receivedAt: "2026-08-10T09:00:00Z" } } });
         const sources = quietSources({
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:05:00Z" }),
         });
-        // Task 2654 — the commit promotes what the gate read, so the gate call is
-        // part of the sequence. A bare commit advances nothing, by design.
-        await run([CHECK], sources);
-        expect(await run([CHECK], sources, true)).toEqual({
-            hasWork: true,
-            reasons: ["mail"],
-            errored: [],
-            advanced: [KEY],
-            skipped: [],
-        });
+        const gate = await run([CHECK], sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual([KEY]);
         const written = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(written.mailOutlook[KEY]).toEqual({ receivedAt: "2026-08-10T09:05:00Z" });
     });
@@ -983,7 +1080,7 @@ describe("mail check — outlook provider", () => {
         const sources = quietSources({
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:00:00Z" }),
         });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
     });
     it("orders by instant, not lexically, so a fractional second is not read as older", async () => {
         seedWatermarks({ mailOutlook: { [KEY]: { receivedAt: "2026-08-10T09:00:00Z" } } });
@@ -991,17 +1088,13 @@ describe("mail check — outlook provider", () => {
             // Lexically "…00.500Z" sorts BELOW "…00Z" ('.' is 0x2E, 'Z' is 0x5A).
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:00:00.500Z" }),
         });
-        expect(await run([CHECK], sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(await run([CHECK], sources)).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
     });
-    it("reports an empty folder as skipped on a commit rather than advancing onto nothing", async () => {
+    it("records no position for an empty folder rather than advancing onto nothing", async () => {
         const sources = quietSources({ mailOutlook: async () => ({ newestReceivedAt: null }) });
-        expect(await run([CHECK], sources, true)).toEqual({
-            hasWork: false,
-            reasons: [],
-            errored: [],
-            advanced: [],
-            skipped: ["mail"],
-        });
+        const gate = await run([CHECK], sources);
+        expect(gate).toEqual({ hasWork: false, reasons: [], errored: [], observed: {} });
+        expect(advanceGateMark(EVENT, platformRoot, gate.observed).advanced).toEqual([]);
     });
     it("keys the folder segment lower-cased, so two spellings address one entry", async () => {
         seedWatermarks({ mailOutlook: { [KEY]: { receivedAt: "2026-08-10T09:00:00Z" } } });
@@ -1009,7 +1102,7 @@ describe("mail check — outlook provider", () => {
         const sources = quietSources({
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:00:00Z" }),
         });
-        expect(await run([check], sources)).toEqual({ hasWork: false, reasons: [], errored: [] });
+        expect(await run([check], sources)).toMatchObject({ hasWork: false, reasons: [], errored: [] });
     });
     it("counts a probe that throws as work, and never as quiet", async () => {
         const sources = quietSources({
@@ -1017,7 +1110,7 @@ describe("mail check — outlook provider", () => {
                 throw new Error("No Outlook mailbox admin@muvin.co.uk is connected");
             },
         });
-        expect(await run([CHECK], sources)).toEqual({
+        expect(await run([CHECK], sources)).toMatchObject({
             hasWork: true,
             reasons: ["mail"],
             errored: [{ kind: "mail", detail: "No Outlook mailbox admin@muvin.co.uk is connected" }],
@@ -1025,7 +1118,7 @@ describe("mail check — outlook provider", () => {
     });
     it("throws on a provider outside the accepted list", async () => {
         const check = { type: "mail", mailbox: "a@b.com", provider: "pop3" };
-        expect(await run([check], quietSources())).toEqual({
+        expect(await run([check], quietSources())).toMatchObject({
             hasWork: true,
             reasons: ["mail"],
             errored: [{ kind: "mail", detail: 'unknown mail provider "pop3" — accepted: imap, outlook' }],
@@ -1036,9 +1129,9 @@ describe("mail check — outlook provider", () => {
         const sources = quietSources({
             mailOutlook: async () => ({ newestReceivedAt: "2026-08-10T09:00:00Z" }),
         });
-        // Task 2654 — the gate call records the position the commit promotes.
-        await run([CHECK], sources);
-        await run([CHECK], sources, true);
+        // Task 2663 — the gate call records the position the advance promotes.
+        const gate = await run([CHECK], sources);
+        advanceGateMark(EVENT, platformRoot, gate.observed);
         const written = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(written.mail[KEY]).toEqual({ uid: 42, uidValidity: 7 });
         expect(written.mailOutlook[KEY]).toEqual({ receivedAt: "2026-08-10T09:00:00Z" });
@@ -1056,18 +1149,21 @@ describe("mail check — outlook provider", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// Task 2654 — a source that moves between the gate call and the commit.
+// Task 2654, kept under Task 2663 — a source that moves between the gate call
+// and the advance.
 //
-// The commit runs at the END of the agent turn, so its own probe already
-// includes whatever arrived while the turn ran. Writing that position puts the
-// arrival BELOW the watermark and no later fire reports it. The commit writes
-// what the GATE read instead, so the mover stays above.
+// The advance happens after the wake was accepted, by which time the source may
+// have moved again. Writing what the source holds THEN would put the arrival
+// below the mark and no later fire would report it. The dispatcher writes what
+// the GATE returned instead, so the mover stays above. Under 2654 that guarantee
+// depended on a sidecar file being fresh; it is now structural, because the
+// positions travel with the result.
 //
-// Each check is driven alone, and each test runs the real sequence: gate,
-// source moves, commit, gate again.
+// Each check is driven alone, and each test runs the real sequence: gate, source
+// moves, advance, gate again.
 // ---------------------------------------------------------------------------
-describe("a source that moves between the gate call and the commit", () => {
-    it("mail: a UID that arrives mid-turn is still reported after the commit", async () => {
+describe("a source that moves between the gate call and the advance", () => {
+    it("mail: a UID that arrives mid-turn is still reported after the advance", async () => {
         let highest = 105;
         const sources = quietSources({
             mail: async (_c, sinceUid) => ({
@@ -1077,14 +1173,15 @@ describe("a source that moves between the gate call and the commit", () => {
             }),
         });
         const checks = [{ type: "mail", mailbox: "ops@example.com" }];
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        const gate = await run(checks, sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["mail"], errored: [] });
         highest = 106; // arrives while the turn runs
-        await run(checks, sources, true);
+        advanceGateMark(EVENT, platformRoot, gate.observed);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(marks.mail["ops@example.com|inbox"].uid).toBe(105);
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["mail"], errored: [] });
+        expect(await run(checks, sources)).toMatchObject({ hasWork: true, reasons: ["mail"] });
     });
-    it("whatsapp: an inbound message mid-turn is still reported after the commit", async () => {
+    it("whatsapp: an inbound message mid-turn is still reported after the advance", async () => {
         let latest = 1_754_000_100;
         const sources = quietSources({
             whatsappInbound: async (_a, since) => ({
@@ -1093,86 +1190,96 @@ describe("a source that moves between the gate call and the commit", () => {
             }),
         });
         const checks = [{ type: "whatsapp", scope: "inbound" }];
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["whatsapp"], errored: [] });
+        const gate = await run(checks, sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["whatsapp"], errored: [] });
         latest = 1_754_000_200;
-        await run(checks, sources, true);
+        advanceGateMark(EVENT, platformRoot, gate.observed);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(marks.whatsapp.inbound).toBe(1_754_000_100);
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["whatsapp"], errored: [] });
+        expect(await run(checks, sources)).toMatchObject({ hasWork: true, reasons: ["whatsapp"] });
     });
-    it("telegram: an inbound message mid-turn is still reported after the commit", async () => {
+    it("telegram: an inbound message mid-turn is still reported after the advance", async () => {
         let newest = "2026-08-10T10:00:00.000Z";
         const sources = quietSources({ telegramInbound: async () => ({ newestInboundAt: newest }) });
         const checks = [{ type: "telegram", scope: "inbound" }];
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["telegram"], errored: [] });
+        const gate = await run(checks, sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["telegram"], errored: [] });
         newest = "2026-08-10T10:30:00.000Z";
-        await run(checks, sources, true);
+        advanceGateMark(EVENT, platformRoot, gate.observed);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(marks.telegram.inbound).toBe("2026-08-10T10:00:00.000Z");
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["telegram"], errored: [] });
+        expect(await run(checks, sources)).toMatchObject({ hasWork: true, reasons: ["telegram"] });
     });
-    it("calendar: a connector change mid-turn is still reported after the commit", async () => {
+    it("calendar: a connector change mid-turn is still reported after the advance", async () => {
         let digest = "DIGEST-A";
         const sources = quietSources({ calendarDigest: async () => digest });
         const checks = [{ type: "calendar", connector: "google" }];
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
+        const gate = await run(checks, sources);
+        expect(gate).toMatchObject({ hasWork: true, reasons: ["calendar"], errored: [] });
         digest = "DIGEST-B";
-        await run(checks, sources, true);
+        advanceGateMark(EVENT, platformRoot, gate.observed);
         const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
         expect(marks.calendar.digest).toBe("DIGEST-A");
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
-    });
-    // Task 2654 — the no-event case. A message swallowed in production emitted
-    // nothing at all, and re-running the gate reproduced nothing, so the pair below
-    // is the only way to see a watermark that jumped past an unseen window.
-    describe("gate-read and commit positions pair on one fire", () => {
+        expect(await run(checks, sources)).toMatchObject({ hasWork: true, reasons: ["calendar"] });
+    });
+    // Task 2663 — the no-event case. The gate that could never go quiet emitted a
+    // line on every fire that looked exactly like a healthy one, because it named
+    // only what the probe had just read and never the value it was compared
+    // against. Both sides now print, so a mark stuck on an empty slot is legible
+    // from one line without reproducing anything.
+    describe("gate-read names both sides of the comparison", () => {
         // `console.error` is already spied in `beforeEach`, so its recorded calls are
         // the log. Re-mocking it here would drop the lines written before this point.
         const errorLines = () => vi.mocked(console.error).mock.calls.map((c) => c.map(String).join(" "));
-        it("names the position read at gate time and the position written at commit time", async () => {
+        it("names null stored on a first fire, and the observed position beside it", async () => {
+            const sources = quietSources({ calendarDigest: async () => "abcdef0123456789" });
+            await run([{ type: "calendar", connector: "google" }], sources);
+            expect(errorLines()).toContainEqual(expect.stringContaining("op=gate-read eventId=65ef758c check=calendar stored=null observed=abcdef01"));
+        });
+        it("names the stored position once the mark has advanced", async () => {
             const sources = quietSources({ calendarDigest: async () => "abcdef0123456789" });
             const checks = [{ type: "calendar", connector: "google" }];
+            const gate = await run(checks, sources);
+            advanceGateMark(EVENT, platformRoot, gate.observed);
             await run(checks, sources);
-            await run(checks, sources, true);
-            expect(errorLines()).toContainEqual(expect.stringContaining("op=gate-read eventId=65ef758c check=calendar position=abcdef01"));
-            expect(errorLines()).toContainEqual(expect.stringContaining("positions=calendar:abcdef01"));
-        });
-        it("names an unreadable observation, which otherwise reads as a first commit", async () => {
-            // A present-but-unusable file stops every watermark advancing while
-            // `op=commit` still prints an empty `advanced=` — indistinguishable from a
-            // healthy first commit without a line of its own.
-            const sources = quietSources({ calendarDigest: async () => "DIGEST-Z" });
-            const checks = [{ type: "calendar", connector: "google" }];
-            await run(checks, sources);
-            writeFileSync(observationPath(EVENT, platformRoot), "{ not json");
-            const result = await run(checks, sources, true);
-            expect(result.advanced).toEqual([]);
-            expect(errorLines()).toContainEqual(expect.stringContaining("op=observation-unreadable eventId=65ef758c reason="));
-        });
-        it("says nothing when no observation file exists, which is a first fire", async () => {
-            const sources = quietSources({ calendarDigest: async () => "DIGEST-Z" });
-            await run([{ type: "calendar", connector: "google" }], sources, true);
-            expect(errorLines().filter((l) => l.includes("op=observation-unreadable"))).toEqual([]);
+            expect(errorLines()).toContainEqual(expect.stringContaining("op=gate-read eventId=65ef758c check=calendar stored=abcdef01 observed=abcdef01"));
         });
         it("emits no gate-read for a check that holds no position", async () => {
-            // `op=check-error` and `skipped=` already cover a check with no position;
-            // a `position=null` line would only add a value nobody can compare.
+            // `op=check-error` already covers a check with no position; a line of two
+            // nulls would only add a value nobody can compare.
             await run([{ type: "d1", database: "b", sql: "SELECT count(*) FROM b" }], quietSources());
             expect(errorLines().filter((l) => l.includes("op=gate-read"))).toEqual([]);
         });
     });
-    it("a commit with no gate call before it advances nothing", async () => {
-        // Route two (PLUGIN.md) lets a separate action event issue the commit. With
-        // no observation on file there is no position anyone saw, so the watermark
-        // stays put and the next fire reports the work again — the fail-open
-        // direction the whole tool holds to.
-        const sources = quietSources({ calendarDigest: async () => "DIGEST-Z" });
-        const checks = [{ type: "calendar", connector: "google" }];
-        const result = await run(checks, sources, true);
-        expect(result.advanced).toEqual([]);
-        const marks = JSON.parse(readFileSync(watermarkPath(EVENT, platformRoot), "utf-8"));
-        expect(marks.calendar).toBeUndefined();
-        expect(await run(checks, sources)).toEqual({ hasWork: true, reasons: ["calendar"], errored: [] });
+});
+// Task 2663 — the gate hands its readings back to the dispatcher and touches no
+// sidecar. The commit and the `<eventId>.observed.json` file it promoted from
+// are both gone: a sidecar survives a gate call that errored, so the stale
+// positions from an earlier fire would be promoted on the next accepted wake and
+// mark as seen messages nobody read.
+describe("observed positions (Task 2663)", () => {
+    it("returns the positions it read, and writes no sidecar", async () => {
+        const result = await run([{ type: "telegram", scope: "inbound", botId: "555" }], quietSources({ telegramInbound: async () => ({ newestInboundAt: "2026-08-10T18:00:00.000Z" }) }));
+        expect(result.observed).toEqual({ telegram: { byBot: { "555": "2026-08-10T18:00:00.000Z" } } });
+        expect(existsSync(join(platformRoot, "..", "state", "scheduling-gate", `${EVENT}.observed.json`))).toBe(false);
+    });
+    it("reports no position for a check that holds none", async () => {
+        // `d1` reads a current value rather than a position in a stream, so there is
+        // nothing for the dispatcher to promote and `observed` is empty rather than
+        // carrying a fabricated key.
+        const result = await run([{ type: "d1", database: "b", sql: "SELECT 1" }], quietSources({ d1: async () => 1 }));
+        expect(result.observed).toEqual({});
+    });
+    it("reports no position for a check that threw", async () => {
+        // A check that errored knows nothing about its source. Recording a position
+        // for it would let the dispatcher advance past work the gate never saw.
+        const result = await run([{ type: "telegram", scope: "inbound", botId: "555" }], quietSources({
+            telegramInbound: async () => {
+                throw new Error("fetch failed");
+            },
+        }));
+        expect(result.hasWork).toBe(true);
+        expect(result.observed).toEqual({});
     });
 });
 //# sourceMappingURL=scheduling-gate.test.js.map