@mycadet/gateway 0.12.10 → 0.13.0

package/src/__tests__/feature-flag-resolver.test.ts

@@ -50,7 +50,6 @@ beforeEach(() => {
   _setRegistryCandidateOverrides([defaultsPath]);
   resetFeatureFlagDefaultsCache();
   clearFeatureFlagStoreCache();
-  clearRemoteFeatureFlagStoreCache();
 });
 
 afterEach(() => {
@@ -63,7 +62,6 @@ afterEach(() => {
   _setRegistryCandidateOverrides(null);
   resetFeatureFlagDefaultsCache();
   clearFeatureFlagStoreCache();
-  clearRemoteFeatureFlagStoreCache();
   resetEnvOverridesCache();
   delete process.env.CADET_FLAG_BROWSER;
   delete process.env.CADET_FLAG_A2A_CHANNEL;
@@ -76,8 +74,6 @@ const { resetFeatureFlagDefaultsCache, _setRegistryCandidateOverrides } =
   await import("../feature-flag-defaults.js");
 const { clearFeatureFlagStoreCache, writeFeatureFlag } =
   await import("../feature-flag-store.js");
-const { clearRemoteFeatureFlagStoreCache, writeRemoteFeatureFlags } =
-  await import("../feature-flag-remote-store.js");
 const { resetEnvOverridesCache } =
   await import("../feature-flag-env-overrides.js");
 
@@ -95,19 +91,8 @@ describe("isFeatureFlagEnabled", () => {
     expect(isFeatureFlagEnabled("a2a-channel")).toBe(true);
   });
 
-  test("uses explicit remote values for declared flags", () => {
-    writeRemoteFeatureFlags({
-      browser: false,
-      "a2a-channel": true,
-    });
-
-    expect(isFeatureFlagEnabled("browser")).toBe(false);
-    expect(isFeatureFlagEnabled("a2a-channel")).toBe(true);
-  });
-
-  test("ignores persisted and remote values for undeclared flags", () => {
+  test("ignores persisted values for undeclared flags", () => {
     writeFeatureFlag("unknown", true);
-    writeRemoteFeatureFlags({ unknown: true });
 
     expect(isFeatureFlagEnabled("unknown")).toBe(false);
   });
@@ -146,19 +131,7 @@ describe("getFeatureFlagValue", () => {
     expect(getFeatureFlagValue("default-model")).toBe("gpt-4");
   });
 
-  test("remote string value overrides default when no persisted value", () => {
-    writeRemoteFeatureFlags({ "default-model": "gpt-4" });
-    expect(getFeatureFlagValue("default-model")).toBe("gpt-4");
-  });
-
-  test("persisted takes precedence over remote for string flags", () => {
-    writeRemoteFeatureFlags({ "default-model": "remote-model" });
-    writeFeatureFlag("default-model", "persisted-model");
-    expect(getFeatureFlagValue("default-model")).toBe("persisted-model");
-  });
-
-  test("env override wins over persisted, remote, and default values", () => {
-    writeRemoteFeatureFlags({ browser: false });
+  test("env override wins over persisted and default values", () => {
     writeFeatureFlag("browser", false);
 
     process.env.CADET_FLAG_BROWSER = "true";
@@ -168,7 +141,6 @@ describe("getFeatureFlagValue", () => {
   });
 
   test("env override wins for string flags", () => {
-    writeRemoteFeatureFlags({ "default-model": "remote-model" });
     writeFeatureFlag("default-model", "persisted-model");
 
     process.env.CADET_FLAG_DEFAULT_MODEL = "env-model";

package/src/__tests__/feature-flag-watcher-callback.test.ts

@@ -13,12 +13,6 @@ mock.module("../feature-flag-store.js", () => ({
   getFeatureFlagStorePath: () => join(flagDir, "feature-flags.json"),
 }));
 
-mock.module("../feature-flag-remote-store.js", () => ({
-  refreshRemoteFeatureFlagStoreCache: mock(() => {}),
-  getRemoteFeatureFlagStorePath: () =>
-    join(flagDir, "remote-feature-flags.json"),
-}));
-
 const { FeatureFlagWatcher } = await import("../feature-flag-watcher.js");
 
 describe("FeatureFlagWatcher onChanged callback", () => {
@@ -52,22 +46,6 @@ describe("FeatureFlagWatcher onChanged callback", () => {
     watcher.stop();
   });
 
-  test("calls onChanged after debounce fires on remote flag file change", async () => {
-    const onChanged = mock(() => {});
-    const watcher = new FeatureFlagWatcher({ onChanged });
-    watcher.start();
-
-    writeFileSync(
-      join(flagDir, "remote-feature-flags.json"),
-      JSON.stringify({ remote: true }),
-    );
-
-    await new Promise((r) => setTimeout(r, 700));
-
-    expect(onChanged).toHaveBeenCalledTimes(1);
-    watcher.stop();
-  });
-
   test("does not call onChanged when no callback is provided", async () => {
     const watcher = new FeatureFlagWatcher();
     watcher.start();

package/src/__tests__/feature-flags-route.test.ts

@@ -11,10 +11,6 @@ import { testSecurityDir } from "./test-preload.js";
 
 const protectedDir = testSecurityDir;
 const featureFlagStorePath = join(protectedDir, "feature-flags.json");
-const remoteFeatureFlagStorePath = join(
-  protectedDir,
-  "feature-flags-remote.json",
-);
 
 // Write the test registry to an isolated temp path so we never touch
 // the committed gateway/src/feature-flag-registry.json file.
@@ -65,7 +61,6 @@ beforeEach(() => {
   _setRegistryCandidateOverrides([defaultsPath]);
   resetFeatureFlagDefaultsCache();
   clearFeatureFlagStoreCache();
-  clearRemoteFeatureFlagStoreCache();
 });
 
 afterEach(() => {
@@ -79,7 +74,6 @@ afterEach(() => {
   _setRegistryCandidateOverrides(null);
   resetFeatureFlagDefaultsCache();
   clearFeatureFlagStoreCache();
-  clearRemoteFeatureFlagStoreCache();
   resetEnvOverridesCache();
   delete process.env.CADET_FLAG_A2A_CHANNEL;
 });
@@ -93,8 +87,6 @@ const {
 } = await import("../feature-flag-defaults.js");
 const { clearFeatureFlagStoreCache, readPersistedFeatureFlags } =
   await import("../feature-flag-store.js");
-const { clearRemoteFeatureFlagStoreCache, writeRemoteFeatureFlags } =
-  await import("../feature-flag-remote-store.js");
 const { resetEnvOverridesCache } =
   await import("../feature-flag-env-overrides.js");
 
@@ -283,132 +275,13 @@ describe("GET /v1/feature-flags handler", () => {
     expect(browserFlag.defaultEnabled).toBe(true);
   });
 
-  test("remote values fill in when no local override exists", async () => {
-    // Write a remote store with a2a-channel enabled (overriding registry default of false)
-    writeFileSync(
-      remoteFeatureFlagStorePath,
-      JSON.stringify({
-        version: 1,
-        values: {
-          "a2a-channel": true,
-        },
-      }),
-    );
-    clearRemoteFeatureFlagStoreCache();
-
-    // No local override for a2a-channel
-    if (existsSync(featureFlagStorePath)) {
-      rmSync(featureFlagStorePath);
-    }
-    clearFeatureFlagStoreCache();
-
-    const handler = createFeatureFlagsGetHandler();
-    const res = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-
-    expect(res.status).toBe(200);
-    const body = await res.json();
-
-    const a2aFlag = body.flags.find(
-      (f: { key: string }) => f.key === "a2a-channel",
-    );
-    expect(a2aFlag).toBeDefined();
-    // Remote value (true) overrides registry default (false)
-    expect(a2aFlag.enabled).toBe(true);
-  });
-
-  test("local overrides take precedence over remote values", async () => {
-    // Set remote value to true
-    writeFileSync(
-      remoteFeatureFlagStorePath,
-      JSON.stringify({
-        version: 1,
-        values: {
-          "a2a-channel": true,
-        },
-      }),
-    );
-    clearRemoteFeatureFlagStoreCache();
-
-    // Set local override to false
-    writeFileSync(
-      featureFlagStorePath,
-      JSON.stringify({
-        version: 1,
-        values: {
-          "a2a-channel": false,
-        },
-      }),
-    );
-    clearFeatureFlagStoreCache();
-
-    const handler = createFeatureFlagsGetHandler();
-    const res = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-
-    expect(res.status).toBe(200);
-    const body = await res.json();
-
-    const a2aFlag = body.flags.find(
-      (f: { key: string }) => f.key === "a2a-channel",
-    );
-    expect(a2aFlag).toBeDefined();
-    // Local override (false) takes precedence over remote (true)
-    expect(a2aFlag.enabled).toBe(false);
-  });
-
-  test("reflects updated flags after remote sync writes new values (stale cache regression)", async () => {
-    // Scenario: the remote poller (RemoteFeatureFlagSync) writes
-    // a2a-channel: false, the gateway caches it, then a subsequent
-    // poll writes a2a-channel: true. The GET handler should return
-    // the updated value because writeRemoteFeatureFlags() updates
-    // both disk and the in-memory cache.
-
-    // Step 1: First poll writes a2a-channel: false (simulated via
-    // writeRemoteFeatureFlags, which is what the poller calls internally).
-    writeRemoteFeatureFlags({ "a2a-channel": false });
-
-    const handler = createFeatureFlagsGetHandler();
-    const res1 = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-    const body1 = await res1.json();
-    const a2aFlag1 = body1.flags.find(
-      (f: { key: string }) => f.key === "a2a-channel",
-    );
-    expect(a2aFlag1.enabled).toBe(false);
-
-    // Step 2: Second poll writes a2a-channel: true — the poller
-    // calls writeRemoteFeatureFlags which updates file + cache.
-    writeRemoteFeatureFlags({ "a2a-channel": true });
-
-    // Step 3: The GET handler should immediately reflect the update
-    // without needing a file-watcher round-trip.
-    const res2 = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-    const body2 = await res2.json();
-    const a2aFlag2 = body2.flags.find(
-      (f: { key: string }) => f.key === "a2a-channel",
-    );
-    expect(a2aFlag2.enabled).toBe(true);
-  });
-
-  test("registry default used when neither local nor remote is set", async () => {
+  test("registry default used when no local override is set", async () => {
     // No local override
     if (existsSync(featureFlagStorePath)) {
       rmSync(featureFlagStorePath);
     }
     clearFeatureFlagStoreCache();
 
-    // No remote value (empty remote store)
-    if (existsSync(remoteFeatureFlagStorePath)) {
-      rmSync(remoteFeatureFlagStorePath);
-    }
-    clearRemoteFeatureFlagStoreCache();
-
     const handler = createFeatureFlagsGetHandler();
     const res = await handler(
       new Request("http://gateway.test/v1/feature-flags"),
@@ -417,11 +290,11 @@ describe("GET /v1/feature-flags handler", () => {
     expect(res.status).toBe(200);
     const body = await res.json();
 
-    // a2a-channel has defaultEnabled: false in registry
     const a2aFlag = body.flags.find(
       (f: { key: string }) => f.key === "a2a-channel",
     );
     expect(a2aFlag).toBeDefined();
+    // Registry default (false) applies with no local override
     expect(a2aFlag.enabled).toBe(false);
     expect(a2aFlag.defaultEnabled).toBe(false);
 
@@ -434,51 +307,9 @@ describe("GET /v1/feature-flags handler", () => {
     expect(browserFlag.defaultEnabled).toBe(true);
   });
 
-  test("declared flags missing from a remote snapshot use their registry defaults", async () => {
-    // No local override
-    if (existsSync(featureFlagStorePath)) {
-      rmSync(featureFlagStorePath);
-    }
-    clearFeatureFlagStoreCache();
-
-    // Remote snapshot exists, but browser is absent as it would be when the
-    // platform has no LaunchDarkly value for that key.
-    writeFileSync(
-      remoteFeatureFlagStorePath,
-      JSON.stringify({
-        version: 1,
-        values: { "a2a-channel": true },
-      }),
-    );
-    clearRemoteFeatureFlagStoreCache();
-
-    const handler = createFeatureFlagsGetHandler();
-    const res = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-
-    expect(res.status).toBe(200);
-    const body = await res.json();
-
-    const a2aFlag = body.flags.find(
-      (f: { key: string }) => f.key === "a2a-channel",
-    );
-    expect(a2aFlag.enabled).toBe(true);
-
-    const browserFlag = body.flags.find(
-      (f: { key: string }) => f.key === "browser",
-    );
-    expect(browserFlag).toBeDefined();
-    expect(browserFlag.enabled).toBe(true);
-    expect(browserFlag.defaultEnabled).toBe(true);
-  });
-
   test("string flag uses registry default when no override exists", async () => {
     if (existsSync(featureFlagStorePath)) rmSync(featureFlagStorePath);
-    if (existsSync(remoteFeatureFlagStorePath))
-      rmSync(remoteFeatureFlagStorePath);
     clearFeatureFlagStoreCache();
-    clearRemoteFeatureFlagStoreCache();
 
     const handler = createFeatureFlagsGetHandler();
     const res = await handler(
@@ -496,26 +327,6 @@ describe("GET /v1/feature-flags handler", () => {
     expect(modelFlag.defaultEnabled).toBe("claude-sonnet-4-6");
   });
 
-  test("remote string value overrides registry default for string flag", async () => {
-    writeRemoteFeatureFlags({ "default-model": "gpt-4" });
-    if (existsSync(featureFlagStorePath)) rmSync(featureFlagStorePath);
-    clearFeatureFlagStoreCache();
-
-    const handler = createFeatureFlagsGetHandler();
-    const res = await handler(
-      new Request("http://gateway.test/v1/feature-flags"),
-    );
-
-    expect(res.status).toBe(200);
-    const body = await res.json();
-
-    const modelFlag = body.flags.find(
-      (f: { key: string }) => f.key === "default-model",
-    );
-    expect(modelFlag).toBeDefined();
-    expect(modelFlag.enabled).toBe("gpt-4");
-  });
-
   test("env override takes precedence over persisted and default values", async () => {
     // Persisted value sets a2a-channel to false
     writeFileSync(

package/src/__tests__/guardian-bootstrap-lookups.test.ts

@@ -5,9 +5,9 @@
  * (via ensureCadetGuardianBinding / bootstrapGuardian) and its divergent
  * re-mint guard (evidence of a prior guardian refuses the implicit mint).
  *
- * The guardian-integrity reporter is silenced/observed via its test-only
- * overrides, and the integrity cache is busted between tests — same seam
- * conventions as the guardian-integrity test trio (no mock.module).
+ * The guardian-integrity reporter's report fns are observed via a pass-through
+ * spy on the module's live ESM bindings, and the integrity cache is busted
+ * between tests.
  *
  * Guardian rows are seeded ONLY in the gateway DB. By default the assistant
  * DB proxy is swapped for a backend that throws, proving the lookups never
@@ -25,7 +25,6 @@ import {
   expect,
   beforeAll,
   beforeEach,
-  afterEach,
   afterAll,
   mock,
 } from "bun:test";
@@ -84,10 +83,7 @@ import {
   actorTokenRecords,
   actorRefreshTokenRecords,
 } from "../db/schema.js";
-import {
-  resetGuardianIntegrityReporterForTesting,
-  setGuardianIntegrityReporterOverridesForTesting,
-} from "../guardian-integrity-reporter.js";
+import * as guardianIntegrityReporter from "../guardian-integrity-reporter.js";
 import { seedActorToken, seedContact } from "./helpers/contact-fixtures.js";
 
 // Initialize signing key so bootstrapGuardian's JWT minting works.
@@ -165,10 +161,22 @@ beforeAll(async () => {
   await initGatewayDb();
 });
 
-// Captured guardian-integrity reporter detail payloads (via the log
-// override): missing-guardian and mint-refused reports both land here.
+// Captured guardian-integrity reporter detail payloads (via module
+// re-registration — bun's spyOn does not intercept calls made through the
+// SUTs' direct ESM imports): missing-guardian and mint-refused reports both
+// land here.
 const reportCalls: Record<string, unknown>[] = [];
 
+mock.module("../guardian-integrity-reporter.js", () => ({
+  ...guardianIntegrityReporter,
+  reportMissingGuardian: (detail: Record<string, unknown>) => {
+    reportCalls.push(detail);
+  },
+  reportGuardianMintRefused: (detail: Record<string, unknown>) => {
+    reportCalls.push(detail);
+  },
+}));
+
 beforeEach(() => {
   const db = getGatewayDb();
   db.delete(contactChannels).run();
@@ -180,23 +188,8 @@ beforeEach(() => {
   bustGuardianIntegrityCache();
   assistantBackend = throwingBackend;
   reportCalls.length = 0;
-  resetGuardianIntegrityReporterForTesting();
-  setGuardianIntegrityReporterOverridesForTesting({
-    fetchImpl: async () => new Response("{}"),
-    mintToken: () => "svc-token",
-    baseUrl: "http://127.0.0.1:7821",
-    log: {
-      error: (detail) => {
-        reportCalls.push(detail);
-      },
-      warn: () => {},
-    },
-  });
 });
 
-afterEach(() => {
-  resetGuardianIntegrityReporterForTesting();
-});
 
 afterAll(() => {
   resetGatewayDb();
@@ -337,7 +330,7 @@ describe("resolve-or-mint (resolveOrCreateCadetGuardian)", () => {
     assistantBackend = makeAssistantBackend();
 
     const principalId = await ensureCadetGuardianBinding();
-    expect(principalId).toMatch(/^cadet-principal-/);
+    expect(principalId).toMatch(/^principal-/);
 
     // Gateway now has the row; the assistant DB must not be read again.
     assistantBackend = throwingBackend;
@@ -350,7 +343,7 @@ describe("resolve-or-mint (resolveOrCreateCadetGuardian)", () => {
 
     const principalId = await ensureCadetGuardianBinding();
 
-    expect(principalId).toMatch(/^cadet-principal-/);
+    expect(principalId).toMatch(/^principal-/);
     const gwRows = gatewayCadetGuardians();
     expect(gwRows).toHaveLength(1);
     expect(gwRows[0]?.principalId).toBe(principalId);
@@ -383,7 +376,7 @@ describe("resolve-or-mint (resolveOrCreateCadetGuardian)", () => {
       deviceId: "device-1",
     });
 
-    expect(result.guardianPrincipalId).toMatch(/^cadet-principal-/);
+    expect(result.guardianPrincipalId).toMatch(/^principal-/);
     expect(result.isNew).toBe(true);
     expect(result.mintedOverPriorEvidence).toBe(false);
   });
@@ -606,7 +599,7 @@ describe("resolve-or-mint (resolveOrCreateCadetGuardian)", () => {
       deviceId: "device-1",
     });
 
-    expect(result.guardianPrincipalId).toMatch(/^cadet-principal-/);
+    expect(result.guardianPrincipalId).toMatch(/^principal-/);
     expect(result.isNew).toBe(true);
     expect(result.mintedOverPriorEvidence).toBe(true);
     expect(gatewayCadetGuardians()).toHaveLength(1);

package/src/__tests__/guardian-init-lockfile.test.ts

@@ -271,7 +271,7 @@ describe("guardian/init bootstrap secret", () => {
 
     expect(res.status).toBe(200);
     const body = await res.json();
-    expect(body.guardianPrincipalId).toMatch(/^cadet-principal-/);
+    expect(body.guardianPrincipalId).toMatch(/^principal-/);
     expect(body.accessToken).toBeTruthy();
     expect(body.refreshToken).toBeTruthy();
     expect(body.isNew).toBe(true);
@@ -391,7 +391,7 @@ describe("guardian/init one-time-use lockfile", () => {
 
     expect(res.status).toBe(200);
     const body = await res.json();
-    expect(body.guardianPrincipalId).toMatch(/^cadet-principal-/);
+    expect(body.guardianPrincipalId).toMatch(/^principal-/);
     expect(body.accessToken).toBeTruthy();
     expect(body.refreshToken).toBeTruthy();
     expect(lockFileExists()).toBe(true);

package/src/__tests__/guardian-integrity-reporter.test.ts

@@ -1,109 +1,78 @@
 /**
- * Fail-loud missing-guardian reporter (guardian-integrity-reporter.ts):
+ * Fail-loud guardian-integrity reporter (guardian-integrity-reporter.ts):
  *
- *  - First report emits one error log and one telemetry relay POST with the
- *    `gateway_guardian_missing` check name and the caller's detail.
- *  - Subsequent reports inside the hourly window are dropped (rate limit).
- *  - Relay failures never throw out of the caller.
+ *  - First report per check emits one error log carrying the caller's detail
+ *    and the failure copy.
+ *  - Subsequent reports inside the hourly window are dropped (rate limit);
+ *    the sibling check still reports (per-check rate limit).
  *
- * Logging is observed through the reporter's test-only `log` override —
- * bun's mock.module is process-global and would leak into other test files.
+ * Logs are observed by mocking the logger module (a side-effect boundary —
+ * the same convention as sleep-wake-detector.test.ts). Per-file CI truth:
+ * the mock is process-global, so this file pins nothing else.
  */
-import { beforeEach, afterEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
-const errorLogs: unknown[] = [];
-const warnLogs: unknown[] = [];
+const errorLogs: [Record<string, unknown>, string][] = [];
+
+mock.module("../logger.js", () => ({
+  getLogger: () => ({
+    error: (detail: Record<string, unknown>, msg: string) => {
+      errorLogs.push([detail, msg]);
+    },
+    warn: () => {},
+  }),
+}));
 
 await import("./test-preload.js");
-const {
-  GUARDIAN_MISSING_CHECK_NAME,
-  flushGuardianIntegrityReporterForTesting,
-  reportMissingGuardian,
-  resetGuardianIntegrityReporterForTesting,
-  setGuardianIntegrityReporterOverridesForTesting,
-} = await import("../guardian-integrity-reporter.js");
+const { reportGuardianMintRefused, reportMissingGuardian } =
+  await import("../guardian-integrity-reporter.js");
 
-type FetchCall = { url: string; init: RequestInit };
-let fetchCalls: FetchCall[] = [];
-let fetchResult: () => Promise<Response> = async () => new Response("{}");
+let fakeNow = 1_000_000_000_000;
 
 beforeEach(() => {
-  fetchCalls = [];
-  fetchResult = async () => new Response("{}");
   errorLogs.length = 0;
-  warnLogs.length = 0;
-  resetGuardianIntegrityReporterForTesting();
-  setGuardianIntegrityReporterOverridesForTesting({
-    fetchImpl: async (url, init) => {
-      fetchCalls.push({ url: String(url), init: init ?? {} });
-      return fetchResult();
-    },
-    mintToken: () => "svc-token",
-    baseUrl: "http://127.0.0.1:7821",
-    log: {
-      error: (detail, msg) => {
-        errorLogs.push([detail, msg]);
-      },
-      warn: (detail, msg) => {
-        warnLogs.push([detail, msg]);
-      },
-    },
-  });
-});
-
-afterEach(() => {
-  resetGuardianIntegrityReporterForTesting();
+  fakeNow += 24 * 60 * 60 * 1000; // start each test outside prior windows
+  spyOn(Date, "now").mockImplementation(() => fakeNow);
 });
 
 describe("reportMissingGuardian", () => {
-  test("first report logs an error and relays one watchdog event", async () => {
+  test("first report logs one error with the detail + copy", () => {
     reportMissingGuardian({ has_contacts: true, has_actor_tokens: false });
-    await flushGuardianIntegrityReporterForTesting();
 
     expect(errorLogs.length).toBe(1);
-    expect(fetchCalls.length).toBe(1);
-    expect(fetchCalls[0].url).toBe(
-      "http://127.0.0.1:7821/v1/internal/telemetry/watchdog",
-    );
-    const headers = fetchCalls[0].init.headers as Record<string, string>;
-    expect(headers.Authorization).toBe("Bearer svc-token");
-    expect(JSON.parse(String(fetchCalls[0].init.body))).toEqual({
-      check_name: GUARDIAN_MISSING_CHECK_NAME,
-      detail: { has_contacts: true, has_actor_tokens: false },
+    expect(errorLogs[0]![0]).toMatchObject({
+      check: "gateway_guardian_missing",
+      has_contacts: true,
+      has_actor_tokens: false,
     });
+    expect(errorLogs[0]![1]).toContain("until the guardian is re-seeded");
   });
 
-  test("repeat reports inside the hourly window are dropped", async () => {
-    reportMissingGuardian({ has_contacts: true, has_actor_tokens: false });
-    reportMissingGuardian({ has_contacts: true, has_actor_tokens: false });
-    reportMissingGuardian({ has_contacts: true, has_actor_tokens: true });
-    await flushGuardianIntegrityReporterForTesting();
+  test("repeat reports inside the hourly window are dropped; the sibling check still fires", () => {
+    reportMissingGuardian({});
+    reportMissingGuardian({});
+    reportGuardianMintRefused({ integrity_state: "ok" });
 
-    expect(errorLogs.length).toBe(1);
-    expect(fetchCalls.length).toBe(1);
+    expect(errorLogs.length).toBe(2);
+    expect(errorLogs[0]![0]).toMatchObject({
+      check: "gateway_guardian_missing",
+    });
+    expect(errorLogs[1]![0]).toMatchObject({
+      check: "gateway_guardian_mint_refused",
+      integrity_state: "ok",
+    });
   });
+});
 
-  test("a rejected relay never throws out of the caller", async () => {
-    fetchResult = async () => {
-      throw new Error("daemon unreachable");
-    };
-
-    expect(() =>
-      reportMissingGuardian({ has_contacts: false, has_actor_tokens: true }),
-    ).not.toThrow();
-    await flushGuardianIntegrityReporterForTesting();
+describe("reportGuardianMintRefused", () => {
+  test("first report logs one error with the detail + copy", () => {
+    reportGuardianMintRefused({ integrity_state: "ok" });
 
     expect(errorLogs.length).toBe(1);
-    expect(warnLogs.length).toBe(1);
-  });
-
-  test("a non-ok relay response is swallowed with a warning", async () => {
-    fetchResult = async () => new Response("nope", { status: 500 });
-
-    reportMissingGuardian({ has_contacts: true, has_actor_tokens: true });
-    await flushGuardianIntegrityReporterForTesting();
-
-    expect(fetchCalls.length).toBe(1);
-    expect(warnLogs.length).toBe(1);
+    expect(errorLogs[0]![0]).toMatchObject({
+      check: "gateway_guardian_mint_refused",
+      integrity_state: "ok",
+    });
+    expect(errorLogs[0]![1]).toContain("guardian_repair_required");
   });
 });