@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/middleware/step-up.js

@@ -1,6 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { verifyUserJwt } from './jwt-verify.js';
+import { recordAuthzDenial } from './permission-gates.js';
 import { tagRouteGate } from './route-table.js';
 import { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';
 import { createEnvRedisClient, createRedisReadyGate } from '../services/env-redis.js';
@@ -142,6 +143,7 @@ async function _requireStepUp(options, req, res, next) {
     // so "a machine credential never satisfies an assurance requirement" is a
     // property of this gate, not a side effect of how step-up tokens are minted.
     if (isServiceAccountPrincipal(req)) {
+        recordAuthzDenial(req, 'step-up (STEP_UP_NOT_AVAILABLE: service account)');
         sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');
         return;
     }
@@ -160,10 +162,16 @@ async function _requireStepUp(options, req, res, next) {
         payload = await verifyStepUpToken(token);
     }
     catch {
+        // A presented-but-unverifiable token (forged, expired, wrong key) is on the
+        // trail; a MISSING one (STEP_UP_REQUIRED above) is the UI's normal first
+        // attempt and is not.
+        recordAuthzDenial(req, 'step-up (STEP_UP_INVALID)');
         sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');
         return;
     }
     if (payload.sub !== callerSub) {
+        // Someone else's step-up token replayed on this session — never a UI bug.
+        recordAuthzDenial(req, 'step-up (STEP_UP_MISMATCH)');
         sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');
         return;
     }
@@ -171,11 +179,13 @@ async function _requireStepUp(options, req, res, next) {
     // earned by the wrong factor can still be spent on a route that accepts it —
     // burning it here would make the refusal destructive as well as confusing.
     if (options.methods && !(payload.method && options.methods.includes(payload.method))) {
+        recordAuthzDenial(req, `step-up (STEP_UP_METHOD_REQUIRED: ${options.methods.join(' or ')}, got ${payload.method ?? 'none'})`);
         sendError(res, 401, 'This action must be confirmed with a passkey or an authenticator code', 'STEP_UP_METHOD_REQUIRED', { methods: [...options.methods] });
         return;
     }
     try {
         if (!(await consumeStepUpJti(payload.jti, payload.exp))) {
+            recordAuthzDenial(req, 'step-up (STEP_UP_REPLAY)');
             sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');
             return;
         }
@@ -187,4 +197,4 @@ async function _requireStepUp(options, req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;\n * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing\n * key it mints access tokens with, so these services verify it through the same\n * JWKS. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, so the verify + single-use jti live in api-core where any\n * service can require them.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { verifyUserJwt } from './jwt-verify.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/**\n * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here\n * as its own union so a verifier can name the factors it accepts without\n * importing platform.\n */\nexport type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';\n\n/**\n * The factors that count as a SECOND FACTOR, for routes that may only be\n * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).\n *\n * A password or a provider re-auth proves the same single factor the session was\n * already opened with, so on those routes they are not enough: the point is that\n * someone holding only a stolen session — or only a stolen password — cannot\n * proceed.\n */\nexport const STRONG_STEP_UP_METHODS: readonly StepUpMethod[] = ['webauthn', 'totp'];\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  /** Which factor earned it. Absent only on a token minted before the claim\n   *  existed, which a method-restricted gate treats as \"not proven\". */\n  method?: StepUpMethod;\n  iat: number;\n  exp: number;\n}\n\n/** Options for {@link requireStepUp}. */\nexport interface RequireStepUpOptions {\n  /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).\n   *  Omitted means any factor the platform will issue a token for. */\n  methods?: readonly StepUpMethod[];\n}\n\n/**\n * Verify a step-up token: a valid ES256 signature from one of platform's\n * published signing keys, issuer and audience when configured, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same\n * key and carries the same `sub`, so without asserting the step-up shape it\n * would bypass the gate. Throws on any failure (an unfetchable key set included:\n * an unverifiable token is not a step-up). Does NOT bind to a caller —\n * `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than\n * re-implementing it. The hand-rolled copy this replaced dropped TWO of its\n * guards: it never pinned issuer/audience, and its previous-secret retry had no\n * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.\n */\nexport async function verifyStepUpToken(token: string): Promise<StepUpTokenPayload> {\n  const payload = await verifyUserJwt<StepUpTokenPayload>(token);\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\ntype JtiRedis = ReadyAwareRedis & { set: (...args: unknown[]) => Promise<unknown> };\nlet _redis: JtiRedis | null | undefined;\nlet _redisReady: (() => Promise<void>) | undefined;\n/**\n * The jti client, built lazily. The env client has no offline queue, so a SET on\n * a connection that isn't up yet is rejected — the FIRST step-up on every pod\n * would fail. Wait (bounded, never rejecting) for readiness before\n * handing it out; a genuinely down Redis still fails closed on the SET below.\n */\nasync function redis(): Promise<JtiRedis | null> {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<JtiRedis>('step-up-jti');\n    _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;\n  }\n  if (_redisReady) await _redisReady();\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = await redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n *\n * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the\n * ordinary any-factor gate, or call it with `{ methods }` to demand that the\n * confirmation was earned by a specific factor — `requireStepUp({ methods:\n * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a\n * meaningful second proof.\n */\nexport function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;\nexport function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireStepUp(\n  reqOrOptions: Request | RequireStepUpOptions,\n  res?: Response,\n  next?: NextFunction,\n): Promise<void> | ((req: Request, res: Response, next: NextFunction) => void) {\n  // The direct form RETURNS the promise (Express ignores it; a test awaits it),\n  // so composing the gate as `router.post('/x', requireStepUp, h)` behaves\n  // exactly as it did before the options form existed.\n  if (res && next && 'headers' in reqOrOptions) {\n    return _requireStepUp({}, reqOrOptions as Request, res, next);\n  }\n  const options = reqOrOptions as RequireStepUpOptions;\n  return tagRouteGate(\n    (reqInner: Request, resInner: Response, nextInner: NextFunction) => {\n      void _requireStepUp(options, reqInner, resInner, nextInner);\n    },\n    { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) },\n  );\n}\ntagRouteGate(requireStepUp, { kind: 'stepUp' });\n\nasync function _requireStepUp(options: RequireStepUpOptions, req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with a SERVICE's own ES256 key,\n  // which no external client holds, so this can't be spoofed to skip\n  // step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a\n  // member is, and there is no person behind it to re-verify — so it can NEVER\n  // pass step-up. Refuse explicitly (rather than letting it fall through to the\n  // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)\n  // so \"a machine credential never satisfies an assurance requirement\" is a\n  // property of this gate, not a side effect of how step-up tokens are minted.\n  if (isServiceAccountPrincipal(req)) {\n    sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = await verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  // Factor restriction. Checked BEFORE the jti is consumed, so a token\n  // earned by the wrong factor can still be spent on a route that accepts it —\n  // burning it here would make the refusal destructive as well as confusing.\n  if (options.methods && !(payload.method && options.methods.includes(payload.method))) {\n    sendError(\n      res, 401,\n      'This action must be confirmed with a passkey or an authenticator code',\n      'STEP_UP_METHOD_REQUIRED',\n      { methods: [...options.methods] },\n    );\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;\n * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing\n * key it mints access tokens with, so these services verify it through the same\n * JWKS. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, so the verify + single-use jti live in api-core where any\n * service can require them.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { verifyUserJwt } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/**\n * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here\n * as its own union so a verifier can name the factors it accepts without\n * importing platform.\n */\nexport type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';\n\n/**\n * The factors that count as a SECOND FACTOR, for routes that may only be\n * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).\n *\n * A password or a provider re-auth proves the same single factor the session was\n * already opened with, so on those routes they are not enough: the point is that\n * someone holding only a stolen session — or only a stolen password — cannot\n * proceed.\n */\nexport const STRONG_STEP_UP_METHODS: readonly StepUpMethod[] = ['webauthn', 'totp'];\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  /** Which factor earned it. Absent only on a token minted before the claim\n   *  existed, which a method-restricted gate treats as \"not proven\". */\n  method?: StepUpMethod;\n  iat: number;\n  exp: number;\n}\n\n/** Options for {@link requireStepUp}. */\nexport interface RequireStepUpOptions {\n  /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).\n   *  Omitted means any factor the platform will issue a token for. */\n  methods?: readonly StepUpMethod[];\n}\n\n/**\n * Verify a step-up token: a valid ES256 signature from one of platform's\n * published signing keys, issuer and audience when configured, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same\n * key and carries the same `sub`, so without asserting the step-up shape it\n * would bypass the gate. Throws on any failure (an unfetchable key set included:\n * an unverifiable token is not a step-up). Does NOT bind to a caller —\n * `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than\n * re-implementing it. The hand-rolled copy this replaced dropped TWO of its\n * guards: it never pinned issuer/audience, and its previous-secret retry had no\n * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.\n */\nexport async function verifyStepUpToken(token: string): Promise<StepUpTokenPayload> {\n  const payload = await verifyUserJwt<StepUpTokenPayload>(token);\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\ntype JtiRedis = ReadyAwareRedis & { set: (...args: unknown[]) => Promise<unknown> };\nlet _redis: JtiRedis | null | undefined;\nlet _redisReady: (() => Promise<void>) | undefined;\n/**\n * The jti client, built lazily. The env client has no offline queue, so a SET on\n * a connection that isn't up yet is rejected — the FIRST step-up on every pod\n * would fail. Wait (bounded, never rejecting) for readiness before\n * handing it out; a genuinely down Redis still fails closed on the SET below.\n */\nasync function redis(): Promise<JtiRedis | null> {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<JtiRedis>('step-up-jti');\n    _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;\n  }\n  if (_redisReady) await _redisReady();\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = await redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n *\n * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the\n * ordinary any-factor gate, or call it with `{ methods }` to demand that the\n * confirmation was earned by a specific factor — `requireStepUp({ methods:\n * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a\n * meaningful second proof.\n */\nexport function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;\nexport function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireStepUp(\n  reqOrOptions: Request | RequireStepUpOptions,\n  res?: Response,\n  next?: NextFunction,\n): Promise<void> | ((req: Request, res: Response, next: NextFunction) => void) {\n  // The direct form RETURNS the promise (Express ignores it; a test awaits it),\n  // so composing the gate as `router.post('/x', requireStepUp, h)` behaves\n  // exactly as it did before the options form existed.\n  if (res && next && 'headers' in reqOrOptions) {\n    return _requireStepUp({}, reqOrOptions as Request, res, next);\n  }\n  const options = reqOrOptions as RequireStepUpOptions;\n  return tagRouteGate(\n    (reqInner: Request, resInner: Response, nextInner: NextFunction) => {\n      void _requireStepUp(options, reqInner, resInner, nextInner);\n    },\n    { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) },\n  );\n}\ntagRouteGate(requireStepUp, { kind: 'stepUp' });\n\nasync function _requireStepUp(options: RequireStepUpOptions, req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with a SERVICE's own ES256 key,\n  // which no external client holds, so this can't be spoofed to skip\n  // step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a\n  // member is, and there is no person behind it to re-verify — so it can NEVER\n  // pass step-up. Refuse explicitly (rather than letting it fall through to the\n  // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)\n  // so \"a machine credential never satisfies an assurance requirement\" is a\n  // property of this gate, not a side effect of how step-up tokens are minted.\n  if (isServiceAccountPrincipal(req)) {\n    recordAuthzDenial(req, 'step-up (STEP_UP_NOT_AVAILABLE: service account)');\n    sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = await verifyStepUpToken(token);\n  } catch {\n    // A presented-but-unverifiable token (forged, expired, wrong key) is on the\n    // trail; a MISSING one (STEP_UP_REQUIRED above) is the UI's normal first\n    // attempt and is not.\n    recordAuthzDenial(req, 'step-up (STEP_UP_INVALID)');\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    // Someone else's step-up token replayed on this session — never a UI bug.\n    recordAuthzDenial(req, 'step-up (STEP_UP_MISMATCH)');\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  // Factor restriction. Checked BEFORE the jti is consumed, so a token\n  // earned by the wrong factor can still be spent on a route that accepts it —\n  // burning it here would make the refusal destructive as well as confusing.\n  if (options.methods && !(payload.method && options.methods.includes(payload.method))) {\n    recordAuthzDenial(req, `step-up (STEP_UP_METHOD_REQUIRED: ${options.methods.join(' or ')}, got ${payload.method ?? 'none'})`);\n    sendError(\n      res, 401,\n      'This action must be confirmed with a passkey or an authenticator code',\n      'STEP_UP_METHOD_REQUIRED',\n      { methods: [...options.methods] },\n    );\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      recordAuthzDenial(req, 'step-up (STEP_UP_REPLAY)');\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/services/ai-call-weight.d.ts

@@ -0,0 +1,24 @@
+/** Largest weight one model may carry — one call can never reserve more than this many units. */
+export declare const MAX_AI_CALL_WEIGHT = 100;
+/**
+ * Parse `AI_MODEL_WEIGHTS` — a JSON object of `key → integer weight` — into
+ * lower-cased entries. A malformed value is IGNORED (logged), never fatal: the
+ * weights are an optional pricing lever and every call still meters at 1.
+ */
+export declare function parseAiModelWeights(raw: string | undefined): Record<string, number>;
+/**
+ * How many `aiCalls` units one call on `{ provider, modelId }` reserves.
+ *
+ * MODEL-CLASS WEIGHTING is OFF by default: with `AI_MODEL_WEIGHTS` unset every
+ * model weighs 1 — except the self-hosted provider, which weighs 0 (see
+ * {@link BUILT_IN_WEIGHTS}). Matching, first hit wins:
+ *  1. a key equal to the PROVIDER id (`"openai-compatible": 0`, `"bedrock": 2`);
+ *  2. the LONGEST key contained in the model id (`"opus": 3` matches
+ *     `claude-opus-4-1`; `"sonnet": 1`, `"haiku": 1`).
+ * No match → 1. A weight of 0 means the call reserves nothing (it is still
+ * recorded in the usage ledger with its tokens).
+ */
+export declare function aiCallWeight(selection: {
+    provider: string;
+    modelId: string;
+}): number;

package/lib/services/ai-call-weight.js

@@ -0,0 +1,77 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { OPENAI_COMPATIBLE_PROVIDER_ID } from '../constants/ai-providers.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('ai-call-weight');
+/** Largest weight one model may carry — one call can never reserve more than this many units. */
+export const MAX_AI_CALL_WEIGHT = 100;
+/**
+ * Built-in weights, under whatever `AI_MODEL_WEIGHTS` sets. The self-hosted
+ * OpenAI-compatible provider (the in-cluster `ask-model`) runs on hardware the
+ * operator already pays for, so a call on it spends NO `aiCalls` unit by default;
+ * set `{"openai-compatible": 1}` to meter it like any other model.
+ */
+const BUILT_IN_WEIGHTS = { [OPENAI_COMPATIBLE_PROVIDER_ID]: 0 };
+/**
+ * Parse `AI_MODEL_WEIGHTS` — a JSON object of `key → integer weight` — into
+ * lower-cased entries. A malformed value is IGNORED (logged), never fatal: the
+ * weights are an optional pricing lever and every call still meters at 1.
+ */
+export function parseAiModelWeights(raw) {
+    const out = { ...BUILT_IN_WEIGHTS };
+    if (!raw || raw.trim() === '')
+        return out;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn('AI_MODEL_WEIGHTS is not valid JSON; every model weighs 1');
+        return out;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        logger.warn('AI_MODEL_WEIGHTS must be a JSON object; every model weighs 1');
+        return out;
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > MAX_AI_CALL_WEIGHT) {
+            logger.warn('AI_MODEL_WEIGHTS entry ignored (weight must be an integer 0..100)', { key });
+            continue;
+        }
+        out[key.trim().toLowerCase()] = value;
+    }
+    return out;
+}
+let cached;
+function currentWeights() {
+    const raw = process.env.AI_MODEL_WEIGHTS;
+    if (!cached || cached.raw !== raw)
+        cached = { raw, weights: parseAiModelWeights(raw) };
+    return cached.weights;
+}
+/**
+ * How many `aiCalls` units one call on `{ provider, modelId }` reserves.
+ *
+ * MODEL-CLASS WEIGHTING is OFF by default: with `AI_MODEL_WEIGHTS` unset every
+ * model weighs 1 — except the self-hosted provider, which weighs 0 (see
+ * {@link BUILT_IN_WEIGHTS}). Matching, first hit wins:
+ *  1. a key equal to the PROVIDER id (`"openai-compatible": 0`, `"bedrock": 2`);
+ *  2. the LONGEST key contained in the model id (`"opus": 3` matches
+ *     `claude-opus-4-1`; `"sonnet": 1`, `"haiku": 1`).
+ * No match → 1. A weight of 0 means the call reserves nothing (it is still
+ * recorded in the usage ledger with its tokens).
+ */
+export function aiCallWeight(selection) {
+    const weights = currentWeights();
+    const provider = selection.provider.toLowerCase();
+    if (provider in weights)
+        return weights[provider];
+    const model = selection.modelId.toLowerCase();
+    let best;
+    for (const [key, weight] of Object.entries(weights)) {
+        if (key.length > 0 && model.includes(key) && (!best || key.length > best.key.length))
+            best = { key, weight };
+    }
+    return best ? best.weight : 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/audit-context.d.ts

@@ -0,0 +1,105 @@
+import type { Request } from 'express';
+import type { JwtPayload } from '../types/common.js';
+/** Inbound correlation ids a caller (CLI, Lambda, CodeBuild) may forward. */
+export interface AuditCorrelation {
+    /** `X-Pipeline-Execution-Id` — the CodePipeline execution that made the call. */
+    pipelineExecutionId?: string;
+    /** `X-CodeBuild-Build-Id` — the CodeBuild build that made the call. */
+    codebuildBuildId?: string;
+    /** `X-Source-Event-Id` — the upstream event (EventBridge / webhook) being handled. */
+    sourceEventId?: string;
+}
+/** Background-work identity for events recorded outside any request. */
+export interface AuditJobContext {
+    /** Stable job name (e.g. `registry-gc`, `vuln-rescan`). */
+    jobId?: string;
+    /** This run's id (a BullMQ job id, a sweep's uuid). */
+    runId?: string;
+    /** What started it: `schedule`, `queue`, `startup`, `manual`, … */
+    trigger?: string;
+}
+export interface AuditContext {
+    requestId?: string;
+    traceId?: string;
+    ip?: string;
+    userAgent?: string;
+    correlation?: AuditCorrelation;
+    job?: AuditJobContext;
+    /**
+     * The VERIFIED principal of the inbound request. A getter, not a value: the
+     * scope opens before `requireAuth` runs, so `req.user` is read at the moment
+     * an event is recorded.
+     */
+    principal?: () => JwtPayload | undefined;
+}
+/**
+ * The credential behind an audited action — reserved `details._auth`, so it is
+ * covered by the audit hash chain (which hashes `details`). Built only from a
+ * verified token, never from caller input; the remote-audit client overwrites
+ * any `_auth` a call site put in `details`.
+ */
+export interface AuditAuthBlock {
+    principalType?: string;
+    /** The internal service, when the principal is a service token. */
+    service?: string;
+    /**
+     * The revocable credential: the access key (PAT / service-account key) the
+     * token derives from (`parentKeyId`), else the token's own `jti` (an exchanged
+     * key token's key id, an impersonation session id, a service mint id).
+     */
+    keyId?: string;
+    /** Refresh-session slot the token was minted on. */
+    sid?: string;
+    scope?: string;
+    tokenUse?: string;
+    /** The token's permissions were narrowed to a subset at credential creation. */
+    permissionsRestricted?: true;
+    /** The principal is a platform superadmin. */
+    superAdmin?: true;
+    /**
+     * The principal's active org is the system org (vendor staff acting through a
+     * system-org job Role). With `superAdmin`, this is what lets the remote-audit
+     * client claim a cross-org `affectedOrgId` (see `auditCrossOrg`).
+     */
+    systemOrg?: true;
+}
+/**
+ * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer
+ * one (a job started inside a request keeps the request's id), with the inner
+ * fields winning.
+ */
+export declare function runWithAuditContext<T>(ctx: AuditContext, fn: () => T): T;
+/** The active audit context, or undefined outside any scope. */
+export declare function currentAuditContext(): AuditContext | undefined;
+/** Inbound correlation headers recorded into the audit context. */
+export declare const AUDIT_CORRELATION_HEADERS: {
+    readonly pipelineExecutionId: 'x-pipeline-execution-id';
+    readonly codebuildBuildId: 'x-codebuild-build-id';
+    readonly sourceEventId: 'x-source-event-id';
+};
+/**
+ * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):
+ * a bounded opaque token, else `undefined` — an invalid value is dropped, never
+ * truncated into something that looks like a different id.
+ *
+ * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its
+ * account segment emptied, and a bare 12-digit value is refused. The generic
+ * 12-digit-run scrub is NOT used here — it would redact the all-digit final
+ * group of roughly one uuid in three hundred, corrupting the id it exists to
+ * correlate.
+ */
+export declare function sanitizeCorrelationId(raw: unknown): string | undefined;
+/** Strip control characters from a User-Agent and cap its length; undefined when empty. */
+export declare function sanitizeUserAgent(raw: unknown): string | undefined;
+/**
+ * The audit context for an inbound request. `requestId` is the id the
+ * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh
+ * uuid); the principal is read lazily from `req.user` (auth runs later in the
+ * chain).
+ */
+export declare function auditContextFromRequest(req: Request, ids?: {
+    requestId?: string;
+    traceId?: string;
+}): AuditContext;
+/** The `_auth` block for a verified principal (undefined when there is none). */
+export declare function auditAuthBlock(user: JwtPayload | undefined): AuditAuthBlock | undefined;

package/lib/services/audit-context.js

@@ -0,0 +1,134 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Ambient audit context: the request/job facts every audit event should carry
+ * (request id, trace id, client ip / user agent, the verified principal's
+ * credential, inbound correlation ids) without each of the ~150 `recordAudit`
+ * call sites threading them through by hand.
+ *
+ * api-server's request pipeline opens a scope per inbound request
+ * (`auditContextFromRequest` + `runWithAuditContext`); background work opens its
+ * own with `runWithAuditContext({ job: { jobId, runId, trigger } }, fn)`. The
+ * remote-audit client reads the scope when an event is RECORDED and stamps the
+ * result onto the event itself, so a spooled re-delivery minutes later still
+ * carries the context of the moment it happened.
+ */
+import { AsyncLocalStorage } from 'async_hooks';
+import { serviceNameOf } from '../middleware/service-tokens.js';
+import { isSystemOrgId } from '../middleware/system-org.js';
+const storage = new AsyncLocalStorage();
+/**
+ * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer
+ * one (a job started inside a request keeps the request's id), with the inner
+ * fields winning.
+ */
+export function runWithAuditContext(ctx, fn) {
+    const outer = storage.getStore();
+    const merged = outer
+        ? { ...outer, ...ctx, correlation: ctx.correlation ?? outer.correlation, job: ctx.job ? { ...outer.job, ...ctx.job } : outer.job }
+        : ctx;
+    return storage.run(merged, fn);
+}
+/** The active audit context, or undefined outside any scope. */
+export function currentAuditContext() {
+    return storage.getStore();
+}
+/** Inbound correlation headers recorded into the audit context. */
+export const AUDIT_CORRELATION_HEADERS = {
+    pipelineExecutionId: 'x-pipeline-execution-id',
+    codebuildBuildId: 'x-codebuild-build-id',
+    sourceEventId: 'x-source-event-id',
+};
+/** Max length of a stored correlation id / request id. */
+const MAX_CORRELATION_LEN = 128;
+/** Ids are opaque tokens: uuids, `project:uuid` build ids, ULIDs. Nothing else is stored. */
+const CORRELATION_ID = /^[A-Za-z0-9._:/@+=-]+$/;
+/** A bare AWS account id. */
+const BARE_ACCOUNT_ID = /^\d{12}$/;
+/** Max stored User-Agent length — a hostile header must not bloat audit rows. */
+const MAX_USER_AGENT_LEN = 512;
+/** C0 + DEL + C1 control characters, replaced so a UA can't inject into the UI/CSV export. */
+const CONTROL_CHARS = new RegExp('[\\u0000-\\u001f\\u007f-\\u009f]', 'g');
+function firstHeader(raw) {
+    return Array.isArray(raw) ? raw[0] : raw;
+}
+/**
+ * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):
+ * a bounded opaque token, else `undefined` — an invalid value is dropped, never
+ * truncated into something that looks like a different id.
+ *
+ * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its
+ * account segment emptied, and a bare 12-digit value is refused. The generic
+ * 12-digit-run scrub is NOT used here — it would redact the all-digit final
+ * group of roughly one uuid in three hundred, corrupting the id it exists to
+ * correlate.
+ */
+export function sanitizeCorrelationId(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const value = raw.trim();
+    if (value.length === 0 || value.length > MAX_CORRELATION_LEN || !CORRELATION_ID.test(value))
+        return undefined;
+    if (BARE_ACCOUNT_ID.test(value))
+        return undefined;
+    if (/^arn:/i.test(value)) {
+        const parts = value.split(':');
+        if (parts.length > 4)
+            parts[4] = '';
+        return parts.join(':');
+    }
+    return value;
+}
+/** Strip control characters from a User-Agent and cap its length; undefined when empty. */
+export function sanitizeUserAgent(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    const cleaned = raw.replace(CONTROL_CHARS, ' ').trim();
+    return cleaned.length === 0 ? undefined : cleaned.slice(0, MAX_USER_AGENT_LEN);
+}
+/**
+ * The audit context for an inbound request. `requestId` is the id the
+ * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh
+ * uuid); the principal is read lazily from `req.user` (auth runs later in the
+ * chain).
+ */
+export function auditContextFromRequest(req, ids = {}) {
+    const correlation = {};
+    for (const [field, header] of Object.entries(AUDIT_CORRELATION_HEADERS)) {
+        const value = sanitizeCorrelationId(firstHeader(req.headers[header]));
+        if (value)
+            correlation[field] = value;
+    }
+    return {
+        requestId: ids.requestId,
+        traceId: ids.traceId,
+        ip: req.ip,
+        userAgent: sanitizeUserAgent(firstHeader(req.headers['user-agent'])),
+        correlation: Object.keys(correlation).length > 0 ? correlation : undefined,
+        principal: () => req.user,
+    };
+}
+/** The `_auth` block for a verified principal (undefined when there is none). */
+export function auditAuthBlock(user) {
+    if (!user)
+        return undefined;
+    const block = {
+        principalType: user.principalType,
+        service: serviceNameOf(user),
+        keyId: user.parentKeyId ?? user.jti,
+        sid: user.sid,
+        scope: user.scope,
+        tokenUse: user.token_use,
+        ...(user.permissionsRestricted === true ? { permissionsRestricted: true } : {}),
+        ...(user.isSuperAdmin === true ? { superAdmin: true } : {}),
+        // A SERVICE token in the system org is the platform's own plumbing, not staff
+        // acting on a tenant; only human / service-account principals count.
+        ...(user.principalType !== 'service' && isSystemOrgId(user.organizationId) ? { systemOrg: true } : {}),
+    };
+    for (const key of Object.keys(block)) {
+        if (block[key] === undefined)
+            delete block[key];
+    }
+    return Object.keys(block).length > 0 ? block : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-context.js","sourceRoot":"","sources":["../../src/services/audit-context.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Ambient audit context: the request/job facts every audit event should carry\n * (request id, trace id, client ip / user agent, the verified principal's\n * credential, inbound correlation ids) without each of the ~150 `recordAudit`\n * call sites threading them through by hand.\n *\n * api-server's request pipeline opens a scope per inbound request\n * (`auditContextFromRequest` + `runWithAuditContext`); background work opens its\n * own with `runWithAuditContext({ job: { jobId, runId, trigger } }, fn)`. The\n * remote-audit client reads the scope when an event is RECORDED and stamps the\n * result onto the event itself, so a spooled re-delivery minutes later still\n * carries the context of the moment it happened.\n */\n\nimport { AsyncLocalStorage } from 'async_hooks';\nimport type { Request } from 'express';\nimport { serviceNameOf } from '../middleware/service-tokens.js';\nimport { isSystemOrgId } from '../middleware/system-org.js';\nimport type { JwtPayload } from '../types/common.js';\n\n/** Inbound correlation ids a caller (CLI, Lambda, CodeBuild) may forward. */\nexport interface AuditCorrelation {\n  /** `X-Pipeline-Execution-Id` — the CodePipeline execution that made the call. */\n  pipelineExecutionId?: string;\n  /** `X-CodeBuild-Build-Id` — the CodeBuild build that made the call. */\n  codebuildBuildId?: string;\n  /** `X-Source-Event-Id` — the upstream event (EventBridge / webhook) being handled. */\n  sourceEventId?: string;\n}\n\n/** Background-work identity for events recorded outside any request. */\nexport interface AuditJobContext {\n  /** Stable job name (e.g. `registry-gc`, `vuln-rescan`). */\n  jobId?: string;\n  /** This run's id (a BullMQ job id, a sweep's uuid). */\n  runId?: string;\n  /** What started it: `schedule`, `queue`, `startup`, `manual`, … */\n  trigger?: string;\n}\n\nexport interface AuditContext {\n  requestId?: string;\n  traceId?: string;\n  ip?: string;\n  userAgent?: string;\n  correlation?: AuditCorrelation;\n  job?: AuditJobContext;\n  /**\n   * The VERIFIED principal of the inbound request. A getter, not a value: the\n   * scope opens before `requireAuth` runs, so `req.user` is read at the moment\n   * an event is recorded.\n   */\n  principal?: () => JwtPayload | undefined;\n}\n\n/**\n * The credential behind an audited action — reserved `details._auth`, so it is\n * covered by the audit hash chain (which hashes `details`). Built only from a\n * verified token, never from caller input; the remote-audit client overwrites\n * any `_auth` a call site put in `details`.\n */\nexport interface AuditAuthBlock {\n  principalType?: string;\n  /** The internal service, when the principal is a service token. */\n  service?: string;\n  /**\n   * The revocable credential: the access key (PAT / service-account key) the\n   * token derives from (`parentKeyId`), else the token's own `jti` (an exchanged\n   * key token's key id, an impersonation session id, a service mint id).\n   */\n  keyId?: string;\n  /** Refresh-session slot the token was minted on. */\n  sid?: string;\n  scope?: string;\n  tokenUse?: string;\n  /** The token's permissions were narrowed to a subset at credential creation. */\n  permissionsRestricted?: true;\n  /** The principal is a platform superadmin. */\n  superAdmin?: true;\n  /**\n   * The principal's active org is the system org (vendor staff acting through a\n   * system-org job Role). With `superAdmin`, this is what lets the remote-audit\n   * client claim a cross-org `affectedOrgId` (see `auditCrossOrg`).\n   */\n  systemOrg?: true;\n}\n\nconst storage = new AsyncLocalStorage<AuditContext>();\n\n/**\n * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer\n * one (a job started inside a request keeps the request's id), with the inner\n * fields winning.\n */\nexport function runWithAuditContext<T>(ctx: AuditContext, fn: () => T): T {\n  const outer = storage.getStore();\n  const merged: AuditContext = outer\n    ? { ...outer, ...ctx, correlation: ctx.correlation ?? outer.correlation, job: ctx.job ? { ...outer.job, ...ctx.job } : outer.job }\n    : ctx;\n  return storage.run(merged, fn);\n}\n\n/** The active audit context, or undefined outside any scope. */\nexport function currentAuditContext(): AuditContext | undefined {\n  return storage.getStore();\n}\n\n/** Inbound correlation headers recorded into the audit context. */\nexport const AUDIT_CORRELATION_HEADERS = {\n  pipelineExecutionId: 'x-pipeline-execution-id',\n  codebuildBuildId: 'x-codebuild-build-id',\n  sourceEventId: 'x-source-event-id',\n} as const;\n\n/** Max length of a stored correlation id / request id. */\nconst MAX_CORRELATION_LEN = 128;\n/** Ids are opaque tokens: uuids, `project:uuid` build ids, ULIDs. Nothing else is stored. */\nconst CORRELATION_ID = /^[A-Za-z0-9._:/@+=-]+$/;\n/** A bare AWS account id. */\nconst BARE_ACCOUNT_ID = /^\\d{12}$/;\n\n/** Max stored User-Agent length — a hostile header must not bloat audit rows. */\nconst MAX_USER_AGENT_LEN = 512;\n/** C0 + DEL + C1 control characters, replaced so a UA can't inject into the UI/CSV export. */\nconst CONTROL_CHARS = new RegExp('[\\\\u0000-\\\\u001f\\\\u007f-\\\\u009f]', 'g');\n\nfunction firstHeader(raw: string | string[] | undefined): string | undefined {\n  return Array.isArray(raw) ? raw[0] : raw;\n}\n\n/**\n * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):\n * a bounded opaque token, else `undefined` — an invalid value is dropped, never\n * truncated into something that looks like a different id.\n *\n * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its\n * account segment emptied, and a bare 12-digit value is refused. The generic\n * 12-digit-run scrub is NOT used here — it would redact the all-digit final\n * group of roughly one uuid in three hundred, corrupting the id it exists to\n * correlate.\n */\nexport function sanitizeCorrelationId(raw: unknown): string | undefined {\n  if (typeof raw !== 'string') return undefined;\n  const value = raw.trim();\n  if (value.length === 0 || value.length > MAX_CORRELATION_LEN || !CORRELATION_ID.test(value)) return undefined;\n  if (BARE_ACCOUNT_ID.test(value)) return undefined;\n  if (/^arn:/i.test(value)) {\n    const parts = value.split(':');\n    if (parts.length > 4) parts[4] = '';\n    return parts.join(':');\n  }\n  return value;\n}\n\n/** Strip control characters from a User-Agent and cap its length; undefined when empty. */\nexport function sanitizeUserAgent(raw: unknown): string | undefined {\n  if (typeof raw !== 'string' || raw.length === 0) return undefined;\n  const cleaned = raw.replace(CONTROL_CHARS, ' ').trim();\n  return cleaned.length === 0 ? undefined : cleaned.slice(0, MAX_USER_AGENT_LEN);\n}\n\n/**\n * The audit context for an inbound request. `requestId` is the id the\n * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh\n * uuid); the principal is read lazily from `req.user` (auth runs later in the\n * chain).\n */\nexport function auditContextFromRequest(req: Request, ids: { requestId?: string; traceId?: string } = {}): AuditContext {\n  const correlation: AuditCorrelation = {};\n  for (const [field, header] of Object.entries(AUDIT_CORRELATION_HEADERS) as Array<[keyof AuditCorrelation, string]>) {\n    const value = sanitizeCorrelationId(firstHeader(req.headers[header]));\n    if (value) correlation[field] = value;\n  }\n  return {\n    requestId: ids.requestId,\n    traceId: ids.traceId,\n    ip: req.ip,\n    userAgent: sanitizeUserAgent(firstHeader(req.headers['user-agent'])),\n    correlation: Object.keys(correlation).length > 0 ? correlation : undefined,\n    principal: () => req.user,\n  };\n}\n\n/** The `_auth` block for a verified principal (undefined when there is none). */\nexport function auditAuthBlock(user: JwtPayload | undefined): AuditAuthBlock | undefined {\n  if (!user) return undefined;\n  const block: AuditAuthBlock = {\n    principalType: user.principalType,\n    service: serviceNameOf(user),\n    keyId: user.parentKeyId ?? user.jti,\n    sid: user.sid,\n    scope: user.scope,\n    tokenUse: user.token_use,\n    ...(user.permissionsRestricted === true ? { permissionsRestricted: true as const } : {}),\n    ...(user.isSuperAdmin === true ? { superAdmin: true as const } : {}),\n    // A SERVICE token in the system org is the platform's own plumbing, not staff\n    // acting on a tenant; only human / service-account principals count.\n    ...(user.principalType !== 'service' && isSystemOrgId(user.organizationId) ? { systemOrg: true as const } : {}),\n  };\n  for (const key of Object.keys(block) as Array<keyof AuditAuthBlock>) {\n    if (block[key] === undefined) delete block[key];\n  }\n  return Object.keys(block).length > 0 ? block : undefined;\n}\n"]}

package/lib/services/index.d.ts

@@ -3,6 +3,7 @@ export { createCacheService, type RedisCacheClient, type CacheInvalidationMessag
 export { withLeaderLock, createEnvRedisLock, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, type LockRedis, type LeaderLockRun, type LeaderLockOptions, type LeaderLockAbortReason, } from './leader-lock.js';
 export { sendSystemNotification, SYSTEM_NOTIFY_PATH, type SystemNotification, } from './system-notification.js';
 export { createScheduler, type SchedulerOptions, type Scheduler, } from './scheduler.js';
+export { assessVersionVulns, versionScanFacts, scanFreshness, scanWarnings, lastScannedAt, scanStaleHours, severityOf, maxSeverity, severityAtLeast, VULN_SEVERITIES, setVulnPolicyComplianceClientForTests, type VulnSeverity, type VulnWarning, type ScannedRecord, type VulnConsumptionPolicy, type VulnAcceptance, type VersionScanFacts, type VersionVulnInput, type VersionVulnAssessment, } from './version-vuln-policy.js';
 export { createComplianceClient, type ComplianceCheckResult, type ComplianceViolation, } from './compliance-client.js';
 export { pluginRunsOwnImage, pluginComplianceTags, derivePluginImageCompliance, type PluginComplianceAttributes, PLUGIN_IMAGE_COMPLIANCE_FIELDS, type PluginImageRow, } from '../utils/plugin-compliance.js';
 export * from './compliance-event-subscriber.js';
@@ -15,8 +16,11 @@ export { createEnvRedisDurableEventBus, type EventSubscription, type DurableEven
 export { getErrorRetryDecision, } from './retry-strategy.js';
 export type { RetryConfig, } from './retry-strategy.js';
 export { nextBackoffMs, retryForever, } from './retry-forever.js';
-export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, type QuotaReserveResult, type QuotaService, } from './quota.js';
-export { createRemoteAuditClient, wireAuthzDenialAuditor, recordAudit, type RemoteAuditEvent, type RemoteAuditClient, } from './remote-audit-client.js';
+export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, meteredQuotaTypeFor, callQuotaExemption, QUOTA_CHECK_TIMEOUT_MS, quotaAttributionFromRequest, type AiKeySource, type AiLimitCode, type CallQuotaExemption, type QuotaReserveResult, type QuotaTokenUsage, type QuotaService, type QuotaUsageAttribution, } from './quota.js';
+export { aiCallWeight, parseAiModelWeights, MAX_AI_CALL_WEIGHT, } from './ai-call-weight.js';
+export { QuotaIncrementBatcher, flushQuotaIncrements, QUOTA_INCREMENT_FLUSH_MS, QUOTA_INCREMENT_BUFFER_MAX, MAX_GROUPS_PER_INCREMENT, type MeteredIncrementGroup, } from './quota-increment-batcher.js';
+export { createRemoteAuditClient, wireAuthzDenialAuditor, recordAudit, type RemoteAuditEvent, type RemoteAuditWireEvent, type RemoteAuditClient, } from './remote-audit-client.js';
+export { runWithAuditContext, currentAuditContext, auditContextFromRequest, auditAuthBlock, sanitizeCorrelationId, sanitizeUserAgent, AUDIT_CORRELATION_HEADERS, type AuditContext, type AuditCorrelation, type AuditJobContext, type AuditAuthBlock, } from './audit-context.js';
 export { auditSpoolKey, createEnvRedisAuditSpool, type AuditSpool, } from './audit-spool.js';
 export { resolveRedisConnection, describeRedisConnection, createRedisClient, createEnvRedisClient, createRedisReadyGate, incrWindow, RedisConfigError, type RedisEvalClient, } from './env-redis.js';
 export { createRedisTokenRevocationStore, createEnvRedisTokenRevocationStore, publishTokenRevocation, publishSessionRevocation, publishCredentialRevocation, } from './token-revocation.js';
@@ -27,3 +31,4 @@ export { alertDeliveryConfig, canDeliverAnywhere, deadmanConfig, reportAlertDeli
 export { verifyPagerDutySignature, onCallInboundConfig, fetchRotaCoverage, parseOnCallWebhook, ackLatencySeconds, PAGERDUTY_API_URL, type OnCallInboundConfig, type OnCallWebhookEvent, type OnCallWebhookEventType, type RotaCoverage, } from './pagerduty-inbound.js';
 export { sendPagerDutyEvent, pagerDutyConfig, resolveEventsEndpoint, PAGERDUTY_EVENTS_URL, type OnCallProvider, type PagerDutyAction, type PagerDutyConfig, type PagerDutyEvent, type PagerDutyResult, type PagerDutySeverity, } from './pagerduty.js';
 export { createEcosystemNotifyClient, ECOSYSTEM_NOTIFY_PATH, type EcosystemNotifyClient, } from './ecosystem-notify-client.js';
+export { fetchOrgAIAccess, fetchOrgAIKey, assertOrgAIEnabled, requireOrgAIEnabled, resetOrgAICache, ORG_AI_ACCESS_PATH, ORG_AI_KEYS_PATH, type OrgAIAccess, } from './org-ai-client.js';