@rubytech/create-maxy-code 0.1.590 → 0.1.592

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

@@ -13,13 +13,6 @@ const runCalls = [];
 const writeCalls = [];
 /** What the pre-read reports the stored row holds; per-test. */
 let storedRow = {};
-/** Task 2634 — what the commit-action read finds on the account; per-test. The
- *  two reads share one mocked session, so they are told apart by the only thing
- *  that distinguishes them at the driver: the query text. */
-let commitActionRows = [];
-function isCommitActionRead(query) {
-    return query.includes("actionTool: 'scheduling-gate'");
-}
 vi.mock("../../lib/embedding.js", () => ({
     computeEmbedding: vi.fn(async () => []),
 }));
@@ -27,13 +20,6 @@ vi.mock("../../lib/neo4j.js", () => ({
     getSession: () => ({
         run: vi.fn(async (query, params) => {
             runCalls.push({ query, params });
-            if (isCommitActionRead(query)) {
-                return {
-                    records: commitActionRows.map((row) => ({
-                        get: (k) => row[k] ?? null,
-                    })),
-                };
-            }
             return {
                 records: [
                     {
@@ -50,9 +36,35 @@ vi.mock("../../../../../../lib/graph-write/dist/index.js", () => ({
         writeCalls.push(props);
     }),
 }));
+/** Task 2658 — what the bind-time probe reports, per-test. The real prober is
+ *  covered by `scheduling-gate.test.ts`; this file owns the GUARD, so the probe
+ *  is stubbed and its call arguments are asserted instead. Without the stub the
+ *  pre-existing `mail`-gate tests below would open a live IMAP connection.
+ *
+ *  `gateHasWork` is a SEPARATE knob from `gateErrored` on purpose. Deriving one
+ *  from the other would make "the sources answered, work pending" and "the
+ *  sources answered, nothing pending" the same fixture, and a guard that
+ *  wrongly keys on `hasWork` would pass both. */
+let gateErrored = [];
+let gateHasWork = false;
+const gateRunCalls = [];
+vi.mock("../scheduling-gate.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        runSchedulingGate: vi.fn(async (params) => {
+            gateRunCalls.push(params);
+            return {
+                hasWork: gateHasWork || gateErrored.length > 0,
+                reasons: gateHasWork ? ["d1"] : [],
+                errored: gateErrored,
+            };
+        }),
+    };
+});
 import { scheduleUpdate } from "../schedule-update.js";
 import { scheduleEvent } from "../schedule-event.js";
-import { validateGate, hasCommitAction } from "../schedule-event.js";
+import { validateGate, probeGateAtBindTime, assertGateProbed } from "../schedule-event.js";
 const ACCOUNT_ID = "11111111-1111-4111-8111-111111111111";
 const PHONE = "+447700900001";
 const GATE = { plugin: "scheduling", tool: "scheduling-gate", args: { eventId: "e1", checks: [] } };
@@ -70,7 +82,9 @@ beforeEach(() => {
     runCalls.length = 0;
     writeCalls.length = 0;
     storedRow = {};
-    commitActionRows = [];
+    gateErrored = [];
+    gateHasWork = false;
+    gateRunCalls.length = 0;
     const root = mkdtempSync(join(tmpdir(), "sched-gate-write-"));
     platformRoot = join(root, "platform");
     mkdirSync(platformRoot, { recursive: true });
@@ -85,17 +99,17 @@ afterEach(() => {
 });
 describe("validateGate", () => {
     it("accepts a gate on a complete agent dispatch", () => {
-        expect(() => validateGate(GATE, { hasAction: false, hasCompleteAgentDispatch: true, resultingPrompt: null, eventId: null, hasCommitAction: false })).not.toThrow();
+        expect(() => validateGate(GATE, { hasAction: false, hasCompleteAgentDispatch: true, eventId: null })).not.toThrow();
     });
     it("refuses a gate on an action-mode event", () => {
-        expect(() => validateGate(GATE, { hasAction: true, hasCompleteAgentDispatch: false, resultingPrompt: null, eventId: null, hasCommitAction: false })).toThrow(/action already runs headlessly/);
+        expect(() => validateGate(GATE, { hasAction: true, hasCompleteAgentDispatch: false, eventId: null })).toThrow(/action already runs headlessly/);
     });
     it("refuses a gate with no complete agent dispatch", () => {
-        expect(() => validateGate(GATE, { hasAction: false, hasCompleteAgentDispatch: false, resultingPrompt: null, eventId: null, hasCommitAction: false })).toThrow(/requires a complete agentDispatch/);
+        expect(() => validateGate(GATE, { hasAction: false, hasCompleteAgentDispatch: false, eventId: null })).toThrow(/requires a complete agentDispatch/);
     });
     it("refuses a gate missing plugin or tool", () => {
-        expect(() => validateGate({ plugin: "", tool: "t" }, { hasAction: false, hasCompleteAgentDispatch: true, resultingPrompt: null, eventId: null, hasCommitAction: false })).toThrow(/both 'plugin' and 'tool'/);
-        expect(() => validateGate({ plugin: "p", tool: "" }, { hasAction: false, hasCompleteAgentDispatch: true, resultingPrompt: null, eventId: null, hasCommitAction: false })).toThrow(/both 'plugin' and 'tool'/);
+        expect(() => validateGate({ plugin: "", tool: "t" }, { hasAction: false, hasCompleteAgentDispatch: true, eventId: null })).toThrow(/both 'plugin' and 'tool'/);
+        expect(() => validateGate({ plugin: "p", tool: "" }, { hasAction: false, hasCompleteAgentDispatch: true, eventId: null })).toThrow(/both 'plugin' and 'tool'/);
     });
 });
 describe("scheduleEvent — gate", () => {
@@ -277,235 +291,10 @@ const UNWATERMARKED_GATE = {
         ],
     },
 };
-// Task 2634 — the seed substitutes `<<gateCommit>>` out of the prompt before it
-// is stored (`routine-templates/src/index.ts`), so a shipped routine's stored
-// prompt carries the expanded argument and never the token. Both spellings are
-// the same route and both are tested: accepting only the token would refuse
-// every seeded routine on its next gate edit.
-const TOKEN_PROMPT = "sweep, then call scheduling-gate with <<gateCommit>>";
-const COMMIT_PROMPT = 'sweep, then call scheduling-gate with {"eventId":"e1","checks":[{"type":"mail","mailbox":"ops@example.com"}],"commit":true}';
-/** The live shape Task 2634 was filed on: names the tool, forbids the call. */
-const FORBIDS_COMMIT_PROMPT = "sweep. Do NOT call scheduling-gate yourself. A separate routine advances the watermark.";
-/** A scheduled action event that commits this row's watermark with no model. */
-function commitActionRow(over = {}) {
-    return {
-        eventStatus: "scheduled",
-        actionPlugin: "scheduling",
-        actionTool: "scheduling-gate",
-        actionArgs: JSON.stringify({
-            eventId: "e1",
-            checks: [{ type: "mail", mailbox: "ops@example.com" }],
-            commit: true,
-        }),
-        ...over,
-    };
-}
-describe("commitless watermarked gate", () => {
-    it("is refused on update when the resulting prompt has no commit step", async () => {
-        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
-        await expect(scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE })).rejects.toThrow(/scheduling-gate/);
-        expect(writeCalls).toHaveLength(0);
-        expect(lastSet()?.query ?? "").not.toContain("e.gatePlugin");
-    });
-    it("is accepted on update when the stored prompt carries the commit step", async () => {
-        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: COMMIT_PROMPT };
-        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE });
-        expect(lastSet().query).toContain("e.gatePlugin");
-    });
-    it("reads the SUPPLIED prompt over the stored one", async () => {
-        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
-        await scheduleUpdate({
-            accountId: ACCOUNT_ID,
-            eventId: "e1",
-            gate: MAIL_GATE,
-            agentDispatch: { channel: "whatsapp", destination: PHONE, prompt: COMMIT_PROMPT },
-        });
-        expect(lastSet().query).toContain("e.gatePlugin");
-    });
-    it("accepts an unwatermarked gate against a prompt with no commit step", async () => {
-        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
-        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: UNWATERMARKED_GATE });
-        expect(lastSet().query).toContain("e.gatePlugin");
-    });
-    it("is refused on create too, because both paths share validateGate", () => {
-        expect(() => validateGate(MAIL_GATE, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: "sweep",
-            eventId: null,
-            hasCommitAction: false,
-        })).toThrow(/scheduling-gate/);
-        expect(() => validateGate(MAIL_GATE, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: COMMIT_PROMPT,
-            eventId: null,
-            hasCommitAction: false,
-        })).not.toThrow();
-    });
-    // The watermark file is a `scheduling-gate` concept, so the reason this
-    // refusal exists does not apply to a different tool's arguments.
-    it("does not refuse a gate belonging to another tool", () => {
-        expect(() => validateGate({ plugin: "other", tool: "other-gate", args: { checks: [{ type: "mail", mailbox: "m" }] } }, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: "sweep",
-            eventId: null,
-            hasCommitAction: false,
-        })).not.toThrow();
-    });
-});
-// ---------------------------------------------------------------------------
-// Task 2634 — the guard above was a substring test on the prompt, so a prompt
-// reading "Do NOT call scheduling-gate yourself" satisfied a guard that exists
-// to prove the prompt calls it. Two routes replace it, and the refusal names
-// both: the prompt carries the commit argument, or a scheduled action-mode
-// event commits this row's watermark with no model in the path.
-// ---------------------------------------------------------------------------
-describe("commit route — prompt (route 1)", () => {
-    function check(prompt, over = {}) {
-        return () => validateGate(MAIL_GATE, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: prompt,
-            eventId: "e1",
-            hasCommitAction: false,
-            ...over,
-        });
-    }
-    it("refuses a prompt that names the tool only to forbid the call", () => {
-        expect(check(FORBIDS_COMMIT_PROMPT)).toThrow(/scheduling-gate/);
-    });
-    it("names both routes in the refusal", () => {
-        expect(check(FORBIDS_COMMIT_PROMPT)).toThrow(/"commit":true/);
-        expect(check(FORBIDS_COMMIT_PROMPT)).toThrow(/action-mode event/);
-    });
-    it("accepts the unexpanded roster token", () => {
-        expect(check(TOKEN_PROMPT)).not.toThrow();
-    });
-    it("accepts the seeded prompt, whose token the seed already expanded", () => {
-        expect(check(COMMIT_PROMPT)).not.toThrow();
-    });
-    it("accepts the commit argument written with a space after the key", () => {
-        expect(check('call scheduling-gate with {"eventId":"e1", "commit": true}')).not.toThrow();
-    });
-    it("refuses prose that says commit without carrying the argument", () => {
-        expect(check("sweep, then commit the watermark with scheduling-gate")).toThrow(/scheduling-gate/);
-    });
-    it("leaves an unwatermarked gate alone whatever the prompt says", () => {
-        expect(() => validateGate(UNWATERMARKED_GATE, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: FORBIDS_COMMIT_PROMPT,
-            eventId: "e1",
-            hasCommitAction: false,
-        })).not.toThrow();
-    });
-});
-describe("commit route — bound action event (route 2)", () => {
-    it("accepts a watermarked gate whose commit is a separate action event", () => {
-        expect(() => validateGate(MAIL_GATE, {
-            hasAction: false,
-            hasCompleteAgentDispatch: true,
-            resultingPrompt: FORBIDS_COMMIT_PROMPT,
-            eventId: "e1",
-            hasCommitAction: true,
-        })).not.toThrow();
-    });
-    describe("hasCommitAction", () => {
-        it("matches a scheduled scheduling-gate action naming this event with commit true", () => {
-            expect(hasCommitAction([commitActionRow()], "e1")).toBe(true);
-        });
-        it("rejects commit false", () => {
-            const args = JSON.parse(commitActionRow().actionArgs);
-            args.commit = false;
-            expect(hasCommitAction([commitActionRow({ actionArgs: JSON.stringify(args) })], "e1")).toBe(false);
-        });
-        it("rejects a different eventId", () => {
-            expect(hasCommitAction([commitActionRow()], "e2")).toBe(false);
-        });
-        it("rejects a row whose eventStatus is not scheduled", () => {
-            expect(hasCommitAction([commitActionRow({ eventStatus: "suspended" })], "e1")).toBe(false);
-            expect(hasCommitAction([commitActionRow({ eventStatus: "cancelled" })], "e1")).toBe(false);
-        });
-        it("rejects a row bound to another tool", () => {
-            expect(hasCommitAction([commitActionRow({ actionTool: "schedule-list" })], "e1")).toBe(false);
-            expect(hasCommitAction([commitActionRow({ actionPlugin: "work" })], "e1")).toBe(false);
-        });
-        // A row whose args do not parse is a non-match, not a throw: the validator's
-        // job is to refuse cleanly, and one malformed row must not take down the
-        // write path for every other row on the account.
-        it("treats unparseable or absent args as a non-match", () => {
-            expect(hasCommitAction([commitActionRow({ actionArgs: "{not json" })], "e1")).toBe(false);
-            expect(hasCommitAction([commitActionRow({ actionArgs: null })], "e1")).toBe(false);
-            expect(hasCommitAction([commitActionRow({ actionArgs: "[1,2]" })], "e1")).toBe(false);
-        });
-        // At create time the id is minted after the validator runs, so there is no
-        // id for an action event to have named. Route 2 is unreachable on that path
-        // by construction, and a null id must never match a row.
-        it("never matches when the row has no id yet", () => {
-            expect(hasCommitAction([commitActionRow()], null)).toBe(false);
-        });
-        it("is false on an empty account", () => {
-            expect(hasCommitAction([], "e1")).toBe(false);
-        });
-        // The row Task 2634 was filed on, read from laptop 192.168.88.10 SiteDesk
-        // account 5e99bba5 on 2026-08-09. Verbatim, because the stub above chose its
-        // own key order and the live writer chose a different one: this is the only
-        // assertion that the shape the fleet actually stores parses the same way.
-        // Its routine's prompt carries neither spelling of the commit argument
-        // (measured: `agentPrompt CONTAINS '"commit":true'` and `CONTAINS
-        // '<<gateCommit>>'` are both FALSE, while the old substring test's
-        // `CONTAINS 'scheduling-gate'` is TRUE), so route 2 alone is what keeps it
-        // valid on its next edit.
-        it("matches the live SiteDesk commit action verbatim", () => {
-            const live = {
-                eventStatus: "scheduled",
-                actionPlugin: "scheduling",
-                actionTool: "scheduling-gate",
-                actionArgs: '{"eventId":"14414285-8549-4ce1-907d-0d9cadd370ee","commit":true,"checks":[{"type":"mail","mailbox":"hello@beagle.direct","folder":"inbox"},{"type":"mail","mailbox":"operations@sitedesk.online","folder":"inbox"}]}',
-            };
-            expect(hasCommitAction([live], "14414285-8549-4ce1-907d-0d9cadd370ee")).toBe(true);
-            expect(hasCommitAction([live], "ae361343-2d85-426d-8eb3-fde621c8cce0")).toBe(false);
-        });
-    });
-});
-describe("scheduleUpdate — commit routes end to end", () => {
-    beforeEach(() => {
-        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: FORBIDS_COMMIT_PROMPT };
-    });
-    it("refuses when neither route is taken", async () => {
-        await expect(scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE })).rejects.toThrow(/scheduling-gate/);
-        expect(lastSet()?.query ?? "").not.toContain("e.gatePlugin");
-    });
-    it("accepts when a bound action event commits the watermark", async () => {
-        commitActionRows = [commitActionRow()];
-        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE });
-        expect(lastSet().query).toContain("e.gatePlugin");
-    });
-    it("refuses when the bound action event commits nothing", async () => {
-        const args = JSON.parse(commitActionRow().actionArgs);
-        args.commit = false;
-        commitActionRows = [commitActionRow({ actionArgs: JSON.stringify(args) })];
-        await expect(scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE })).rejects.toThrow(/scheduling-gate/);
-    });
-    it("scopes the commit-action read to the calling account", async () => {
-        commitActionRows = [commitActionRow()];
-        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: MAIL_GATE });
-        const read = runCalls.find((c) => isCommitActionRead(c.query));
-        expect(read?.params.accountId).toBe(ACCOUNT_ID);
-    });
-    // The read costs a round trip, so it runs only for the gates that have a
-    // commit route to look for.
-    it("does not read commit actions for an unwatermarked gate", async () => {
-        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: UNWATERMARKED_GATE });
-        expect(runCalls.some((c) => isCommitActionRead(c.query))).toBe(false);
-    });
-});
-// A guard that refuses silently is indistinguishable from one that never ran,
-// and an acceptance that does not name its route is indistinguishable from a
-// skipped guard. Both lines carry the check types, so a refusal can be read
-// without going back to the row.
+// Task 2663 — the three prompt fixtures are gone with the guard that read them.
+// A prompt is no longer any part of whether a gate is accepted: the platform
+// advances the mark on every accepted wake, so there is nothing for a prompt to
+// arrange and nothing to inspect it for.
 describe("gate decision evidence", () => {
     let lines;
     beforeEach(() => {
@@ -519,9 +308,7 @@ describe("gate decision evidence", () => {
             validateGate(MAIL_GATE, {
                 hasAction: false,
                 hasCompleteAgentDispatch: true,
-                resultingPrompt: FORBIDS_COMMIT_PROMPT,
                 eventId: "e1",
-                hasCommitAction: false,
                 ...over,
             });
         }
@@ -530,30 +317,18 @@ describe("gate decision evidence", () => {
         }
         return lines.filter((l) => l.includes("op=gate-"));
     }
-    it("emits one refusal line naming the reason and the checks", () => {
-        expect(decide({})).toEqual(["[schedule-authoring] op=gate-refused eventId=e1 reason=no-commit-route checks=mail"]);
-    });
-    it("emits route=token when the prompt carries the commit", () => {
-        expect(decide({ resultingPrompt: COMMIT_PROMPT })).toEqual([
-            "[schedule-authoring] op=gate-accepted eventId=e1 route=token checks=mail",
-        ]);
-    });
-    it("emits route=action-event when a bound action carries it", () => {
-        expect(decide({ hasCommitAction: true })).toEqual([
-            "[schedule-authoring] op=gate-accepted eventId=e1 route=action-event checks=mail",
-        ]);
-    });
-    it("carries a dash for the id the create path has not minted yet", () => {
-        expect(decide({ eventId: null })[0]).toContain("eventId=-");
+    it("emits no decision line for a watermarked gate, which needs no arrangement (Task 2663)", () => {
+        // The refusal this block was written for is deleted: the platform advances
+        // the mark on every accepted wake, so a watermarked check is no longer a
+        // reason to refuse a write and there is no route to name.
+        expect(decide({})).toEqual([]);
     });
     it("says nothing for a gate with no commit route to take", () => {
         lines = [];
         validateGate(UNWATERMARKED_GATE, {
             hasAction: false,
             hasCompleteAgentDispatch: true,
-            resultingPrompt: "sweep",
             eventId: "e1",
-            hasCommitAction: false,
         });
         expect(lines.filter((l) => l.includes("op=gate-"))).toEqual([]);
     });
@@ -576,9 +351,7 @@ const gateWith = (checks) => ({
 const ctx = (over = {}) => ({
     hasAction: false,
     hasCompleteAgentDispatch: true,
-    resultingPrompt: COMMIT_PROMPT,
     eventId: "e1",
-    hasCommitAction: false,
     ...over,
 });
 describe("unknown gate check type", () => {
@@ -613,11 +386,12 @@ describe("unknown gate check type", () => {
     it("accepts a telegram check", () => {
         expect(() => validateGate(gateWith([{ type: "telegram", scope: "inbound" }]), ctx())).not.toThrow();
     });
-    it("treats a telegram check as watermarked, so a commitless one is refused", () => {
-        // It compares against a stored position exactly as mail and calendar do, so
-        // without a commit it reports work on every fire and saves nothing.
+    it("accepts a telegram check with no commit arrangement (Task 2663)", () => {
+        // It compares against a stored position exactly as mail and calendar do, and
+        // the dispatcher advances that position itself now, so nothing about the
+        // prompt is any longer a reason to refuse the write.
         const gate = gateWith([{ type: "telegram", scope: "inbound" }]);
-        expect(() => validateGate(gate, ctx({ resultingPrompt: "sweep" }))).toThrow(/scheduling-gate/);
+        expect(() => validateGate(gate, ctx())).not.toThrow();
     });
     it("leaves a gate on another plugin's tool alone", () => {
         // The accepted set is this tool's own vocabulary. A gate pointing at some
@@ -626,4 +400,294 @@ describe("unknown gate check type", () => {
         expect(() => validateGate(foreign, ctx())).not.toThrow();
     });
 });
+// Task 2657 — a mail provider the prober cannot answer, refused at write time.
+//
+// Same reasoning as the unknown check type above: stored, it throws on every
+// fire, the dispatcher fails OPEN, and the routine spends a full model turn
+// while every surface reads "gated".
+describe("unknown mail provider", () => {
+    let refusalLines;
+    beforeEach(() => {
+        refusalLines = [];
+        vi.spyOn(console, "error").mockImplementation((line) => {
+            refusalLines.push(String(line));
+        });
+    });
+    const mailGate = (provider) => gateWith([
+        provider === undefined
+            ? { type: "mail", mailbox: "a@b.com" }
+            : { type: "mail", mailbox: "a@b.com", provider },
+    ]);
+    it("refuses a provider outside the accepted list", () => {
+        expect(() => validateGate(mailGate("pop3"), ctx())).toThrow(/provider not recognised/i);
+    });
+    it("names the provider and the accepted set on the refusal line", () => {
+        expect(() => validateGate(mailGate("pop3"), ctx())).toThrow();
+        const line = refusalLines.find((l) => l.includes("reason=unknown-mail-provider"));
+        expect(line).toContain("providers=pop3");
+    });
+    it("accepts outlook", () => {
+        expect(() => validateGate(mailGate("outlook"), ctx())).not.toThrow();
+    });
+    it("accepts imap named explicitly", () => {
+        expect(() => validateGate(mailGate("imap"), ctx())).not.toThrow();
+    });
+    it("accepts a mail check carrying no provider at all", () => {
+        expect(() => validateGate(mailGate(), ctx())).not.toThrow();
+    });
+    it("refuses a provider on a check that is not mail", () => {
+        // Task 2662 REVERSES Task 2657's decision here, deliberately.
+        //
+        // 2657 allowed a stray `provider` on a non-mail check, reasoning that it is
+        // the mail check's own field and refusing it "would reject a valid gate". A
+        // gate carrying a field nothing reads is not valid, it is misleading: that
+        // is the exact defect an operator reported against 0.1.590, having passed a
+        // `botId` to a telegram check and watched it report work with the field
+        // discarded. `provider` on a d1 check is the same class.
+        const gate = gateWith([{ type: "d1", database: "b", sql: "SELECT 1", provider: "pop3" }]);
+        expect(() => validateGate(gate, ctx())).toThrow(/provider/);
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 2662 — a field the prober never reads.
+//
+// `validateGate` judged the check's `type`, its `provider` and the commit route,
+// and nothing else. `checks` is `z.array(z.record(z.unknown()))`, so every other
+// key passed and was dropped on the floor. The operator reproduced it twice: a
+// real bot id on a telegram check reported work, then `0000000000` reported work,
+// because neither reached anything that read them.
+// ---------------------------------------------------------------------------
+describe("unknown gate check field", () => {
+    let fieldLines;
+    beforeEach(() => {
+        fieldLines = [];
+        vi.spyOn(console, "error").mockImplementation((line) => {
+            fieldLines.push(String(line));
+        });
+    });
+    it("is refused, naming the field and the keys that type accepts", () => {
+        const gate = gateWith([{ type: "telegram", scope: "inbound", nonsense: 1 }]);
+        expect(() => validateGate(gate, ctx())).toThrow(/nonsense/);
+        expect(() => validateGate(gate, ctx())).toThrow(/type.*scope.*botId/);
+    });
+    it("logs op=gate-refused so the refusal is greppable", () => {
+        try {
+            validateGate(gateWith([{ type: "telegram", scope: "inbound", nonsense: 1 }]), ctx());
+        }
+        catch {
+            /* asserted above */
+        }
+        const line = fieldLines.find((l) => l.includes("op=gate-refused"));
+        expect(line).toContain("reason=unknown-check-field");
+        expect(line).toContain("telegram:nonsense");
+    });
+    it("accepts botId on a telegram check", () => {
+        const gate = gateWith([{ type: "telegram", scope: "inbound", botId: "111" }]);
+        expect(() => validateGate(gate, ctx())).not.toThrow();
+    });
+    it("refuses a telegram scope other than inbound", () => {
+        // `scope` was decorative: probe()'s telegram arm never read it, so any
+        // value passed and behaved as `inbound`.
+        const gate = gateWith([{ type: "telegram", scope: "status" }]);
+        expect(() => validateGate(gate, ctx())).toThrow(/scope/);
+    });
+    it("still accepts every shape the four other checks legitimately carry", () => {
+        const gate = gateWith([
+            { type: "mail", mailbox: "ops@example.com", folder: "INBOX", subjectPrefixes: ["RE:"] },
+            { type: "mail", mailbox: "ops@example.com", provider: "outlook" },
+            { type: "d1", database: "b", sql: "SELECT count(*) FROM b" },
+            { type: "whatsapp", scope: "status" },
+            { type: "calendar", connector: "google" },
+        ]);
+        expect(() => validateGate(gate, ctx())).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 2658 — the four refusals above all judge the gate's SHAPE. A gate naming
+// an unregistered database, a mailbox whose host does not resolve, or an
+// account whose socket is down is well-formed JSON and passes every one of
+// them. It then stores cleanly, throws inside the tool on each fire, and the
+// dispatcher fails OPEN: two muvin routines cost 96 and 95 model turns in 24
+// hours that way while `schedule-list` and `/routines` both read "gated".
+// ---------------------------------------------------------------------------
+const D1_GATE = {
+    plugin: "scheduling",
+    tool: "scheduling-gate",
+    args: { eventId: "e1", checks: [{ type: "d1", database: "unregistered", sql: "SELECT 1" }] },
+};
+describe("probeGateAtBindTime", () => {
+    it("runs the gate exactly once, and the gate writes nothing (Task 2663)", async () => {
+        // `commit` is deleted, so a bind-time probe cannot leave a mark behind for a
+        // row that does not exist yet: the gate has no write path at all.
+        await probeGateAtBindTime(D1_GATE, ACCOUNT_ID, "e1");
+        expect(gateRunCalls).toHaveLength(1);
+        expect(gateRunCalls[0]).not.toHaveProperty("commit");
+    });
+    it("passes the row's own id on update, so a watermarked check reads its real position", async () => {
+        await probeGateAtBindTime(D1_GATE, ACCOUNT_ID, "e1");
+        expect(gateRunCalls[0].eventId).toBe("e1");
+    });
+    it("passes no id on create, so checks read position zero", async () => {
+        await probeGateAtBindTime(D1_GATE, ACCOUNT_ID, null);
+        expect(gateRunCalls[0].eventId).toBe("");
+    });
+    it("returns null for a gate belonging to another tool, and probes nothing", async () => {
+        const probe = await probeGateAtBindTime({ plugin: "other", tool: "other-gate", args: { checks: [{ type: "d1" }] } }, ACCOUNT_ID, "e1");
+        expect(probe).toBeNull();
+        expect(gateRunCalls).toHaveLength(0);
+    });
+    it("reports every distinct kind the gate carries", async () => {
+        const probe = await probeGateAtBindTime({
+            plugin: "scheduling",
+            tool: "scheduling-gate",
+            args: {
+                checks: [
+                    { type: "d1", database: "db", sql: "SELECT 1" },
+                    { type: "d1", database: "db2", sql: "SELECT 1" },
+                    { type: "whatsapp", scope: "status" },
+                ],
+            },
+        }, ACCOUNT_ID, "e1");
+        expect(probe?.kinds).toEqual(["d1", "whatsapp"]);
+    });
+    it("passes the errored list straight through", async () => {
+        gateErrored = [{ kind: "d1", detail: "HTTP 403" }];
+        const probe = await probeGateAtBindTime(D1_GATE, ACCOUNT_ID, "e1");
+        expect(probe?.errored).toEqual([{ kind: "d1", detail: "HTTP 403" }]);
+    });
+});
+describe("assertGateProbed", () => {
+    /** The lines the guard wrote, joined. */
+    function captured(fn) {
+        const lines = [];
+        const spy = vi.spyOn(console, "error").mockImplementation((...a) => {
+            lines.push(a.join(" "));
+        });
+        try {
+            fn();
+        }
+        finally {
+            spy.mockRestore();
+        }
+        return lines.join("\n");
+    }
+    it("does nothing at all when the gate was not probed", () => {
+        let threw = false;
+        const out = captured(() => {
+            try {
+                assertGateProbed(null, "e1");
+            }
+            catch {
+                threw = true;
+            }
+        });
+        expect(threw).toBe(false);
+        expect(out).toBe("");
+    });
+    it("accepts a gate whose checks all answered, and says so", () => {
+        const out = captured(() => assertGateProbed({ errored: [], kinds: ["d1", "mail"] }, "e1"));
+        expect(out).toContain("op=gate-accepted eventId=e1 route=probed checks=d1,mail");
+    });
+    it("refuses a gate whose check could not answer, carrying the source's own text", () => {
+        let message = "";
+        const out = captured(() => {
+            try {
+                assertGateProbed({
+                    errored: [{ kind: "d1", detail: "HTTP 403 on POST /api/storage/d1/query" }],
+                    kinds: ["d1"],
+                }, "e1");
+            }
+            catch (err) {
+                message = err instanceof Error ? err.message : String(err);
+            }
+        });
+        expect(message).toContain("HTTP 403 on POST /api/storage/d1/query");
+        expect(out).toContain("op=gate-refused eventId=e1 reason=check-unreachable checks=d1");
+    });
+    // The refusal names the kinds that FAILED, as `reason=unknown-check-type`
+    // names only the offending types: that is the set the author has to fix.
+    it("names only the kinds that errored in the refusal line", () => {
+        const out = captured(() => {
+            try {
+                assertGateProbed({ errored: [{ kind: "mail", detail: "getaddrinfo EAI_AGAIN" }], kinds: ["d1", "mail"] }, "e1");
+            }
+            catch {
+                /* asserted by the line, not the throw */
+            }
+        });
+        expect(out).toContain("reason=check-unreachable checks=mail");
+    });
+    it("writes '-' for the id on the create path, where none is minted yet", () => {
+        const out = captured(() => assertGateProbed({ errored: [], kinds: ["d1"] }, null));
+        expect(out).toContain("eventId=- route=probed");
+    });
+});
+// Both paths asserted separately. One path guarded is the drift
+// `gateRequiresCommitRoute`'s docstring exists to prevent.
+describe("unreachable gate — write paths", () => {
+    const createBase = {
+        accountId: ACCOUNT_ID,
+        name: "Quarter-hourly sweep",
+        startDate: "2026-08-03T08:00:00.000Z",
+        recurrence: "*/15 * * * *",
+        sessionKey: "sess-1",
+        createdBy: { agent: "admin", session: "sess-1", tool: "schedule-event" },
+    };
+    it("is refused on create, carrying the source's own text", async () => {
+        gateErrored = [{ kind: "d1", detail: "HTTP 403 on POST /api/storage/d1/query" }];
+        await expect(scheduleEvent({ ...createBase, agentDispatch: DISPATCH, gate: D1_GATE })).rejects.toThrow(/HTTP 403 on POST \/api\/storage\/d1\/query/);
+        expect(writeCalls).toHaveLength(0);
+    });
+    it("is refused on update, carrying the source's own text", async () => {
+        gateErrored = [{ kind: "d1", detail: "HTTP 403 on POST /api/storage/d1/query" }];
+        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
+        await expect(scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: D1_GATE })).rejects.toThrow(/HTTP 403 on POST \/api\/storage\/d1\/query/);
+        expect(lastSet()?.query ?? "").not.toContain("e.gatePlugin");
+    });
+    // `hasWork` is NOT judged. A guard keying on it passes the false case and
+    // silently refuses every account that happens to be busy at bind time, so
+    // both answers are asserted and the two fixtures differ only in `hasWork`.
+    it("is stored when the checks answer 'work pending'", async () => {
+        gateErrored = [];
+        gateHasWork = true;
+        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
+        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: D1_GATE });
+        expect(lastSet().query).toContain("e.gatePlugin");
+    });
+    it("is stored when the checks answer 'nothing pending'", async () => {
+        gateErrored = [];
+        gateHasWork = false;
+        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
+        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: D1_GATE });
+        expect(lastSet().query).toContain("e.gatePlugin");
+    });
+    it("probes with the row's own id on update", async () => {
+        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
+        await scheduleUpdate({ accountId: ACCOUNT_ID, eventId: "e1", gate: D1_GATE });
+        expect(gateRunCalls[0].eventId).toBe("e1");
+        expect(gateRunCalls[0]).not.toHaveProperty("commit");
+    });
+    it("probes with no id on create", async () => {
+        await scheduleEvent({ ...createBase, agentDispatch: DISPATCH, gate: D1_GATE });
+        expect(gateRunCalls[0].eventId).toBe("");
+        expect(gateRunCalls[0]).not.toHaveProperty("commit");
+    });
+    // The ordering rule the 2471 refusal already states: a caller with no
+    // dispatch is told about the dispatch, not about a source it cannot reach.
+    it("tells a caller with no agent dispatch about the dispatch first", async () => {
+        gateErrored = [{ kind: "d1", detail: "HTTP 403" }];
+        await expect(scheduleEvent({ ...createBase, gate: D1_GATE })).rejects.toThrow(/requires a complete agentDispatch/);
+        expect(gateRunCalls).toHaveLength(0);
+    });
+    it("does not probe a gate belonging to another tool", async () => {
+        storedRow = { agentChannel: "whatsapp", agentDestination: PHONE, agentPrompt: "sweep" };
+        await scheduleUpdate({
+            accountId: ACCOUNT_ID,
+            eventId: "e1",
+            gate: { plugin: "other", tool: "other-gate", args: { checks: [{ type: "d1" }] } },
+        });
+        expect(gateRunCalls).toHaveLength(0);
+        expect(lastSet().query).toContain("e.gatePlugin");
+    });
+});
 //# sourceMappingURL=schedule-gate-write.test.js.map