@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/services/quota.js

@@ -1,11 +1,14 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { currentAuditContext, sanitizeCorrelationId } from './audit-context.js';
 import { createSafeClient } from './http-client.js';
-import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { batcherFor } from './quota-increment-batcher.js';
+import { onBehalfCaller } from '../middleware/on-behalf.js';
+import { getServiceAuthHeader, isServicePrincipal } from '../middleware/service-tokens.js';
 import { SYSTEM_ORG_ID } from '../middleware/system-org.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { DEFAULT_TIER, isValidTier } from '../types/quota-tiers.js';
-import { envBool } from '../utils/env.js';
+import { envBool, envInt } from '../utils/env.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';
@@ -23,6 +26,28 @@ const QUOTA_REQUEST_OPTIONS = {
     maxRateLimitRetries: 0,
     maxRetries: 1,
 };
+/**
+ * Budget for one `check` of a COUNTER quota (`QUOTA_CHECK_TIMEOUT_MS`, default
+ * 300), with no retry.
+ *
+ * The check is a read gate that FAILS OPEN, run ahead of the request it gates:
+ * the old 5 s timeout × 2 attempts meant a slow quota service added up to 10 s
+ * to every metered request and then let it through anyway. A short budget turns
+ * the same incident into a ≤ 300 ms fail-open (counted on
+ * `quota_fail_open_total`, which alerts) — and with the per-pod check cache in
+ * front (api-server `checkQuota`) a healthy service is asked at most once per
+ * org/type per cache TTL.
+ *
+ * `storageBytes` keeps the client timeout and one retry: it is a MEASURED read
+ * (the quota service walks the org's registry namespace on a cold cache) behind
+ * the registry's fail-CLOSED push gate, where a premature timeout refuses a push.
+ */
+export const QUOTA_CHECK_TIMEOUT_MS = envInt('QUOTA_CHECK_TIMEOUT_MS', 300, { min: 1 });
+function checkRequestOptions(quotaType) {
+    if (quotaType === 'storageBytes')
+        return QUOTA_REQUEST_OPTIONS;
+    return { maxRateLimitRetries: 0, maxRetries: 0, timeout: QUOTA_CHECK_TIMEOUT_MS };
+}
 const logger = createLogger('quota');
 // RESERVE FAIL MODE — explicit, single policy.
 //
@@ -41,6 +66,121 @@ const logger = createLogger('quota');
 // (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.
 // `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.
 const QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);
+/** Longest attribution string the client sends (the quota service enforces the same bound). */
+const MAX_ATTRIBUTION_LEN = 200;
+function bounded(value) {
+    return typeof value === 'string' && value.length > 0 ? value.slice(0, MAX_ATTRIBUTION_LEN) : undefined;
+}
+/** The principal half of an attribution block, from a VERIFIED token. */
+function principalAttribution(user) {
+    if (!user)
+        return {};
+    return {
+        principalType: user.principalType,
+        principalId: bounded(user.sub),
+        keyId: bounded(user.parentKeyId ?? user.jti),
+    };
+}
+/**
+ * Attribution for the request being served: the verified principal, the matched
+ * route pattern, the pipeline (`:pipelineId` param or a sanitized
+ * `X-Pipeline-Id` header) and the request id. Read off `req` directly rather than
+ * the ambient audit context because the metering middleware runs in a `finish`
+ * listener, where the request's async scope is no longer guaranteed.
+ */
+export function quotaAttributionFromRequest(req) {
+    const routePath = req.route?.path;
+    const route = typeof routePath === 'string' ? `${req.method} ${(req.baseUrl ?? '') + routePath}` : undefined;
+    const header = req.headers['x-pipeline-id'];
+    const pipelineId = sanitizeCorrelationId(req.params?.pipelineId) ?? sanitizeCorrelationId(Array.isArray(header) ? header[0] : header);
+    const requestIdHeader = req.headers['x-request-id'];
+    const requestId = req.requestId
+        ?? sanitizeCorrelationId(Array.isArray(requestIdHeader) ? requestIdHeader[0] : requestIdHeader);
+    return {
+        ...principalAttribution(req.user),
+        ...(route ? { route: route.slice(0, MAX_ATTRIBUTION_LEN) } : {}),
+        ...(pipelineId ? { pipelineId } : {}),
+        ...(requestId ? { requestId: bounded(requestId) } : {}),
+    };
+}
+/**
+ * Attribution from the ambient audit context, for calls made inside a request
+ * scope that did not pass one explicitly (the reserve / refund helpers every
+ * service uses). Empty outside any scope.
+ */
+function attributionFromContext() {
+    const ctx = currentAuditContext();
+    if (!ctx)
+        return {};
+    return {
+        ...principalAttribution(ctx.principal?.()),
+        ...(ctx.requestId ? { requestId: bounded(ctx.requestId) } : {}),
+    };
+}
+/** The attribution a quota write sends: the explicit block, else the ambient one. */
+function resolveAttribution(explicit) {
+    const resolved = explicit ?? attributionFromContext();
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+/**
+ * The quota type a metered request actually spends.
+ *
+ * `apiCalls` is the PEOPLE's budget — an interactive session. A request made by
+ * a NON-INTERACTIVE credential spends `automationCalls` instead, never both, so
+ * a fleet of self-mutating pipelines can't exhaust the console for the humans
+ * in the same org:
+ *  - an org SERVICE ACCOUNT (`principalType: 'service_account'` —
+ *    platform-automation, pipeline-register, reporting-ingest, registry-push);
+ *  - a PERSONAL ACCESS KEY: the exchanged key token (`token_use: 'api_key'`)
+ *    and anything minted while holding one (`parentKeyId`). A PAT in a CI job
+ *    is automation whoever owns it — billing it as a person let one script
+ *    lock its owner's teammates out of the console. CI should still use a
+ *    service-account key (it survives the person leaving); either way the
+ *    traffic now lands on `automationCalls`.
+ * Every other type is returned unchanged: an AI call or a pipeline creation
+ * costs the same whoever makes it.
+ *
+ * `meterQuotaOnSuccess` and `checkQuota` call this themselves, so a service
+ * mounts both with `'apiCalls'` and the split happens per request.
+ */
+export function meteredQuotaTypeFor(req, quotaType) {
+    if (quotaType !== 'apiCalls' || !req.user)
+        return quotaType;
+    const u = req.user;
+    if (u.principalType === 'service_account' || u.token_use === 'api_key' || u.parentKeyId)
+        return 'automationCalls';
+    return quotaType;
+}
+/**
+ * Whether the apiCalls/automationCalls meter AND check skip this (verified)
+ * request, and why. One function for both halves, so the gate never refuses a
+ * call the meter would not bill:
+ *  - `service` — an internal service principal: peer traffic is caused by a
+ *    user action the originating service already metered;
+ *  - `impersonation` — a sysadmin impersonation session (`impersonatorId`).
+ *    Vendor staff looking at a tenant's console must neither spend the tenant's
+ *    budget nor be locked out by it while diagnosing an exhausted org; the
+ *    session is audited on its own trail;
+ *  - `on_behalf` — a user token FORWARDED by an internal service as part of a
+ *    request already metered where it arrived (the ask agent's tools,
+ *    pipeline's placeholder-plugin confirm), proven by a signed marker the
+ *    user cannot forge (middleware/on-behalf.ts).
+ * Applies to the CALL budgets only: reservation-gated quotas (pipelines,
+ * plugins …) are charged whoever asks. `aiCalls` mirrors the impersonation half
+ * on its own (api-server `withAiCallReservation` skips the slot when the
+ * session is an impersonation; the call is still audited).
+ */
+export function callQuotaExemption(req) {
+    if (!req.user)
+        return undefined;
+    if (isServicePrincipal(req))
+        return 'service';
+    if (req.user.impersonatorId)
+        return 'impersonation';
+    if (onBehalfCaller(req))
+        return 'on_behalf';
+    return undefined;
+}
 /**
  * Service-principal `Authorization` header for a quota call made on behalf of
  * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health
@@ -56,6 +196,7 @@ const QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);
 export function getQuotaServiceAuthHeader(orgId) {
     return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });
 }
+const AI_LIMIT_CODES = new Set([ErrorCode.AI_MEMBER_SHARE_EXCEEDED, ErrorCode.AI_TOKEN_BUDGET_EXCEEDED]);
 /**
  * Apply the explicit reserve fail-mode policy to a reservation the quota service
  * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.
@@ -139,7 +280,7 @@ export function createQuotaService(config = {}) {
     return {
         async check(orgId, quotaType, authHeader, requestId) {
             const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;
-            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...checkRequestOptions(quotaType) });
             if (!response) {
                 logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });
                 emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });
@@ -154,28 +295,67 @@ export function createQuotaService(config = {}) {
             }
             return response.body.data.status;
         },
-        async increment(orgId, quotaType, authHeader, amount = 1, requestId) {
+        async increment(orgId, quotaType, authHeader, amount = 1, attribution) {
             const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            const attr = resolveAttribution(attribution);
             const response = await client
-                .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
-            if (!response || response.statusCode !== 200) {
+                .post(path, { quotaType, amount, ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (response?.statusCode === 429) {
+                // Over the limit: the quota service refused AND recorded the denial in
+                // its ledger. Not a failure of metering — the counter is exactly where
+                // it should be.
+                logger.debug('Quota increment refused (over limit)', { orgId, quotaType, amount });
+            }
+            else if (!response || response.statusCode !== 200) {
                 logger.warn('Failed to increment quota', {
                     orgId, quotaType, amount, statusCode: response?.statusCode,
                 });
+                // A lost metering increment is a unit the org consumed and never paid
+                // for. Counted (labelled by the emitting `service`) so a sustained rate
+                // pages instead of silently under-billing — see QuotaIncrementFailures.
+                emitCounter('quota_increment_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });
             }
             else {
                 logger.debug('Quota incremented', { orgId, quotaType, amount });
             }
         },
-        async reserve(orgId, quotaType, authHeader, amount = 1, requestId) {
+        async incrementMetered(orgId, quotaType, authHeader, groups) {
             const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            const amount = groups.reduce((sum, g) => sum + g.amount, 0);
+            if (amount <= 0)
+                return { counted: 0, overshoot: 0 };
+            const response = await client.post(path, { quotaType, amount, meter: true, groups }, { headers: buildHeaders(orgId, authHeader), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200 || !response.body?.success) {
+                logger.warn('Failed to apply metered quota increment', { orgId, quotaType, amount, statusCode: response?.statusCode });
+                // Every unit in the batch went uncounted — see QuotaIncrementFailures.
+                emitCounter('quota_increment_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });
+                return null;
+            }
+            const counted = response.body.data?.counted ?? amount;
+            const overshoot = response.body.data?.overshoot ?? 0;
+            logger.debug('Metered quota increment applied', { orgId, quotaType, amount, counted, overshoot });
+            return { counted, overshoot };
+        },
+        async reserve(orgId, quotaType, authHeader, amount = 1, attribution) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            const attr = resolveAttribution(attribution);
             // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.
             // Both shapes are normalized into QuotaReserveResult.
-            const response = await client.post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            const response = await client.post(path, { quotaType, amount, ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });
             if (!response)
                 return unconfirmedReserve(orgId, quotaType, 'unreachable');
             if (response.statusCode === 429) {
                 const q = response.body.details?.quota;
+                // An optional org AI control (per-member share, token budget) refused the
+                // slot: a genuine, final denial — relayed with its own code and message.
+                if (response.body.code && AI_LIMIT_CODES.has(response.body.code)) {
+                    return {
+                        exceeded: true,
+                        code: response.body.code,
+                        ...(response.body.message ? { message: response.body.message } : {}),
+                        quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },
+                    };
+                }
                 // Only a GENUINE quota-exceeded 429 means "over quota". A generic 429 —
                 // an intervening gateway or rate limiter — did not confirm anything, so
                 // it goes through the same unconfirmed-reservation policy as an outage.
@@ -196,10 +376,11 @@ export function createQuotaService(config = {}) {
                 quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },
             };
         },
-        async decrement(orgId, quotaType, authHeader, amount = 1, resetAtSnapshot, requestId) {
+        async decrement(orgId, quotaType, authHeader, amount = 1, resetAtSnapshot, attribution) {
             const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;
+            const attr = resolveAttribution(attribution);
             const response = await client
-                .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+                .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }), ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });
             if (!response || response.statusCode !== 200) {
                 // Rollback failure is logged but never propagated  the action's own
                 // failure has already been surfaced to the caller; a stuck counter
@@ -212,6 +393,26 @@ export function createQuotaService(config = {}) {
                 logger.debug('Quota decremented', { orgId, quotaType, amount });
             }
         },
+        async reportUsage(orgId, quotaType, authHeader, tokens, attribution) {
+            const tokensIn = Math.max(0, Math.floor(tokens.tokensIn || 0));
+            const tokensOut = Math.max(0, Math.floor(tokens.tokensOut || 0));
+            const attr = resolveAttribution(attribution);
+            // Nothing to say: no tokens and no attribution to make a zero row useful.
+            if (tokensIn === 0 && tokensOut === 0 && !attr)
+                return;
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            try {
+                const response = await client.post(path, { quotaType, report: true, tokensIn, tokensOut, ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });
+                if (!response || response.statusCode !== 200) {
+                    logger.warn('Failed to report AI usage', { orgId, quotaType, statusCode: response?.statusCode });
+                    emitCounter('quota_usage_report_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });
+                }
+            }
+            catch (err) {
+                logger.warn('Failed to report AI usage', { orgId, quotaType, error: errorMessage(err) });
+                emitCounter('quota_usage_report_failures_total', { reason: 'exception', quotaType });
+            }
+        },
         async getTier(orgId, authHeader, requestId) {
             const known = constantTierFor(orgId);
             if (known)
@@ -259,21 +460,36 @@ function constantTierFor(orgId) {
     return orgId.toLowerCase() === SYSTEM_ORG_ID ? 'unlimited' : null;
 }
 /**
- * Fire-and-forget quota METERING increment with standardized error logging.
+ * Fire-and-forget quota METERING increment.
+ *
+ * Buffered: the unit joins the pod's per-(org, type) aggregate and is sent with
+ * the next flush (`QUOTA_INCREMENT_FLUSH_MS`, see quota-increment-batcher.ts)
+ * as one metered increment — partial admission against the cap, the excess
+ * recorded as `overshoot`. The counter therefore lags by at most one flush
+ * interval. Only the request meter uses this; reservations stay synchronous.
  *
  * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never
- * with the end user's token: `/quotas/:orgId/increment` is service-principal /
- * system-admin only, so a forwarded user JWT was always rejected (403) and the
- * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never
- * moved.
+ * with the end user's token: `/quotas/:orgId/increment` is service-principal
+ * only, so a forwarded user JWT was always rejected (403) and the metered quota
+ * (e.g. `apiCalls`, and the `api_pack` bundle raising it) never moved.
  *
  * @param quotaService - Quota service client
  * @param orgId - Organization ID whose counter is incremented
  * @param quotaType - Quota type to increment
  * @param logWarn - Logging function for warnings
+ * @param attribution - Who spent the unit (defaults to the ambient request context)
  */
-export function incrementQuota(quotaService, orgId, quotaType, logWarn) {
-    quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err) => logWarn('Quota increment failed', { error: errorMessage(err) }));
+export function incrementQuota(quotaService, orgId, quotaType, logWarn, attribution) {
+    try {
+        const batcher = batcherFor(quotaService, async (org, type, groups) => {
+            await quotaService.incrementMetered(org, type, getQuotaServiceAuthHeader(org), groups);
+        });
+        batcher.add(orgId, quotaType, resolveAttribution(attribution));
+    }
+    catch (err) {
+        logWarn('Quota increment failed', { error: errorMessage(err) });
+        emitCounter('quota_increment_failures_total', { reason: 'exception', quotaType });
+    }
 }
 /**
  * Atomic reserve helper for the "reserve + commit / rollback" pattern.
@@ -296,8 +512,8 @@ export function incrementQuota(quotaService, orgId, quotaType, logWarn) {
  * }
  * ```
  */
-export function reserveQuota(quotaService, orgId, quotaType, authHeader, amount = 1, requestId) {
-    return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);
+export function reserveQuota(quotaService, orgId, quotaType, authHeader, amount = 1, attribution) {
+    return quotaService.reserve(orgId, quotaType, authHeader, amount, attribution);
 }
 /** Seconds a client should wait before retrying when quota couldn't be confirmed. */
 const QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;
@@ -310,6 +526,17 @@ const QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;
  * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.
  */
 export function sendQuotaReserveDenied(res, quotaType, reservation) {
+    if (reservation.code) {
+        // An optional org AI control (per-member share / token budget): its own
+        // code, so the client can say "your share" rather than "the org is out".
+        const resetAt = reservation.quota.resetAt;
+        if (!res.headersSent && resetAt) {
+            res.setHeader('Retry-After', Math.max(0, Math.ceil((new Date(resetAt).getTime() - Date.now()) / 1000)));
+        }
+        emitCounter('quota_denied_total', { type: quotaType });
+        sendError(res, 429, reservation.message ?? `Your organization's ${quotaType} limit for this period has been reached.`, reservation.code, { quota: reservation.quota, quotaType, ...(resetAt ? { resetAt } : {}) });
+        return;
+    }
     if (reservation.unavailable) {
         if (!res.headersSent)
             res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);
@@ -323,7 +550,10 @@ export function sendQuotaReserveDenied(res, quotaType, reservation) {
  * Logs on failure but never throws  the action that needed the rollback
  * has already failed, no point compounding the error.
  */
-export function decrementQuota(quotaService, orgId, quotaType, authHeader, logWarn, amount = 1, resetAtSnapshot) {
-    quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err) => logWarn('Quota rollback failed', { error: errorMessage(err) }));
+export function decrementQuota(quotaService, orgId, quotaType, authHeader, logWarn, amount = 1, resetAtSnapshot, attribution) {
+    const sent = attribution
+        ? quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot, attribution)
+        : quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot);
+    sent.catch((err) => logWarn('Quota rollback failed', { error: errorMessage(err) }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { SYSTEM_ORG_ID } from '../middleware/system-org.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\n/**\n * Retry options for quota calls — fail fast (a slow quota service must not stall the request).\n *\n * NEVER retry a 429. The quota service answers an over-limit org with 429\n * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP\n * client honors that (capped at 60s), so a single rate-limit retry stalled the\n * request well past the handler timeout, which then answered 503 and the real\n * 429 was lost. A 429 is a final answer here.\n */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// RESERVE FAIL MODE — explicit, single policy.\n//\n// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI\n// calls, platform feature slots). Every quota type is a per-period FLOW counter\n// with no after-the-fact reconciliation: a unit consumed while the reservation\n// could not be confirmed is never counted, so fail-open lets an org consume\n// unbounded unmetered units for the whole length of an incident — and an\n// unconfirmed reserve (timeout, open circuit) may even have landed server-side.\n// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:\n//   - unreachable / timed out / circuit breaker open (no response),\n//   - a reachable-but-errored response (5xx, 4xx, malformed body),\n//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).\n// Operators who prefer availability over enforcement opt the WHOLE set into\n// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter\n// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.\n// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.\nconst QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);\n\n/**\n * Service-principal `Authorization` header for a quota call made on behalf of\n * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health\n * router reports).\n *\n * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)\n * reject anything but a signed service principal or a system admin, so\n * forwarding the end user's bearer token there is always a 403. Service tokens\n * are also exempt from the quota service's per-IP rate limiter, so hot-path\n * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently\n * turn enforcement off. Scoped to the target org with the lowest role (member).\n */\nexport function getQuotaServiceAuthHeader(orgId: string): string {\n  return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });\n}\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  /** True when the slot was NOT reserved — the gated action must not run. */\n  exceeded: boolean;\n  /**\n   * Set (true) by the quota CLIENT when the reservation was denied because the\n   * quota service could not CONFIRM it (unreachable / timeout / circuit open /\n   * errored) — not because the org is over its limit. Always paired with\n   * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to\n   * 503 instead of a misleading 429 \"quota exceeded\".\n   */\n  unavailable?: boolean;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —\n   * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless\n   * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n  /**\n   * FAIL-CLOSED twin of {@link getTier}: the org's tier as the quota service\n   * CONFIRMED it, or `null` when it could not be confirmed (unreachable, non-ok,\n   * missing or unrecognized tier). For decisions that must never be taken on a\n   * guess — anything that revokes, downgrades or deletes on the strength of a\n   * tier (e.g. a verified-publisher grace sweep) must skip the org on `null`,\n   * never act on `DEFAULT_TIER`.\n   */\n  getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Apply the explicit reserve fail-mode policy to a reservation the quota service\n * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.\n */\nfunction unconfirmedReserve(\n  orgId: string,\n  quotaType: QuotaType,\n  reason: 'unreachable' | 'transient-429' | 'non-ok',\n  statusCode?: number,\n): QuotaReserveResult {\n  if (QUOTA_RESERVE_FAIL_OPEN) {\n    logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });\n    emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });\n    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n  }\n  logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });\n  emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });\n  return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? serviceEndpoint('quota').host,\n    port: config.port ?? serviceEndpoint('quota').port,\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  /** One tier read: the confirmed tier, or why there isn't one. */\n  async function readTier(\n    orgId: string, authHeader: string, requestId?: string,\n  ): Promise<{ tier: QuotaTier; reason?: undefined; statusCode?: number } | { tier: null; reason: 'unreachable' | 'non-ok' | 'invalid-tier'; statusCode?: number }> {\n    const response = await client.get<{\n      success: boolean;\n      data?: { quota?: { tier?: string } };\n      message?: string;\n    }>(`/quotas/${encodeURIComponent(orgId)}`, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n    if (!response) return { tier: null, reason: 'unreachable' };\n    if (response.statusCode !== 200 || !response.body?.success) return { tier: null, reason: 'non-ok', statusCode: response.statusCode };\n    const tier = response.body.data?.quota?.tier;\n    if (!tier || !isValidTier(tier)) return { tier: null, reason: 'invalid-tier', statusCode: response.statusCode };\n    return { tier, statusCode: response.statusCode };\n  }\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        /** `sendError`'s error-code field. */\n        code?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) return unconfirmedReserve(orgId, quotaType, 'unreachable');\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // an intervening gateway or rate limiter — did not confirm anything, so\n        // it goes through the same unconfirmed-reservation policy as an outage.\n        if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const known = constantTierFor(orgId);\n      if (known) return known;\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n        orgId, statusCode: read.statusCode, reason: read.reason, defaultTier: DEFAULT_TIER,\n      });\n      emitCounter('quota_fail_open_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return DEFAULT_TIER;\n    },\n\n    async getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null> {\n      const known = constantTierFor(orgId);\n      if (known) return known;\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn('QUOTA_FAIL_CLOSED: tier could not be confirmed', { orgId, statusCode: read.statusCode, reason: read.reason });\n      emitCounter('quota_fail_closed_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return null;\n    },\n  };\n}\n\n/**\n * The system org's tier is a CONSTANT, not a billing fact, so it is answered\n * without a lookup.\n *\n * The platform's own org is always `unlimited` (platform/src/services/\n * auth-service.ts seeds it that way): nothing meters it and it is never sold.\n * Asking the quota service was therefore a network hop whose only possible\n * outcomes were the answer we already knew, or a failure.\n *\n * The failure is what made this worth fixing. `getTier` fails OPEN to\n * DEFAULT_TIER, which with billing enabled is `developer` — the most\n * constrained tier — and its documented job is build-queue partitioning. A\n * blip in the quota service therefore routed the SYSTEM org's builds onto the\n * developer queue; the Official catalog load is 119 of them. `getTierStrict`\n * fails CLOSED to null, so a sweep that must not guess would skip the\n * platform's own org instead.\n */\nfunction constantTierFor(orgId: string): QuotaTier | null {\n  return orgId.toLowerCase() === SYSTEM_ORG_ID ? 'unlimited' : null;\n}\n\n/**\n * Fire-and-forget quota METERING increment with standardized error logging.\n *\n * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never\n * with the end user's token: `/quotas/:orgId/increment` is service-principal /\n * system-admin only, so a forwarded user JWT was always rejected (403) and the\n * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never\n * moved.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID whose counter is incremented\n * @param quotaType - Quota type to increment\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: errorMessage(err) }),\n  );\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  requestId?: string,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);\n}\n\n/** Seconds a client should wait before retrying when quota couldn't be confirmed. */\nconst QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;\n\n/**\n * Answer a DENIED reservation (`reservation.exceeded === true`).\n *\n * - `unavailable` (the quota service couldn't confirm the slot) → **503**\n *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its\n *   limit, so a 429 \"quota exceeded\" would send users to upgrade for an outage.\n * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.\n */\nexport function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void {\n  if (reservation.unavailable) {\n    if (!res.headersSent) res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);\n    sendError(\n      res,\n      503,\n      `Unable to confirm ${quotaType} quota right now. Please try again shortly.`,\n      ErrorCode.SERVICE_UNAVAILABLE,\n    );\n    return;\n  }\n  sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: errorMessage(err) }),\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\n\nimport { currentAuditContext, sanitizeCorrelationId } from './audit-context.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { batcherFor, type MeteredIncrementGroup } from './quota-increment-batcher.js';\nimport { onBehalfCaller } from '../middleware/on-behalf.js';\nimport { getServiceAuthHeader, isServicePrincipal } from '../middleware/service-tokens.js';\nimport { SYSTEM_ORG_ID } from '../middleware/system-org.js';\nimport type { JwtPayload, PrincipalType, QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { envBool, envInt } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\n/**\n * Retry options for quota calls — fail fast (a slow quota service must not stall the request).\n *\n * NEVER retry a 429. The quota service answers an over-limit org with 429\n * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP\n * client honors that (capped at 60s), so a single rate-limit retry stalled the\n * request well past the handler timeout, which then answered 503 and the real\n * 429 was lost. A 429 is a final answer here.\n */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\n/**\n * Budget for one `check` of a COUNTER quota (`QUOTA_CHECK_TIMEOUT_MS`, default\n * 300), with no retry.\n *\n * The check is a read gate that FAILS OPEN, run ahead of the request it gates:\n * the old 5 s timeout × 2 attempts meant a slow quota service added up to 10 s\n * to every metered request and then let it through anyway. A short budget turns\n * the same incident into a ≤ 300 ms fail-open (counted on\n * `quota_fail_open_total`, which alerts) — and with the per-pod check cache in\n * front (api-server `checkQuota`) a healthy service is asked at most once per\n * org/type per cache TTL.\n *\n * `storageBytes` keeps the client timeout and one retry: it is a MEASURED read\n * (the quota service walks the org's registry namespace on a cold cache) behind\n * the registry's fail-CLOSED push gate, where a premature timeout refuses a push.\n */\nexport const QUOTA_CHECK_TIMEOUT_MS = envInt('QUOTA_CHECK_TIMEOUT_MS', 300, { min: 1 });\n\nfunction checkRequestOptions(quotaType: QuotaType): Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries' | 'timeout'> {\n  if (quotaType === 'storageBytes') return QUOTA_REQUEST_OPTIONS;\n  return { maxRateLimitRetries: 0, maxRetries: 0, timeout: QUOTA_CHECK_TIMEOUT_MS };\n}\n\nconst logger = createLogger('quota');\n\n// RESERVE FAIL MODE — explicit, single policy.\n//\n// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI\n// calls, platform feature slots). Every quota type is a per-period FLOW counter\n// with no after-the-fact reconciliation: a unit consumed while the reservation\n// could not be confirmed is never counted, so fail-open lets an org consume\n// unbounded unmetered units for the whole length of an incident — and an\n// unconfirmed reserve (timeout, open circuit) may even have landed server-side.\n// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:\n//   - unreachable / timed out / circuit breaker open (no response),\n//   - a reachable-but-errored response (5xx, 4xx, malformed body),\n//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).\n// Operators who prefer availability over enforcement opt the WHOLE set into\n// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter\n// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.\n// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.\nconst QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);\n\n// USAGE ATTRIBUTION — who spent a unit.\n//\n// The quota service keeps one aggregate counter per (org, type); on its own that\n// can say an org is at 100% but never WHICH key, route or pipeline got it there.\n// Every increment / reserve / refund therefore carries an attribution block the\n// quota service writes into its usage ledger (`GET /quotas/:orgId/usage`). It is\n// metadata only — enforcement never reads it — and every field is optional, so a\n// caller that knows nothing still meters correctly.\n\n/** Who / what spent (or got back) a quota unit. All fields optional. */\nexport interface QuotaUsageAttribution {\n  principalType?: PrincipalType;\n  /** The user id or service-account id behind the call (the token's `sub`). */\n  principalId?: string;\n  /** The revocable credential: the access key the token derives from, else its `jti`. */\n  keyId?: string;\n  /** `METHOD /route/:pattern` — the matched route PATTERN, never the raw URL (no ids, no query). */\n  route?: string;\n  /** The pipeline the call was made for (`:pipelineId` param or `X-Pipeline-Id` header). */\n  pipelineId?: string;\n  requestId?: string;\n  /**\n   * AI calls only: which product surface spent the unit — `ask`, `agent`,\n   * `agent-tool:<name>`, `pipeline-generate`, `plugin-generate`,\n   * `report-summary`. Set by api-server's `withAiCallReservation`.\n   */\n  feature?: string;\n  /** AI calls only: the model id the reservation was resolved to (never a key). */\n  model?: string;\n  /** AI calls only: whose key served the call — `platform`, `org` or `request` (BYOK). */\n  keySource?: AiKeySource;\n}\n\n/** Whose key serves an AI call (mirrors ai-core `KeySource`). Only `platform` spends `aiCalls`. */\nexport type AiKeySource = 'platform' | 'org' | 'request';\n\n/** Token counts an AI call reports after it settles (see {@link QuotaService.reportUsage}). */\nexport interface QuotaTokenUsage {\n  tokensIn: number;\n  tokensOut: number;\n}\n\n/** Longest attribution string the client sends (the quota service enforces the same bound). */\nconst MAX_ATTRIBUTION_LEN = 200;\n\nfunction bounded(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value.slice(0, MAX_ATTRIBUTION_LEN) : undefined;\n}\n\n/** The principal half of an attribution block, from a VERIFIED token. */\nfunction principalAttribution(user: JwtPayload | undefined): QuotaUsageAttribution {\n  if (!user) return {};\n  return {\n    principalType: user.principalType,\n    principalId: bounded(user.sub),\n    keyId: bounded(user.parentKeyId ?? user.jti),\n  };\n}\n\n/**\n * Attribution for the request being served: the verified principal, the matched\n * route pattern, the pipeline (`:pipelineId` param or a sanitized\n * `X-Pipeline-Id` header) and the request id. Read off `req` directly rather than\n * the ambient audit context because the metering middleware runs in a `finish`\n * listener, where the request's async scope is no longer guaranteed.\n */\nexport function quotaAttributionFromRequest(req: Request): QuotaUsageAttribution {\n  const routePath = req.route?.path;\n  const route = typeof routePath === 'string' ? `${req.method} ${(req.baseUrl ?? '') + routePath}` : undefined;\n  const header = req.headers['x-pipeline-id'];\n  const pipelineId = sanitizeCorrelationId(req.params?.pipelineId) ?? sanitizeCorrelationId(Array.isArray(header) ? header[0] : header);\n  const requestIdHeader = req.headers['x-request-id'];\n  const requestId = (req as Request & { requestId?: string }).requestId\n    ?? sanitizeCorrelationId(Array.isArray(requestIdHeader) ? requestIdHeader[0] : requestIdHeader);\n  return {\n    ...principalAttribution(req.user),\n    ...(route ? { route: route.slice(0, MAX_ATTRIBUTION_LEN) } : {}),\n    ...(pipelineId ? { pipelineId } : {}),\n    ...(requestId ? { requestId: bounded(requestId) } : {}),\n  };\n}\n\n/**\n * Attribution from the ambient audit context, for calls made inside a request\n * scope that did not pass one explicitly (the reserve / refund helpers every\n * service uses). Empty outside any scope.\n */\nfunction attributionFromContext(): QuotaUsageAttribution {\n  const ctx = currentAuditContext();\n  if (!ctx) return {};\n  return {\n    ...principalAttribution(ctx.principal?.()),\n    ...(ctx.requestId ? { requestId: bounded(ctx.requestId) } : {}),\n  };\n}\n\n/** The attribution a quota write sends: the explicit block, else the ambient one. */\nfunction resolveAttribution(explicit?: QuotaUsageAttribution): QuotaUsageAttribution | undefined {\n  const resolved = explicit ?? attributionFromContext();\n  return Object.keys(resolved).length > 0 ? resolved : undefined;\n}\n\n/**\n * The quota type a metered request actually spends.\n *\n * `apiCalls` is the PEOPLE's budget — an interactive session. A request made by\n * a NON-INTERACTIVE credential spends `automationCalls` instead, never both, so\n * a fleet of self-mutating pipelines can't exhaust the console for the humans\n * in the same org:\n *  - an org SERVICE ACCOUNT (`principalType: 'service_account'` —\n *    platform-automation, pipeline-register, reporting-ingest, registry-push);\n *  - a PERSONAL ACCESS KEY: the exchanged key token (`token_use: 'api_key'`)\n *    and anything minted while holding one (`parentKeyId`). A PAT in a CI job\n *    is automation whoever owns it — billing it as a person let one script\n *    lock its owner's teammates out of the console. CI should still use a\n *    service-account key (it survives the person leaving); either way the\n *    traffic now lands on `automationCalls`.\n * Every other type is returned unchanged: an AI call or a pipeline creation\n * costs the same whoever makes it.\n *\n * `meterQuotaOnSuccess` and `checkQuota` call this themselves, so a service\n * mounts both with `'apiCalls'` and the split happens per request.\n */\nexport function meteredQuotaTypeFor(req: Pick<Request, 'user'>, quotaType: QuotaType): QuotaType {\n  if (quotaType !== 'apiCalls' || !req.user) return quotaType;\n  const u = req.user;\n  if (u.principalType === 'service_account' || u.token_use === 'api_key' || u.parentKeyId) return 'automationCalls';\n  return quotaType;\n}\n\n/** Why a request is not metered/checked against apiCalls (see {@link callQuotaExemption}). */\nexport type CallQuotaExemption = 'service' | 'impersonation' | 'on_behalf';\n\n/**\n * Whether the apiCalls/automationCalls meter AND check skip this (verified)\n * request, and why. One function for both halves, so the gate never refuses a\n * call the meter would not bill:\n *  - `service` — an internal service principal: peer traffic is caused by a\n *    user action the originating service already metered;\n *  - `impersonation` — a sysadmin impersonation session (`impersonatorId`).\n *    Vendor staff looking at a tenant's console must neither spend the tenant's\n *    budget nor be locked out by it while diagnosing an exhausted org; the\n *    session is audited on its own trail;\n *  - `on_behalf` — a user token FORWARDED by an internal service as part of a\n *    request already metered where it arrived (the ask agent's tools,\n *    pipeline's placeholder-plugin confirm), proven by a signed marker the\n *    user cannot forge (middleware/on-behalf.ts).\n * Applies to the CALL budgets only: reservation-gated quotas (pipelines,\n * plugins …) are charged whoever asks. `aiCalls` mirrors the impersonation half\n * on its own (api-server `withAiCallReservation` skips the slot when the\n * session is an impersonation; the call is still audited).\n */\nexport function callQuotaExemption(req: Request): CallQuotaExemption | undefined {\n  if (!req.user) return undefined;\n  if (isServicePrincipal(req)) return 'service';\n  if (req.user.impersonatorId) return 'impersonation';\n  if (onBehalfCaller(req)) return 'on_behalf';\n  return undefined;\n}\n\n/**\n * Service-principal `Authorization` header for a quota call made on behalf of\n * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health\n * router reports).\n *\n * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)\n * reject anything but a signed service principal or a system admin, so\n * forwarding the end user's bearer token there is always a 403. Service tokens\n * are also exempt from the quota service's per-IP rate limiter, so hot-path\n * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently\n * turn enforcement off. Scoped to the target org with the lowest role (member).\n */\nexport function getQuotaServiceAuthHeader(orgId: string): string {\n  return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });\n}\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  /** True when the slot was NOT reserved — the gated action must not run. */\n  exceeded: boolean;\n  /**\n   * Set (true) by the quota CLIENT when the reservation was denied because the\n   * quota service could not CONFIRM it (unreachable / timeout / circuit open /\n   * errored) — not because the org is over its limit. Always paired with\n   * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to\n   * 503 instead of a misleading 429 \"quota exceeded\".\n   */\n  unavailable?: boolean;\n  /**\n   * Set when an `aiCalls` reservation was refused by one of the org's OPTIONAL\n   * AI controls rather than the period cap: {@link ErrorCode.AI_MEMBER_SHARE_EXCEEDED}\n   * (the caller's per-member share is spent) or\n   * {@link ErrorCode.AI_TOKEN_BUDGET_EXCEEDED} (the org's per-period token\n   * budget is spent). Paired with `exceeded: true` and the quota service's\n   * `message`; {@link sendQuotaReserveDenied} relays both.\n   */\n  code?: AiLimitCode;\n  message?: string;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/** The 429 codes an `aiCalls` reservation answers when an optional org AI control refuses it. */\nexport type AiLimitCode = ErrorCode.AI_MEMBER_SHARE_EXCEEDED | ErrorCode.AI_TOKEN_BUDGET_EXCEEDED;\n\nconst AI_LIMIT_CODES: ReadonlySet<string> = new Set([ErrorCode.AI_MEMBER_SHARE_EXCEEDED, ErrorCode.AI_TOKEN_BUDGET_EXCEEDED]);\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /**\n   * Increment quota usage. Returns a promise so callers can optionally handle\n   * errors. `attribution` defaults to the ambient request context.\n   */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, attribution?: QuotaUsageAttribution): Promise<void>;\n  /**\n   * METERED increment of a pre-aggregated batch (the per-pod batcher's flush,\n   * see `quota-increment-batcher.ts`): the sum of `groups` is applied with\n   * PARTIAL admission — the counter moves by as much as fits under the cap and\n   * the remainder is recorded as `overshoot` — and each group's attribution is\n   * written to the usage ledger. Never a 429. Resolves with what was counted,\n   * or `null` when the quota service did not answer ok (counted on\n   * `quota_increment_failures_total`).\n   */\n  incrementMetered(orgId: string, quotaType: QuotaType, authHeader: string, groups: MeteredIncrementGroup[]): Promise<{ counted: number; overshoot: number } | null>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —\n   * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless\n   * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, attribution?: QuotaUsageAttribution): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, attribution?: QuotaUsageAttribution): Promise<void>;\n  /**\n   * Record what an AI call COST after it settled — its token counts — in the\n   * usage ledger, without moving any counter (a zero-unit ledger row carrying\n   * `tokensIn` / `tokensOut` under the call's attribution). Also how a call that\n   * spent NO `aiCalls` unit (a BYOK key, an impersonation session, a weight-0\n   * model) still shows up in the usage breakdown. Fire-and-forget — never throws.\n   * Optional so test doubles need not implement it.\n   */\n  reportUsage?(orgId: string, quotaType: QuotaType, authHeader: string, tokens: QuotaTokenUsage, attribution?: QuotaUsageAttribution): Promise<void>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n  /**\n   * FAIL-CLOSED twin of {@link getTier}: the org's tier as the quota service\n   * CONFIRMED it, or `null` when it could not be confirmed (unreachable, non-ok,\n   * missing or unrecognized tier). For decisions that must never be taken on a\n   * guess — anything that revokes, downgrades or deletes on the strength of a\n   * tier (e.g. a verified-publisher grace sweep) must skip the org on `null`,\n   * never act on `DEFAULT_TIER`.\n   */\n  getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Apply the explicit reserve fail-mode policy to a reservation the quota service\n * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.\n */\nfunction unconfirmedReserve(\n  orgId: string,\n  quotaType: QuotaType,\n  reason: 'unreachable' | 'transient-429' | 'non-ok',\n  statusCode?: number,\n): QuotaReserveResult {\n  if (QUOTA_RESERVE_FAIL_OPEN) {\n    logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });\n    emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });\n    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n  }\n  logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });\n  emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });\n  return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? serviceEndpoint('quota').host,\n    port: config.port ?? serviceEndpoint('quota').port,\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  /** One tier read: the confirmed tier, or why there isn't one. */\n  async function readTier(\n    orgId: string, authHeader: string, requestId?: string,\n  ): Promise<{ tier: QuotaTier; reason?: undefined; statusCode?: number } | { tier: null; reason: 'unreachable' | 'non-ok' | 'invalid-tier'; statusCode?: number }> {\n    const response = await client.get<{\n      success: boolean;\n      data?: { quota?: { tier?: string } };\n      message?: string;\n    }>(`/quotas/${encodeURIComponent(orgId)}`, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n    if (!response) return { tier: null, reason: 'unreachable' };\n    if (response.statusCode !== 200 || !response.body?.success) return { tier: null, reason: 'non-ok', statusCode: response.statusCode };\n    const tier = response.body.data?.quota?.tier;\n    if (!tier || !isValidTier(tier)) return { tier: null, reason: 'invalid-tier', statusCode: response.statusCode };\n    return { tier, statusCode: response.statusCode };\n  }\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...checkRequestOptions(quotaType) });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, attribution?: QuotaUsageAttribution): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n      const attr = resolveAttribution(attribution);\n\n      const response = await client\n        .post(path, { quotaType, amount, ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (response?.statusCode === 429) {\n        // Over the limit: the quota service refused AND recorded the denial in\n        // its ledger. Not a failure of metering — the counter is exactly where\n        // it should be.\n        logger.debug('Quota increment refused (over limit)', { orgId, quotaType, amount });\n      } else if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n        // A lost metering increment is a unit the org consumed and never paid\n        // for. Counted (labelled by the emitting `service`) so a sustained rate\n        // pages instead of silently under-billing — see QuotaIncrementFailures.\n        emitCounter('quota_increment_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async incrementMetered(orgId: string, quotaType: QuotaType, authHeader: string, groups: MeteredIncrementGroup[]): Promise<{ counted: number; overshoot: number } | null> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n      const amount = groups.reduce((sum, g) => sum + g.amount, 0);\n      if (amount <= 0) return { counted: 0, overshoot: 0 };\n      const response = await client.post<{ success: boolean; data?: { counted?: number; overshoot?: number } }>(\n        path,\n        { quotaType, amount, meter: true, groups },\n        { headers: buildHeaders(orgId, authHeader), ...QUOTA_REQUEST_OPTIONS },\n      );\n      if (!response || response.statusCode !== 200 || !response.body?.success) {\n        logger.warn('Failed to apply metered quota increment', { orgId, quotaType, amount, statusCode: response?.statusCode });\n        // Every unit in the batch went uncounted — see QuotaIncrementFailures.\n        emitCounter('quota_increment_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });\n        return null;\n      }\n      const counted = response.body.data?.counted ?? amount;\n      const overshoot = response.body.data?.overshoot ?? 0;\n      logger.debug('Metered quota increment applied', { orgId, quotaType, amount, counted, overshoot });\n      return { counted, overshoot };\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, attribution?: QuotaUsageAttribution): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n      const attr = resolveAttribution(attribution);\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        /** `sendError`'s error-code field. */\n        code?: string;\n        message?: string;\n      }>(path, { quotaType, amount, ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) return unconfirmedReserve(orgId, quotaType, 'unreachable');\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // An optional org AI control (per-member share, token budget) refused the\n        // slot: a genuine, final denial — relayed with its own code and message.\n        if (response.body.code && AI_LIMIT_CODES.has(response.body.code)) {\n          return {\n            exceeded: true,\n            code: response.body.code as AiLimitCode,\n            ...(response.body.message ? { message: response.body.message } : {}),\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // an intervening gateway or rate limiter — did not confirm anything, so\n        // it goes through the same unconfirmed-reservation policy as an outage.\n        if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, attribution?: QuotaUsageAttribution): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const attr = resolveAttribution(attribution);\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }), ...(attr && { attribution: attr }) }, { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reportUsage(orgId: string, quotaType: QuotaType, authHeader: string, tokens: QuotaTokenUsage, attribution?: QuotaUsageAttribution): Promise<void> {\n      const tokensIn = Math.max(0, Math.floor(tokens.tokensIn || 0));\n      const tokensOut = Math.max(0, Math.floor(tokens.tokensOut || 0));\n      const attr = resolveAttribution(attribution);\n      // Nothing to say: no tokens and no attribution to make a zero row useful.\n      if (tokensIn === 0 && tokensOut === 0 && !attr) return;\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n      try {\n        const response = await client.post(\n          path,\n          { quotaType, report: true, tokensIn, tokensOut, ...(attr && { attribution: attr }) },\n          { headers: buildHeaders(orgId, authHeader, attr?.requestId), ...QUOTA_REQUEST_OPTIONS },\n        );\n        if (!response || response.statusCode !== 200) {\n          logger.warn('Failed to report AI usage', { orgId, quotaType, statusCode: response?.statusCode });\n          emitCounter('quota_usage_report_failures_total', { reason: response ? 'non-ok' : 'unreachable', quotaType });\n        }\n      } catch (err) {\n        logger.warn('Failed to report AI usage', { orgId, quotaType, error: errorMessage(err) });\n        emitCounter('quota_usage_report_failures_total', { reason: 'exception', quotaType });\n      }\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const known = constantTierFor(orgId);\n      if (known) return known;\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n        orgId, statusCode: read.statusCode, reason: read.reason, defaultTier: DEFAULT_TIER,\n      });\n      emitCounter('quota_fail_open_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return DEFAULT_TIER;\n    },\n\n    async getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null> {\n      const known = constantTierFor(orgId);\n      if (known) return known;\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn('QUOTA_FAIL_CLOSED: tier could not be confirmed', { orgId, statusCode: read.statusCode, reason: read.reason });\n      emitCounter('quota_fail_closed_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return null;\n    },\n  };\n}\n\n/**\n * The system org's tier is a CONSTANT, not a billing fact, so it is answered\n * without a lookup.\n *\n * The platform's own org is always `unlimited` (platform/src/services/\n * auth-service.ts seeds it that way): nothing meters it and it is never sold.\n * Asking the quota service was therefore a network hop whose only possible\n * outcomes were the answer we already knew, or a failure.\n *\n * The failure is what made this worth fixing. `getTier` fails OPEN to\n * DEFAULT_TIER, which with billing enabled is `developer` — the most\n * constrained tier — and its documented job is build-queue partitioning. A\n * blip in the quota service therefore routed the SYSTEM org's builds onto the\n * developer queue; the Official catalog load is 119 of them. `getTierStrict`\n * fails CLOSED to null, so a sweep that must not guess would skip the\n * platform's own org instead.\n */\nfunction constantTierFor(orgId: string): QuotaTier | null {\n  return orgId.toLowerCase() === SYSTEM_ORG_ID ? 'unlimited' : null;\n}\n\n/**\n * Fire-and-forget quota METERING increment.\n *\n * Buffered: the unit joins the pod's per-(org, type) aggregate and is sent with\n * the next flush (`QUOTA_INCREMENT_FLUSH_MS`, see quota-increment-batcher.ts)\n * as one metered increment — partial admission against the cap, the excess\n * recorded as `overshoot`. The counter therefore lags by at most one flush\n * interval. Only the request meter uses this; reservations stay synchronous.\n *\n * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never\n * with the end user's token: `/quotas/:orgId/increment` is service-principal\n * only, so a forwarded user JWT was always rejected (403) and the metered quota\n * (e.g. `apiCalls`, and the `api_pack` bundle raising it) never moved.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID whose counter is incremented\n * @param quotaType - Quota type to increment\n * @param logWarn - Logging function for warnings\n * @param attribution - Who spent the unit (defaults to the ambient request context)\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  logWarn: (message: string, data?: unknown) => void,\n  attribution?: QuotaUsageAttribution,\n): void {\n  try {\n    const batcher = batcherFor(quotaService, async (org, type, groups) => {\n      await quotaService.incrementMetered(org, type, getQuotaServiceAuthHeader(org), groups);\n    });\n    batcher.add(orgId, quotaType, resolveAttribution(attribution));\n  } catch (err) {\n    logWarn('Quota increment failed', { error: errorMessage(err) });\n    emitCounter('quota_increment_failures_total', { reason: 'exception', quotaType });\n  }\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  attribution?: QuotaUsageAttribution,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, attribution);\n}\n\n/** Seconds a client should wait before retrying when quota couldn't be confirmed. */\nconst QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;\n\n/**\n * Answer a DENIED reservation (`reservation.exceeded === true`).\n *\n * - `unavailable` (the quota service couldn't confirm the slot) → **503**\n *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its\n *   limit, so a 429 \"quota exceeded\" would send users to upgrade for an outage.\n * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.\n */\nexport function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void {\n  if (reservation.code) {\n    // An optional org AI control (per-member share / token budget): its own\n    // code, so the client can say \"your share\" rather than \"the org is out\".\n    const resetAt = reservation.quota.resetAt;\n    if (!res.headersSent && resetAt) {\n      res.setHeader('Retry-After', Math.max(0, Math.ceil((new Date(resetAt).getTime() - Date.now()) / 1000)));\n    }\n    emitCounter('quota_denied_total', { type: quotaType });\n    sendError(\n      res,\n      429,\n      reservation.message ?? `Your organization's ${quotaType} limit for this period has been reached.`,\n      reservation.code,\n      { quota: reservation.quota, quotaType, ...(resetAt ? { resetAt } : {}) },\n    );\n    return;\n  }\n  if (reservation.unavailable) {\n    if (!res.headersSent) res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);\n    sendError(\n      res,\n      503,\n      `Unable to confirm ${quotaType} quota right now. Please try again shortly.`,\n      ErrorCode.SERVICE_UNAVAILABLE,\n    );\n    return;\n  }\n  sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n  attribution?: QuotaUsageAttribution,\n): void {\n  const sent = attribution\n    ? quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot, attribution)\n    : quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot);\n  sent.catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: errorMessage(err) }),\n  );\n}\n"]}