proactive-gate 0.1.2 → 0.2.0

package/dist/src/types.d.ts

@@ -29,6 +29,14 @@ export interface UserState {
     createdAt?: Date | string;
     /** Surfaces the user allows, in preference order. Defaults to the candidate's surfaces. */
     surfaces?: Surface[];
+    /** Named consents a preset can require, e.g. { ad: true, night: false }. */
+    consents?: Record<string, boolean>;
+    /** Last message the user sent to the assistant; drives inbound-window presets. */
+    lastInboundAt?: Date | string | null;
+    /** True when the user is a minor under the applicable rules. */
+    minor?: boolean;
+    /** True when a soft opt-in for existing customers applies. */
+    existingCustomer?: boolean;
 }
 /** The thing the agent wants to say. */
 export interface Candidate {
@@ -38,6 +46,14 @@ export interface Candidate {
     priority?: Priority;
     /** Surfaces this candidate can be delivered on, in preference order. */
     surfaces?: Surface[];
+    /** Channel or chat the message goes to; rate limits keyed by channel read it. */
+    channel?: string;
+    /** The caller's own signal that the user is busy right now; boundedDeferral reads it. */
+    busy?: boolean;
+    /** Caller-estimated probability the user accepts this message; utilityFloor reads it. */
+    pAccept?: number;
+    /** Caller-estimated probability the user needs it; utilityFloor reads it, default 1. */
+    pNeed?: number;
     /** Free-form payload; the gate never reads it. */
     payload?: unknown;
 }
@@ -50,6 +66,11 @@ export interface EvaluateInput {
 /** What a single check may say. */
 export type CheckOutcome = {
     kind: "pass";
+    reason?: string;
+    nearLimit?: {
+        used: number;
+        limit: number;
+    };
 } | {
     kind: "reject";
     reason: string;
@@ -61,6 +82,10 @@ export type CheckOutcome = {
 } | {
     kind: "skip";
     reason: string;
+} | {
+    kind: "defer";
+    reason: string;
+    retryAt: Date;
 };
 export interface CheckContext {
     user: UserState;
@@ -75,26 +100,50 @@ export interface Check {
     id: string;
     /** True when the check can never reject; it only adjusts timing or surfaces. */
     nonRejecting?: boolean;
+    /** True to record what the check would have done without letting it stop evaluation. */
+    shadow?: boolean;
     run(ctx: CheckContext): Promise<CheckOutcome> | CheckOutcome;
+    /**
+     * Budget-like checks consume one unit at commit time. Return false when the
+     * unit was not available (a concurrent delivery took it). The gate calls
+     * consume() in check order, once per decision.
+     */
+    consume?(ctx: CheckContext): Promise<boolean>;
 }
 export interface TraceEntry {
     id: string;
     outcome: CheckOutcome["kind"];
     reason?: string;
     ms: number;
+    /** Present when the check ran in shadow mode and would have stopped evaluation. */
+    shadow?: boolean;
 }
 export interface Decision {
+    /** Unique per evaluation: userId, candidateId, the instant and a sequence number. commit() is idempotent on it. */
+    id: string;
     allowed: boolean;
     userId: string;
     candidateId: string;
-    /** Surfaces to route to when allowed. Empty when rejected. */
+    /** Surfaces to route to when allowed. Empty when rejected or deferred. */
     surfaces: Surface[];
     /** Set when a non-rejecting check asked for a later delivery. */
     deliverAt?: Date;
     /** The check that rejected, when rejected. */
     rejectedBy?: string;
-    /** Human-readable reason, when rejected. */
+    /** The check that deferred, when deferred. */
+    deferredBy?: string;
+    /** When to evaluate again, when deferred. */
+    retryAt?: Date;
+    /** Human-readable reason, when rejected or deferred. */
     reason?: string;
+    /** Checks in shadow mode that would have rejected or deferred. */
+    shadowed: string[];
+    /** Budget checks that passed close to their limit. */
+    nearLimit: Array<{
+        check: string;
+        used: number;
+        limit: number;
+    }>;
     /** Every check that ran, in order, with what it said. */
     trace: TraceEntry[];
     evaluatedAt: Date;
@@ -113,6 +162,13 @@ export interface Store {
     incr(key: string, ttlSeconds?: number): Promise<number>;
     del(key: string): Promise<void>;
 }
+/** Observation points. Hooks never change a decision; a throwing hook is reported to `error` and ignored. */
+export interface GateHooks {
+    before?(ctx: CheckContext, check: Check): void | Promise<void>;
+    after?(ctx: CheckContext, check: Check, outcome: CheckOutcome, ms: number): void | Promise<void>;
+    error?(ctx: CheckContext, check: Check, error: unknown): void | Promise<void>;
+    finally?(decision: Decision): void | Promise<void>;
+}
 export interface GateOptions {
     checks: Check[];
     store?: Store;
@@ -126,4 +182,20 @@ export interface GateOptions {
     onDecision?: (decision: Decision) => void;
     /** Key prefix for everything the gate writes to the store. */
     keyPrefix?: string;
+    /** Observation hooks, e.g. one OpenTelemetry span per check. */
+    hooks?: GateHooks;
 }
+/** A policy document: the same checks as data. See spec/schema/policy.schema.json. */
+export interface Policy {
+    specVersion: string;
+    onStoreError?: "open" | "closed";
+    keyPrefix?: string;
+    checks: PolicyEntry[];
+}
+export type PolicyEntry = ({
+    id: string;
+    shadow?: boolean;
+} & Record<string, unknown>) | ({
+    preset: string;
+    shadow?: boolean;
+} & Record<string, unknown>);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "proactive-gate",
-  "version": "0.1.2",
-  "description": "Decide whether a proactive AI agent may reach a user right now, and log why not. Ordered checks: kill switch, consent, quiet hours, trust ramp, dismissal cooldown, daily budget.",
+  "version": "0.2.0",
+  "description": "Decide whether a proactive AI agent may reach a user right now, and log why not. Ordered checks as code or JSON, a conformance spec, presets for platform and legal limits, adapters for AI SDK, Mastra, LangChain and OpenAI Agents, and a Python sibling.",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -9,23 +9,51 @@
     ".": {
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
-    }
+    },
+    "./presets": {
+      "types": "./dist/src/presets.d.ts",
+      "import": "./dist/src/presets.js"
+    },
+    "./ai-sdk": {
+      "types": "./dist/src/adapters/ai-sdk.d.ts",
+      "import": "./dist/src/adapters/ai-sdk.js"
+    },
+    "./mastra": {
+      "types": "./dist/src/adapters/mastra.d.ts",
+      "import": "./dist/src/adapters/mastra.js"
+    },
+    "./langchain": {
+      "types": "./dist/src/adapters/langchain.d.ts",
+      "import": "./dist/src/adapters/langchain.js"
+    },
+    "./openai-agents": {
+      "types": "./dist/src/adapters/openai-agents.d.ts",
+      "import": "./dist/src/adapters/openai-agents.js"
+    },
+    "./package.json": "./package.json"
   },
   "bin": {
     "proactive-gate": "dist/src/cli.js"
   },
   "files": [
-    "dist",
+    "dist/src",
     "README.md",
     "LICENSE"
   ],
+  "sideEffects": false,
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test dist/test/gate.test.js",
+    "test": "npm run build && node test/spec-lint.mjs && node --test dist/test/gate.test.js dist/test/conformance.test.js dist/test/presets.test.js dist/test/adapters.test.js dist/test/init.test.js dist/test/properties.test.js test/release.test.mjs test/examples.test.mjs test/naive.test.mjs",
     "lint": "tsc -p tsconfig.json --noEmit",
+    "spec-lint": "node test/spec-lint.mjs",
+    "conformance": "npm run build && node dist/src/cli.js replay --fixtures spec/fixtures",
     "prepublishOnly": "npm test",
-    "examples": "npm run build && node dist/src/cli.js replay examples/day.jsonl --policy examples/policy.js --commit",
-    "bench": "npm run build && node bench/evaluate.mjs"
+    "examples": "npm run build && node dist/src/cli.js replay examples/day.jsonl --policy examples/policy.js --commit && node dist/src/cli.js replay examples/day.jsonl --policy examples/policy.json --commit && node examples/mastra/run.mjs && node examples/ai-sdk/run.mjs",
+    "bench": "npm run build && node bench/evaluate.mjs",
+    "release": "node scripts/release.mjs",
+    "release-gate": "npm run build && node scripts/release-gate.mjs",
+    "trace-svg": "npm run build && node scripts/trace-svg.mjs",
+    "bench:compare": "npm run build && node bench/compare.mjs"
   },
   "engines": {
     "node": ">=20"
@@ -39,7 +67,20 @@
     "quiet-hours",
     "consent",
     "budget",
-    "llm"
+    "llm",
+    "policy",
+    "presets",
+    "langchain",
+    "mastra",
+    "ai-sdk",
+    "openai-agents",
+    "claude-code",
+    "guardrails",
+    "agent-guardrails",
+    "notification-budget",
+    "proactive-ai",
+    "python",
+    "conformance"
   ],
   "author": "Efe Genc",
   "license": "MIT",
@@ -47,7 +88,14 @@
     "type": "git",
     "url": "git+https://github.com/Bubblegunn/proactive-gate.git"
   },
-  "homepage": "https://github.com/Bubblegunn/proactive-gate#readme",
+  "homepage": "https://bubblegunn.github.io/proactive-gate/",
+  "bugs": {
+    "url": "https://github.com/Bubblegunn/proactive-gate/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@types/node": "^26.4.1",

package/dist/test/gate.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/gate.test.js

@@ -1,261 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createGate, MemoryStore, SqliteStore, defaultChecks, checks, localClock, inWindow } from "../src/index.js";
-import { replay, summarize } from "../src/cli.js";
-const user = (overrides = {}) => ({
-    id: "u1",
-    consent: true,
-    proactiveEnabled: true,
-    mode: "normal",
-    intensity: "normal",
-    timezone: "Europe/Istanbul",
-    quietHours: { start: "22:00", end: "08:00" },
-    createdAt: "2026-01-01T00:00:00Z",
-    ...overrides,
-});
-const candidate = (overrides = {}) => ({ id: "c1", type: "reminder", priority: "normal", surfaces: ["push", "feed"], ...overrides });
-const noon = new Date("2026-09-04T09:00:00Z"); // 12:00 in Istanbul (UTC+3)
-const night = new Date("2026-09-04T20:30:00Z"); // 23:30 in Istanbul
-test("happy path: every check passes, surfaces are returned, trace lists all twelve", async () => {
-    const gate = createGate({ checks: defaultChecks() });
-    const d = await gate.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(d.allowed, true);
-    assert.deepEqual(d.surfaces, ["push", "feed"]);
-    assert.equal(d.trace.length, 12);
-    assert.deepEqual(d.trace.map((t) => t.id), ["killSwitch", "consent", "enabled", "mode", "snooze", "mute", "intensity", "quietHours", "trustRamp", "dismissalCooldown", "adaptiveTiming", "dailyBudget"]);
-});
-test("order is visible: consent rejects before quiet hours gets a chance", async () => {
-    const gate = createGate({ checks: defaultChecks() });
-    const d = await gate.evaluate({ user: user({ consent: false }), candidate: candidate(), now: night });
-    assert.equal(d.allowed, false);
-    assert.equal(d.rejectedBy, "consent");
-    assert.equal(d.trace.length, 2);
-});
-test("kill switch silences everything and says so", async () => {
-    const gate = createGate({ checks: defaultChecks({ killSwitch: () => true }) });
-    const d = await gate.evaluate({ user: user(), candidate: candidate({ priority: "critical" }), now: noon });
-    assert.equal(d.rejectedBy, "killSwitch");
-    assert.match(d.reason, /kill switch/);
-});
-test("quiet hours: rejects at 23:30 local, passes at noon, crosses midnight, bypassed at the floor", async () => {
-    const gate = createGate({ checks: [checks.quietHours({ priorityFloor: "high" })] });
-    const late = await gate.evaluate({ user: user(), candidate: candidate(), now: night });
-    assert.equal(late.rejectedBy, "quietHours");
-    assert.match(late.reason, /22:00 to 08:00 Europe\/Istanbul/);
-    const early = await gate.evaluate({ user: user(), candidate: candidate(), now: new Date("2026-09-05T03:30:00Z") }); // 06:30 local
-    assert.equal(early.allowed, false);
-    const day = await gate.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(day.allowed, true);
-    const urgent = await gate.evaluate({ user: user(), candidate: candidate({ priority: "high" }), now: night });
-    assert.equal(urgent.allowed, true);
-    const noTz = await gate.evaluate({ user: user({ timezone: undefined }), candidate: candidate(), now: night });
-    assert.equal(noTz.allowed, true);
-    assert.equal(noTz.trace[0]?.outcome, "skip");
-});
-test("localClock and inWindow handle zones and midnight", () => {
-    assert.equal(localClock(new Date("2026-09-04T20:30:00Z"), "Europe/Istanbul").minutes, 23 * 60 + 30);
-    assert.equal(localClock(new Date("2026-09-04T20:30:00Z"), "America/Los_Angeles").minutes, 13 * 60 + 30);
-    assert.equal(localClock(new Date("2026-09-04T23:30:00Z"), "Europe/Istanbul").day, "2026-09-05");
-    assert.equal(inWindow(23 * 60, 22 * 60, 8 * 60), true);
-    assert.equal(inWindow(7 * 60, 22 * 60, 8 * 60), true);
-    assert.equal(inWindow(12 * 60, 22 * 60, 8 * 60), false);
-    assert.equal(inWindow(12 * 60, 9 * 60, 17 * 60), true);
-    assert.equal(inWindow(12 * 60, 12 * 60, 12 * 60), false);
-});
-test("trust ramp: new users hear only high priority for seven days", async () => {
-    const gate = createGate({ checks: [checks.trustRamp()] });
-    const fresh = user({ createdAt: "2026-09-02T00:00:00Z" });
-    const normal = await gate.evaluate({ user: fresh, candidate: candidate(), now: noon });
-    assert.equal(normal.rejectedBy, "trustRamp");
-    assert.match(normal.reason, /day 3 of 7/);
-    const high = await gate.evaluate({ user: fresh, candidate: candidate({ priority: "high" }), now: noon });
-    assert.equal(high.allowed, true);
-    const old = await gate.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(old.allowed, true);
-});
-test("intensity maps to a priority floor", async () => {
-    const gate = createGate({ checks: [checks.intensity()] });
-    assert.equal((await gate.evaluate({ user: user({ intensity: "low" }), candidate: candidate(), now: noon })).rejectedBy, "intensity");
-    assert.equal((await gate.evaluate({ user: user({ intensity: "low" }), candidate: candidate({ priority: "high" }), now: noon })).allowed, true);
-    assert.equal((await gate.evaluate({ user: user({ intensity: "high" }), candidate: candidate({ priority: "low" }), now: noon })).allowed, true);
-});
-test("snooze, mute, mode and enabled each reject with a specific reason", async () => {
-    const gate = createGate({ checks: defaultChecks() });
-    const cases = [
-        [{ snoozedUntil: "2026-09-04T12:00:00Z" }, "snooze"],
-        [{ mutedTypes: ["reminder"] }, "mute"],
-        [{ mode: "focus" }, "mode"],
-        [{ proactiveEnabled: false }, "enabled"],
-    ];
-    for (const [overrides, expected] of cases) {
-        const d = await gate.evaluate({ user: user(overrides), candidate: candidate(), now: noon });
-        assert.equal(d.rejectedBy, expected, `expected ${expected} to reject`);
-    }
-});
-test("dismissal cooldown: three dismissals in thirty days buy a week of silence for that type only", async () => {
-    const store = new MemoryStore();
-    const gate = createGate({ store, checks: [checks.dismissalCooldown()] });
-    const u = user();
-    for (const day of [1, 2, 3])
-        await gate.record(u, { type: "reminder" }, "dismissed", new Date(`2026-09-0${day}T10:00:00Z`));
-    const silenced = await gate.evaluate({ user: u, candidate: candidate(), now: new Date("2026-09-05T10:00:00Z") });
-    assert.equal(silenced.rejectedBy, "dismissalCooldown");
-    assert.match(silenced.reason, /silent until 2026-09-10T10:00:00.000Z/);
-    const otherType = await gate.evaluate({ user: u, candidate: candidate({ type: "insight" }), now: new Date("2026-09-05T10:00:00Z") });
-    assert.equal(otherType.allowed, true);
-    const later = await gate.evaluate({ user: u, candidate: candidate(), now: new Date("2026-09-11T10:00:00Z") });
-    assert.equal(later.allowed, true);
-    await gate.record(u, { type: "reminder" }, "acted");
-    const acted = await gate.evaluate({ user: u, candidate: candidate(), now: new Date("2026-09-11T10:00:00Z") });
-    assert.equal(acted.allowed, true);
-});
-test("daily budget: evaluate reads, commit consumes atomically and refuses the sixth delivery", async () => {
-    const store = new MemoryStore();
-    const gate = createGate({ store, checks: [checks.dailyBudget({ limit: 5 })] });
-    const input = { user: user(), candidate: candidate(), now: noon };
-    for (let i = 0; i < 5; i++) {
-        const d = await gate.evaluate(input);
-        assert.equal(d.allowed, true, `delivery ${i + 1} should be allowed`);
-        assert.equal(await gate.commit(d, input), true);
-    }
-    const sixth = await gate.evaluate(input);
-    assert.equal(sixth.rejectedBy, "dailyBudget");
-    assert.match(sixth.reason, /5 used \(5\)/);
-    // Two instances that both evaluated before either committed: only one wins.
-    const store2 = new MemoryStore();
-    const gate2 = createGate({ store: store2, checks: [checks.dailyBudget({ limit: 1 })] });
-    const a = await gate2.evaluate(input);
-    const b = await gate2.evaluate(input);
-    assert.equal(a.allowed && b.allowed, true);
-    assert.equal(await gate2.commit(a, input), true);
-    assert.equal(await gate2.commit(b, input), false);
-    // The budget resets on the user's local day, not UTC.
-    const nextLocalDay = new Date("2026-09-04T21:30:00Z"); // 00:30 next day in Istanbul
-    assert.equal((await gate.evaluate({ ...input, now: nextLocalDay })).allowed, true);
-    assert.equal((await gate.inspect(user(), noon)).budgetUsed, 5);
-});
-test("weekly budget: resets on the user's local ISO week and commits atomically", async () => {
-    const store = new MemoryStore();
-    const gate = createGate({ store, checks: [checks.weeklyBudget({ limit: 2 })] });
-    const input = { user: user(), candidate: candidate(), now: new Date("2026-09-04T09:00:00Z") };
-    const first = await gate.evaluate(input);
-    const second = await gate.evaluate(input);
-    assert.equal(await gate.commit(first, input), true);
-    assert.equal(await gate.commit(second, input), true);
-    assert.equal((await gate.evaluate(input)).rejectedBy, "weeklyBudget");
-    const nextWeek = await gate.evaluate({ ...input, now: new Date("2026-09-07T09:00:00Z") });
-    assert.equal(nextWeek.allowed, true);
-});
-const sqliteAvailable = Number(process.versions.node.split(".")[0]) >= 22;
-test("sqlite store supports get, set, increment, delete and expiration", { skip: !sqliteAvailable }, async () => {
-    let now = 1_000_000;
-    const store = new SqliteStore(":memory:", () => now);
-    assert.equal(await store.get("missing"), null);
-    await store.set("key", "value");
-    assert.equal(await store.get("key"), "value");
-    assert.equal(await store.incr("counter"), 1);
-    assert.equal(await store.incr("counter", 10), 2);
-    assert.equal(await store.get("counter"), "2");
-    await store.set("temporary", "value", 5);
-    assert.equal(await store.get("temporary"), "value");
-    now += 5000;
-    assert.equal(await store.get("temporary"), null);
-    await store.del("key");
-    assert.equal(await store.get("key"), null);
-    store.close();
-});
-test("sqlite store preserves values across database connections", { skip: !sqliteAvailable }, async () => {
-    const directory = mkdtempSync(join(tmpdir(), "proactive-gate-"));
-    const path = join(directory, "store.sqlite");
-    try {
-        const first = new SqliteStore(path);
-        await first.set("key", "value");
-        assert.equal(await first.incr("counter"), 1);
-        first.close();
-        const second = new SqliteStore(path);
-        assert.equal(await second.get("key"), "value");
-        assert.equal(await second.get("counter"), "1");
-        second.close();
-    }
-    finally {
-        rmSync(directory, { recursive: true, force: true });
-    }
-});
-test("adaptive timing never rejects; it defers and can narrow surfaces", async () => {
-    const later = new Date("2026-09-04T15:00:00Z");
-    const gate = createGate({
-        checks: [
-            checks.adaptiveTiming({ nextGoodMoment: () => later, surfacesFor: () => ["feed"] }),
-            { id: "rogue", nonRejecting: true, run: () => ({ kind: "reject", reason: "should be ignored" }) },
-        ],
-    });
-    const d = await gate.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(d.allowed, true);
-    assert.equal(d.deliverAt?.toISOString(), later.toISOString());
-    assert.deepEqual(d.surfaces, ["feed"]);
-    assert.equal(d.trace[1]?.outcome, "skip");
-});
-test("store failure fails open by default and closed on request, and the trace says which", async () => {
-    const broken = {
-        get: async () => { throw new Error("redis down"); },
-        set: async () => { throw new Error("redis down"); },
-        incr: async () => { throw new Error("redis down"); },
-        del: async () => { throw new Error("redis down"); },
-    };
-    const open = createGate({ store: broken, checks: [checks.dailyBudget({ limit: 1 })] });
-    const d1 = await open.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(d1.allowed, true);
-    assert.match(d1.trace[0]?.reason ?? "", /failing open/);
-    assert.equal(await open.commit(d1, { user: user(), candidate: candidate(), now: noon }), true);
-    const closed = createGate({ store: broken, onStoreError: "closed", checks: [checks.dailyBudget({ limit: 1 })] });
-    const d2 = await closed.evaluate({ user: user(), candidate: candidate(), now: noon });
-    assert.equal(d2.allowed, false);
-    assert.equal(d2.rejectedBy, "dailyBudget");
-});
-test("user surfaces filter candidate surfaces; onDecision sees every decision", async () => {
-    const seen = [];
-    const gate = createGate({ checks: defaultChecks(), onDecision: (d) => seen.push(`${d.candidateId}:${d.allowed}`) });
-    const d = await gate.evaluate({ user: user({ surfaces: ["feed"] }), candidate: candidate({ surfaces: ["push", "feed", "voice"] }), now: noon });
-    assert.deepEqual(d.surfaces, ["feed"]);
-    await gate.evaluate({ user: user({ consent: false }), candidate: candidate({ id: "c2" }), now: noon });
-    assert.deepEqual(seen, ["c1:true", "c2:false"]);
-});
-test("replay summarises a day of candidates and consumes the budget in order", async () => {
-    const gate = createGate({ checks: defaultChecks({ dailyLimit: 2 }) });
-    const lines = [
-        JSON.stringify({ user: user(), candidate: candidate({ id: "a" }), now: noon }),
-        JSON.stringify({ user: user(), candidate: candidate({ id: "b" }), now: noon }),
-        JSON.stringify({ user: user(), candidate: candidate({ id: "c" }), now: noon }),
-        JSON.stringify({ user: user(), candidate: candidate({ id: "d" }), now: night }),
-        JSON.stringify({ user: user({ consent: false }), candidate: candidate({ id: "e" }), now: noon }),
-    ];
-    const decisions = await replay(lines, gate, true);
-    assert.deepEqual(decisions.map((d) => d.allowed), [true, true, false, false, false]);
-    const text = summarize(decisions);
-    assert.match(text, /5 candidates {2}· {2}2 allowed \(40\.0%\)/);
-    assert.match(text, /dailyBudget/);
-    assert.match(text, /quietHours/);
-    assert.match(text, /consent/);
-});
-test("a custom check is an ordinary object: it runs in order, reads the context, and shows in the trace", async () => {
-    const weekendsOnlyHigh = {
-        id: "weekendFloor",
-        run: ({ now, priority }) => {
-            const day = now.getUTCDay();
-            if ((day === 0 || day === 6) && priority !== "high" && priority !== "critical")
-                return { kind: "reject", reason: "weekend: only high priority" };
-            return { kind: "pass" };
-        },
-    };
-    const gate = createGate({ checks: [checks.consent(), weekendsOnlyHigh, checks.dailyBudget({ limit: 5 })] });
-    const saturday = new Date("2026-09-05T10:00:00Z");
-    const d = await gate.evaluate({ user: user(), candidate: candidate(), now: saturday });
-    assert.equal(d.rejectedBy, "weekendFloor");
-    assert.deepEqual(d.trace.map((t) => `${t.id}:${t.outcome}`), ["consent:pass", "weekendFloor:reject"]);
-    const monday = await gate.evaluate({ user: user(), candidate: candidate(), now: new Date("2026-09-07T10:00:00Z") });
-    assert.equal(monday.allowed, true);
-    assert.equal(monday.trace.length, 3);
-});