@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/middleware/on-behalf.js

@@ -0,0 +1,143 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * ON-BEHALF calls: a service forwarding the end user's own bearer token to a
+ * peer, as part of a request that was ALREADY metered where it arrived.
+ *
+ * The ask agent acts strictly as the calling user — its tools forward the
+ * user's token so the peer's tenancy, permission and compliance gates apply as
+ * if the user had called them — and pipeline's confirm-placeholder-plugins does
+ * the same against the plugin service. Each of those hops is a USER request to
+ * the peer, so the peer's `apiCalls` meter billed it: one agent turn was 10-20
+ * apiCalls on top of the turn itself (which is metered, and AI-reserved).
+ *
+ * The marker that waives that second charge has to be something the USER CANNOT
+ * PRODUCE, or any member could stop paying for API calls by setting a header.
+ * So it is a SIGNED SERVICE TOKEN (the calling service's own ES256 key, the same
+ * key material `requireAuth` trusts for service principals), carried in
+ * {@link ON_BEHALF_HEADER} beside the user's untouched `Authorization`:
+ *
+ *  - `type: 'on_behalf'` — never `access`, so the marker is useless as a bearer
+ *    token anywhere (`requireAuth` and `verifyServicePrincipal` both demand
+ *    `type: 'access'`);
+ *  - `obo` + `organizationId` — BOUND to the user and org it vouches for, and
+ *    honoured only when both equal the request's verified `req.user`;
+ *  - the signer must be on {@link ON_BEHALF_CALLERS} — a service that forwards
+ *    user tokens by design — and not on the service-token denylist;
+ *  - 120 s TTL, minted per outbound call.
+ *
+ * What a valid marker changes is narrow: the apiCalls/automationCalls METER and
+ * CHECK skip the request (`callQuotaExemption`). Tenancy, permissions, audit and
+ * every reservation-gated quota (aiCalls, pipelines, plugins) apply exactly as
+ * before — an on-behalf `/generate` still reserves its own aiCalls slot.
+ */
+import { randomUUID } from 'crypto';
+import { issuerAudienceOptions } from './jwt-verify.js';
+import { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';
+import { currentAuditContext } from '../services/audit-context.js';
+import { isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';
+import { decodeJwtHeader } from '../utils/jwk.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('on-behalf');
+/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */
+export const ON_BEHALF_HEADER = 'x-pb-on-behalf';
+/**
+ * Services whose on-behalf marker is honoured: the ones that forward a user's
+ * token as a matter of design. A marker signed by any other service — valid
+ * signature or not — is ignored, so a compromised peer that never forwards user
+ * tokens cannot start waiving its tenants' meters.
+ */
+export const ON_BEHALF_CALLERS = ['ask', 'pipeline'];
+/** Marker lifetime. Minted per outbound call, so it only has to outlive one hop. */
+const ON_BEHALF_TTL_SECONDS = 120;
+/** The `type` claim that makes the marker unusable as an access token. */
+const ON_BEHALF_TOKEN_TYPE = 'on_behalf';
+/**
+ * Headers to add beside a forwarded user `Authorization` so the peer does not
+ * bill the hop a second time. Mint per call (the marker expires in 120 s).
+ *
+ * The subject defaults to the ambient audit context's VERIFIED principal (the
+ * inbound request this call serves). Returns `{}` — the hop is billed normally,
+ * the safe direction — when there is no user principal to vouch for, or when
+ * this process cannot sign (no service key).
+ */
+export function onBehalfHeaders(subject) {
+    const principal = subject ?? ambientSubject();
+    if (!principal)
+        return {};
+    try {
+        const token = signServiceJwt({
+            type: ON_BEHALF_TOKEN_TYPE,
+            principalType: 'service',
+            obo: principal.sub,
+            organizationId: principal.organizationId,
+            jti: randomUUID(),
+        }, { serviceName: process.env.SERVICE_NAME || 'api', expiresInSeconds: ON_BEHALF_TTL_SECONDS, ...issuerAudienceOptions() });
+        return { [ON_BEHALF_HEADER]: token };
+    }
+    catch (err) {
+        logger.debug('On-behalf marker not minted; the peer will meter the hop', { error: String(err) });
+        return {};
+    }
+}
+function ambientSubject() {
+    const user = currentAuditContext()?.principal?.();
+    if (!user || user.principalType === 'service' || !user.sub || !user.organizationId)
+        return undefined;
+    return { sub: user.sub, organizationId: user.organizationId };
+}
+/** Memo per request: the meter (on `finish`) and the check (in requireAuth) both ask. */
+const verdicts = new WeakMap();
+/**
+ * The internal service that vouched for this request with a VALID on-behalf
+ * marker, else `undefined`. Requires the request to be authenticated (`req.user`
+ * set by requireAuth) — the marker is only meaningful against a verified user.
+ *
+ * Every rejection of a PRESENT header is counted on
+ * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands
+ * there as `invalid` (no service key signs it), and the request is billed.
+ */
+export function onBehalfCaller(req) {
+    const memo = verdicts.get(req);
+    if (memo !== undefined)
+        return memo ?? undefined;
+    const verdict = verifyMarker(req);
+    verdicts.set(req, verdict);
+    return verdict ?? undefined;
+}
+function verifyMarker(req) {
+    const raw = req.headers?.[ON_BEHALF_HEADER];
+    const token = Array.isArray(raw) ? raw[0] : raw;
+    if (!token)
+        return null;
+    const reject = (reason) => {
+        emitCounter('quota_on_behalf_rejected_total', { reason });
+        return null;
+    };
+    const user = req.user;
+    if (!user?.sub || !user.organizationId)
+        return reject('unauthenticated');
+    try {
+        const header = decodeJwtHeader(token);
+        if (!header?.kid || !isServiceKid(header.kid))
+            return reject('invalid');
+        const claims = verifyServiceJwt(token, { kid: header.kid, ...issuerAudienceOptions() });
+        if (claims.type !== ON_BEHALF_TOKEN_TYPE || claims.principalType !== 'service')
+            return reject('invalid');
+        const caller = serviceNameOf(claims);
+        if (!caller || isServiceTokenDenied(claims))
+            return reject('denied');
+        if (!ON_BEHALF_CALLERS.includes(caller))
+            return reject('caller');
+        if (claims.obo !== user.sub)
+            return reject('subject');
+        if (String(claims.organizationId ?? '').toLowerCase() !== user.organizationId.toLowerCase())
+            return reject('org');
+        return caller;
+    }
+    catch {
+        return reject('invalid');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"on-behalf.js","sourceRoot":"","sources":["../../src/middleware/on-behalf.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * ON-BEHALF calls: a service forwarding the end user's own bearer token to a\n * peer, as part of a request that was ALREADY metered where it arrived.\n *\n * The ask agent acts strictly as the calling user — its tools forward the\n * user's token so the peer's tenancy, permission and compliance gates apply as\n * if the user had called them — and pipeline's confirm-placeholder-plugins does\n * the same against the plugin service. Each of those hops is a USER request to\n * the peer, so the peer's `apiCalls` meter billed it: one agent turn was 10-20\n * apiCalls on top of the turn itself (which is metered, and AI-reserved).\n *\n * The marker that waives that second charge has to be something the USER CANNOT\n * PRODUCE, or any member could stop paying for API calls by setting a header.\n * So it is a SIGNED SERVICE TOKEN (the calling service's own ES256 key, the same\n * key material `requireAuth` trusts for service principals), carried in\n * {@link ON_BEHALF_HEADER} beside the user's untouched `Authorization`:\n *\n *  - `type: 'on_behalf'` — never `access`, so the marker is useless as a bearer\n *    token anywhere (`requireAuth` and `verifyServicePrincipal` both demand\n *    `type: 'access'`);\n *  - `obo` + `organizationId` — BOUND to the user and org it vouches for, and\n *    honoured only when both equal the request's verified `req.user`;\n *  - the signer must be on {@link ON_BEHALF_CALLERS} — a service that forwards\n *    user tokens by design — and not on the service-token denylist;\n *  - 120 s TTL, minted per outbound call.\n *\n * What a valid marker changes is narrow: the apiCalls/automationCalls METER and\n * CHECK skip the request (`callQuotaExemption`). Tenancy, permissions, audit and\n * every reservation-gated quota (aiCalls, pipelines, plugins) apply exactly as\n * before — an on-behalf `/generate` still reserves its own aiCalls slot.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { issuerAudienceOptions } from './jwt-verify.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { currentAuditContext } from '../services/audit-context.js';\nimport { isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('on-behalf');\n\n/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */\nexport const ON_BEHALF_HEADER = 'x-pb-on-behalf';\n\n/**\n * Services whose on-behalf marker is honoured: the ones that forward a user's\n * token as a matter of design. A marker signed by any other service — valid\n * signature or not — is ignored, so a compromised peer that never forwards user\n * tokens cannot start waiving its tenants' meters.\n */\nexport const ON_BEHALF_CALLERS: readonly string[] = ['ask', 'pipeline'];\n\n/** Marker lifetime. Minted per outbound call, so it only has to outlive one hop. */\nconst ON_BEHALF_TTL_SECONDS = 120;\n\n/** The `type` claim that makes the marker unusable as an access token. */\nconst ON_BEHALF_TOKEN_TYPE = 'on_behalf';\n\n/** Who a marker vouches for. Defaults to the ambient request's verified principal. */\nexport interface OnBehalfSubject {\n  /** The user (`sub`) whose token rides the same request. */\n  sub: string;\n  /** Their active org. */\n  organizationId: string;\n}\n\n/**\n * Headers to add beside a forwarded user `Authorization` so the peer does not\n * bill the hop a second time. Mint per call (the marker expires in 120 s).\n *\n * The subject defaults to the ambient audit context's VERIFIED principal (the\n * inbound request this call serves). Returns `{}` — the hop is billed normally,\n * the safe direction — when there is no user principal to vouch for, or when\n * this process cannot sign (no service key).\n */\nexport function onBehalfHeaders(subject?: OnBehalfSubject): Record<string, string> {\n  const principal = subject ?? ambientSubject();\n  if (!principal) return {};\n  try {\n    const token = signServiceJwt(\n      {\n        type: ON_BEHALF_TOKEN_TYPE,\n        principalType: 'service',\n        obo: principal.sub,\n        organizationId: principal.organizationId,\n        jti: randomUUID(),\n      },\n      { serviceName: process.env.SERVICE_NAME || 'api', expiresInSeconds: ON_BEHALF_TTL_SECONDS, ...issuerAudienceOptions() },\n    );\n    return { [ON_BEHALF_HEADER]: token };\n  } catch (err) {\n    logger.debug('On-behalf marker not minted; the peer will meter the hop', { error: String(err) });\n    return {};\n  }\n}\n\nfunction ambientSubject(): OnBehalfSubject | undefined {\n  const user = currentAuditContext()?.principal?.();\n  if (!user || user.principalType === 'service' || !user.sub || !user.organizationId) return undefined;\n  return { sub: user.sub, organizationId: user.organizationId };\n}\n\n/** Memo per request: the meter (on `finish`) and the check (in requireAuth) both ask. */\nconst verdicts = new WeakMap<Request, string | null>();\n\n/**\n * The internal service that vouched for this request with a VALID on-behalf\n * marker, else `undefined`. Requires the request to be authenticated (`req.user`\n * set by requireAuth) — the marker is only meaningful against a verified user.\n *\n * Every rejection of a PRESENT header is counted on\n * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands\n * there as `invalid` (no service key signs it), and the request is billed.\n */\nexport function onBehalfCaller(req: Request): string | undefined {\n  const memo = verdicts.get(req);\n  if (memo !== undefined) return memo ?? undefined;\n  const verdict = verifyMarker(req);\n  verdicts.set(req, verdict);\n  return verdict ?? undefined;\n}\n\nfunction verifyMarker(req: Request): string | null {\n  const raw = req.headers?.[ON_BEHALF_HEADER];\n  const token = Array.isArray(raw) ? raw[0] : raw;\n  if (!token) return null;\n  const reject = (reason: string): null => {\n    emitCounter('quota_on_behalf_rejected_total', { reason });\n    return null;\n  };\n  const user = req.user;\n  if (!user?.sub || !user.organizationId) return reject('unauthenticated');\n  try {\n    const header = decodeJwtHeader(token);\n    if (!header?.kid || !isServiceKid(header.kid)) return reject('invalid');\n    const claims = verifyServiceJwt<{ type?: string; principalType?: string; sub?: string; obo?: string; organizationId?: string }>(\n      token, { kid: header.kid, ...issuerAudienceOptions() },\n    );\n    if (claims.type !== ON_BEHALF_TOKEN_TYPE || claims.principalType !== 'service') return reject('invalid');\n    const caller = serviceNameOf(claims);\n    if (!caller || isServiceTokenDenied(claims)) return reject('denied');\n    if (!ON_BEHALF_CALLERS.includes(caller)) return reject('caller');\n    if (claims.obo !== user.sub) return reject('subject');\n    if (String(claims.organizationId ?? '').toLowerCase() !== user.organizationId.toLowerCase()) return reject('org');\n    return caller;\n  } catch {\n    return reject('invalid');\n  }\n}\n"]}

package/lib/middleware/permission-gates.d.ts

@@ -3,6 +3,7 @@
  * `authz.denied` audit sink they report refusals to.
  */
 import type { Request, Response, NextFunction } from 'express';
+import { type AuditAuthBlock } from '../services/audit-context.js';
 import { type Permission } from '../types/permissions.js';
 /**
  * Whether the request's user holds `permission`. Superadmins implicitly hold
@@ -26,6 +27,16 @@ export interface AuthzDenialInfo {
     path: string;
     /** What was required: the missing permission(s), or 'system-admin'. */
     required: string;
+    /** Client ip (`req.ip`, proxy-resolved). */
+    ip?: string;
+    /** Sanitized, length-capped User-Agent. */
+    userAgent?: string;
+    /** The request's correlation id (the ambient audit context's, else a valid `X-Request-Id`). */
+    requestId?: string;
+    /** The real sysadmin behind an impersonation token, from the verified token. */
+    impersonatorId?: string;
+    /** The credential that was refused (key id, session, scope, …) — the `_auth` block. */
+    auth?: AuditAuthBlock;
 }
 /**
  * Register (or clear, with `undefined`) the process-wide authorization-denial

package/lib/middleware/permission-gates.js

@@ -3,6 +3,7 @@
 import { tagRouteGate } from './route-table.js';
 import { isServicePrincipal, serviceNameOf } from './service-tokens.js';
 import { HttpStatus } from '../constants/http-status.js';
+import { auditAuthBlock, currentAuditContext, sanitizeCorrelationId, sanitizeUserAgent } from '../services/audit-context.js';
 import { serviceIdentity } from '../services/service-keys.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { hasPermission } from '../types/permissions.js';
@@ -60,6 +61,11 @@ export function recordAuthzDenial(req, required) {
             // query param, and this path is persisted verbatim into the audit log.
             path: (req.originalUrl || req.url).split('?')[0],
             required,
+            ip: req.ip,
+            userAgent: sanitizeUserAgent(req.headers?.['user-agent']),
+            requestId: currentAuditContext()?.requestId ?? sanitizeCorrelationId(req.headers?.['x-request-id']),
+            impersonatorId: req.user?.impersonatorId,
+            auth: auditAuthBlock(req.user),
         });
     }
     catch {
@@ -257,4 +263,4 @@ export function requireFeature(feature) {
         next();
     }, { kind: 'feature', feature });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-gates.js","sourceRoot":"","sources":["../../src/middleware/permission-gates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Authorization gates — permissions, system admin, features — and the\n * `authz.denied` audit sink they report refusals to.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate } from './route-table.js';\nimport { isServicePrincipal, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/** The shared gate preamble: answer 401 and return false when unauthenticated. */\nfunction requireUser(req: Request, res: Response): req is Request & { user: NonNullable<Request['user']> } {\n  if (req.user) return true;\n  sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  return false;\n}\n\n/** Audit + answer a permission refusal (`missing` defaults to every required permission). */\nfunction denyPermission(req: Request, res: Response, permissions: Permission[], mode: 'or' | 'and', missing: Permission[] = permissions): void {\n  recordAuthzDenial(req, permissions.join(` ${mode} `));\n  sendError(\n    res, HttpStatus.FORBIDDEN,\n    `Missing required permission: ${missing.join(` ${mode} `)}`,\n    ErrorCode.INSUFFICIENT_PERMISSIONS,\n  );\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    denyPermission(req, res, permissions, 'and', missing);\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT — never by membership in the well-known 'system' org, which would\n * conflate a Pipeline Builder operator with a customer tenant and let any\n * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared\n * sample data; it confers no privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.\n *  Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-gates.js","sourceRoot":"","sources":["../../src/middleware/permission-gates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Authorization gates — permissions, system admin, features — and the\n * `authz.denied` audit sink they report refusals to.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate } from './route-table.js';\nimport { isServicePrincipal, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { auditAuthBlock, currentAuditContext, sanitizeCorrelationId, sanitizeUserAgent, type AuditAuthBlock } from '../services/audit-context.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n  /** Client ip (`req.ip`, proxy-resolved). */\n  ip?: string;\n  /** Sanitized, length-capped User-Agent. */\n  userAgent?: string;\n  /** The request's correlation id (the ambient audit context's, else a valid `X-Request-Id`). */\n  requestId?: string;\n  /** The real sysadmin behind an impersonation token, from the verified token. */\n  impersonatorId?: string;\n  /** The credential that was refused (key id, session, scope, …) — the `_auth` block. */\n  auth?: AuditAuthBlock;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n      ip: req.ip,\n      userAgent: sanitizeUserAgent(req.headers?.['user-agent']),\n      requestId: currentAuditContext()?.requestId ?? sanitizeCorrelationId(req.headers?.['x-request-id']),\n      impersonatorId: req.user?.impersonatorId,\n      auth: auditAuthBlock(req.user),\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/** The shared gate preamble: answer 401 and return false when unauthenticated. */\nfunction requireUser(req: Request, res: Response): req is Request & { user: NonNullable<Request['user']> } {\n  if (req.user) return true;\n  sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  return false;\n}\n\n/** Audit + answer a permission refusal (`missing` defaults to every required permission). */\nfunction denyPermission(req: Request, res: Response, permissions: Permission[], mode: 'or' | 'and', missing: Permission[] = permissions): void {\n  recordAuthzDenial(req, permissions.join(` ${mode} `));\n  sendError(\n    res, HttpStatus.FORBIDDEN,\n    `Missing required permission: ${missing.join(` ${mode} `)}`,\n    ErrorCode.INSUFFICIENT_PERMISSIONS,\n  );\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    denyPermission(req, res, permissions, 'and', missing);\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT — never by membership in the well-known 'system' org, which would\n * conflate a Pipeline Builder operator with a customer tenant and let any\n * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared\n * sample data; it confers no privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.\n *  Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n"]}

package/lib/middleware/quota-exempt-routes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The routes that never spend `apiCalls` (or `automationCalls`), fleet-wide.
+ *
+ * Every service meters and gates its authenticated user surface on `apiCalls`
+ * (`meterQuotaOnSuccess` + `checkQuota`, mounted at the app-routes level). A few
+ * reads are made BY THE CONSOLE ITSELF, on every page load or on a timer, not by
+ * a person doing something — metering them would burn an idle tab's org budget
+ * all day, and gating them would make a quota-exhausted org's console unable to
+ * render the very banner that says so. This list is that carve-out, and it is
+ * deliberately short: each entry names its caller and why it is free.
+ *
+ * ONE list, read in three places, so they cannot drift:
+ *   - `meterQuotaOnSuccess` skips a matching request (no increment);
+ *   - `checkQuota` skips a matching request (never 429s);
+ *   - `buildRouteTable` marks the route `quota.exempt`, and the quota coverage
+ *     check (api-core testing) treats it as covered.
+ *
+ * Each `path` is matched against BOTH the concrete request path
+ * (`/organization/64f…/seat-usage`) and the route-table pattern
+ * (`/organization/:id/seat-usage`), so a `:param` segment is written as
+ * `[^/]+`. Paths are service-local (nginx strips `/api`).
+ *
+ * The quota service itself is not on the list because it meters nothing: its
+ * reads (`GET /quotas`, which QuotaBanner polls every 60s) never cost a call.
+ * Documented in docs/quotas.md ("Exempt routes").
+ */
+export interface QuotaExemptRoute {
+    method: 'GET' | 'POST';
+    /** Anchored pattern over the service-local path. */
+    path: RegExp;
+    /** Who calls it, and why it must be free. */
+    reason: string;
+}
+export declare const QUOTA_EXEMPT_ROUTES: readonly QuotaExemptRoute[];
+/** Whether `method` + `path` (a request path or a route-table pattern) is quota-exempt. */
+export declare function isQuotaExemptRoute(method: string | undefined, path: string): boolean;

package/lib/middleware/quota-exempt-routes.js

@@ -0,0 +1,47 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export const QUOTA_EXEMPT_ROUTES = [
+    {
+        method: 'GET',
+        path: /^\/user\/profile$/,
+        reason: 'Session bootstrap: the console reads the signed-in profile on every page load.',
+    },
+    {
+        method: 'GET',
+        path: /^\/user\/organizations$/,
+        reason: 'The org switcher, read on every page load.',
+    },
+    {
+        method: 'GET',
+        path: /^\/organization\/[^/]+\/feature-entitlements$/,
+        reason: 'Navigation gating (which features render unlocked), read on every page load.',
+    },
+    {
+        method: 'GET',
+        path: /^\/organization\/[^/]+\/seat-usage$/,
+        reason: 'Billing/quota page read beside the (unmetered) quota reads; an exhausted org must still see what it is using.',
+    },
+    {
+        method: 'GET',
+        path: /^\/messages\/unread\/count$/,
+        reason: 'The sidebar unread badge, polled every 30s whenever the live channel is down.',
+    },
+    {
+        method: 'POST',
+        path: /^\/messages\/notifications\/ticket$/,
+        reason: 'SSE ticket mint for the live notification channel; re-minted on every reconnect.',
+    },
+    {
+        method: 'POST',
+        path: /^\/reports\/execution\/stream\/ticket$/,
+        reason: 'SSE ticket mint for the live execution-status channel; re-minted on every reconnect.',
+    },
+];
+/** Whether `method` + `path` (a request path or a route-table pattern) is quota-exempt. */
+export function isQuotaExemptRoute(method, path) {
+    // HEAD is GET without a body (Express folds it the same way).
+    const upper = (method ?? '').toUpperCase();
+    const m = upper === 'HEAD' ? 'GET' : upper;
+    return QUOTA_EXEMPT_ROUTES.some((r) => r.method === m && r.path.test(path));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVvdGEtZXhlbXB0LXJvdXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9taWRkbGV3YXJlL3F1b3RhLWV4ZW1wdC1yb3V0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQW9DdEMsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQWdDO0lBQzlEO1FBQ0UsTUFBTSxFQUFFLEtBQUs7UUFDYixJQUFJLEVBQUUsbUJBQW1CO1FBQ3pCLE1BQU0sRUFBRSxnRkFBZ0Y7S0FDekY7SUFDRDtRQUNFLE1BQU0sRUFBRSxLQUFLO1FBQ2IsSUFBSSxFQUFFLHlCQUF5QjtRQUMvQixNQUFNLEVBQUUsNENBQTRDO0tBQ3JEO0lBQ0Q7UUFDRSxNQUFNLEVBQUUsS0FBSztRQUNiLElBQUksRUFBRSwrQ0FBK0M7UUFDckQsTUFBTSxFQUFFLDhFQUE4RTtLQUN2RjtJQUNEO1FBQ0UsTUFBTSxFQUFFLEtBQUs7UUFDYixJQUFJLEVBQUUscUNBQXFDO1FBQzNDLE1BQU0sRUFBRSwrR0FBK0c7S0FDeEg7SUFDRDtRQUNFLE1BQU0sRUFBRSxLQUFLO1FBQ2IsSUFBSSxFQUFFLDZCQUE2QjtRQUNuQyxNQUFNLEVBQUUsK0VBQStFO0tBQ3hGO0lBQ0Q7UUFDRSxNQUFNLEVBQUUsTUFBTTtRQUNkLElBQUksRUFBRSxxQ0FBcUM7UUFDM0MsTUFBTSxFQUFFLGtGQUFrRjtLQUMzRjtJQUNEO1FBQ0UsTUFBTSxFQUFFLE1BQU07UUFDZCxJQUFJLEVBQUUsd0NBQXdDO1FBQzlDLE1BQU0sRUFBRSxzRkFBc0Y7S0FDL0Y7Q0FDRixDQUFDO0FBRUYsMkZBQTJGO0FBQzNGLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxNQUEwQixFQUFFLElBQVk7SUFDekUsOERBQThEO0lBQzlELE1BQU0sS0FBSyxHQUFHLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzNDLE1BQU0sQ0FBQyxHQUFHLEtBQUssS0FBSyxNQUFNLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO0lBQzNDLE9BQU8sbUJBQW1CLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0FBQzlFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBUaGUgcm91dGVzIHRoYXQgbmV2ZXIgc3BlbmQgYGFwaUNhbGxzYCAob3IgYGF1dG9tYXRpb25DYWxsc2ApLCBmbGVldC13aWRlLlxuICpcbiAqIEV2ZXJ5IHNlcnZpY2UgbWV0ZXJzIGFuZCBnYXRlcyBpdHMgYXV0aGVudGljYXRlZCB1c2VyIHN1cmZhY2Ugb24gYGFwaUNhbGxzYFxuICogKGBtZXRlclF1b3RhT25TdWNjZXNzYCArIGBjaGVja1F1b3RhYCwgbW91bnRlZCBhdCB0aGUgYXBwLXJvdXRlcyBsZXZlbCkuIEEgZmV3XG4gKiByZWFkcyBhcmUgbWFkZSBCWSBUSEUgQ09OU09MRSBJVFNFTEYsIG9uIGV2ZXJ5IHBhZ2UgbG9hZCBvciBvbiBhIHRpbWVyLCBub3QgYnlcbiAqIGEgcGVyc29uIGRvaW5nIHNvbWV0aGluZyDigJQgbWV0ZXJpbmcgdGhlbSB3b3VsZCBidXJuIGFuIGlkbGUgdGFiJ3Mgb3JnIGJ1ZGdldFxuICogYWxsIGRheSwgYW5kIGdhdGluZyB0aGVtIHdvdWxkIG1ha2UgYSBxdW90YS1leGhhdXN0ZWQgb3JnJ3MgY29uc29sZSB1bmFibGUgdG9cbiAqIHJlbmRlciB0aGUgdmVyeSBiYW5uZXIgdGhhdCBzYXlzIHNvLiBUaGlzIGxpc3QgaXMgdGhhdCBjYXJ2ZS1vdXQsIGFuZCBpdCBpc1xuICogZGVsaWJlcmF0ZWx5IHNob3J0OiBlYWNoIGVudHJ5IG5hbWVzIGl0cyBjYWxsZXIgYW5kIHdoeSBpdCBpcyBmcmVlLlxuICpcbiAqIE9ORSBsaXN0LCByZWFkIGluIHRocmVlIHBsYWNlcywgc28gdGhleSBjYW5ub3QgZHJpZnQ6XG4gKiAgIC0gYG1ldGVyUXVvdGFPblN1Y2Nlc3NgIHNraXBzIGEgbWF0Y2hpbmcgcmVxdWVzdCAobm8gaW5jcmVtZW50KTtcbiAqICAgLSBgY2hlY2tRdW90YWAgc2tpcHMgYSBtYXRjaGluZyByZXF1ZXN0IChuZXZlciA0MjlzKTtcbiAqICAgLSBgYnVpbGRSb3V0ZVRhYmxlYCBtYXJrcyB0aGUgcm91dGUgYHF1b3RhLmV4ZW1wdGAsIGFuZCB0aGUgcXVvdGEgY292ZXJhZ2VcbiAqICAgICBjaGVjayAoYXBpLWNvcmUgdGVzdGluZykgdHJlYXRzIGl0IGFzIGNvdmVyZWQuXG4gKlxuICogRWFjaCBgcGF0aGAgaXMgbWF0Y2hlZCBhZ2FpbnN0IEJPVEggdGhlIGNvbmNyZXRlIHJlcXVlc3QgcGF0aFxuICogKGAvb3JnYW5pemF0aW9uLzY0ZuKApi9zZWF0LXVzYWdlYCkgYW5kIHRoZSByb3V0ZS10YWJsZSBwYXR0ZXJuXG4gKiAoYC9vcmdhbml6YXRpb24vOmlkL3NlYXQtdXNhZ2VgKSwgc28gYSBgOnBhcmFtYCBzZWdtZW50IGlzIHdyaXR0ZW4gYXNcbiAqIGBbXi9dK2AuIFBhdGhzIGFyZSBzZXJ2aWNlLWxvY2FsIChuZ2lueCBzdHJpcHMgYC9hcGlgKS5cbiAqXG4gKiBUaGUgcXVvdGEgc2VydmljZSBpdHNlbGYgaXMgbm90IG9uIHRoZSBsaXN0IGJlY2F1c2UgaXQgbWV0ZXJzIG5vdGhpbmc6IGl0c1xuICogcmVhZHMgKGBHRVQgL3F1b3Rhc2AsIHdoaWNoIFF1b3RhQmFubmVyIHBvbGxzIGV2ZXJ5IDYwcykgbmV2ZXIgY29zdCBhIGNhbGwuXG4gKiBEb2N1bWVudGVkIGluIGRvY3MvcXVvdGFzLm1kIChcIkV4ZW1wdCByb3V0ZXNcIikuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUXVvdGFFeGVtcHRSb3V0ZSB7XG4gIG1ldGhvZDogJ0dFVCcgfCAnUE9TVCc7XG4gIC8qKiBBbmNob3JlZCBwYXR0ZXJuIG92ZXIgdGhlIHNlcnZpY2UtbG9jYWwgcGF0aC4gKi9cbiAgcGF0aDogUmVnRXhwO1xuICAvKiogV2hvIGNhbGxzIGl0LCBhbmQgd2h5IGl0IG11c3QgYmUgZnJlZS4gKi9cbiAgcmVhc29uOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjb25zdCBRVU9UQV9FWEVNUFRfUk9VVEVTOiByZWFkb25seSBRdW90YUV4ZW1wdFJvdXRlW10gPSBbXG4gIHtcbiAgICBtZXRob2Q6ICdHRVQnLFxuICAgIHBhdGg6IC9eXFwvdXNlclxcL3Byb2ZpbGUkLyxcbiAgICByZWFzb246ICdTZXNzaW9uIGJvb3RzdHJhcDogdGhlIGNvbnNvbGUgcmVhZHMgdGhlIHNpZ25lZC1pbiBwcm9maWxlIG9uIGV2ZXJ5IHBhZ2UgbG9hZC4nLFxuICB9LFxuICB7XG4gICAgbWV0aG9kOiAnR0VUJyxcbiAgICBwYXRoOiAvXlxcL3VzZXJcXC9vcmdhbml6YXRpb25zJC8sXG4gICAgcmVhc29uOiAnVGhlIG9yZyBzd2l0Y2hlciwgcmVhZCBvbiBldmVyeSBwYWdlIGxvYWQuJyxcbiAgfSxcbiAge1xuICAgIG1ldGhvZDogJ0dFVCcsXG4gICAgcGF0aDogL15cXC9vcmdhbml6YXRpb25cXC9bXi9dK1xcL2ZlYXR1cmUtZW50aXRsZW1lbnRzJC8sXG4gICAgcmVhc29uOiAnTmF2aWdhdGlvbiBnYXRpbmcgKHdoaWNoIGZlYXR1cmVzIHJlbmRlciB1bmxvY2tlZCksIHJlYWQgb24gZXZlcnkgcGFnZSBsb2FkLicsXG4gIH0sXG4gIHtcbiAgICBtZXRob2Q6ICdHRVQnLFxuICAgIHBhdGg6IC9eXFwvb3JnYW5pemF0aW9uXFwvW14vXStcXC9zZWF0LXVzYWdlJC8sXG4gICAgcmVhc29uOiAnQmlsbGluZy9xdW90YSBwYWdlIHJlYWQgYmVzaWRlIHRoZSAodW5tZXRlcmVkKSBxdW90YSByZWFkczsgYW4gZXhoYXVzdGVkIG9yZyBtdXN0IHN0aWxsIHNlZSB3aGF0IGl0IGlzIHVzaW5nLicsXG4gIH0sXG4gIHtcbiAgICBtZXRob2Q6ICdHRVQnLFxuICAgIHBhdGg6IC9eXFwvbWVzc2FnZXNcXC91bnJlYWRcXC9jb3VudCQvLFxuICAgIHJlYXNvbjogJ1RoZSBzaWRlYmFyIHVucmVhZCBiYWRnZSwgcG9sbGVkIGV2ZXJ5IDMwcyB3aGVuZXZlciB0aGUgbGl2ZSBjaGFubmVsIGlzIGRvd24uJyxcbiAgfSxcbiAge1xuICAgIG1ldGhvZDogJ1BPU1QnLFxuICAgIHBhdGg6IC9eXFwvbWVzc2FnZXNcXC9ub3RpZmljYXRpb25zXFwvdGlja2V0JC8sXG4gICAgcmVhc29uOiAnU1NFIHRpY2tldCBtaW50IGZvciB0aGUgbGl2ZSBub3RpZmljYXRpb24gY2hhbm5lbDsgcmUtbWludGVkIG9uIGV2ZXJ5IHJlY29ubmVjdC4nLFxuICB9LFxuICB7XG4gICAgbWV0aG9kOiAnUE9TVCcsXG4gICAgcGF0aDogL15cXC9yZXBvcnRzXFwvZXhlY3V0aW9uXFwvc3RyZWFtXFwvdGlja2V0JC8sXG4gICAgcmVhc29uOiAnU1NFIHRpY2tldCBtaW50IGZvciB0aGUgbGl2ZSBleGVjdXRpb24tc3RhdHVzIGNoYW5uZWw7IHJlLW1pbnRlZCBvbiBldmVyeSByZWNvbm5lY3QuJyxcbiAgfSxcbl07XG5cbi8qKiBXaGV0aGVyIGBtZXRob2RgICsgYHBhdGhgIChhIHJlcXVlc3QgcGF0aCBvciBhIHJvdXRlLXRhYmxlIHBhdHRlcm4pIGlzIHF1b3RhLWV4ZW1wdC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc1F1b3RhRXhlbXB0Um91dGUobWV0aG9kOiBzdHJpbmcgfCB1bmRlZmluZWQsIHBhdGg6IHN0cmluZyk6IGJvb2xlYW4ge1xuICAvLyBIRUFEIGlzIEdFVCB3aXRob3V0IGEgYm9keSAoRXhwcmVzcyBmb2xkcyBpdCB0aGUgc2FtZSB3YXkpLlxuICBjb25zdCB1cHBlciA9IChtZXRob2QgPz8gJycpLnRvVXBwZXJDYXNlKCk7XG4gIGNvbnN0IG0gPSB1cHBlciA9PT0gJ0hFQUQnID8gJ0dFVCcgOiB1cHBlcjtcbiAgcmV0dXJuIFFVT1RBX0VYRU1QVF9ST1VURVMuc29tZSgocikgPT4gci5tZXRob2QgPT09IG0gJiYgci5wYXRoLnRlc3QocGF0aCkpO1xufVxuIl19

package/lib/middleware/route-table.d.ts

@@ -9,6 +9,28 @@ import type { Permission } from '../types/permissions.js';
  *                `HUMAN_SESSION_REQUIRED`), e.g. minting another credential.
  */
 export type OrgAdminAssuranceMachines = 'allow' | 'refuse';
+/**
+ * The CLOSED set of principal kinds a `dynamicAuthz` rule may admit.
+ *
+ * A route whose authority is resolved in the handler still has to say WHO can
+ * get through it. These are the kinds, deliberately coarse — the precise
+ * predicate lives in the prose rule and in the code:
+ *
+ *  - `superadmin`    — the `User.isSuperAdmin` flag (`isSystemAdmin(req)`).
+ *  - `system-org`    — a member of the system org holding a named permission;
+ *                      list the ids in `permissions` so the coverage scan and
+ *                      the contract can see them.
+ *  - `tenant-admin`  — an admin or owner of the target's own org, or of an
+ *                      ancestor of it. NOT a superadmin by virtue of the flag:
+ *                      several of these rules refuse the flag on purpose.
+ *  - `tenant-member` — any member of the target's org, admin or not.
+ *  - `subject`       — the very user the request is about (self-service).
+ *  - `service`       — a service principal / internal caller.
+ *  - `gateway`       — the ingress itself supplies the fact (the console
+ *                      `auth_request` passes the console class in a header).
+ */
+export declare const DYNAMIC_PRINCIPALS: readonly ['superadmin', 'system-org', 'tenant-admin', 'tenant-member', 'subject', 'service', 'gateway'];
+export type DynamicPrincipal = typeof DYNAMIC_PRINCIPALS[number];
 /** One requirement a gate middleware enforces. */
 export type RouteGate = {
     kind: 'auth';
@@ -19,6 +41,40 @@ export type RouteGate = {
     allowService?: boolean;
 } | {
     kind: 'systemAdmin';
+}
+/**
+ * Authorization the route CANNOT express statically, resolved in the handler.
+ *
+ * Some authority depends on the request: impersonation asks whether the caller
+ * is a sysadmin OR an admin of an ancestor of the TARGET user's org, which is
+ * only answerable once the target is known. Those gates were correct but
+ * invisible — the route table showed no requirement, and
+ * `docs/permission-contract.md` is derived from the table, so the artifact the
+ * repo calls its review surface read blank for the strongest privilege in the
+ * system.
+ *
+ * This records the requirement in prose AND as a closed set of principal
+ * kinds. It authorizes NOTHING; the handler still does the work. Its value is
+ * that a reviewer reading the contract sees a stated rule instead of an empty
+ * cell, and that removing the real check leaves a declaration behind that no
+ * longer matches.
+ *
+ * WHY `reachableBy` EXISTS BESIDE THE PROSE. Prose is unreviewable by a test,
+ * and one of these rules was wrong: the impersonation `decide` route declared
+ * "a DIFFERENT sysadmin than the requester (two-person rule)", which is only
+ * its break-glass branch — the ordinary branch is the tenant's named approver
+ * or a genuine tenant admin, and a sysadmin alone is explicitly REFUSED there.
+ * Nothing could notice, because the only machine-readable fields said
+ * `systemAdmin: false, permissions: []`. A closed set makes the author
+ * enumerate principals, lets the coverage scan assert the declaration exists,
+ * and lets "which routes can the superadmin flag reach?" be answered by a
+ * query instead of by reading six paragraphs.
+ */
+ | {
+    kind: 'dynamicAuthz';
+    rule: string;
+    reachableBy: readonly DynamicPrincipal[];
+    permissions?: readonly Permission[];
 } | {
     kind: 'servicePrincipal';
 }
@@ -60,6 +116,15 @@ export type RouteGate = {
 } | {
     kind: 'audit';
     actions: readonly string[];
+}
+/** A quota middleware: `meter` increments the type once per 2xx
+ *  (`meterQuotaOnSuccess`), `check` 429s when the type is spent (`checkQuota`).
+ *  Recorded so the quota coverage check can see an unmetered user route — and a
+ *  route metered TWICE, which double-bills every call. */
+ | {
+    kind: 'quota';
+    mode: 'meter' | 'check';
+    quotaType: string;
 };
 /**
  * Attach gate metadata to a middleware function (appends to any existing tags)
@@ -77,6 +142,18 @@ export declare function getRouteGates(fn: unknown): readonly RouteGate[];
  * `router.post('/', audited('pipeline.create'), handler)`. The handler still
  * emits the event itself.
  */
+/**
+ * Declare authorization that the handler resolves (see the `dynamicAuthz` gate).
+ * A no-op middleware, exactly like {@link audited}: it records the rule on the
+ * route table so the contract can print it.
+ *
+ * `rule` is read by a human, so it should name the real predicate — e.g.
+ * `'sysadmin, or an admin of an ancestor org of the target user'`.
+ */
+export declare function dynamicAuthz(rule: string, opts: {
+    reachableBy: readonly DynamicPrincipal[];
+    permissions?: readonly Permission[];
+}): (req: unknown, res: unknown, next: () => void) => void;
 export declare function audited(...actions: string[]): (req: unknown, res: unknown, next: () => void) => void;
 /** Resolved requirements for one method + path. */
 export interface RouteTableEntry {
@@ -92,6 +169,20 @@ export interface RouteTableEntry {
     }>;
     systemAdmin: boolean;
     servicePrincipal: boolean;
+    /** Authorization the HANDLER resolves, in prose — see the `dynamicAuthz` gate.
+     *  Empty when the route's authority is fully expressed by the gates above. */
+    dynamicAuthz: string[];
+    /** The principal kinds those dynamic rules admit, deduped and sorted. Absent
+     *  when the route declares no dynamic rule, so tables without one are
+     *  unchanged. This is the machine-readable half of `dynamicAuthz`: it is how
+     *  "which routes can the superadmin flag reach?" is answerable without
+     *  reading prose. */
+    dynamicReachableBy?: DynamicPrincipal[];
+    /** Permission ids a dynamic rule consults inside the handler, deduped and
+     *  sorted. Absent when none does. These are REAL enforcement — the coverage
+     *  scan counts a `userHasPermission(req, 'x')` in a controller — so the
+     *  contract should not read as though the route asked for nothing. */
+    dynamicPermissions?: Permission[];
     /**
      * The services allowed to call this route when it is INTERNAL (`requireInternalService`).
      * An empty array means the route is not internal — a user token may reach it,
@@ -132,6 +223,19 @@ export interface RouteTableEntry {
     features: string[];
     scopes: string[];
     audit: string[];
+    /**
+     * The quota middleware in the chain: the types metered (once per 2xx) and
+     * checked (429 when spent). `metered` is NOT deduped — a type listed twice is
+     * metered twice, which the coverage check flags. `exempt` marks a route on the
+     * fleet-wide `QUOTA_EXEMPT_ROUTES` list, where the `apiCalls` meter and check
+     * are no-ops at runtime (so `apiCalls` is left out of both lists). Absent when
+     * the chain has no quota middleware and the route is not exempt.
+     */
+    quota?: {
+        metered: string[];
+        checked: string[];
+        exempt?: true;
+    };
 }
 /**
  * Build the route table of an assembled Express app (or router): one entry per