@cosmicdrift/kumiko-framework 0.269.2 → 0.270.0

package/src/engine/feature-ast/__tests__/patcher.test.ts

@@ -131,14 +131,14 @@ describe("FeaturePatcher — typed add helpers for mixed (closure-bearing) patte
       name: "task:list",
       schemaSource: "z.object({})",
       handlerSource: "async (q, ctx) => []",
-      access: { openToAll: true },
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
     });
     const result = parseSourceFile(sf);
     const pattern = result.patterns[0];
     expect(pattern).toMatchObject({
       kind: "queryHandler",
       handlerName: "task:list",
-      access: { openToAll: true },
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
     });
   });
 
@@ -441,7 +441,7 @@ defineFeature("tasks", (r) => {
       name: "task:list",
       schemaSource: "z.object({})",
       handlerSource: "async (q, ctx) => []",
-      access: { openToAll: true },
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
     });
     p.addStreamHandler({
       name: "task:stream",

package/src/engine/feature-ast/__tests__/read-optional-access-rule.test.ts

@@ -20,9 +20,9 @@ describe("readOptionalAccessRule — openToAll.personalData", () => {
     ).toEqual({ openToAll: { reason: "signup" } });
   });
 
-  test("the deprecated openToAll: true form carries no personalData", () => {
-    expect(readOptionalAccessRule({ openToAll: true, personalData: "tenant-members" })).toEqual({
-      openToAll: true,
-    });
+  test("the deprecated openToAll: true form is not extracted — fail-closed, consistent with isOpenToAllGranted", () => {
+    expect(
+      readOptionalAccessRule({ openToAll: true, personalData: "tenant-members" }),
+    ).toBeUndefined();
   });
 });

package/src/engine/feature-ast/__tests__/render-roundtrip.test.ts

@@ -209,7 +209,11 @@ defineFeature("workflow", (r) => {
     "step:list",
     z.object({}),
     async (q, ctx) => [],
-    { access: { openToAll: true }, description: "Lists steps.", agent: { risk: "low" } },
+    {
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+      description: "Lists steps.",
+      agent: { risk: "low" },
+    },
   );
 
   r.streamHandler(

package/src/engine/feature-ast/extractors/handlers.ts

@@ -4,12 +4,13 @@ import type {
   AccessRule,
   AgentHandlerHints,
   AgentRisk,
+  EscapeHatchDeclaration,
   RateLimitOption,
 } from "../../types/handlers";
 import type { QueryHandlerPattern, StreamHandlerPattern, WriteHandlerPattern } from "../patterns";
 import type { SourceLocation } from "../source-location";
 import { sourceLocationFromNode } from "../source-location";
-import { readOptionalAccessRule, readOptionalRateLimit } from "./hooks";
+import { readOptionalAccessRule, readOptionalEscapeHatch, readOptionalRateLimit } from "./hooks";
 import {
   type ExtractOutput,
   fail,
@@ -32,6 +33,7 @@ export type ParsedHandlerCall = {
   readonly agent?: AgentHandlerHints;
   readonly rateLimit?: RateLimitOption;
   readonly unsafeSkipTransitionGuard?: boolean;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 const AGENT_RISK_VALUES: readonly AgentRisk[] = ["low", "mid", "high"];
@@ -85,18 +87,20 @@ function readDescriptionAndAgent(
  */
 function readOptionsFields(
   options: unknown,
-): Pick<ParsedHandlerCall, "access" | "rateLimit" | "description" | "agent"> {
+): Pick<ParsedHandlerCall, "access" | "rateLimit" | "description" | "agent" | "escapeHatch"> {
   if (!isPlainObject(options)) return {};
   const access = readOptionalAccessRule(options["access"]);
   const rateLimit = readOptionalRateLimit(options["rateLimit"]);
   const description =
     typeof options["description"] === "string" ? options["description"] : undefined;
   const agent = readOptionalAgentHints(options["agent"]);
+  const escapeHatch = readOptionalEscapeHatch(options["escapeHatch"]);
   return {
     ...(access !== undefined && { access }),
     ...(description !== undefined && { description }),
     ...(agent !== undefined && { agent }),
     ...(rateLimit !== undefined && { rateLimit }),
+    ...(escapeHatch !== undefined && { escapeHatch }),
   };
 }
 
@@ -188,6 +192,13 @@ export function parseHandlerCall(
       : undefined;
     const { description, agent } = readDescriptionAndAgent(obj);
     const skip = readBooleanProperty(obj, "unsafeSkipTransitionGuard");
+    const escapeHatchInit = obj
+      .getProperty("escapeHatch")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const escapeHatch = escapeHatchInit
+      ? readOptionalEscapeHatch(readDataLiteralNode(escapeHatchInit))
+      : undefined;
     return ok({
       source: sourceLocationFromNode(call, sourceFile),
       handlerName: nameLiteral.getLiteralValue(),
@@ -198,6 +209,7 @@ export function parseHandlerCall(
       ...(agent !== undefined && { agent }),
       ...(rateLimit !== undefined && { rateLimit }),
       ...(skip === true && { unsafeSkipTransitionGuard: true }),
+      ...(escapeHatch !== undefined && { escapeHatch }),
     });
   }
 
@@ -271,6 +283,7 @@ export function extractWriteHandler(
     ...(parsed.pattern.agent !== undefined && { agent: parsed.pattern.agent }),
     ...(parsed.pattern.rateLimit !== undefined && { rateLimit: parsed.pattern.rateLimit }),
     ...(parsed.pattern.unsafeSkipTransitionGuard === true && { unsafeSkipTransitionGuard: true }),
+    ...(parsed.pattern.escapeHatch !== undefined && { escapeHatch: parsed.pattern.escapeHatch }),
   });
 }
 
@@ -296,6 +309,7 @@ export function extractQueryHandler(
     ...readHandlerFields(parsed),
     ...(parsed.pattern.description !== undefined && { description: parsed.pattern.description }),
     ...(parsed.pattern.agent !== undefined && { agent: parsed.pattern.agent }),
+    ...(parsed.pattern.escapeHatch !== undefined && { escapeHatch: parsed.pattern.escapeHatch }),
   });
 }
 

package/src/engine/feature-ast/extractors/hooks.ts

@@ -1,7 +1,7 @@
 import type { CallExpression, Node, SourceFile } from "ts-morph";
 import { SyntaxKind } from "ts-morph";
 import type { LifecycleHookType } from "../../constants";
-import type { AccessRule, RateLimitOption } from "../../types/handlers";
+import type { AccessRule, EscapeHatchDeclaration, RateLimitOption } from "../../types/handlers";
 import type { HookPhase } from "../../types/hooks";
 import type { AuthClaimsPattern, HookPattern } from "../patterns";
 import { sourceLocationFromNode } from "../source-location";
@@ -37,14 +37,12 @@ export function readOptionalPhase(node: Node | undefined): HookPhase | undefined
   return undefined;
 }
 
+// `openToAll: true` (deprecated) is not recognised here — isOpenToAllGranted never grants it, so extracting it would round-trip a rule that looks configured but denies everyone.
 export function readOptionalAccessRule(value: unknown): AccessRule | undefined {
   if (!isPlainObject(value)) return undefined;
   if (Array.isArray(value["roles"]) && value["roles"].every((r) => typeof r === "string")) {
     return { roles: value["roles"] as readonly string[] };
   }
-  if (value["openToAll"] === true) {
-    return { openToAll: true };
-  }
   const openToAll = value["openToAll"];
   if (isPlainObject(openToAll) && typeof openToAll["reason"] === "string") {
     const personalData =
@@ -64,6 +62,25 @@ export function readOptionalRateLimit(value: unknown): RateLimitOption | undefin
   return value as unknown as RateLimitOption;
 }
 
+export function readOptionalEscapeHatch(value: unknown): EscapeHatchDeclaration | undefined {
+  if (!isPlainObject(value)) return undefined;
+  if (typeof value["reason"] !== "string") return undefined;
+  return { reason: value["reason"] };
+}
+
+// Extracts the `escapeHatch` sub-property node first, not via readDataLiteralNode on the whole object — a sibling property like `handler` (a closure) isn't representable as plain data, which would make the whole-object read return undefined.
+export function readOptionalHookEscapeHatch(
+  node: Node | undefined,
+): EscapeHatchDeclaration | undefined {
+  const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (!obj) return undefined;
+  const init = obj
+    .getProperty("escapeHatch")
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer();
+  return init ? readOptionalEscapeHatch(readDataLiteralNode(init)) : undefined;
+}
+
 // r.hook's target: a NameOrRef, a list of them, or an entity-wide
 // `{ allOf: entityRef }` (replaces the old r.entityHook(type, entity, fn)).
 // Checked first so a malformed `{ allOf }` doesn't silently fall through
@@ -154,6 +171,7 @@ export function extractHook(
       );
     }
     const phase = readOptionalPhase(obj);
+    const escapeHatch = readOptionalHookEscapeHatch(obj);
     return ok({
       kind: "hook",
       source: sourceLocationFromNode(call, sourceFile),
@@ -161,6 +179,7 @@ export function extractHook(
       target,
       fnBody: sourceLocationFromNode(fn, sourceFile),
       ...(phase !== undefined && { phase }),
+      ...(escapeHatch !== undefined && { escapeHatch }),
     });
   }
 
@@ -212,6 +231,7 @@ export function extractHook(
     );
   }
   const phase = readOptionalPhase(args[3]);
+  const escapeHatch = readOptionalHookEscapeHatch(args[3]);
   return ok({
     kind: "hook",
     source: sourceLocationFromNode(call, sourceFile),
@@ -219,6 +239,7 @@ export function extractHook(
     target,
     fnBody: sourceLocationFromNode(fn, sourceFile),
     ...(phase !== undefined && { phase }),
+    ...(escapeHatch !== undefined && { escapeHatch }),
   });
 }
 

package/src/engine/feature-ast/patcher.ts

@@ -31,7 +31,12 @@ import type {
 } from "../types/config";
 import type { MetricOptions, SecretOptions } from "../types/feature";
 import type { EntityDefinition } from "../types/fields";
-import type { AccessRule, ClaimKeyType, RateLimitOption } from "../types/handlers";
+import type {
+  AccessRule,
+  ClaimKeyType,
+  EscapeHatchDeclaration,
+  RateLimitOption,
+} from "../types/handlers";
 import type { HookPhase } from "../types/hooks";
 import type { HttpRouteMethod } from "../types/http-route";
 import type { NavDefinition } from "../types/nav";
@@ -94,6 +99,7 @@ export type AddWriteHandlerArgs = {
   readonly access?: AccessRule;
   readonly rateLimit?: RateLimitOption;
   readonly unsafeSkipTransitionGuard?: boolean;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 export type AddQueryHandlerArgs = {
@@ -102,6 +108,7 @@ export type AddQueryHandlerArgs = {
   readonly handlerSource: string;
   readonly access?: AccessRule;
   readonly rateLimit?: RateLimitOption;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 export type AddStreamHandlerArgs = {
@@ -121,6 +128,7 @@ export type AddHookArgs = {
   /** Source text of the closure, e.g. `"async (event, ctx) => { ... }"`. */
   readonly handlerSource: string;
   readonly phase?: HookPhase;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 export type AddJobArgs = {
@@ -380,6 +388,7 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
       access,
       rateLimit,
       unsafeSkipTransitionGuard,
+      escapeHatch,
     }) {
       add({
         kind: "writeHandler",
@@ -390,10 +399,11 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
         ...(access !== undefined && { access }),
         ...(rateLimit !== undefined && { rateLimit }),
         ...(unsafeSkipTransitionGuard === true && { unsafeSkipTransitionGuard: true }),
+        ...(escapeHatch !== undefined && { escapeHatch }),
       });
     },
 
-    addQueryHandler({ name, schemaSource, handlerSource, access, rateLimit }) {
+    addQueryHandler({ name, schemaSource, handlerSource, access, rateLimit, escapeHatch }) {
       add({
         kind: "queryHandler",
         source: SYNTHETIC_LOC,
@@ -402,6 +412,7 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
         handlerBody: rawLoc(handlerSource),
         ...(access !== undefined && { access }),
         ...(rateLimit !== undefined && { rateLimit }),
+        ...(escapeHatch !== undefined && { escapeHatch }),
       });
     },
 
@@ -417,7 +428,7 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
       });
     },
 
-    addHook({ type, target, handlerSource, phase }) {
+    addHook({ type, target, handlerSource, phase, escapeHatch }) {
       add({
         kind: "hook",
         source: SYNTHETIC_LOC,
@@ -425,6 +436,7 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
         target,
         fnBody: rawLoc(handlerSource),
         ...(phase !== undefined && { phase }),
+        ...(escapeHatch !== undefined && { escapeHatch }),
       });
     },
 

package/src/engine/feature-ast/patterns.ts

@@ -70,6 +70,7 @@ import type {
   AccessRule,
   AgentHandlerHints,
   ClaimKeyType,
+  EscapeHatchDeclaration,
   RateLimitOption,
 } from "../types/handlers";
 import type { HookPhase } from "../types/hooks";
@@ -388,6 +389,7 @@ export type WriteHandlerPattern = {
   readonly agent?: AgentHandlerHints;
   readonly rateLimit?: RateLimitOption;
   readonly unsafeSkipTransitionGuard?: boolean;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 // `r.queryHandler(...)` — registers a read handler: name, Zod input schema,
@@ -410,6 +412,7 @@ export type QueryHandlerPattern = {
   readonly description?: string;
   readonly agent?: AgentHandlerHints;
   readonly rateLimit?: RateLimitOption;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 // `r.streamHandler(...)` — registers a streaming read handler: name, Zod
@@ -444,6 +447,7 @@ export type HookPattern = {
   readonly target: string | readonly string[] | { readonly allOf: string };
   readonly fnBody: SourceLocation;
   readonly phase?: HookPhase;
+  readonly escapeHatch?: EscapeHatchDeclaration;
 };
 
 // `r.job(name, options, handler)` — registers a background job, qualified

package/src/engine/feature-ast/render.ts

@@ -408,6 +408,7 @@ function renderWriteHandler(p: WriteHandlerPattern): string {
   if (p.agent !== undefined) lines.push(`  agent: ${renderValue(p.agent)},`);
   if (p.rateLimit !== undefined) lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
   if (p.unsafeSkipTransitionGuard === true) lines.push("  unsafeSkipTransitionGuard: true,");
+  if (p.escapeHatch !== undefined) lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
   lines.push("});");
   return lines.join("\n");
 }
@@ -422,6 +423,7 @@ function renderQueryHandler(p: QueryHandlerPattern): string {
   if (p.description !== undefined) lines.push(`  description: ${JSON.stringify(p.description)},`);
   if (p.agent !== undefined) lines.push(`  agent: ${renderValue(p.agent)},`);
   if (p.rateLimit !== undefined) lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
+  if (p.escapeHatch !== undefined) lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
   lines.push("});");
   return lines.join("\n");
 }
@@ -450,6 +452,7 @@ function renderHook(p: HookPattern): string {
   lines.push(`  target: ${renderHookTarget(p.target)},`);
   lines.push(`  handler: ${reindentBody(p.fnBody.raw, PATTERN_INDENT)},`);
   if (p.phase !== undefined) lines.push(`  phase: ${JSON.stringify(p.phase)},`);
+  if (p.escapeHatch !== undefined) lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
   lines.push("});");
   return lines.join("\n");
 }

package/src/engine/pattern-library/shared-fields.ts

@@ -61,9 +61,13 @@ export const accessRuleField: FormFieldSpec = {
       label: { en: "Open to all (auth still required)", de: "Für alle (Auth nötig)" },
       fields: [
         {
-          path: "access.openToAll",
-          label: { en: "Open to all", de: "Offen für alle" },
-          input: "boolean",
+          path: "access.openToAll.reason",
+          label: { en: "Reason", de: "Begründung" },
+          hint: {
+            en: "Who may call this, and why that is safe without a role — required, `true` alone no longer grants access.",
+          },
+          input: "text",
+          required: true,
         },
       ],
     },

package/src/entrypoint/__tests__/entrypoint-attach-dispatcher.integration.test.ts

@@ -41,7 +41,7 @@ const writeProbeFeature = defineFeature("writeProbe", (r) => {
       });
       return { isSuccess: true as const, data: { note: event.payload.note } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job("write-via-job", { trigger: { manual: true }, retries: 0 }, async (payload, ctx) => {
     try {

package/src/entrypoint/__tests__/entrypoint-job-wiring.integration.test.ts

@@ -33,7 +33,7 @@ const wiringFeature = defineFeature("wiring", (r) => {
       isSuccess: true as const,
       data: { id: 1, sku: event.payload.sku },
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job(
     "record-order",
@@ -57,7 +57,7 @@ const mixedLaneFeature = defineFeature("mixed", (r) => {
       isSuccess: true as const,
       data: { id: 1, msg: event.payload.msg },
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job(
     "handle-on-worker",
@@ -240,7 +240,7 @@ const featureGateJobFeature = defineFeature("featuregate", (r) => {
       isSuccess: true as const,
       data: { id: 1, msg: event.payload.msg },
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job(
     "record-features",

package/src/entrypoint/__tests__/split-deploy.integration.test.ts

@@ -57,7 +57,7 @@ const workerWriteFeature = defineFeature("workerWrite", (r) => {
       });
       return { isSuccess: true as const, data: { note: event.payload.note } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.multiStreamProjection({
     name: "consume-notes",

package/src/es-ops/__tests__/runner.integration.test.ts

@@ -58,7 +58,7 @@ const seedTestFeature = defineFeature("esopstest", (r) => {
     "probe:create",
     z.object({ label: z.string().min(1) }),
     async (event, ctx) => probeExecutor.create(event.payload, event.user, ctx.db),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.writeHandler(
     "probe:fail",
@@ -70,7 +70,7 @@ const seedTestFeature = defineFeature("esopstest", (r) => {
         currentVersion: 2,
       });
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   // Role-gated handler (no openToAll): the bare system actor has no bypass
   // for explicit role gates — only systemWriteAs' extraRoles reaches it.

package/src/jobs/__tests__/job-event-trigger.integration.test.ts

@@ -26,7 +26,7 @@ const ordersFeature = defineFeature("orders", (r) => {
         data: { id: 1, product: event.payload.product, amount: event.payload.amount },
       };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 
@@ -51,7 +51,7 @@ const analyticsFeature = defineFeature("analytics", (r) => {
       isSuccess: true as const,
       data: null,
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.job("trackOrder", { trigger: { on: "orders:write:orders:create" } }, async (payload) => {

package/src/jobs/__tests__/job-multi-trigger.integration.test.ts

@@ -27,13 +27,13 @@ const orderFeature = defineFeature("multi", (r) => {
     "order:open",
     z.object({ id: z.string() }),
     async (event) => ({ isSuccess: true, data: { id: event.payload.id } }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.writeHandler(
     "order:cancel",
     z.object({ id: z.string() }),
     async (event) => ({ isSuccess: true, data: { id: event.payload.id } }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job(
     "fanout",

package/src/jobs/__tests__/jobs.integration.test.ts

@@ -119,7 +119,7 @@ const testFeature = defineFeature("test", (r) => {
     "capped-event",
     z.object({ n: z.number() }),
     async (event) => ({ isSuccess: true, data: { n: event.payload.n } }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   // Event-triggered twin — exercises handleEvent's maxPerTenant guard
   // (dispatch and handleEvent share isOverPerTenantLimit).

package/src/observability/__tests__/observability.integration.test.ts

@@ -33,7 +33,7 @@ const productFeature = defineFeature("product", (r) => {
       ctx.metrics.inc("tracked_total", { kind: event.payload.kind });
       return { isSuccess: true, data: { ok: true } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 
@@ -44,7 +44,7 @@ const errorFeature = defineFeature("err", (r) => {
     async () => {
       throw new Error("boom from handler");
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 
@@ -90,7 +90,7 @@ const todoFeature = defineFeature("todo", (r) => {
         },
       };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.hook("postSave", "create", async (_save: SaveContext) => {
@@ -288,7 +288,7 @@ describe("Observability (integration) — Redis wrapper", () => {
         await ctx.redis.get("session:abc123:token");
         return { isSuccess: true, data: { ok: true } };
       },
-      { access: { openToAll: true } },
+      { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
     );
   });
 
@@ -352,7 +352,7 @@ describe("Observability (integration) — Pino trace bridge", () => {
         ctx.log?.info(event.payload.msg, { custom: "field" });
         return { isSuccess: true, data: { ok: true } };
       },
-      { access: { openToAll: true } },
+      { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
     );
   });
 
@@ -581,7 +581,7 @@ const consumerAFeature = defineFeature("consumer-a", (r) => {
       recordSharedCall(ctx);
       return { isSuccess: true, data: { ok: true } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 
@@ -594,7 +594,7 @@ const consumerBFeature = defineFeature("consumer-b", (r) => {
       ctx.metricsFor("unregistered-lib").inc("never_total");
       return { isSuccess: true, data: { ok: true } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 

package/src/pipeline/__tests__/archive-stream.integration.test.ts

@@ -109,14 +109,14 @@ const archFeature = defineFeature("archtest", (r) => {
     "item:events",
     z.object({ id: z.uuid() }),
     async (query, ctx) => ctx.loadAggregate(query.payload.id),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.queryHandler(
     "item:is-archived",
     z.object({ id: z.uuid() }),
     async (query, ctx) => ctx.isStreamArchived(query.payload.id),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });