@cosmicdrift/kumiko-bundled-features 0.388.0 → 0.390.0

package/dist/agent-tools/index.d.ts

@@ -4,5 +4,5 @@ export { buildAgentManifest } from "./agent-manifest.ts";
 export { AGENT_TOOLS_FEATURE_NAME, createAgentToolsFeature } from "./feature.ts";
 export { buildToolCatalog, OPEN_FORM_TOOL_NAME, toolNameForQn } from "./tool-catalog.ts";
 export type { ToolCallRequest, ToolCallResult, ToolDispatcher } from "./tool-dispatch.ts";
-export { dispatchToolCall } from "./tool-dispatch.ts";
+export { dispatchToolCall, TOOL_CALL_ERROR_CODES } from "./tool-dispatch.ts";
 export type { AgentManifest, AgentManifestEntity, AgentManifestFeature, AgentManifestField, AgentManifestHandler, AgentManifestNav, AgentManifestOptions, AgentManifestScreen, AgentManifestWorkspace, AgentToolMode, RegistryManifestView, RegistrySearchView, ToolCatalog, ToolCatalogOptions, ToolDefinition, ToolDispatchDescriptor, } from "./types.ts";

package/dist/agent-tools/index.js

@@ -2,4 +2,4 @@ export { AgentDocGapKinds, findAgentDocGaps, findHandlerTranslationGaps, formatA
 export { buildAgentManifest } from "./agent-manifest.js";
 export { AGENT_TOOLS_FEATURE_NAME, createAgentToolsFeature } from "./feature.js";
 export { buildToolCatalog, OPEN_FORM_TOOL_NAME, toolNameForQn } from "./tool-catalog.js";
-export { dispatchToolCall } from "./tool-dispatch.js";
+export { dispatchToolCall, TOOL_CALL_ERROR_CODES } from "./tool-dispatch.js";

package/dist/agent-tools/tool-dispatch.d.ts

@@ -37,11 +37,16 @@ export type ToolCallRequest = {
     /** Receives the cause of unexpected (5xx) failures, which the tool result never carries. */
     readonly log?: Pick<Logger, "error">;
 };
+export declare const TOOL_CALL_ERROR_CODES: {
+    readonly invalidToolCall: "invalid_tool_call";
+    readonly unknownTool: "unknown_tool";
+};
 /** Executes one LLM-issued tool call. Never throws: every failure comes back as `{ ok: false }`
  *  so the agent loop can feed the error back to the model instead of crashing.
- *  Handler and dispatcher failures carry a `code` (429 adds `retryable`); client errors (< 500)
- *  keep their message, server failures (>= 500, unknown throws) are logged and returned as a
- *  generic message. Local validation errors (unknown tool, bad arguments) have no `code`.
+ *  Every failure carries a `code`: the handler's own code for handler and dispatcher failures
+ *  (429 adds `retryable`), `invalid_tool_call` for bad arguments and `unknown_tool` for a tool
+ *  that is not in the table. Client errors (< 500) keep their message, server failures (>= 500,
+ *  unknown throws) are logged and returned as a generic message.
  *  `request.user` must be the caller's real identity: server-kind tools run through the same
  *  permission-checked pipeline as an HTTP request. */
 export declare function dispatchToolCall(request: ToolCallRequest): Promise<ToolCallResult>;

package/dist/agent-tools/tool-dispatch.js

@@ -3,6 +3,16 @@ import { runAsAgentToolCallEntry } from "@cosmicdrift/kumiko-framework/internal/
 import { createFallbackLogger } from "@cosmicdrift/kumiko-framework/logging";
 import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
 import { FILTER_OPS, isRecord } from "./filter-ops.js";
+export const TOOL_CALL_ERROR_CODES = {
+    invalidToolCall: "invalid_tool_call",
+    unknownTool: "unknown_tool",
+};
+function invalidToolCall(error) {
+    return { ok: false, error, code: TOOL_CALL_ERROR_CODES.invalidToolCall };
+}
+function unknownTool(error) {
+    return { ok: false, error, code: TOOL_CALL_ERROR_CODES.unknownTool };
+}
 const HTTP_TOO_MANY_REQUESTS = 429;
 const HTTP_SERVER_ERROR = 500;
 const UNEXPECTED_FAILURE_MESSAGE = "Tool failed unexpectedly";
@@ -52,14 +62,14 @@ function isFilterOp(value) {
 function buildSearchPayload(toolName, toolInput) {
     const query = toolInput["query"];
     if (typeof query !== "string" || query.length === 0) {
-        return { ok: false, error: `Tool "${toolName}" requires a non-empty string "query" argument` };
+        return invalidToolCall(`Tool "${toolName}" requires a non-empty string "query" argument`);
     }
     return { ok: true, value: { search: query, limit: SEARCH_RESULT_LIMIT } };
 }
 function buildFindByPayload(toolName, fieldName, toolInput) {
     const value = toolInput[fieldName];
     if (value === undefined) {
-        return { ok: false, error: `Tool "${toolName}" requires a "${fieldName}" argument` };
+        return invalidToolCall(`Tool "${toolName}" requires a "${fieldName}" argument`);
     }
     return {
         ok: true,
@@ -75,28 +85,28 @@ function buildEntityListPayload(list, input) {
     const search = input["search"];
     if (search !== undefined) {
         if (typeof search !== "string") {
-            return { ok: false, error: `"search" must be a string` };
+            return invalidToolCall(`"search" must be a string`);
         }
         if (list.searchableFields.length === 0) {
-            return { ok: false, error: "This entity has no searchable fields" };
+            return invalidToolCall("This entity has no searchable fields");
         }
         payload["search"] = search;
     }
     const filters = input["filters"];
     if (filters !== undefined) {
         if (!Array.isArray(filters)) {
-            return { ok: false, error: `"filters" must be an array` };
+            return invalidToolCall(`"filters" must be an array`);
         }
         const validated = [];
         for (const entry of filters) {
             if (!isRecord(entry) || typeof entry["field"] !== "string" || !("value" in entry)) {
-                return { ok: false, error: `Each filter must be { field, op, value }` };
+                return invalidToolCall(`Each filter must be { field, op, value }`);
             }
             if (!list.filterableFields.includes(entry["field"])) {
-                return { ok: false, error: `Field "${entry["field"]}" is not filterable on this entity` };
+                return invalidToolCall(`Field "${entry["field"]}" is not filterable on this entity`);
             }
             if (!isFilterOp(entry["op"])) {
-                return { ok: false, error: `Unsupported filter operator "${String(entry["op"])}"` };
+                return invalidToolCall(`Unsupported filter operator "${String(entry["op"])}"`);
             }
             validated.push({ field: entry["field"], op: entry["op"], value: entry["value"] });
         }
@@ -147,7 +157,7 @@ async function dispatchServerQuery(descriptor, dispatcher, user, input) {
     if (descriptor.detail) {
         const id = input["id"];
         if (typeof id !== "string" || id.length === 0) {
-            return { ok: false, error: `This tool requires a non-empty string "id" argument` };
+            return invalidToolCall(`This tool requires a non-empty string "id" argument`);
         }
         const data = await dispatcher.query(descriptor.qn, { id }, user);
         return { ok: true, data };
@@ -171,15 +181,15 @@ async function dispatchServerWrite(descriptor, dispatcher, user, input, runId, t
     if (descriptor.injectsVersion) {
         const id = input["id"];
         if (typeof id !== "string" || id.length === 0) {
-            return { ok: false, error: `This tool requires a non-empty string "id" argument` };
+            return invalidToolCall(`This tool requires a non-empty string "id" argument`);
         }
         if (!descriptor.detailQn) {
-            return { ok: false, error: "Tool is misconfigured: no detail handler to read version from" };
+            return invalidToolCall("Tool is misconfigured: no detail handler to read version from");
         }
         const current = await dispatcher.query(descriptor.detailQn, { id }, user);
         const version = isRecord(current) && typeof current["version"] === "number" ? current["version"] : undefined;
         if (version === undefined) {
-            return { ok: false, error: `Could not read the current "version" for id "${id}"` };
+            return invalidToolCall(`Could not read the current "version" for id "${id}"`);
         }
         payload = { ...input, version };
     }
@@ -211,37 +221,37 @@ function dispatchClientNavigate(descriptor, input) {
     if (typeof entity === "string") {
         const screenId = descriptor.entityScreens.get(entity);
         if (!screenId)
-            return { ok: false, error: `Unknown entity "${entity}" for navigation` };
+            return invalidToolCall(`Unknown entity "${entity}" for navigation`);
         const id = input["id"];
         if (typeof id !== "string" || id.length === 0) {
-            return { ok: false, error: `Navigating to "${entity}" requires a non-empty string "id"` };
+            return invalidToolCall(`Navigating to "${entity}" requires a non-empty string "id"`);
         }
         return { ok: true, data: { kind: "navigate", screenId, params: { id } } };
     }
     const screenId = input["screenId"];
     if (typeof screenId === "string") {
         if (!descriptor.screenIds.has(screenId)) {
-            return { ok: false, error: `Unknown screen "${screenId}"` };
+            return invalidToolCall(`Unknown screen "${screenId}"`);
         }
         const params = input["params"];
         if (params !== undefined) {
             if (!isRecord(params) || Object.values(params).some((value) => typeof value !== "string")) {
-                return { ok: false, error: `"params" must be an object of string values` };
+                return invalidToolCall(`"params" must be an object of string values`);
             }
             return { ok: true, data: { kind: "navigate", screenId, params } };
         }
         return { ok: true, data: { kind: "navigate", screenId, params: {} } };
     }
-    return { ok: false, error: `navigate requires either { entity, id } or { screenId }` };
+    return invalidToolCall(`navigate requires either { entity, id } or { screenId }`);
 }
 function dispatchClientOpenForm(descriptor, input) {
     const handlerQn = input["handlerQn"];
     if (typeof handlerQn !== "string") {
-        return { ok: false, error: `open_form requires a string "handlerQn" argument` };
+        return invalidToolCall(`open_form requires a string "handlerQn" argument`);
     }
     const screenId = descriptor.formScreens.get(handlerQn);
     if (!screenId)
-        return { ok: false, error: `No form screen mounted for handler "${handlerQn}"` };
+        return invalidToolCall(`No form screen mounted for handler "${handlerQn}"`);
     return {
         ok: true,
         data: { kind: "open_form", screenId, handlerQn, prefill: input["prefill"] ?? {} },
@@ -253,14 +263,14 @@ function isStringArray(value) {
 function dispatchClientAskUser(input) {
     const question = input["question"];
     if (typeof question !== "string" || question.length === 0) {
-        return { ok: false, error: `ask_user requires a non-empty string "question" argument` };
+        return invalidToolCall(`ask_user requires a non-empty string "question" argument`);
     }
     const options = input["options"];
     if (options === undefined) {
         return { ok: true, data: { kind: "ask_user", question } };
     }
     if (!isStringArray(options)) {
-        return { ok: false, error: `ask_user "options" argument must be an array of strings` };
+        return invalidToolCall(`ask_user "options" argument must be an array of strings`);
     }
     return { ok: true, data: { kind: "ask_user", question, options } };
 }
@@ -276,9 +286,10 @@ function dispatchClient(descriptor, input) {
 }
 /** Executes one LLM-issued tool call. Never throws: every failure comes back as `{ ok: false }`
  *  so the agent loop can feed the error back to the model instead of crashing.
- *  Handler and dispatcher failures carry a `code` (429 adds `retryable`); client errors (< 500)
- *  keep their message, server failures (>= 500, unknown throws) are logged and returned as a
- *  generic message. Local validation errors (unknown tool, bad arguments) have no `code`.
+ *  Every failure carries a `code`: the handler's own code for handler and dispatcher failures
+ *  (429 adds `retryable`), `invalid_tool_call` for bad arguments and `unknown_tool` for a tool
+ *  that is not in the table. Client errors (< 500) keep their message, server failures (>= 500,
+ *  unknown throws) are logged and returned as a generic message.
  *  `request.user` must be the caller's real identity: server-kind tools run through the same
  *  permission-checked pipeline as an HTTP request. */
 export async function dispatchToolCall(request) {
@@ -286,7 +297,7 @@ export async function dispatchToolCall(request) {
     const classifyFailure = createFailureClassifier(toolName, request.log ?? fallbackLog);
     const descriptor = dispatchTable.get(toolName);
     if (!descriptor) {
-        return { ok: false, error: `Unknown tool "${toolName}"` };
+        return unknownTool(`Unknown tool "${toolName}"`);
     }
     try {
         return await runAsAgentToolCallEntry(async () => {

package/dist/audit/feature.js

@@ -23,6 +23,7 @@ import { AUDIT_I18N } from "./web/i18n.js";
 // framework).
 export function createAuditFeature() {
     return defineFeature("audit", (r) => {
+        r.adoptsBundledLists();
         r.describe("Exposes the framework's event store as a paginated, filterable audit log via the `audit:query:list` handler (accessible to `Admin` and `SystemAdmin` roles). No separate table or projection \u2014 the event store is the audit trail by construction: every entity write already records who, when, what entity, and the event payload with PII stripped. A SystemAdmin can pass `scope: \"system\"` to read the app-instance system events such as `app.started`, and reads the events of every tenant (system tenant excluded) through `audit:query:list-all-tenants` and the `audit-log-all-tenants` screen. Filter by `aggregateType`, `aggregateId`, `eventType`, `userId`, or time range. Also records `audit:event:escape-hatch-used` whenever a handler uses one of the framework's escape hatches (unsafeRaw, acknowledgeCrossTenant, db.global() writes, or a granted identity switch).");
         r.uiHints({
             displayLabel: "Audit Log",
@@ -56,7 +57,7 @@ export function createAuditFeature() {
                 await runEscapeHatchRetention({
                     db: ctx.db.unsafeRaw(),
                     registry: ctx.registry,
-                    configResolver: ctx.configResolver,
+                    configResolver: ctx.services.configResolver,
                     userId: SYSTEM_USER_ID,
                 });
             },

package/dist/auth-email-password/auth-user-row.js

@@ -1,4 +1,4 @@
-// Narrow cross-feature query results (ctx.queryAs → Promise<unknown>) into
+// Narrow cross-feature query results (ctx.dispatch.queryAs → Promise<unknown>) into
 // the shape the auth handlers actually read. Replaces a bare
 // `as AuthUserRow | null` at the system boundary — the coding standard
 // requires a TypeGuard in place of unchecked casts from unknown.

package/dist/auth-email-password/bootstrap.js

@@ -7,6 +7,7 @@
 import { makeDispatchSystemWrite, makeDispatchWriteAs, } from "@cosmicdrift/kumiko-framework/api";
 import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
 import { ConfigScopes, createSystemUser, } from "@cosmicdrift/kumiko-framework/engine";
+import { runInSystemRowLevelSecurityScope } from "@cosmicdrift/kumiko-framework/internal/row-level-security";
 import { parseRoles } from "@cosmicdrift/kumiko-framework/utils";
 // kumiko-lint-ignore cross-feature-import bootstrap sets per-tenant config through the config feature's write handler
 import { ConfigHandlers } from "../config/web/constants.js";
@@ -139,7 +140,11 @@ async function decideInvite(deps, invite) {
 function isMailingOutcome(outcome) {
     return outcome === "invited" || outcome === "resent";
 }
-export async function bootstrapTenants(deps, plan) {
+// A one-shot operator process, not a tenant request: it looks up users, memberships and invitations across tenants.
+export function bootstrapTenants(deps, plan) {
+    return runInSystemRowLevelSecurityScope("boot tenant bootstrap creates tenants and memberships before any tenant exists", () => bootstrapTenantsInScope(deps, plan));
+}
+async function bootstrapTenantsInScope(deps, plan) {
     const plannedInvites = planInvites(plan);
     const dispatchSystemWrite = makeDispatchSystemWrite(deps.dispatcher);
     const dispatchWriteAsRoles = makeDispatchWriteAs(deps.dispatcher);

package/dist/auth-email-password/feature.js

@@ -48,7 +48,7 @@ export const authEmailPasswordEnvSchema = z.object({
         .describe("Optional `iss` claim pinned on every minted JWT."),
 });
 // Auth feature — email+password login. Depends on the user feature for
-// identity lookups (via ctx.queryAs) and on the tenant feature for
+// identity lookups (via ctx.dispatch.queryAs) and on the tenant feature for
 // membership resolution. No direct imports of foreign tables.
 export function createAuthEmailPasswordFeature(opts = {}) {
     // ≥32 chars, symmetric to the JWT_SECRET env check: a short HMAC secret

package/dist/auth-email-password/handlers/change-password.write.js

@@ -5,7 +5,7 @@ import { UserHandlers, UserQueries } from "../../user/index.js";
 import { invalidCredentials } from "../errors.js";
 import { passwordSchema } from "../password-policy.js";
 // Change-password — authenticated. The user supplies their current password
-// (re-auth) and the new one. The new hash is written via ctx.writeAs(system)
+// (re-auth) and the new one. The new hash is written via ctx.dispatch.writeAs(system)
 // against the user feature's update handler; field-access on passwordHash
 // (privileged-only) lets the system identity through.
 export const changePasswordWrite = defineWriteHandler({
@@ -21,8 +21,8 @@ export const changePasswordWrite = defineWriteHandler({
     },
     escapeHatch: {
         grants: ["systemIdentity"],
-        reason: "Reads the caller's own passwordHash (privileged-only field) via ctx.queryAs(SYSTEM, ...) " +
-            "and writes the new hash via ctx.writeAs(SYSTEM, user:update) — the caller's own " +
+        reason: "Reads the caller's own passwordHash (privileged-only field) via ctx.dispatch.queryAs(SYSTEM, ...) " +
+            "and writes the new hash via ctx.dispatch.writeAs(SYSTEM, user:update) — the caller's own " +
             "identity can't reach either, field-access on passwordHash is privileged-only.",
     },
     // Payload carries the old and new password.
@@ -31,7 +31,7 @@ export const changePasswordWrite = defineWriteHandler({
     handler: async (event, ctx) => {
         const systemUser = createSystemUser(event.user.tenantId);
         // Load self with passwordHash — only visible to the privileged caller.
-        const me = (await ctx.queryAs(systemUser, UserQueries.findForAuth, {
+        const me = (await ctx.dispatch.queryAs(systemUser, UserQueries.findForAuth, {
             id: event.user.id,
         })); // @cast-boundary db-runner
         if (!me?.passwordHash) {
@@ -43,13 +43,13 @@ export const changePasswordWrite = defineWriteHandler({
         }
         const newHash = await hashPassword(event.payload.newPassword);
         // The user aggregate is systemStream: its event stream lives on
-        // SYSTEM_TENANT_ID deterministically. Previously scattered streams need the
-        // one-time backfillUserStreamTenants migration.
+        // SYSTEM_TENANT_ID deterministically. Previously scattered streams are moved by the
+        // boot-time stream-tenant backfill (runStreamTenantBackfillOnBoot).
         const writer = createSystemUser(SYSTEM_TENANT_ID);
         // Apply via user feature's update handler — writeAs(system) satisfies
         // the privileged-only write rule on passwordHash. Pass the current version
         // through so optimistic locking still applies end-to-end.
-        const writeRes = await ctx.writeAs(writer, UserHandlers.update, {
+        const writeRes = await ctx.dispatch.writeAs(writer, UserHandlers.update, {
             id: me.id,
             version: me.version,
             changes: { passwordHash: newHash },

package/dist/auth-email-password/handlers/confirm-account-unlock.write.js

@@ -29,9 +29,9 @@ export function createConfirmAccountUnlockHandler(opts) {
                     i18nKey: "auth.errors.unlockNotConfigured",
                 }));
             }
-            if (!ctx.redis) {
+            if (!ctx.services.redis) {
                 return writeFailure(new InternalError({
-                    message: "account-unlock requires ctx.redis to clear lockout state",
+                    message: "account-unlock requires ctx.services.redis to clear lockout state",
                 }));
             }
             // All verify failures (malformed / bad_signature / expired) fold into
@@ -40,7 +40,7 @@ export function createConfirmAccountUnlockHandler(opts) {
             const verify = verifyUnlockToken(event.payload.token, opts.hmacSecret);
             if (!verify.ok)
                 return invalidUnlockToken();
-            await clearLockoutState(ctx.redis, verify.userId);
+            await clearLockoutState(ctx.services.redis, verify.userId);
             return { isSuccess: true, data: { kind: "account-unlocked" } };
         },
     });

package/dist/auth-email-password/handlers/confirm-token-flow.js

@@ -30,10 +30,10 @@ export async function runConfirmTokenFlow(ctx, userId, expiresAtMs, spec) {
     declareEscapeHatch({
         reason: "writes the confirming user's row via UserHandlers.update on the caller's handler context, using a SYSTEM_TENANT-scoped identity; the calling handler declares its own escapeHatch",
     });
-    if (!ctx.redis) {
+    if (!ctx.services.redis) {
         return writeFailure(new InternalError({ message: spec.redisRequiredMessage }));
     }
-    const redis = ctx.redis;
+    const redis = ctx.services.redis;
     const burn = await burnToken(redis, spec.purpose, userId, expiresAtMs);
     if (burn === "already-used")
         return spec.invalidToken();
@@ -52,7 +52,7 @@ export async function runConfirmTokenFlow(ctx, userId, expiresAtMs, spec) {
             return { isSuccess: true, data: spec.alreadyDone.data };
         }
         const changes = await spec.buildChanges(me);
-        const writeRes = await ctx.writeAs(systemUser, UserHandlers.update, {
+        const writeRes = await ctx.dispatch.writeAs(systemUser, UserHandlers.update, {
             id: me.id,
             version: me.version,
             changes,
@@ -89,7 +89,7 @@ async function loadValidatedUser(ctx, systemUser, userId) {
     declareEscapeHatch({
         reason: "reads the confirming user's row via UserQueries.findForAuth on the caller's handler context, using a SYSTEM_TENANT-scoped identity; the calling handler declares its own escapeHatch",
     });
-    const me = parseAuthUserRow(await ctx.queryAs(systemUser, UserQueries.findForAuth, { id: userId }));
+    const me = parseAuthUserRow(await ctx.dispatch.queryAs(systemUser, UserQueries.findForAuth, { id: userId }));
     if (!me || me.isDeleted || me.version === undefined || me.version < 1)
         return null;
     return { ...me, version: me.version };

package/dist/auth-email-password/handlers/invite-accept-with-login.write.js

@@ -64,13 +64,13 @@ export function createInviteAcceptWithLoginHandler(opts = {}) {
         agent: { expose: false },
         // kumiko-lint-ignore complexity-budget reuses login.write.ts's gate chain (lockout/password/email/status/membership/mfa) plus invite-specific branches (email match, already-member check, invitation update, unburn-on-failure) — splitting would scatter gate order across functions without reducing risk
         handler: async (event, ctx) => {
-            if (!ctx.redis) {
-                return writeFailure(new InternalError({ message: "invite-accept-with-login requires ctx.redis" }));
+            if (!ctx.services.redis) {
+                return writeFailure(new InternalError({ message: "invite-accept-with-login requires ctx.services.redis" }));
             }
-            const invitationId = await getInvitationIdForToken(ctx.redis, event.payload.token);
+            const invitationId = await getInvitationIdForToken(ctx.services.redis, event.payload.token);
             if (!invitationId)
                 return invalidInviteToken();
-            const burn = await burnInviteToken(ctx.redis, event.payload.token);
+            const burn = await burnInviteToken(ctx.services.redis, event.payload.token);
             if (burn === "already-used")
                 return invalidInviteToken();
             let committed = false;
@@ -131,6 +131,7 @@ export function createInviteAcceptWithLoginHandler(opts = {}) {
                     db: dbConn,
                     tenantId: invitationTenantId,
                     mode: "system",
+                    reason: "invitation tenant differs from the caller's tenant, the accept step updates the invitation row there",
                 });
                 const updateResult = await invitationExecutor.update({
                     id: invitationId,
@@ -139,7 +140,7 @@ export function createInviteAcceptWithLoginHandler(opts = {}) {
                 }, createSystemUser(invitationTenantId), invitationTdb);
                 if (!updateResult.isSuccess)
                     return updateResult;
-                await deleteInviteToken(ctx.redis, { invitationId, token: event.payload.token });
+                await deleteInviteToken(ctx.services.redis, { invitationId, token: event.payload.token });
                 // buildSessionRoles calls stripForbiddenMembershipRoles internally —
                 // a reserved role on an existing membership must never reach the session.
                 const mergedRoles = buildSessionRoles(globalGrant.data.roles, grant.data.roles);
@@ -172,8 +173,8 @@ export function createInviteAcceptWithLoginHandler(opts = {}) {
                 };
             }
             finally {
-                if (!committed && ctx.redis) {
-                    await unburnInviteToken(ctx.redis, event.payload.token);
+                if (!committed && ctx.services.redis) {
+                    await unburnInviteToken(ctx.services.redis, event.payload.token);
                 }
             }
         },

package/dist/auth-email-password/handlers/invite-accept.write.js

@@ -55,13 +55,15 @@ export function createInviteAcceptHandler() {
         },
         // kumiko-lint-ignore complexity-budget invite branches (auth/anon/burn) stay in one handler
         handler: async (event, ctx) => {
-            if (!ctx.redis) {
-                return writeFailure(new InternalError({ message: "invite-accept requires ctx.redis for token consumption" }));
+            if (!ctx.services.redis) {
+                return writeFailure(new InternalError({
+                    message: "invite-accept requires ctx.services.redis for token consumption",
+                }));
             }
-            const invitationId = await getInvitationIdForToken(ctx.redis, event.payload.token);
+            const invitationId = await getInvitationIdForToken(ctx.services.redis, event.payload.token);
             if (!invitationId)
                 return invalidInviteToken();
-            const burn = await burnInviteToken(ctx.redis, event.payload.token);
+            const burn = await burnInviteToken(ctx.services.redis, event.payload.token);
             if (burn === "already-used")
                 return invalidInviteToken();
             let committed = false;
@@ -111,6 +113,7 @@ export function createInviteAcceptHandler() {
                     db: dbConn,
                     tenantId: invitationTenantId,
                     mode: "system",
+                    reason: "invitation tenant differs from the caller's tenant, the accept step updates the invitation row there",
                 });
                 const updateResult = await invitationExecutor.update({
                     id: invitationId,
@@ -119,7 +122,7 @@ export function createInviteAcceptHandler() {
                 }, createSystemUser(invitationTenantId), invitationTdb);
                 if (!updateResult.isSuccess)
                     return updateResult;
-                await deleteInviteToken(ctx.redis, { invitationId, token: event.payload.token });
+                await deleteInviteToken(ctx.services.redis, { invitationId, token: event.payload.token });
                 committed = true;
                 return {
                     isSuccess: true,
@@ -132,8 +135,8 @@ export function createInviteAcceptHandler() {
                 };
             }
             finally {
-                if (!committed && ctx.redis) {
-                    await unburnInviteToken(ctx.redis, event.payload.token);
+                if (!committed && ctx.services.redis) {
+                    await unburnInviteToken(ctx.services.redis, event.payload.token);
                 }
             }
         },

package/dist/auth-email-password/handlers/invite-create.write.js

@@ -76,8 +76,8 @@ async function currentMembershipVersion(ctx, tenantId, email) {
     return membershipVersionOf(ctx.db, tenantId, user.id);
 }
 async function issueInvitation(opts, ttlSeconds, request, inviter, ctx, refuseAccepted = false) {
-    if (!ctx.redis) {
-        return writeFailure(new InternalError({ message: "invite-create requires ctx.redis for token store" }));
+    if (!ctx.services.redis) {
+        return writeFailure(new InternalError({ message: "invite-create requires ctx.services.redis for token store" }));
     }
     const email = request.email.toLowerCase();
     const tenantId = inviter.tenantId;
@@ -100,7 +100,7 @@ async function issueInvitation(opts, ttlSeconds, request, inviter, ctx, refuseAc
         const existingVersion = existing["version"]; // @cast-boundary db-row
         // At most one live invite token per invitation: invalidate
         // whatever's there before minting the new one.
-        await invalidateExistingInviteToken(ctx.redis, invitationId);
+        await invalidateExistingInviteToken(ctx.services.redis, invitationId);
         const updateResult = await executor.update({
             id: invitationId,
             version: existingVersion,
@@ -133,7 +133,7 @@ async function issueInvitation(opts, ttlSeconds, request, inviter, ctx, refuseAc
         invitationId = createResult.data.id; // @cast-boundary engine-payload
     }
     const token = generateToken();
-    await storeInviteToken(ctx.redis, { invitationId, token, ttlSeconds });
+    await storeInviteToken(ctx.services.redis, { invitationId, token, ttlSeconds });
     const locale = request.locale ?? resolveHandlerMailLocale(ctx, opts.locale);
     await dispatchMagicLinkMail(ctx.notify, {
         handlerName: "invite-create",

package/dist/auth-email-password/handlers/invite-info.query.js

@@ -40,9 +40,9 @@ export const inviteInfoQuery = defineQueryHandler({
     description: "Anonymous, read-only invite lookup for the invite-acceptance page: reveals the invited " +
         "email and whether an account already exists for it, without consuming the token.",
     handler: async (query, ctx) => {
-        if (!ctx.redis)
+        if (!ctx.services.redis)
             throwInvalidInviteToken();
-        const invitationId = await getInvitationIdForToken(ctx.redis, query.payload.token);
+        const invitationId = await getInvitationIdForToken(ctx.services.redis, query.payload.token);
         if (!invitationId)
             throwInvalidInviteToken();
         const invitation = await fetchOne(ctx.db.unsafeRaw(), tenantInvitationsTable, {

package/dist/auth-email-password/handlers/invite-signup-complete.write.js

@@ -55,13 +55,13 @@ export function createInviteSignupCompleteHandler(opts = {}) {
             reason: INVITE_SIGNUP_COMPLETE_ESCAPE_HATCH_REASON,
         },
         handler: async (event, ctx) => {
-            if (!ctx.redis) {
-                return writeFailure(new InternalError({ message: "invite-signup-complete requires ctx.redis" }));
+            if (!ctx.services.redis) {
+                return writeFailure(new InternalError({ message: "invite-signup-complete requires ctx.services.redis" }));
             }
-            const invitationId = await getInvitationIdForToken(ctx.redis, event.payload.token);
+            const invitationId = await getInvitationIdForToken(ctx.services.redis, event.payload.token);
             if (!invitationId)
                 return invalidInviteToken();
-            const burn = await burnInviteToken(ctx.redis, event.payload.token);
+            const burn = await burnInviteToken(ctx.services.redis, event.payload.token);
             if (burn === "already-used")
                 return invalidInviteToken();
             let committed = false;
@@ -115,6 +115,7 @@ export function createInviteSignupCompleteHandler(opts = {}) {
                     db: dbConn,
                     tenantId: invitationTenantId,
                     mode: "system",
+                    reason: "invitation tenant differs from the caller's tenant, the accept step updates the invitation row there",
                 });
                 const updateResult = await invitationExecutor.update({
                     id: invitationId,
@@ -130,7 +131,7 @@ export function createInviteSignupCompleteHandler(opts = {}) {
                 // call, but an MFA-gated role gets the MFA step instead of a session.
                 // It runs before the token is deleted so a throwing check leaves the link retryable.
                 const mfaGate = await gateEnforceMfa(ctx, { mfaStatusChecker: opts.mfaStatusChecker }, userId, invitationTenantId, mergedRoles);
-                await deleteInviteToken(ctx.redis, { invitationId, token: event.payload.token });
+                await deleteInviteToken(ctx.services.redis, { invitationId, token: event.payload.token });
                 if (mfaGate !== undefined) {
                     committed = true;
                     return { isSuccess: true, data: mfaGate };
@@ -153,8 +154,8 @@ export function createInviteSignupCompleteHandler(opts = {}) {
                 };
             }
             finally {
-                if (!committed && ctx.redis) {
-                    await unburnInviteToken(ctx.redis, event.payload.token);
+                if (!committed && ctx.services.redis) {
+                    await unburnInviteToken(ctx.services.redis, event.payload.token);
                 }
             }
         },