@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setConfig } from "./helpers/set-config.js";
+
 // Default the warm-pool gate to OPEN — these tests probe disk-pressure
 // behavior, not the pre-first-message guard.
 mock.module("../runtime/pre-first-message-gate.js", () => ({
@@ -7,44 +9,6 @@ mock.module("../runtime/pre-first-message-gate.js", () => ({
   _resetPreFirstMessageGateCacheForTests: () => {},
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    debug: () => {},
-    warn: () => {},
-    error: () => {},
-  }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    heartbeat: {
-      enabled: true,
-      intervalMs: 60_000,
-      cronExpression: null,
-      timezone: null,
-      activeHoursStart: undefined,
-      activeHoursEnd: undefined,
-    },
-    timeouts: {
-      backgroundTurnTimeoutSec: 1800,
-      scheduleTurnTimeoutSec: 1800,
-    },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getConfigReadOnly: () => ({}),
-  applyNestedDefaults: (config: unknown) => config,
-  deepMergeOverwrite: (base: unknown) => base,
-  mergeDefaultWorkspaceConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  API_KEY_PROVIDERS: [],
-  _writeQuarantineNotice: () => {},
-  invalidateConfigCache: () => {},
-}));
-
 const mockInsertPendingHeartbeatRun = mock(() => "run-1");
 const mockStartHeartbeatRun = mock(() => true);
 const mockCompleteHeartbeatRun = mock(() => true);
@@ -150,6 +114,13 @@ const { HeartbeatService } = await import("../heartbeat/heartbeat-service.js");
 
 describe("HeartbeatService disk pressure gate", () => {
   beforeEach(() => {
+    // Null active hours disable the time-of-day guard so runs are gated by
+    // disk pressure alone, independent of the wall clock.
+    setConfig("heartbeat", {
+      intervalMs: 60_000,
+      activeHoursStart: null,
+      activeHoursEnd: null,
+    });
     createdConversations.length = 0;
     mockInsertPendingHeartbeatRun.mockClear();
     mockStartHeartbeatRun.mockClear();

package/src/__tests__/heartbeat-service.test.ts

@@ -36,29 +36,44 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 
-// Mock config loader
-let mockConfig = {
-  heartbeat: {
+// ── Heartbeat config seeding ────────────────────────────────────────
+//
+// The service reads `getConfig().heartbeat` lazily on every call, so tests
+// seed the real workspace config instead of mocking the loader. Null active
+// hours disable the time-of-day guard (the schema defaults to an 8–22
+// window, which would make runs wall-clock dependent); the disposition text
+// is asserted verbatim by the prompt tests.
+import { setConfig } from "./helpers/set-config.js";
+
+type HeartbeatSeed = {
+  enabled: boolean;
+  intervalMs: number;
+  cronExpression: string | null;
+  timezone: string | null;
+  activeHoursStart: number | null;
+  activeHoursEnd: number | null;
+  disposition: string;
+};
+
+function defaultHeartbeatSeed(): HeartbeatSeed {
+  return {
     enabled: true,
     intervalMs: 60_000,
-    cronExpression: null as string | null,
-    timezone: null as string | null,
-    activeHoursStart: undefined as number | undefined,
-    activeHoursEnd: undefined as number | undefined,
+    cronExpression: null,
+    timezone: null,
+    activeHoursStart: null,
+    activeHoursEnd: null,
     disposition: "Default disposition text mentioning notifications skill.",
-  },
-  timeouts: {
-    backgroundTurnTimeoutSec: 1800,
-  },
-};
+  };
+}
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-}));
+let heartbeatConfig = defaultHeartbeatSeed();
+
+/** Apply overrides onto the current seed and write it to the workspace config. */
+function setHeartbeatConfig(overrides: Partial<HeartbeatSeed> = {}): void {
+  Object.assign(heartbeatConfig, overrides);
+  setConfig("heartbeat", heartbeatConfig);
+}
 
 // ── Recurrence engine mock ──────────────────────────────────────────
 //
@@ -269,7 +284,9 @@ let _testProcessMessage:
 
 mock.module("../daemon/process-message.js", () => ({
   processMessage: async (...args: unknown[]) => {
-    if (_testProcessMessage) return _testProcessMessage(...args);
+    if (_testProcessMessage) {
+      return _testProcessMessage(...args);
+    }
     return { messageId: `mock-msg-${Date.now()}` };
   },
   processMessageInBackground: async () => ({ messageId: "mock-bg" }),
@@ -308,33 +325,6 @@ const SCAFFOLD_PERSONA = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE).trim();
 const { resolveCallSiteConfig } = await import("../config/llm-resolver.js");
 const { LLMSchema } = await import("../config/schemas/llm.js");
 
-// Minimal fully-specified `llm.default` block. The resolver requires every
-// `LLMConfigBase` field to be present in `default`, so we provide the same
-// fixture the resolver test suite uses.
-const LLM_DEFAULT = {
-  provider: "anthropic" as const,
-  model: "claude-opus-4-7",
-  maxTokens: 64000,
-  effort: "max" as const,
-  speed: "standard" as const,
-  temperature: null,
-  thinking: { enabled: true, streamThinking: true },
-  contextWindow: {
-    enabled: true,
-    maxInputTokens: 200000,
-    targetBudgetRatio: 0.3,
-    compactThreshold: 0.8,
-    summaryBudgetRatio: 0.05,
-    overflowRecovery: {
-      enabled: true,
-      safetyMarginRatio: 0.05,
-      maxAttempts: 3,
-      interactiveLatestTurnCompression: "summarize" as const,
-      nonInteractiveLatestTurnCompression: "truncate" as const,
-    },
-  },
-};
-
 // Capture broadcastMessage so tests can observe the alerts and
 // conversation-created events the heartbeat service emits directly.
 type BroadcastedMessage = { type: string; [key: string]: unknown };
@@ -417,20 +407,8 @@ describe("HeartbeatService", () => {
     mockCountCompletedHeartbeatRuns.mockClear();
     mockCountCompletedHeartbeatRuns.mockImplementation(() => 10);
 
-    mockConfig = {
-      heartbeat: {
-        enabled: true,
-        intervalMs: 60_000,
-        cronExpression: null,
-        timezone: null,
-        activeHoursStart: undefined,
-        activeHoursEnd: undefined,
-        disposition: "Default disposition text mentioning notifications skill.",
-      },
-      timeouts: {
-        backgroundTurnTimeoutSec: 1800,
-      },
-    };
+    heartbeatConfig = defaultHeartbeatSeed();
+    setHeartbeatConfig();
   });
 
   function createService(overrides?: {
@@ -533,8 +511,7 @@ describe("HeartbeatService", () => {
   });
 
   test("active hours guard skips outside window", async () => {
-    mockConfig.heartbeat.activeHoursStart = 9;
-    mockConfig.heartbeat.activeHoursEnd = 17;
+    setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 
     const service = createService({ getCurrentHour: () => 3 });
     await service.runOnce();
@@ -543,8 +520,7 @@ describe("HeartbeatService", () => {
   });
 
   test("active hours skip still advances nextRunAt", async () => {
-    mockConfig.heartbeat.activeHoursStart = 9;
-    mockConfig.heartbeat.activeHoursEnd = 17;
+    setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 
     const service = createService({ getCurrentHour: () => 3 });
     service.start();
@@ -555,14 +531,13 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(0);
     expect(service.nextRunAt).not.toBeNull();
     expect(service.nextRunAt!).toBeGreaterThanOrEqual(
-      before + mockConfig.heartbeat.intervalMs,
+      before + heartbeatConfig.intervalMs,
     );
     service.stop();
   });
 
   test("active hours guard allows within window", async () => {
-    mockConfig.heartbeat.activeHoursStart = 9;
-    mockConfig.heartbeat.activeHoursEnd = 17;
+    setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 
     const service = createService({ getCurrentHour: () => 12 });
     await service.runOnce();
@@ -571,8 +546,7 @@ describe("HeartbeatService", () => {
   });
 
   test("active hours handles overnight window", async () => {
-    mockConfig.heartbeat.activeHoursStart = 22;
-    mockConfig.heartbeat.activeHoursEnd = 6;
+    setHeartbeatConfig({ activeHoursStart: 22, activeHoursEnd: 6 });
 
     // 23:00 should be within the window
     const service = createService({ getCurrentHour: () => 23 });
@@ -618,7 +592,7 @@ describe("HeartbeatService", () => {
   });
 
   test("disabled config prevents start", () => {
-    mockConfig.heartbeat.enabled = false;
+    setHeartbeatConfig({ enabled: false });
     const service = createService();
     service.start();
     // No error, just a no-op. We can verify by calling stop which should also be a no-op.
@@ -627,7 +601,7 @@ describe("HeartbeatService", () => {
   });
 
   test("disabled config prevents runOnce", async () => {
-    mockConfig.heartbeat.enabled = false;
+    setHeartbeatConfig({ enabled: false });
     const service = createService();
     await service.runOnce();
 
@@ -635,7 +609,7 @@ describe("HeartbeatService", () => {
   });
 
   test("force bypasses disabled config", async () => {
-    mockConfig.heartbeat.enabled = false;
+    setHeartbeatConfig({ enabled: false });
     const service = createService();
     await service.runOnce({ force: true });
 
@@ -643,8 +617,7 @@ describe("HeartbeatService", () => {
   });
 
   test("force bypasses active hours guard", async () => {
-    mockConfig.heartbeat.activeHoursStart = 9;
-    mockConfig.heartbeat.activeHoursEnd = 17;
+    setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 
     const service = createService({ getCurrentHour: () => 3 });
     await service.runOnce({ force: true });
@@ -704,7 +677,7 @@ describe("HeartbeatService", () => {
     expect(service.lastRunAt!).toBeGreaterThanOrEqual(before);
     expect(service.nextRunAt).not.toBeNull();
     expect(service.nextRunAt!).toBeGreaterThanOrEqual(
-      before + mockConfig.heartbeat.intervalMs,
+      before + heartbeatConfig.intervalMs,
     );
   });
 
@@ -741,7 +714,7 @@ describe("HeartbeatService", () => {
     expect(afterReset).not.toBeNull();
     // The new nextRunAt should be >= the interval from now
     expect(afterReset!).toBeGreaterThanOrEqual(
-      before + mockConfig.heartbeat.intervalMs,
+      before + heartbeatConfig.intervalMs,
     );
     service.stop();
   });
@@ -755,7 +728,7 @@ describe("HeartbeatService", () => {
   });
 
   test("resetTimer() is a no-op when heartbeat is disabled", () => {
-    mockConfig.heartbeat.enabled = false;
+    setHeartbeatConfig({ enabled: false });
     const service = createService();
     service.start();
     expect(service.nextRunAt).toBeNull();
@@ -808,7 +781,6 @@ describe("HeartbeatService", () => {
     // processMessage, and (b) the resolver maps that identifier to the
     // user's configured speed.
     const llm = LLMSchema.parse({
-      default: LLM_DEFAULT,
       callSites: {
         heartbeatAgent: { speed: "fast" },
       },
@@ -1217,8 +1189,10 @@ describe("HeartbeatService", () => {
     test("start() with cronExpression sets nextRunAt to cron occurrence, not now+intervalMs", () => {
       const cronNextRunAt = Date.now() + 7_200_000; // 2 hours from now
       mockComputeNextRunAtResult = cronNextRunAt;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
-      mockConfig.heartbeat.timezone = "America/New_York";
+      setHeartbeatConfig({
+        cronExpression: "0 9,12,15,18 * * *",
+        timezone: "America/New_York",
+      });
 
       const service = createService();
       service.start();
@@ -1226,7 +1200,7 @@ describe("HeartbeatService", () => {
       expect(service.nextRunAt).toBe(cronNextRunAt);
       // Should NOT be now + intervalMs
       expect(service.nextRunAt).not.toBeCloseTo(
-        Date.now() + mockConfig.heartbeat.intervalMs,
+        Date.now() + heartbeatConfig.intervalMs,
         -3,
       );
       service.stop();
@@ -1235,7 +1209,7 @@ describe("HeartbeatService", () => {
     test("runOnce() does not call scheduleNextRun(intervalMs) in cron mode — nextRunAt is not clobbered", async () => {
       const cronNextRunAt = Date.now() + 7_200_000;
       mockComputeNextRunAtResult = cronNextRunAt;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
 
       const service = createService();
       service.start();
@@ -1256,7 +1230,7 @@ describe("HeartbeatService", () => {
     test("after runOnce() rejects in cron mode, the next cron run is still scheduled via finally", async () => {
       const cronNextRunAt = Date.now() + 7_200_000;
       mockComputeNextRunAtResult = cronNextRunAt;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
 
       const service = createService({
         processMessage: async () => {
@@ -1276,7 +1250,7 @@ describe("HeartbeatService", () => {
     test("resetTimer() in cron mode recomputes from the current time", () => {
       const firstCronTime = Date.now() + 3_600_000;
       mockComputeNextRunAtResult = firstCronTime;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
 
       const service = createService();
       service.start();
@@ -1301,7 +1275,7 @@ describe("HeartbeatService", () => {
       // Reconfigure to cron mode
       const cronNextRunAt = Date.now() + 7_200_000;
       mockComputeNextRunAtResult = cronNextRunAt;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
       service.reconfigure();
 
       expect(service.nextRunAt).toBe(cronNextRunAt);
@@ -1311,29 +1285,31 @@ describe("HeartbeatService", () => {
     test("reconfigure() switches from cron to interval mode", () => {
       const cronNextRunAt = Date.now() + 7_200_000;
       mockComputeNextRunAtResult = cronNextRunAt;
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
 
       const service = createService();
       service.start();
       expect(service.nextRunAt).toBe(cronNextRunAt);
 
       // Reconfigure to interval mode
-      mockConfig.heartbeat.cronExpression = null;
+      setHeartbeatConfig({ cronExpression: null });
       const before = Date.now();
       service.reconfigure();
 
       expect(service.nextRunAt).not.toBeNull();
       expect(service.nextRunAt!).toBeGreaterThanOrEqual(
-        before + mockConfig.heartbeat.intervalMs,
+        before + heartbeatConfig.intervalMs,
       );
       service.stop();
     });
 
     test("active hours guard uses cron timezone when configured", async () => {
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
-      mockConfig.heartbeat.timezone = "UTC";
-      mockConfig.heartbeat.activeHoursStart = 9;
-      mockConfig.heartbeat.activeHoursEnd = 17;
+      setHeartbeatConfig({
+        cronExpression: "0 9,12,15,18 * * *",
+        timezone: "UTC",
+        activeHoursStart: 9,
+        activeHoursEnd: 17,
+      });
       mockComputeNextRunAtResult = Date.now() + 3_600_000;
 
       const service = createService();
@@ -1350,10 +1326,12 @@ describe("HeartbeatService", () => {
     });
 
     test("active hours guard falls back to getCurrentHour when cron mode has no timezone", async () => {
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
-      mockConfig.heartbeat.timezone = null;
-      mockConfig.heartbeat.activeHoursStart = 9;
-      mockConfig.heartbeat.activeHoursEnd = 17;
+      setHeartbeatConfig({
+        cronExpression: "0 9,12,15,18 * * *",
+        timezone: null,
+        activeHoursStart: 9,
+        activeHoursEnd: 17,
+      });
       mockComputeNextRunAtResult = Date.now() + 3_600_000;
 
       // getCurrentHour returns 3 (outside 9-17 window), so runOnce should skip
@@ -1367,14 +1345,14 @@ describe("HeartbeatService", () => {
 
     test("runtime fallback: computeNextRunAt throws, service falls back to interval mode", () => {
       mockComputeNextRunAtError = new Error("No upcoming runs");
-      mockConfig.heartbeat.cronExpression = "0 9,12,15,18 * * *";
+      setHeartbeatConfig({ cronExpression: "0 9,12,15,18 * * *" });
 
       const service = createService();
       service.start();
 
       // Should have fallen back to interval mode — nextRunAt should be ~now + intervalMs
       expect(service.nextRunAt).not.toBeNull();
-      const expectedMin = Date.now() + mockConfig.heartbeat.intervalMs - 100;
+      const expectedMin = Date.now() + heartbeatConfig.intervalMs - 100;
       expect(service.nextRunAt!).toBeGreaterThanOrEqual(expectedMin);
 
       // Should have logged a warning about the fallback
@@ -1384,7 +1362,7 @@ describe("HeartbeatService", () => {
     });
 
     test("null cronExpression behaves identically to current fixed-interval mode", () => {
-      mockConfig.heartbeat.cronExpression = null;
+      setHeartbeatConfig({ cronExpression: null });
 
       const service = createService();
       const before = Date.now();
@@ -1392,7 +1370,7 @@ describe("HeartbeatService", () => {
 
       expect(service.nextRunAt).not.toBeNull();
       expect(service.nextRunAt!).toBeGreaterThanOrEqual(
-        before + mockConfig.heartbeat.intervalMs,
+        before + heartbeatConfig.intervalMs,
       );
       // computeNextRunAt should not have been called
       expect(computeNextRunAtCallCount).toBe(0);
@@ -1447,8 +1425,7 @@ describe("HeartbeatService", () => {
     });
 
     test("active-hours skip calls skipHeartbeatRun", async () => {
-      mockConfig.heartbeat.activeHoursStart = 9;
-      mockConfig.heartbeat.activeHoursEnd = 17;
+      setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 
       const service = createService({ getCurrentHour: () => 3 });
       service.start();
@@ -1570,7 +1547,7 @@ describe("HeartbeatService", () => {
       service.start();
 
       // Now disable config and call runOnce — should skip the pending row
-      mockConfig.heartbeat.enabled = false;
+      setHeartbeatConfig({ enabled: false });
       mockSkipHeartbeatRun.mockClear();
 
       await service.runOnce();
@@ -1709,7 +1686,7 @@ describe("HeartbeatService", () => {
 
   describe("configurable disposition", () => {
     test("injects the configured disposition inside <heartbeat-disposition>", () => {
-      mockConfig.heartbeat.disposition = "Marker text from config.";
+      setHeartbeatConfig({ disposition: "Marker text from config." });
       const service = createService();
       const { prompt } = service.buildPrompt("- Check things", [], 10);
 
@@ -1719,7 +1696,7 @@ describe("HeartbeatService", () => {
     });
 
     test("omits the block when disposition is empty", () => {
-      mockConfig.heartbeat.disposition = "";
+      setHeartbeatConfig({ disposition: "" });
       const service = createService();
       const { prompt } = service.buildPrompt("- Check things", [], 10);
 

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -61,6 +61,16 @@ mock.module("../../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => undefined,
 }));
 
+// The inbound pipeline creates guardian requests and delivery rows through
+// the gateway client; tests here have no live gateway, so serve that surface
+// from the in-memory bridge fake (seed/inspect/reset via its `bridgeState`).
+import { gatewayGuardianRequestsStoreBridge } from "./gateway-guardian-requests-store-bridge.js";
+
+mock.module(
+  "../../channels/gateway-guardian-requests.js",
+  () => gatewayGuardianRequestsStoreBridge,
+);
+
 import type { TrustClass, TrustVerdict } from "@vellumai/gateway-client";
 
 import { isChannelId } from "../../channels/types.js";

package/src/__tests__/helpers/gateway-guardian-requests-store-bridge.ts

@@ -0,0 +1,155 @@
+/**
+ * Test-only in-memory fake serving the daemon's gateway guardian-request
+ * client surface. Rows live in a `guardian-gateway-sim` instance — the same
+ * fake the decide-cluster suites use — with two wire-parity layers on top:
+ *
+ * - Create/decide/delivery params are validated against the shared contract
+ *   schemas (the validation the gateway route applies), so malformed daemon
+ *   params fail here exactly as they would on the wire, and decisionable
+ *   kinds without a `guardianPrincipalId` are rejected like the gateway
+ *   store's integrity guard.
+ * - Decide applies `aclOutcome` through the daemon relay each outcome
+ *   variant maps to (member activation/seed/block, outbound-session mint),
+ *   so suites observe the same ACL writes the gateway transaction performs;
+ *   an outcome failure reverts the status CAS, mirroring the transaction
+ *   rollback.
+ *
+ * Wire it in with a module mock:
+ *
+ *   mock.module("../channels/gateway-guardian-requests.js", () =>
+ *     gatewayGuardianRequestsStoreBridge,
+ *   );
+ *
+ * Suites seed and inspect rows through the exported `bridgeState` sim
+ * handle (`bridgeState.seedRequest(...)`, `bridgeState.deliveries`,
+ * `bridgeState.reset()` in beforeEach, ...).
+ */
+
+import {
+  type CreateGuardianRequestDeliveryIpcParams,
+  CreateGuardianRequestDeliveryIpcParamsSchema,
+  type CreateGuardianRequestIpcParams,
+  CreateGuardianRequestIpcParamsSchema,
+  type DecideGuardianRequestIpcParams,
+  DecideGuardianRequestIpcParamsSchema,
+  type DecideGuardianRequestIpcResponse,
+  type GuardianRequestAclOutcome,
+} from "@vellumai/gateway-client";
+
+import {
+  createGuardianGatewaySim,
+  type SimGuardianDelivery,
+  type SimGuardianRequest,
+} from "../guardian-gateway-sim.js";
+
+/** Backing rows + failure-injection seams; reset between tests. */
+export const bridgeState = createGuardianGatewaySim();
+
+async function createGuardianRequest(
+  params: CreateGuardianRequestIpcParams,
+): Promise<SimGuardianRequest> {
+  // The schema requires `guardianPrincipalId`, mirroring the gateway store's
+  // integrity guard (every contract kind is decisionable).
+  return bridgeState.seedRequest(
+    CreateGuardianRequestIpcParamsSchema.parse(params),
+  );
+}
+
+async function createGuardianRequestDelivery(
+  params: CreateGuardianRequestDeliveryIpcParams,
+): Promise<SimGuardianDelivery> {
+  return bridgeState.seedDelivery(
+    CreateGuardianRequestDeliveryIpcParamsSchema.parse(params),
+  );
+}
+
+/**
+ * Apply the decision's ACL outcome through the daemon relay each variant
+ * maps to (per the contract), so tests observe the same ACL writes the
+ * gateway transaction performs. Throws when the outcome does not land —
+ * the caller reverts the CAS like the gateway transaction rollback.
+ * Relay imports are deferred to call time so this helper installs no
+ * production coupling before a test's own setup/mocks run.
+ */
+async function applyAclOutcome(
+  outcome: GuardianRequestAclOutcome,
+): Promise<{ mintedSession?: DecideAppliedResponse["mintedSession"] }> {
+  switch (outcome.type) {
+    case "activate_member": {
+      const { activateMemberChannel } =
+        await import("../../contacts/member-write-relay.js");
+      const { type: _type, ...params } = outcome;
+      const result = await activateMemberChannel(params);
+      if (result.status !== "activated") {
+        throw new Error("bridge: gateway refused the member activation");
+      }
+      return {};
+    }
+    case "seed_unverified": {
+      const { seedUnverifiedMemberChannel } =
+        await import("../../contacts/member-write-relay.js");
+      const { type: _type, ...params } = outcome;
+      await seedUnverifiedMemberChannel(params);
+      return {};
+    }
+    case "block": {
+      const { blockSenderChannel } =
+        await import("../../contacts/member-write-relay.js");
+      const { type: _type, ...params } = outcome;
+      const result = await blockSenderChannel(params);
+      if (!result.revoked) {
+        throw new Error("bridge: block did not land");
+      }
+      return {};
+    }
+    case "mint_outbound_session": {
+      const { createOutboundSession } =
+        await import("../../channels/gateway-verification-sessions.js");
+      const { type: _type, ...params } = outcome;
+      return { mintedSession: await createOutboundSession(params) };
+    }
+  }
+}
+
+type DecideAppliedResponse = Extract<
+  DecideGuardianRequestIpcResponse,
+  { applied: true }
+>;
+
+async function decideGuardianRequest(
+  params: DecideGuardianRequestIpcParams,
+): Promise<DecideGuardianRequestIpcResponse> {
+  const parsed = DecideGuardianRequestIpcParamsSchema.parse(params);
+  const { aclOutcome, ...cas } = parsed;
+  const result = await bridgeState.module.decideGuardianRequest(cas);
+  if (!result.applied || !aclOutcome) {
+    return result as DecideGuardianRequestIpcResponse;
+  }
+
+  let mintedSession: DecideAppliedResponse["mintedSession"];
+  try {
+    ({ mintedSession } = await applyAclOutcome(aclOutcome));
+  } catch (err) {
+    // Mirror the gateway transaction rollback: the CAS never lands.
+    bridgeState.reopenRequest(parsed.id, parsed.status);
+    throw err;
+  }
+
+  return {
+    applied: true,
+    request: result.request,
+    ...(mintedSession ? { mintedSession } : {}),
+  } as DecideGuardianRequestIpcResponse;
+}
+
+/**
+ * Module-shaped delegate for `channels/gateway-guardian-requests.js`
+ * covering the full client surface (create, delivery recording, and the
+ * decide/lookup cluster).
+ */
+export const gatewayGuardianRequestsStoreBridge = {
+  ...bridgeState.module,
+  createGuardianRequest,
+  createGuardianRequestDelivery,
+  decideGuardianRequest,
+};