@empire-builder-kit/nx 1.0.0-rc.4 → 1.0.0-rc.40

package/src/generators/slice/built-in-plan-performance-files.js

@@ -4,6 +4,7 @@ exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = void 0;
 exports.renderProductPerformanceFiles = renderProductPerformanceFiles;
 const built_in_plan_shared_js_1 = require("./built-in-plan-shared.js");
 const index_js_1 = require("../../performance/index.js");
+const built_in_plan_key_value_performance_js_1 = require("./built-in-plan-key-value-performance.js");
 exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = [
     'docs/runbooks/performance-capacity-cost.md',
     'performance/aggregate-count-provider.ts',
@@ -13,11 +14,31 @@ exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = [
     'performance/policy.json',
 ];
 /** @internal */
-function renderProductPerformanceFiles(name) {
+function renderProductPerformanceFiles(name, deploymentProfile = 'starter') {
+    const databaseAdapter = 'ebk-dynamodb-v1';
+    const asyncAdapter = 'ebk-dynamodb-async-v1';
+    const databaseSignal = 'dynamodb:protected-request-budget-utilization-percent';
+    const asyncSignal = 'dynamodb:protected-run-unprocessed-effects-percent';
     const pascalName = name
         .split('-')
         .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
         .join('');
+    const costDefaults = deploymentProfile === 'starter'
+        ? {
+            accountMonthlyMaximumUsd: 250,
+            anomalyThresholdUsd: 10,
+            pilotMonthlyMaximumUsd: 50,
+        }
+        : {
+            accountMonthlyMaximumUsd: 1_000,
+            anomalyThresholdUsd: 50,
+            pilotMonthlyMaximumUsd: 250,
+        };
+    const rehearsalStage = deploymentProfile === 'starter' ? 'development' : 'staging';
+    const rehearsalStageTitle = rehearsalStage === 'development' ? 'Development' : 'Staging';
+    const protectedPerformanceStages = deploymentProfile === 'starter'
+        ? ['development', 'production']
+        : ['staging', 'production'];
     return {
         'infra/performance-cost-controls.ts': `import {
   createFoundationAccountCostControlPlan,
@@ -53,6 +74,7 @@ export function create${pascalName}PerformanceCostControls(input: {
   const foundationAccountCostControl = createFoundationAccountCostControlPlan({
     evaluatedAt,
     policy: accountCostPolicy,
+    rehearsalStage: '${rehearsalStage}',
     region: process.env.AWS_REGION,
     stage: $app.stage,
     workspace: input.workspace,
@@ -61,6 +83,7 @@ export function create${pascalName}PerformanceCostControls(input: {
     accountBudgetAuthority: foundationAccountCostControl.authority,
     evaluatedAt,
     policy: performancePolicy,
+    rehearsalStage: '${rehearsalStage}',
     region: process.env.AWS_REGION,
     stage: $app.stage,
     workspace: input.workspace,
@@ -119,39 +142,10 @@ export function create${pascalName}PerformanceCostControls(input: {
         timeUnit: plan.pilotBudget.timeUnit,
       })
     : undefined;
-  const anomalyMonitor = plan.anomaly
-    ? new aws.costexplorer.AnomalyMonitor(
-        '${pascalName}CostAnomalyMonitor',
-        {
-          monitorSpecification: plan.anomaly.monitor.monitorSpecification,
-          monitorType: plan.anomaly.monitor.monitorType,
-          name: plan.anomaly.monitor.name,
-          tags,
-        },
-      )
-    : undefined;
-  const anomalySubscription =
-    plan.anomaly && anomalyMonitor
-      ? new aws.costexplorer.AnomalySubscription(
-          '${pascalName}CostAnomalySubscription',
-          {
-            frequency: plan.anomaly.subscription.frequency,
-            monitorArnLists: [anomalyMonitor.arn],
-            name: plan.anomaly.subscription.name,
-            subscribers: [
-              { address: input.alertTopicArn, type: 'SNS' },
-            ],
-            tags,
-            thresholdExpression:
-              plan.anomaly.subscription.thresholdExpression,
-          },
-          { dependsOn: [anomalyMonitor] },
-        )
-      : undefined;
   return {
     accountBudgetAuthority: deployedAccountBudgetAuthority,
-    anomalyMonitor,
-    anomalySubscription,
+    anomalyMonitor: undefined,
+    anomalySubscription: undefined,
     materialDigest: plan.materialDigest,
     pilotBudget,
     policyDigest: plan.policyDigest,
@@ -215,7 +209,7 @@ export function create${pascalName}PerformanceCostControls(input: {
                     population: 'all',
                     scenarioRef: 'scenario:normal-month',
                     status: 'example',
-                    threshold: 1_000,
+                    threshold: costDefaults.accountMonthlyMaximumUsd,
                     unit: 'usd',
                 },
             ],
@@ -241,19 +235,19 @@ export function create${pascalName}PerformanceCostControls(input: {
                     kind: 'async-worker',
                     protectionRef: 'control:async-worker-concurrency',
                     quotaMaximum: null,
-                    saturationSignalRef: 'database:protected-async-backlog-utilization-percent',
+                    saturationSignalRef: asyncSignal,
                     status: 'requires-adopter-value',
                 },
                 {
-                    capacityUnit: 'database-connections',
+                    capacityUnit: 'concurrent-requests',
                     configuredMaximum: null,
                     downstreamMaximum: null,
-                    failureMode: 'connection-or-capacity-exhaustion',
+                    failureMode: 'request-latency-or-throttling',
                     id: 'database',
                     kind: 'database',
-                    protectionRef: 'control:database-connections',
+                    protectionRef: 'control:database-request-concurrency',
                     quotaMaximum: null,
-                    saturationSignalRef: 'database:connection-utilization-percent',
+                    saturationSignalRef: databaseSignal,
                     status: 'requires-adopter-value',
                 },
                 {
@@ -270,13 +264,13 @@ export function create${pascalName}PerformanceCostControls(input: {
                 },
             ],
             cost: {
-                accountMonthlyMaximumUsd: 1_000,
+                accountMonthlyMaximumUsd: costDefaults.accountMonthlyMaximumUsd,
                 actualNotificationThresholdPercent: 80,
                 anomalyRouteRef: 'alarm:cost-anomaly',
-                anomalyThresholdUsd: 50,
+                anomalyThresholdUsd: costDefaults.anomalyThresholdUsd,
                 forecastNotificationThresholdPercent: 100,
                 notificationRoute: 'foundation-alert-topic',
-                pilotMonthlyMaximumUsd: 250,
+                pilotMonthlyMaximumUsd: costDefaults.pilotMonthlyMaximumUsd,
                 sharedCostAllocationRef: 'performance/cost-allocation.json',
                 status: 'example',
                 testRunMaximumUsd: 25,
@@ -288,7 +282,7 @@ export function create${pascalName}PerformanceCostControls(input: {
             },
             kind: 'ebk-performance-policy',
             load: {
-                allowedProtectedStages: ['staging'],
+                allowedProtectedStages: [rehearsalStage],
                 maximumConcurrency: 100,
                 maximumDurationSeconds: 1_800,
                 maximumEstimatedCostUsd: 25,
@@ -308,8 +302,6 @@ export function create${pascalName}PerformanceCostControls(input: {
                     'ebk:framework-version',
                     'ebk:managed-by',
                     'ebk:owner',
-                    'ebk:production-profile',
-                    'ebk:repository',
                     'ebk:slice',
                     'ebk:stage',
                     'ebk:workspace',
@@ -332,22 +324,22 @@ export function create${pascalName}PerformanceCostControls(input: {
                 },
                 {
                     adapterStatus: 'managed',
-                    adapterId: 'ebk-async-worker-v1',
+                    adapterId: asyncAdapter,
                     demandShape: 'bounded-flash-burst-and-recovery',
                     disabledUntilAdopted: true,
                     estimatedCostUsdPerRequest: 0.00002,
-                    id: 'async-burst',
-                    saturationSignalRef: 'database:protected-async-backlog-utilization-percent',
+                    id: 'async-key-value-burst',
+                    saturationSignalRef: asyncSignal,
                     workload: 'async-worker',
                 },
                 {
                     adapterStatus: 'managed',
-                    adapterId: 'ebk-database-v1',
-                    demandShape: 'idle-window-then-first-request',
+                    adapterId: databaseAdapter,
+                    demandShape: 'bounded-write-and-consistent-read',
                     disabledUntilAdopted: true,
                     estimatedCostUsdPerRequest: 0.0001,
-                    id: 'database-cold-resume',
-                    saturationSignalRef: 'database:connection-utilization-percent',
+                    id: 'database-read-write',
+                    saturationSignalRef: databaseSignal,
                     workload: 'database',
                 },
                 {
@@ -428,14 +420,14 @@ export function create${pascalName}PerformanceCostControls(input: {
                 accountBudgetBinding: 'foundation-discovery-schema-v6-policy-digest-and-amount',
                 accountBudgetInfrastructure: 'packages/foundation/infra/foundation.ts',
                 accountBudgetOwner: 'foundation',
-                accountBudgetStages: ['staging', 'production'],
-                anomalyMonitorScope: 'workspace-slice-stage-composite-tag',
-                anomalySubscriptionFrequency: 'IMMEDIATE',
+                accountBudgetStages: [rehearsalStage, 'production'],
+                anomalyMonitorScope: 'foundation-production-account-aws-services',
+                anomalySubscriptionOwner: 'foundation',
                 automaticSpendActions: 'forbidden',
                 infrastructure: 'infra/performance-cost-controls.ts',
                 owner: 'performance/policy.json#owner',
                 pilotBudgetOwner: 'product-slice',
-                pilotBudgetStage: 'staging',
+                pilotBudgetStage: rehearsalStage,
                 policy: 'performance/policy.json#cost',
                 route: 'foundation-alert-topic',
                 status: 'blocked-until-cost-policy-adopted',
@@ -450,13 +442,13 @@ export function create${pascalName}PerformanceCostControls(input: {
             evidence: {
                 exactReleaseRequiredForProtectedResults: true,
                 provenanceLabels: ['estimate', 'test', 'actual'],
-                stagingIsNotProduction: true,
+                rehearsalIsNotProduction: true,
             },
             liveEvidence: {
                 accountBudgetAndAnomalyRoute: 'required-pre-v1',
                 actualBillingAndTwoUnitCosts: 'required-pre-v1',
                 coldAndWarmLambdaNextPaths: 'required-pre-v1',
-                databaseColdResumeAndIdleCost: 'required-pre-v1',
+                databaseColdResumeAndIdleCost: 'not-applicable-without-sql',
                 profileTransitionRehearsal: 'required-pre-v1',
                 protectedApiAsyncDatabaseLoad: 'required-pre-v1',
                 serviceRuntimeLoad: 'required-pre-v1-adopter-integration',
@@ -465,8 +457,8 @@ export function create${pascalName}PerformanceCostControls(input: {
             load: {
                 allowlistedScenarioAdapters: [
                     'ebk-api-lambda-v1',
-                    'ebk-async-worker-v1',
-                    'ebk-database-v1',
+                    asyncAdapter,
+                    databaseAdapter,
                 ],
                 localProtectedMutationForbidden: true,
                 productionExceptionalOnly: true,
@@ -759,7 +751,7 @@ process.stdout.write(JSON.stringify(result) + '\\n');
     accountFingerprint: string;
     region: string;
     slice: string;
-    stage: 'production' | 'staging';
+    stage: 'development' | 'production' | 'staging';
     workspace: string;
   }>;
   period: Readonly<{ end: string; start: string }>;
@@ -990,7 +982,7 @@ if (
   !/^(?:af|ap|ca|cn|eu|il|me|mx|sa|us)(?:-gov|-iso|-isob)?-[a-z]+-\\d$/.test(
     environment.region,
   ) ||
-  (stage !== 'staging' && stage !== 'production')
+  !${JSON.stringify(protectedPerformanceStages)}.includes(stage)
 ) {
   throw new Error(
     'Aggregate environment and closed billing period are invalid.',
@@ -1492,6 +1484,33 @@ import {
   runBoundedProtectedLoad,
   validatePerformancePolicy,
 } from '@empire-builder-kit/nx/performance';
+import { assertWorkspaceStageOwnershipForWorkspace } from '@empire-builder-kit/nx/workspace-deployment';
+import { resolve } from 'node:path';
+
+const stage = process.env.EBK_STAGE?.trim();
+if (!['development', 'staging', 'production'].includes(stage)) {
+  throw new Error('Protected load runner requires one canonical EBK stage.');
+}
+const ownership = await assertWorkspaceStageOwnershipForWorkspace(
+  resolve(import.meta.dirname, '../../..'),
+  stage,
+  {
+    ...(process.env.AWS_PROFILE ? { profile: process.env.AWS_PROFILE } : {}),
+    ...(process.env.AWS_CONFIG_FILE ? { configFilepath: process.env.AWS_CONFIG_FILE } : {}),
+    ...(process.env.AWS_SHARED_CREDENTIALS_FILE
+      ? { credentialsFilepath: process.env.AWS_SHARED_CREDENTIALS_FILE }
+      : {}),
+  },
+);
+if (process.env.AWS_REGION?.trim() !== ownership.region) {
+  throw new Error('Protected load runner Region differs from its exact workspace owner tuple.');
+}
+for (const name of [
+  'AWS_ACCESS_KEY_ID',
+  'AWS_SECRET_ACCESS_KEY',
+  'AWS_SESSION_TOKEN',
+  'AWS_SECURITY_TOKEN',
+]) delete process.env[name];
 
 const planPath = process.env.EBK_PROTECTED_LOAD_PLAN_PATH?.trim();
 const authorizationPath =
@@ -1691,6 +1710,33 @@ import {
   createProtectedLoadPlan,
   validatePerformancePolicy,
 } from '@empire-builder-kit/nx/performance';
+import { assertWorkspaceStageOwnershipForWorkspace } from '@empire-builder-kit/nx/workspace-deployment';
+import { resolve } from 'node:path';
+
+const stage = process.env.EBK_STAGE?.trim();
+if (!['development', 'staging', 'production'].includes(stage)) {
+  throw new Error('Protected load cleanup requires one canonical EBK stage.');
+}
+const ownership = await assertWorkspaceStageOwnershipForWorkspace(
+  resolve(import.meta.dirname, '../../..'),
+  stage,
+  {
+    ...(process.env.AWS_PROFILE ? { profile: process.env.AWS_PROFILE } : {}),
+    ...(process.env.AWS_CONFIG_FILE ? { configFilepath: process.env.AWS_CONFIG_FILE } : {}),
+    ...(process.env.AWS_SHARED_CREDENTIALS_FILE
+      ? { credentialsFilepath: process.env.AWS_SHARED_CREDENTIALS_FILE }
+      : {}),
+  },
+);
+if (process.env.AWS_REGION?.trim() !== ownership.region) {
+  throw new Error('Protected load cleanup Region differs from its exact workspace owner tuple.');
+}
+for (const name of [
+  'AWS_ACCESS_KEY_ID',
+  'AWS_SECRET_ACCESS_KEY',
+  'AWS_SESSION_TOKEN',
+  'AWS_SECURITY_TOKEN',
+]) delete process.env[name];
 
 const planPath = process.env.EBK_PROTECTED_LOAD_PLAN_PATH?.trim();
 const hmacKeyPath =
@@ -1857,18 +1903,15 @@ import {
   handleProtectedLoadCleanupEndpoint,
   handleProtectedLoadScenarioEndpoint,
   type ProtectedLoadEndpointBindingV1,
-  type ProtectedLoadEndpointAdapterId,
   type ProtectedLoadRequestAuthorizationV1,
+${'  DYNAMODB_PROTECTED_REQUEST_BUDGET_MS,\n'}\
 } from '@empire-builder-kit/runtime/performance';
-import { randomUUID } from 'node:crypto';
-import { withPrimaryDatabase } from '../../../../../database/runtime-client';
+${`import { dataStore } from '../../../../../data/key-value';
+import { createPerformancePersistence } from '../../../../../performance/persistence';`}
 import { Secrets } from '../../../../../secrets/declarations';
 import { createStandardSliceSecretRuntime } from '../../../../../secrets/runtime';
 
-type ManagedAdapterId = Exclude<
-  ProtectedLoadEndpointAdapterId,
-  'ebk-service-v1'
->;
+type ManagedAdapterId = 'ebk-api-lambda-v1' | '${asyncAdapter}' | '${databaseAdapter}';
 
 function required(name: string): string {
   const value = process.env[name]?.trim();
@@ -1879,11 +1922,21 @@ function required(name: string): string {
 type EndpointSecretRuntime = ReturnType<
   typeof createStandardSliceSecretRuntime
 >;
+const protectedPerformanceStages = ${JSON.stringify(protectedPerformanceStages)} as const;
+type ProtectedPerformanceStage = (typeof protectedPerformanceStages)[number];
+
+function isProtectedPerformanceStage(
+  value: string | undefined,
+): value is ProtectedPerformanceStage {
+  return value !== undefined &&
+    (protectedPerformanceStages as readonly string[]).includes(value);
+}
+
 let endpointSecretRuntime: EndpointSecretRuntime | undefined;
-let endpointSecretRuntimeStage: 'production' | 'staging' | undefined;
+let endpointSecretRuntimeStage: ProtectedPerformanceStage | undefined;
 
 function performanceSecretRuntime(
-  stage: 'production' | 'staging',
+  stage: ProtectedPerformanceStage,
 ): EndpointSecretRuntime {
   if (
     endpointSecretRuntimeStage !== undefined &&
@@ -1906,12 +1959,12 @@ async function withEndpointBinding<Result>(
   const stage = process.env.EBK_STAGE;
   if (
     process.env.EBK_PERFORMANCE_LOAD_ENABLED !== 'true' ||
-    (stage !== 'staging' && stage !== 'production')
+    !isProtectedPerformanceStage(stage)
   ) {
     throw new Error('protected-performance-endpoint-disabled');
   }
   return performanceSecretRuntime(stage).runWithSecret({
-    declaration: Secrets.${pascalName}PerformanceLoadHmacKeys,
+    declaration: Secrets.GeneratedPerformanceLoadHmacKeys,
     isAuthenticationFailure: () => false,
     operation: (hmacKeys) =>
       operation({
@@ -1996,396 +2049,7 @@ function memorySaturation(): number {
   return Math.min(100, (memory.heapUsed / memory.heapTotal) * 100);
 }
 
-function effectUuid(effectId: string): string {
-  return [
-    effectId.slice(0, 8),
-    effectId.slice(8, 12),
-    '4' + effectId.slice(13, 16),
-    '8' + effectId.slice(17, 20),
-    effectId.slice(20, 32),
-  ].join('-');
-}
-
-interface ProtectedPerformanceRunRow {
-  adapterId: string;
-  cleanupStartedAt: Date | null;
-  createdAt: Date;
-  expiresAt: Date;
-  maximumRequests: number;
-  releaseMaterialDigest: string;
-  runId: string;
-  scenarioId: string;
-  sourceCommit: string;
-  stage: string;
-}
-
-function matchesProtectedPerformanceRun(
-  actual: ProtectedPerformanceRunRow | undefined,
-  authorization: ProtectedLoadRequestAuthorizationV1,
-): actual is ProtectedPerformanceRunRow {
-  return (
-    actual !== undefined &&
-    actual.adapterId === authorization.adapterId &&
-    actual.createdAt.toISOString() === authorization.createdAt &&
-    actual.expiresAt.toISOString() === authorization.expiresAt &&
-    actual.maximumRequests === authorization.maximumRequests &&
-    actual.releaseMaterialDigest ===
-      authorization.release.releaseMaterialDigest &&
-    actual.runId === authorization.runId &&
-    actual.scenarioId === authorization.scenarioId &&
-    actual.sourceCommit === authorization.release.sourceCommit &&
-    actual.stage === authorization.stage
-  );
-}
-
-export async function reserveRequest(
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        await client.query(
-          \`INSERT INTO performance_load_runs
-             (plan_digest, run_id, adapter_id, scenario_id, stage,
-              source_commit, release_material_digest, maximum_requests,
-              created_at, expires_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz,
-                   $10::timestamptz)
-           ON CONFLICT (plan_digest) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.runId,
-            authorization.adapterId,
-            authorization.scenarioId,
-            authorization.stage,
-            authorization.release.sourceCommit,
-            authorization.release.releaseMaterialDigest,
-            authorization.maximumRequests,
-            authorization.createdAt,
-            authorization.expiresAt,
-          ],
-        );
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        const actual = run.rows[0];
-        if (
-          !matchesProtectedPerformanceRun(actual, authorization) ||
-          actual.cleanupStartedAt !== null
-        ) {
-          throw new Error('protected-performance-run-collision');
-        }
-        const claimed = await client.query(
-          \`INSERT INTO performance_load_requests
-             (plan_digest, request_ordinal, effect_id)
-           VALUES ($1, $2, $3)
-           ON CONFLICT (plan_digest, request_ordinal) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.requestOrdinal,
-            authorization.effectId,
-          ],
-        );
-        if (claimed.rowCount !== 1) {
-          throw new Error('protected-performance-request-replayed');
-        }
-        await client.query('COMMIT');
-        return 'claimed' as const;
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
-export async function databaseExecution(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
-  effectId: string,
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        const activeRun = run.rows[0];
-        if (
-          !matchesProtectedPerformanceRun(activeRun, authorization) ||
-          activeRun.cleanupStartedAt !== null
-        ) {
-          throw new Error('protected-performance-run-cleaning');
-        }
-        if (adapterId === 'ebk-async-worker-v1') {
-          const inserted = await client.query(
-            \`INSERT INTO performance_load_async_effects
-               (effect_id, plan_digest, run_id, expires_at)
-             VALUES ($1, $2, $3, now() + INTERVAL '24 hours')
-             ON CONFLICT (effect_id) DO NOTHING\`,
-            [
-              effectId,
-              authorization.planMaterialDigest,
-              authorization.runId,
-            ],
-          );
-          const identity = await client.query<{
-            planDigest: string;
-            runId: string;
-          }>(
-            \`SELECT
-               plan_digest AS "planDigest",
-               run_id AS "runId"
-             FROM performance_load_async_effects
-             WHERE effect_id = $1\`,
-            [effectId],
-          );
-          if (
-            identity.rows[0]?.planDigest !==
-              authorization.planMaterialDigest ||
-            identity.rows[0]?.runId !== authorization.runId
-          ) {
-            throw new Error('protected-performance-effect-collision');
-          }
-          const pending = await client.query<{ count: string }>(
-            \`SELECT count(*)::text AS count
-             FROM performance_load_async_effects
-             WHERE processed_at IS NULL AND expires_at > now()\`,
-          );
-          const maximum = authorization.configuredMaximum;
-          if (!Number.isFinite(maximum) || maximum <= 0) {
-            throw new Error('protected-performance-async-maximum-invalid');
-          }
-          const result = {
-            effectState:
-              inserted.rowCount === 1
-                ? ('created' as const)
-                : ('already-existed' as const),
-            saturationPercent: Math.min(
-              100,
-              (Number(pending.rows[0]?.count ?? 0) / maximum) * 100,
-            ),
-          };
-          await client.query('COMMIT');
-          return result;
-        }
-        const id = effectUuid(effectId);
-        const inserted = await client.query(
-          \`INSERT INTO records
-             (id, name, owner_id, run_scope, test_expires_at)
-           VALUES (
-             $1::uuid,
-             'ebk-protected-performance-load',
-             'ebk-performance',
-             $2,
-             now() + INTERVAL '24 hours'
-           )
-           ON CONFLICT (id) DO NOTHING\`,
-          [id, authorization.planMaterialDigest],
-        );
-        const identity = await client.query<{
-          name: string;
-          ownerId: string;
-          runScope: string;
-        }>(
-          \`SELECT
-             name,
-             owner_id AS "ownerId",
-             run_scope AS "runScope"
-           FROM records
-           WHERE id = $1::uuid\`,
-          [id],
-        );
-        if (
-          identity.rows[0]?.name !== 'ebk-protected-performance-load' ||
-          identity.rows[0]?.ownerId !== 'ebk-performance' ||
-          identity.rows[0]?.runScope !== authorization.planMaterialDigest
-        ) {
-          throw new Error('protected-performance-effect-collision');
-        }
-        const activity = await client.query<{
-          active: string;
-          maximum: string;
-        }>(
-          \`SELECT
-             count(*)::text AS active,
-             current_setting('max_connections') AS maximum
-           FROM pg_stat_activity
-           WHERE datname = current_database()\`,
-        );
-        const active = Number(activity.rows[0]?.active ?? 0);
-        const maximum = Number(activity.rows[0]?.maximum ?? 0);
-        if (!Number.isFinite(maximum) || maximum <= 0) {
-          throw new Error('protected-performance-database-maximum-invalid');
-        }
-        const result = {
-          effectState:
-            inserted.rowCount === 1
-              ? ('created' as const)
-              : ('already-existed' as const),
-          saturationPercent: Math.min(100, (active / maximum) * 100),
-        };
-        await client.query('COMMIT');
-        return result;
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
-export async function cleanupRun(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        await client.query(
-          \`INSERT INTO performance_load_runs
-             (plan_digest, run_id, adapter_id, scenario_id, stage,
-              source_commit, release_material_digest, maximum_requests,
-              created_at, expires_at, cleanup_started_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz,
-                   $10::timestamptz, now())
-           ON CONFLICT (plan_digest) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.runId,
-            authorization.adapterId,
-            authorization.scenarioId,
-            authorization.stage,
-            authorization.release.sourceCommit,
-            authorization.release.releaseMaterialDigest,
-            authorization.maximumRequests,
-            authorization.createdAt,
-            authorization.expiresAt,
-          ],
-        );
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        if (!matchesProtectedPerformanceRun(run.rows[0], authorization)) {
-          throw new Error('protected-performance-run-collision');
-        }
-        await client.query(
-          \`UPDATE performance_load_runs
-           SET cleanup_started_at = COALESCE(cleanup_started_at, now())
-           WHERE plan_digest = $1\`,
-          [authorization.planMaterialDigest],
-        );
-        await client.query('COMMIT');
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-
-      await client.query('BEGIN');
-      try {
-        const removed =
-          adapterId === 'ebk-async-worker-v1'
-            ? await client.query(
-                \`DELETE FROM performance_load_async_effects
-                 WHERE plan_digest = $1
-                   AND run_id = $2\`,
-                [authorization.planMaterialDigest, authorization.runId],
-              )
-            : await client.query(
-                \`DELETE FROM records
-                 WHERE owner_id = 'ebk-performance'
-                   AND name = 'ebk-protected-performance-load'
-                   AND run_scope = $1\`,
-                [authorization.planMaterialDigest],
-              );
-        const remaining =
-          adapterId === 'ebk-async-worker-v1'
-            ? await client.query<{ count: string }>(
-                \`SELECT count(*)::text AS count
-                 FROM performance_load_async_effects
-                 WHERE plan_digest = $1
-                   AND run_id = $2\`,
-                [authorization.planMaterialDigest, authorization.runId],
-              )
-            : await client.query<{ count: string }>(
-                \`SELECT count(*)::text AS count
-                 FROM records
-                 WHERE owner_id = 'ebk-performance'
-                   AND name = 'ebk-protected-performance-load'
-                   AND run_scope = $1\`,
-                [authorization.planMaterialDigest],
-              );
-        const remainingEffectCount = Number(remaining.rows[0]?.count ?? 0);
-        if (
-          !Number.isSafeInteger(remainingEffectCount) ||
-          remainingEffectCount !== 0
-        ) {
-          throw new Error('protected-performance-cleanup-incomplete');
-        }
-        await client.query('COMMIT');
-        return {
-          remainingEffectCount,
-          removedEffectCount: removed.rowCount ?? 0,
-        };
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
+${(0, built_in_plan_key_value_performance_js_1.renderKeyValuePerformanceEndpointFunctions)()}
 function refused() {
   return Response.json(
     {
@@ -2410,8 +2074,8 @@ export async function runPerformanceScenarioEndpoint(
         binding,
         execute: async ({ authorization, effectId }) => {
           if (
-            adapterId === 'ebk-async-worker-v1' ||
-            adapterId === 'ebk-database-v1'
+            adapterId === '${asyncAdapter}' ||
+            adapterId === '${databaseAdapter}'
           ) {
             if (!effectId) throw new Error('protected-effect-required');
             return databaseExecution(adapterId, effectId, authorization);
@@ -2429,7 +2093,7 @@ export async function runPerformanceScenarioEndpoint(
 }
 
 export async function runPerformanceCleanupEndpoint(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
+  adapterId: '${asyncAdapter}' | '${databaseAdapter}',
   request: Request,
 ) {
   try {
@@ -2482,11 +2146,11 @@ vi.mock('@empire-builder-kit/runtime/performance', () => ({
     status: 200,
   })),
 }));
-vi.mock('../../../../../database/runtime-client', () => ({
-  withPrimaryDatabase: vi.fn(),
-}));
+${`vi.mock('../../../../../performance/persistence', () => ({
+  createPerformancePersistence: vi.fn(),
+}));`}
 vi.mock('../../../../../secrets/declarations', () => ({
-  Secrets: { ${pascalName}PerformanceLoadHmacKeys: {} },
+  Secrets: { GeneratedPerformanceLoadHmacKeys: {} },
 }));
 vi.mock('../../../../../secrets/runtime', () => ({
   createStandardSliceSecretRuntime: mocks.createSecretRuntime,
@@ -2507,7 +2171,7 @@ describe('${name} protected performance secret cache lifetime', () => {
     process.env.EBK_PERFORMANCE_RELEASE_MATERIAL_DIGEST = 'd'.repeat(64);
     process.env.EBK_PERFORMANCE_SLICE = '${name}';
     process.env.EBK_SOURCE_COMMIT = 'c'.repeat(40);
-    process.env.EBK_STAGE = 'staging';
+    process.env.EBK_STAGE = '${rehearsalStage}';
   });
 
   it('reuses one resolver across requests so declaration TTL is effective', async () => {
@@ -2530,590 +2194,7 @@ describe('${name} protected performance secret cache lifetime', () => {
   });
 });
 `,
-        'integration/performance-load-cleanup.spec.ts': `import { Client } from 'pg';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { ProtectedLoadRequestAuthorizationV1 } from '@empire-builder-kit/runtime/performance';
-import { createInboxCleanupHandler } from '../async/inbox-cleanup.js';
-import {
-  cleanupRun,
-  databaseExecution,
-  reserveRequest,
-} from '../web/src/app/%5F%5Febk/performance/handler.js';
-
-vi.mock('server-only', () => ({}));
-vi.mock('../database/runtime-client.js', () => ({
-  withPrimaryDatabase: async (
-    _context: unknown,
-    _workload: unknown,
-    operation: (client: Client) => Promise<unknown>,
-  ) => {
-    const { Client: RuntimeClient } = await import('pg');
-    const client = new RuntimeClient({
-      connectionString: process.env.DATABASE_URL,
-    });
-    await client.connect();
-    try {
-      return await operation(client);
-    } finally {
-      await client.end();
-    }
-  },
-}));
-
-const databaseUrl = process.env.DATABASE_URL;
-if (!databaseUrl) {
-  throw new Error(
-    'DATABASE_URL is required for ${name} performance cleanup integration proof.',
-  );
-}
-
-const touchedPlanDigests = new Set<string>();
-
-function authorization(input: {
-  effectId: string | null;
-  operation: 'cleanup' | 'execute';
-  planMaterialDigest: string;
-  requestOrdinal?: number;
-}): ProtectedLoadRequestAuthorizationV1 {
-  return {
-    adapterId: 'ebk-async-worker-v1',
-    configuredMaximum: 100,
-    createdAt: '2026-07-29T12:00:00.000Z',
-    durationSeconds: 60,
-    effectId: input.effectId,
-    expiresAt: '2026-07-29T13:00:00.000Z',
-    hmacKeyId: 'integration-v1',
-    maximumRequests: 10,
-    operation: input.operation,
-    planMaterialDigest: input.planMaterialDigest,
-    release: {
-      candidateDigest: 'c'.repeat(64),
-      releaseId: 'integration-release',
-      releaseMaterialDigest: 'd'.repeat(64),
-      sourceCommit: 'b'.repeat(40),
-    },
-    requestOrdinal: input.requestOrdinal ?? 1,
-    runId: 'integration-run-' + input.planMaterialDigest.slice(0, 8),
-    saturationSignalRef:
-      'database:protected-async-backlog-utilization-percent',
-    scenarioId: 'async-burst',
-    stage: 'staging',
-    target: {
-      accountFingerprint: 'sha256:' + 'e'.repeat(64),
-      endpoint:
-        'https://performance.example.test/${name}/__ebk/performance/async-worker',
-      region: 'us-east-1',
-      slice: '${name}',
-    },
-    workload: 'async-worker',
-  };
-}
-
-async function withClient<Result>(
-  operation: (client: Client) => Promise<Result>,
-): Promise<Result> {
-  const client = new Client({ connectionString: databaseUrl });
-  await client.connect();
-  try {
-    return await operation(client);
-  } finally {
-    await client.end();
-  }
-}
-
-// A loaded-host budget: hosted runners share four cores between Vitest,
-// the proof registry, and the dockerized database.
-async function waitForActiveStatement(
-  client: Client,
-  fragment: string,
-): Promise<void> {
-  const deadline = Date.now() + 15_000;
-  while (Date.now() < deadline) {
-    const active = await client.query<{ count: string }>(
-      \`SELECT count(*)::text AS count
-       FROM pg_stat_activity
-       WHERE datname = current_database()
-         AND pid <> pg_backend_pid()
-         AND state = 'active'
-         AND query LIKE $1\`,
-      ['%' + fragment + '%'],
-    );
-    if (Number(active.rows[0]?.count ?? 0) > 0) return;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  throw new Error('Timed out waiting for the adversarial database statement.');
-}
-
-afterEach(async () => {
-  await withClient(async (client) => {
-    await client
-      .query(
-        'DROP TRIGGER IF EXISTS ebk_performance_delay_effect ON performance_load_async_effects',
-      )
-      .catch(() => undefined);
-    await client
-      .query('DROP FUNCTION IF EXISTS ebk_performance_delay_effect()')
-      .catch(() => undefined);
-    for (const planDigest of touchedPlanDigests) {
-      await client.query('DELETE FROM records WHERE run_scope = $1', [
-        planDigest,
-      ]);
-      await client.query(
-        'DELETE FROM performance_load_async_effects WHERE plan_digest = $1',
-        [planDigest],
-      );
-      await client.query(
-        'DELETE FROM performance_load_requests WHERE plan_digest = $1',
-        [planDigest],
-      );
-      await client.query(
-        'DELETE FROM performance_load_runs WHERE plan_digest = $1',
-        [planDigest],
-      );
-    }
-    await client.query(
-      "DELETE FROM cleanup_deadline_reports WHERE feature = 'performance-load'",
-    );
-  });
-  touchedPlanDigests.clear();
-});
-
-describe('${name} protected performance cleanup integration', () => {
-  it('serializes cleanup behind an in-flight effect and rejects every late effect', async () => {
-    const planMaterialDigest = '1'.repeat(64);
-    const effectId = '2'.repeat(64);
-    touchedPlanDigests.add(planMaterialDigest);
-    const executeAuthorization = authorization({
-      effectId,
-      operation: 'execute',
-      planMaterialDigest,
-    });
-    const cleanupAuthorization = authorization({
-      effectId: null,
-      operation: 'cleanup',
-      planMaterialDigest,
-    });
-
-    await reserveRequest(executeAuthorization);
-    await withClient(async (client) => {
-      await client.query(
-        \`CREATE OR REPLACE FUNCTION ebk_performance_delay_effect()
-         RETURNS trigger
-         LANGUAGE plpgsql
-         AS $$
-         BEGIN
-           PERFORM pg_sleep(1);
-           RETURN NEW;
-         END
-         $$\`,
-      );
-      await client.query(
-        \`CREATE TRIGGER ebk_performance_delay_effect
-         BEFORE INSERT ON performance_load_async_effects
-         FOR EACH ROW EXECUTE FUNCTION ebk_performance_delay_effect()\`,
-      );
-    });
-
-    const observer = new Client({ connectionString: databaseUrl });
-    await observer.connect();
-    try {
-      const effect = databaseExecution(
-        'ebk-async-worker-v1',
-        effectId,
-        executeAuthorization,
-      );
-      await waitForActiveStatement(
-        observer,
-        'INSERT INTO performance_load_async_effects',
-      );
-      const cleanup = cleanupRun(
-        'ebk-async-worker-v1',
-        cleanupAuthorization,
-      );
-      await expect(effect).resolves.toMatchObject({ effectState: 'created' });
-      await expect(cleanup).resolves.toEqual({
-        remainingEffectCount: 0,
-        removedEffectCount: 1,
-      });
-    } finally {
-      await observer.end();
-    }
-
-    await expect(
-      databaseExecution(
-        'ebk-async-worker-v1',
-        '3'.repeat(64),
-        {
-          ...executeAuthorization,
-          effectId: '3'.repeat(64),
-          requestOrdinal: 2,
-        },
-      ),
-    ).rejects.toThrow('protected-performance-run-cleaning');
-    await expect(
-      reserveRequest({
-        ...executeAuthorization,
-        effectId: '3'.repeat(64),
-        requestOrdinal: 2,
-      }),
-    ).rejects.toThrow('protected-performance-run-collision');
-
-    await withClient(async (client) => {
-      const state = await client.query<{
-        cleanupStarted: boolean;
-        effects: string;
-      }>(
-        \`SELECT
-           run.cleanup_started_at IS NOT NULL AS "cleanupStarted",
-           (
-             SELECT count(*)::text
-             FROM performance_load_async_effects AS effect
-             WHERE effect.plan_digest = run.plan_digest
-           ) AS effects
-         FROM performance_load_runs AS run
-         WHERE run.plan_digest = $1\`,
-        [planMaterialDigest],
-      );
-      expect(state.rows).toEqual([
-        { cleanupStarted: true, effects: '0' },
-      ]);
-    });
-  });
-
-  it('tombstones and proves an effect-free run absent without a local ledger', async () => {
-    const planMaterialDigest = '4'.repeat(64);
-    touchedPlanDigests.add(planMaterialDigest);
-    const cleanupAuthorization = authorization({
-      effectId: null,
-      operation: 'cleanup',
-      planMaterialDigest,
-    });
-
-    await expect(
-      cleanupRun('ebk-async-worker-v1', cleanupAuthorization),
-    ).resolves.toEqual({
-      remainingEffectCount: 0,
-      removedEffectCount: 0,
-    });
-    await expect(
-      cleanupRun('ebk-async-worker-v1', cleanupAuthorization),
-    ).resolves.toEqual({
-      remainingEffectCount: 0,
-      removedEffectCount: 0,
-    });
-    await expect(
-      reserveRequest({
-        ...cleanupAuthorization,
-        effectId: '5'.repeat(64),
-        operation: 'execute',
-      }),
-    ).rejects.toThrow('protected-performance-run-collision');
-  });
-
-  it('expires only framework-owned due rows and retains fresh audit state', async () => {
-    const oldPlan = '6'.repeat(64);
-    const freshPlan = '7'.repeat(64);
-    const expiredEffectPlan = '8'.repeat(64);
-    const freshEffectPlan = '9'.repeat(64);
-    for (const digest of [
-      oldPlan,
-      freshPlan,
-      expiredEffectPlan,
-      freshEffectPlan,
-    ]) {
-      touchedPlanDigests.add(digest);
-    }
-    const expiredRecordId = '10000000-0000-4000-8000-000000000001';
-    const freshRecordId = '10000000-0000-4000-8000-000000000002';
-    const adopterRecordId = '10000000-0000-4000-8000-000000000003';
-
-    await withClient(async (client) => {
-      await client.query(
-        \`INSERT INTO performance_load_runs
-           (plan_digest, run_id, adapter_id, scenario_id, stage,
-            source_commit, release_material_digest, maximum_requests,
-            created_at, expires_at)
-         VALUES
-           ($1, 'old-run', 'ebk-async-worker-v1', 'async-burst', 'staging',
-            $3, $4, 10, now() - INTERVAL '32 days',
-            now() - INTERVAL '31 days'),
-           ($2, 'fresh-run', 'ebk-async-worker-v1', 'async-burst', 'staging',
-            $3, $4, 10, now() - INTERVAL '30 days',
-            now() - INTERVAL '29 days')\`,
-        [oldPlan, freshPlan, 'b'.repeat(40), 'd'.repeat(64)],
-      );
-      await client.query(
-        \`INSERT INTO performance_load_requests
-           (plan_digest, request_ordinal, effect_id)
-         VALUES ($1, 1, NULL), ($2, 1, NULL)\`,
-        [oldPlan, freshPlan],
-      );
-      await client.query(
-        \`INSERT INTO performance_load_async_effects
-           (effect_id, plan_digest, run_id, expires_at)
-         VALUES
-           ($1, $2, 'expired', now() - INTERVAL '1 minute'),
-           ($3, $4, 'fresh', now() + INTERVAL '1 day')\`,
-        ['a'.repeat(64), expiredEffectPlan, 'f'.repeat(64), freshEffectPlan],
-      );
-      await client.query(
-        \`INSERT INTO records
-           (id, name, owner_id, run_scope, test_expires_at)
-         VALUES
-           ($1::uuid, 'ebk-protected-performance-load', 'ebk-performance',
-            $4, now() - INTERVAL '1 minute'),
-           ($2::uuid, 'ebk-protected-performance-load', 'ebk-performance',
-            $5, now() + INTERVAL '1 day'),
-           ($3::uuid, 'adopter-performance-data', 'adopter-owner',
-            $4, now() - INTERVAL '1 minute')\`,
-        [
-          expiredRecordId,
-          freshRecordId,
-          adopterRecordId,
-          expiredEffectPlan,
-          freshEffectPlan,
-        ],
-      );
-    });
-
-    const emitted: Array<{ metricName?: string; value?: number }> = [];
-    const handler = createInboxCleanupHandler({
-      logger: {
-        error: vi.fn(),
-        info: vi.fn(),
-      } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          emitted.push(metric);
-          return {} as never;
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(handler({ id: 'performance-expiry-proof' })).resolves.toMatchObject({
-      performanceAuditRetentionDays: 30,
-      performanceCleanupDeadlineHours: 24,
-      reportedPerformanceDeadlineBreaches: 0,
-      remainingPerformanceExpired: 0,
-      removedPerformance: 4,
-    });
-    expect(emitted).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupBacklog',
-        value: 0,
-      }),
-    );
-    expect(emitted).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 0,
-      }),
-    );
-
-    await withClient(async (client) => {
-      const effects = await client.query<{ planDigest: string }>(
-        \`SELECT plan_digest AS "planDigest"
-         FROM performance_load_async_effects
-         WHERE plan_digest = ANY($1::text[])
-         ORDER BY plan_digest\`,
-        [[expiredEffectPlan, freshEffectPlan]],
-      );
-      expect(effects.rows).toEqual([{ planDigest: freshEffectPlan }]);
-      const records = await client.query<{ id: string }>(
-        \`SELECT id::text AS id
-         FROM records
-         WHERE id = ANY($1::uuid[])
-         ORDER BY id\`,
-        [[expiredRecordId, freshRecordId, adopterRecordId]],
-      );
-      expect(records.rows).toEqual([
-        { id: freshRecordId },
-        { id: adopterRecordId },
-      ]);
-      const audits = await client.query<{
-        planDigest: string;
-        requests: string;
-      }>(
-        \`SELECT
-           run.plan_digest AS "planDigest",
-           count(request.request_ordinal)::text AS requests
-         FROM performance_load_runs AS run
-         LEFT JOIN performance_load_requests AS request
-           ON request.plan_digest = run.plan_digest
-         WHERE run.plan_digest = ANY($1::text[])
-         GROUP BY run.plan_digest
-         ORDER BY run.plan_digest\`,
-        [[oldPlan, freshPlan]],
-      );
-      expect(audits.rows).toEqual([
-        { planDigest: freshPlan, requests: '1' },
-      ]);
-    });
-  });
-
-  it('durably retries deadline telemetry after deleting stale protected residue', async () => {
-    const stalePlan = 'a'.repeat(64);
-    const staleEffectId = 'b'.repeat(64);
-    const atDeadlinePlan = 'c'.repeat(64);
-    const atDeadlineEffectId = 'd'.repeat(64);
-    const beforeDeadlinePlan = 'e'.repeat(64);
-    const beforeDeadlineEffectId = 'f'.repeat(64);
-    const staleRecordId = '10000000-0000-4000-8000-000000000004';
-    for (const planDigest of [
-      stalePlan,
-      atDeadlinePlan,
-      beforeDeadlinePlan,
-    ]) {
-      touchedPlanDigests.add(planDigest);
-    }
-    await withClient(async (client) => {
-      await client.query(
-        \`INSERT INTO performance_load_async_effects
-           (effect_id, plan_digest, run_id, expires_at)
-         VALUES
-           ($1, $2, 'stale-deadline',
-             clock_timestamp() - INTERVAL '25 hours'),
-           ($3, $4, 'exact-deadline',
-             clock_timestamp() - INTERVAL '24 hours'),
-           ($5, $6, 'before-deadline',
-             clock_timestamp() - INTERVAL '23 hours 59 minutes')\`,
-        [
-          staleEffectId,
-          stalePlan,
-          atDeadlineEffectId,
-          atDeadlinePlan,
-          beforeDeadlineEffectId,
-          beforeDeadlinePlan,
-        ],
-      );
-      await client.query(
-        \`INSERT INTO records
-           (id, name, owner_id, run_scope, test_expires_at)
-         VALUES ($1::uuid, 'ebk-protected-performance-load',
-           'ebk-performance', $2, now() - INTERVAL '25 hours')\`,
-        [staleRecordId, stalePlan],
-      );
-    });
-
-    const failedEmissions: Array<{ metricName?: string; value?: number }> = [];
-    const failedHandler = createInboxCleanupHandler({
-      logger: { error: vi.fn(), info: vi.fn() } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          failedEmissions.push(metric);
-          return metric.metricName ===
-            'PerformanceLoadCleanupDeadlineBreaches'
-            ? undefined
-            : ({} as never);
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(
-      failedHandler({ id: 'performance-deadline-report-failure' }),
-    ).rejects.toThrow('Performance cleanup deadline metric delivery failed.');
-
-    await withClient(async (client) => {
-      const state = await client.query<{
-        effects: string;
-        records: string;
-        reports: string;
-        resourceRefs: string[];
-      }>(
-        \`SELECT
-           (SELECT count(*)::text
-            FROM performance_load_async_effects
-            WHERE effect_id = ANY($1::text[])) AS effects,
-           (SELECT count(*)::text
-            FROM records
-            WHERE id = $2::uuid) AS records,
-           (SELECT count(*)::text
-            FROM cleanup_deadline_reports
-            WHERE feature = 'performance-load') AS reports,
-           (SELECT array_agg(resource_ref ORDER BY resource_ref)
-            FROM cleanup_deadline_reports
-            WHERE feature = 'performance-load') AS "resourceRefs"\`,
-        [
-          [staleEffectId, atDeadlineEffectId, beforeDeadlineEffectId],
-          staleRecordId,
-        ],
-      );
-      expect(state.rows).toEqual([
-        {
-          effects: '0',
-          records: '0',
-          reports: '3',
-          resourceRefs: [
-            'async-effect:' + staleEffectId,
-            'async-effect:' + atDeadlineEffectId,
-            'record:' + staleRecordId,
-          ].sort(),
-        },
-      ]);
-    });
-    expect(JSON.stringify(failedEmissions)).not.toContain(staleEffectId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(staleRecordId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(atDeadlineEffectId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(
-      beforeDeadlineEffectId,
-    );
-
-    const retryEmissions: Array<{ metricName?: string; value?: number }> = [];
-    const retryHandler = createInboxCleanupHandler({
-      logger: { error: vi.fn(), info: vi.fn() } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          retryEmissions.push(metric);
-          return {} as never;
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(
-      retryHandler({ id: 'performance-deadline-report-retry' }),
-    ).rejects.toThrow('performance-load-cleanup-deadline-breached');
-    expect(retryEmissions).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 3,
-      }),
-    );
-    expect(JSON.stringify(retryEmissions)).not.toContain(staleEffectId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(staleRecordId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(atDeadlineEffectId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(
-      beforeDeadlineEffectId,
-    );
-
-    await withClient(async (client) => {
-      const reports = await client.query<{ count: string }>(
-        \`SELECT count(*)::text AS count
-         FROM cleanup_deadline_reports
-         WHERE feature = 'performance-load'\`,
-      );
-      expect(reports.rows).toEqual([{ count: '0' }]);
-    });
-    await expect(
-      retryHandler({ id: 'performance-deadline-after-ack' }),
-    ).resolves.toMatchObject({ reportedPerformanceDeadlineBreaches: 0 });
-  });
-});
-`,
+        ...{},
         'web/src/app/%5F%5Febk/performance/api-lambda/route.ts': `import 'server-only';
 import { runPerformanceScenarioEndpoint } from '../handler';
 
@@ -3125,32 +2206,74 @@ export function GET(request: Request) {
 import { runPerformanceScenarioEndpoint } from '../handler';
 
 export function POST(request: Request) {
-  return runPerformanceScenarioEndpoint('ebk-async-worker-v1', request);
+  return runPerformanceScenarioEndpoint('${asyncAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/async-worker/cleanup/route.ts': `import 'server-only';
 import { runPerformanceCleanupEndpoint } from '../../handler';
 
 export function POST(request: Request) {
-  return runPerformanceCleanupEndpoint('ebk-async-worker-v1', request);
+  return runPerformanceCleanupEndpoint('${asyncAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/database/route.ts': `import 'server-only';
 import { runPerformanceScenarioEndpoint } from '../handler';
 
 export function POST(request: Request) {
-  return runPerformanceScenarioEndpoint('ebk-database-v1', request);
+  return runPerformanceScenarioEndpoint('${databaseAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/database/cleanup/route.ts': `import 'server-only';
 import { runPerformanceCleanupEndpoint } from '../../handler';
 
 export function POST(request: Request) {
-  return runPerformanceCleanupEndpoint('ebk-database-v1', request);
+  return runPerformanceCleanupEndpoint('${databaseAdapter}', request);
 }
 `,
         'docs/runbooks/performance-capacity-cost.md': `# Performance, capacity, and cost
 
+${`The default database scenarios use DynamoDB, not PostgreSQL. The database
+request signal measures the complete protected write/consistent-read operation
+against a one-second budget; it is a latency proxy, not connection count or
+measured DynamoDB service saturation. The async signal measures this run's
+unprocessed synthetic effects against its configured maximum. Expired but
+uncleaned effects remain counted until cleanup, so the signal is conservative.
+The backlog observation is a run-bound sample shared for at most one second
+inside each warm worker process. Concurrent requests reuse that sample instead
+of rescanning the pending collection per request; separate processes may sample
+independently. This is a bounded operational signal, never authorization or a
+global account-wide counter. Cleanup and async processing invalidate the local
+sample; exact per-request identity and effect checks are never cached.
+Neither signal claims account-wide capacity. Cold Aurora resume and idle cost
+apply only after SQL is explicitly declared; default key-value tests do not
+prove that relational acceptance. The signed-request, release, target, quota,
+and exact run-cleanup requirements are unchanged.
+
+Explicit run cleanup closes the exact run before removing effects in bounded
+chunks. A progress response is not acceptance: the harness follows signed
+continuations within its existing deadline and accepts only \`run-absent\` with
+zero remaining effects. If interrupted or timed out, retain the run identity
+and retry its protected cleanup; never reopen the closed run or fabricate an
+absence receipt. Expiry maintenance remains the bounded recovery path.
+
+Native expiry cleanup drains bounded exact pages within a shared four-minute
+invocation budget. It inspects at most 10,000 provider receipts and 5,000
+performance records per invocation; limits and time exhaustion retain cursors
+and report continuation. Provider receipts are removed after thirty days only
+when terminal; uncertain effects stay retained for reconciliation. Performance
+effects expire after twenty-four hours, with request/run audit history retained
+for thirty days after run expiry. Logical request expiry, not physical deletion
+or DynamoDB TTL timing, prevents replay.
+
+Overdue effect deletion and its deadline report commit atomically. Reports stay
+durable until metric emission and acknowledgement succeed; a lost acknowledgement
+may repeat the breach metric. A partial scan does not emit a fabricated zero
+backlog. Require complete-scan evidence and no continuation or pending deadline
+reports before retiring an old signing key. Explicit maintenance pauses retain
+their existing behavior and can delay cleanup; selecting a capacity profile
+does not resume this worker.
+
+`}\
 The generated policy is deliberately an unadopted seed. Replace example budgets,
 unknown capacity values, owner, review date, and allocation drivers from actual
 product requirements before protected promotion. Reliability remains authority
@@ -3163,7 +2286,14 @@ Keep warm/cold and cache hit/miss populations separate. Record p50, p95, and p99
 where meaningful, achieved throughput, the first exhausted dependency, quota
 headroom, and the scenario/tool/network limits. Estimates, test measurements,
 and delayed actual billing are different provenance classes. Never label a
-forecast or staging measurement as production actual.
+forecast or rehearsal-stage measurement as production actual.
+
+Generated Product Slices relay the transactional outbox every minute in
+production. Nonproduction stages use a fifteen-minute relay cadence so an
+idle Aurora Serverless v2 database can pass its five-minute auto-pause window.
+That cost-aware nonproduction default intentionally permits up to fifteen
+minutes of event-delivery latency; use an explicit protected design change if a
+nonproduction product requires production-like latency.
 
 Local commands can validate policy, budgets, capacity, and tag coverage. They
 cannot run protected load. The protected workflow must call
@@ -3171,9 +2301,15 @@ cannot run protected load. The protected workflow must call
 must bind the exact candidate, target account, Region, endpoint, maximum
 concurrency/rate/requests/duration/cost, stop conditions, cleanup, and emergency
 termination. Production load is exceptional and requires explicit human
-evidence; prefer staging, synthetics, canaries, and production observation.
+evidence; prefer the rehearsal stage, synthetics, canaries, and production observation.
+The dedicated protected performance role must allow \`ssm:GetParameter\` on
+the one exact retained \`/ebk/<stage>/workspace-owner\` parameter and must not
+allow owner-record mutation. Both the runner and cleanup recheck that record
+before their first remote application-data mutation, bind \`AWS_REGION\` to the
+claimed tuple, and then remove raw AWS session credentials from their own
+process environment before issuing HTTP load or cleanup requests.
 The three base-Slice managed adapters use fixed API/Lambda, async-worker, and database
-request/cleanup paths. They remain disabled unless the deployed staging
+request/cleanup paths. They remain disabled unless the deployed ${rehearsalStage}
 environment binds the exact plan, run, release, source commit, scenario, signal,
 adapter, exact Slice URL, and deployment-bound HMAC key ID. The workflow obtains
 only the current per-Slice signer from the exact AWSCURRENT Secrets Manager
@@ -3241,14 +2377,19 @@ construction; a separately modeled commercial billing-account provider is
 required before those partitions can adopt this path. The protected Foundation
 stack is the sole owner of the account monthly actual/forecast Budget. It
 publishes the exact policy digest and monthly maximum through Foundation
-discovery. Every protected Product plan must bind both and adopt the same
-maximum before creating a cost resource. The production Product stack creates
-only the Slice-tag-filtered custom Cost Anomaly monitor plus its immediate SNS
-subscription. The custom monitor avoids the
-one-per-account dimensional-monitor collision when several Slices coexist. The
-staging Product stack creates the lower pilot monthly Budget filtered to the exact
-\`ebk:slice\` and \`ebk:stage=staging\` allocation tags. Personal and
-development stages create none of these global billing resources.
+discovery. Production Foundation also owns the account's one AWS Services
+dimensional Cost Anomaly monitor and immediate SNS subscription; this
+AWS-managed monitor is supported by both Organizations management and member
+accounts. Its absolute-impact threshold is five percent of the reviewed
+monthly account maximum, rounded up to the nearest cent. Every protected
+Product plan must bind the Foundation cost authority and adopt the same maximum
+before creating a cost resource. Product stacks create no account anomaly
+resources, avoiding unsupported custom monitors, duplicate global alerts, and
+the one-per-account AWS Services monitor quota. The ${rehearsalStageTitle} Product stack creates
+the lower pilot monthly Budget filtered to the exact
+\`ebk:slice\` and \`ebk:stage=${rehearsalStage}\` allocation tags. Other stages
+outside the profile's rehearsal and production stages create none of
+these global billing resources.
 
 Both Budgets and the anomaly subscription route only to the Foundation alert
 topic and retain the policy digest, semantic route, and named owner in resource
@@ -3260,7 +2401,10 @@ automatic spend-changing response. Investigate through the named owner and
 runbook, then use a separately approved owning tool for any intervention.
 
 Every supported resource must carry the bounded workspace/Slice/stage/owner/
-repository/profile/managed-by/framework tags where AWS supports them.
+cost-allocation/managed-by/framework tags supplied by the provider baseline.
+Repository and production-profile tags are supplementary identity on generated
+resources that explicitly use \`createStandardResourceTags\`; coverage does not
+claim that SST-owned resources receive them.
 Unsupported resources remain visible with a reason and shared-cost allocation
 reference. Never use feature, user, tenant, request, work-item, payload, or raw
 error identifiers as resource tags or metric dimensions.
@@ -3283,10 +2427,12 @@ counts, evidence digests, account, Region, stage, workspace, Slice, period, and
 release from that validated evidence; clean generation reports the missing live
 evidence as incomplete.
 
-The generated scenarios cover API/Lambda, async worker, database cold resume,
-and a Service extension that becomes managed when its Service is generated,
-but are disabled until deliberately adopted. A clean generated Slice therefore reports incomplete rather than
-claiming capacity, cost, or live load evidence.
+The generated scenarios cover API/Lambda, async worker, and DynamoDB-backed
+database operations. Cold Aurora resume and idle cost are separate acceptance
+cases only when SQL is declared. A Service extension becomes managed when its
+Service is generated. Scenarios are disabled until deliberately adopted. A
+clean generated Slice therefore reports incomplete rather than claiming
+capacity, cost, or live load evidence.
 `,
     };
 }