@empire-builder-kit/nx 1.0.0-rc.37 → 1.0.0-rc.39

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

@@ -2,17 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderProductAsyncWorkFiles = renderProductAsyncWorkFiles;
 const built_in_plan_shared_js_1 = require("./built-in-plan-shared.js");
+const built_in_plan_key_value_provider_js_1 = require("./built-in-plan-key-value-provider.js");
+const built_in_plan_key_value_performance_js_1 = require("./built-in-plan-key-value-performance.js");
+const built_in_plan_key_value_cleanup_js_1 = require("./built-in-plan-key-value-cleanup.js");
 /** @internal */
 function renderProductAsyncWorkFiles(name, pascalName) {
     const recordExportWorkflowName = (0, built_in_plan_shared_js_1.stableGeneratedName)(40, name);
     return {
+        ...(0, built_in_plan_key_value_provider_js_1.renderKeyValueProviderFiles)(name),
+        ...(0, built_in_plan_key_value_performance_js_1.renderKeyValuePerformanceFiles)(name),
+        ...(0, built_in_plan_key_value_cleanup_js_1.renderKeyValueCleanupFiles)(name),
         'async/work-contract.json': (0, built_in_plan_shared_js_1.json)({
             capabilities: [
                 {
                     id: 'domain-events',
                     owner: name,
                     primitive: 'eventbridge-event',
-                    recovery: 'not-configured',
+                    recovery: 'streams-and-bounded-reconciliation',
                 },
                 {
                     id: 'durable-work',
@@ -40,15 +46,15 @@ function renderProductAsyncWorkFiles(name, pascalName) {
                 },
             ],
             consistency: {
-                inboxTable: 'ebk_inbox',
-                outboxTable: 'data_lifecycle_outbox',
-                transactionBoundary: 'injected-adapter',
+                inboxTable: 'slice-key-value',
+                outboxTable: 'slice-key-value',
+                transactionBoundary: 'native-dynamodb-transaction',
             },
             queue: {
                 batchItemFailures: true,
                 conflictPolicy: 'same-id-different-payload-fails',
                 idempotencyWindowSeconds: 2_592_000,
-                inboxCleanupBatchSize: 1_000,
+                inboxCleanupBatchSize: 20,
                 inboxCleanupIntervalSeconds: 3_600,
                 inboxCleanupInvocationLimit: 10_000,
                 performanceCleanupDeadlineSeconds: 86_400,
@@ -912,535 +918,6 @@ export function createAsyncRecoveryAdapters(): AsyncRecoveryAdapters {
 }
 
 export type { BackfillReportV1 };
-`,
-        'async/provider-worker.ts': `import { randomUUID } from 'node:crypto';
-import {
-  asyncWorkDigest,
-  processSqsBatch,
-  runProviderDelivery,
-  type ProviderDeliveryV1,
-} from '@empire-builder-kit/runtime/async-work';
-import { deriveOperationalRolloutStableKey } from '@empire-builder-kit/runtime/configuration';
-import { createLogger, type Logger } from '@empire-builder-kit/runtime/logging';
-import type { Client } from 'pg';
-import {
-  createSliceAwsConfigurationProvider,
-  createSliceLocalConfigurationProvider,
-} from '../configuration/provider.js';
-import { evaluateLambdaProviderDelivery } from '../configuration/rollout.js';
-import { withPrimaryDatabase } from '../database/runtime-client.js';
-import {
-  asyncAdapterDeclaration,
-  createAsyncRecoveryAdapters,
-} from './recovery-adapters.js';
-
-const providerWorkerRolloutStableKey =
-  deriveOperationalRolloutStableKey({
-    kind: 'lambda',
-    slice: '${name}',
-    workload: 'provider-worker',
-  });
-
-interface QueueRecord { body: string; messageId: string }
-interface QueueEvent { Records: QueueRecord[] }
-
-interface InboxRow {
-  attempts: number;
-  lastAttemptAt: Date;
-  payloadDigest: string;
-  resultReference: string | null;
-  status: 'claimed' | 'failed' | 'succeeded';
-}
-
-const HANDLER_ID = '${name}.provider-worker';
-const HANDLER_VERSION = '1';
-const CLAIM_LEASE_MILLISECONDS = 120_000;
-const INBOX_RETENTION_DAYS = 30;
-const protectedStage =
-  process.env.EBK_STAGE === 'staging' ||
-  process.env.EBK_STAGE === 'production';
-
-function requiredConfigurationIdentifier(name: string): string {
-  const value = process.env[name]?.trim();
-  if (!value) throw new Error(name + ' is required.');
-  return value;
-}
-
-const configurationProvider = protectedStage
-  ? createSliceAwsConfigurationProvider({
-      applicationIdentifier: requiredConfigurationIdentifier(
-        'EBK_APPCONFIG_APPLICATION_ID',
-      ),
-      environmentIdentifier: requiredConfigurationIdentifier(
-        'EBK_APPCONFIG_ENVIRONMENT_ID',
-      ),
-      profileIdentifier: requiredConfigurationIdentifier(
-        'EBK_APPCONFIG_PROFILE_ID',
-      ),
-    })
-  : createSliceLocalConfigurationProvider();
-
-function expiresAt(createdAt: string) {
-  const value = new Date(createdAt);
-  value.setUTCDate(value.getUTCDate() + INBOX_RETENTION_DAYS);
-  return value.toISOString();
-}
-
-function parseDelivery(body: string): ProviderDeliveryV1<unknown> {
-  const delivery = JSON.parse(body) as ProviderDeliveryV1<unknown>;
-  if (
-    delivery?.version !== 1 ||
-    typeof delivery.deliveryId !== 'string' ||
-    typeof delivery.requestDigest !== 'string' ||
-    asyncWorkDigest(delivery.request) !== delivery.requestDigest
-  ) {
-    throw new Error('provider-delivery-invalid');
-  }
-  return delivery;
-}
-
-export type ProviderClaimResult =
-  | { attemptToken: string; outcome: 'claimed' }
-  | {
-      outcome:
-        | 'conflict'
-        | 'duplicate'
-        | 'retry'
-        | 'terminal-permanent'
-        | 'terminal-reconciliation';
-    };
-
-function attemptReference(
-  state: 'effect-started' | 'prepared',
-  attemptToken: string,
-): string {
-  return state + '-' + attemptToken;
-}
-
-export async function claimProviderDelivery(
-  client: Client,
-  delivery: ProviderDeliveryV1<unknown>,
-  now: string,
-  createAttemptToken: () => string = randomUUID,
-): Promise<ProviderClaimResult> {
-  const attemptToken = createAttemptToken();
-  const preparedReference = attemptReference('prepared', attemptToken);
-  await client.query('BEGIN');
-  try {
-    const inserted = await client.query(
-      \`INSERT INTO ebk_inbox
-         (handler_id, handler_version, message_id, payload_digest, status,
-          attempts, first_seen_at, last_attempt_at, expires_at,
-          result_reference)
-       VALUES ($1, $2, $3, $4, 'claimed', 1, $5, $5, $6, $7)
-       ON CONFLICT (handler_id, message_id) DO NOTHING
-       RETURNING message_id\`,
-      [
-        HANDLER_ID,
-        HANDLER_VERSION,
-        delivery.deliveryId,
-        delivery.requestDigest,
-        now,
-        expiresAt(delivery.createdAt),
-        preparedReference,
-      ],
-    );
-    if (inserted.rowCount === 1) {
-      await client.query('COMMIT');
-      return { attemptToken, outcome: 'claimed' };
-    }
-    const existing = await client.query<InboxRow>(
-      \`SELECT attempts, last_attempt_at AS "lastAttemptAt",
-              payload_digest AS "payloadDigest",
-              result_reference AS "resultReference", status
-       FROM ebk_inbox
-       WHERE handler_id = $1 AND message_id = $2
-       FOR UPDATE\`,
-      [HANDLER_ID, delivery.deliveryId],
-    );
-    const row = existing.rows[0];
-    if (!row || row.payloadDigest !== delivery.requestDigest) {
-      await client.query('COMMIT');
-      return { outcome: 'conflict' };
-    }
-    if (row.status === 'succeeded') {
-      await client.query('COMMIT');
-      return { outcome: 'duplicate' };
-    }
-    if (row.status === 'failed' && row.resultReference) {
-      if (row.resultReference.startsWith('terminal-reconciliation-')) {
-        await client.query('COMMIT');
-        return { outcome: 'terminal-reconciliation' };
-      }
-      if (row.resultReference.startsWith('terminal-permanent-')) {
-        await client.query('COMMIT');
-        return { outcome: 'terminal-permanent' };
-      }
-    }
-    if (
-      row.status === 'claimed' &&
-      Date.parse(now) - row.lastAttemptAt.getTime() <
-        CLAIM_LEASE_MILLISECONDS
-    ) {
-      await client.query('COMMIT');
-      return { outcome: 'retry' };
-    }
-    if (
-      row.status === 'claimed' &&
-      row.resultReference?.startsWith('effect-started-') &&
-      delivery.contract.idempotencyRepeatSafety === 'unproven'
-    ) {
-      const terminal = await client.query(
-        \`UPDATE ebk_inbox
-         SET handler_version = $3, last_attempt_at = $4, status = 'failed',
-             result_reference = $5
-         WHERE handler_id = $1 AND message_id = $2
-           AND status = 'claimed' AND result_reference = $6\`,
-        [
-          HANDLER_ID,
-          delivery.deliveryId,
-          HANDLER_VERSION,
-          now,
-          'terminal-reconciliation-' +
-            asyncWorkDigest({
-              deliveryId: delivery.deliveryId,
-              result: 'provider-effect-outcome-unknown',
-            }),
-          row.resultReference,
-        ],
-      );
-      if (terminal.rowCount !== 1) {
-        throw new Error('provider-reconciliation-transition-lost');
-      }
-      await client.query('COMMIT');
-      return { outcome: 'terminal-reconciliation' };
-    }
-    await client.query(
-      \`UPDATE ebk_inbox
-       SET attempts = attempts + 1, handler_version = $3,
-           last_attempt_at = $4, result_reference = $5, status = 'claimed'
-       WHERE handler_id = $1 AND message_id = $2\`,
-      [
-        HANDLER_ID,
-        delivery.deliveryId,
-        HANDLER_VERSION,
-        now,
-        preparedReference,
-      ],
-    );
-    await client.query('COMMIT');
-    return { attemptToken, outcome: 'claimed' };
-  } catch (error) {
-    await client.query('ROLLBACK').catch(() => undefined);
-    throw error;
-  }
-}
-
-export async function markProviderEffectStarted(
-  client: Client,
-  deliveryId: string,
-  attemptToken: string,
-  now: string,
-): Promise<boolean> {
-  const result = await client.query(
-    \`UPDATE ebk_inbox
-     SET result_reference = $4, last_attempt_at = $5
-     WHERE handler_id = $1 AND message_id = $2 AND status = 'claimed'
-       AND result_reference = $3\`,
-    [
-      HANDLER_ID,
-      deliveryId,
-      attemptReference('prepared', attemptToken),
-      attemptReference('effect-started', attemptToken),
-      now,
-    ],
-  );
-  return result.rowCount === 1;
-}
-
-export async function finishProviderDelivery(
-  client: Client,
-  deliveryId: string,
-  attemptToken: string,
-  input: {
-    expectedState?: 'effect-started' | 'prepared';
-    resultReference?: string;
-    status: 'failed' | 'succeeded';
-  },
-): Promise<boolean> {
-  const result = await client.query(
-    \`UPDATE ebk_inbox
-     SET completed_at = CASE WHEN $3 = 'succeeded' THEN now() ELSE NULL END,
-         result_reference = $4, status = $3, last_attempt_at = now()
-     WHERE handler_id = $1 AND message_id = $2
-       AND status = 'claimed' AND result_reference = $5\`,
-    [
-      HANDLER_ID,
-      deliveryId,
-      input.status,
-      input.resultReference ?? null,
-      attemptReference(input.expectedState ?? 'effect-started', attemptToken),
-    ],
-  );
-  return result.rowCount === 1;
-}
-
-interface ProviderWorkerDependencies {
-  createAttemptToken(): string;
-  deliver: typeof runProviderDelivery;
-  evaluateRollout: typeof evaluateLambdaProviderDelivery;
-  logger: Logger;
-  now(): string;
-  withDatabase: typeof withPrimaryDatabase;
-}
-
-export function createProviderWorkerHandler(
-  dependencies: ProviderWorkerDependencies,
-) {
-  const processRecord = async (record: QueueRecord) => {
-  let delivery: ProviderDeliveryV1<unknown>;
-  try {
-    delivery = parseDelivery(record.body);
-  } catch (error) {
-    dependencies.logger.warn('Provider delivery rejected', {
-      attributes: {
-        errorCode: 'provider-delivery-invalid',
-        messageIdDigest: asyncWorkDigest(record.messageId),
-      },
-      error,
-      outcome: 'failure',
-    });
-    return { errorCode: 'provider-delivery-invalid', outcome: 'terminal' as const };
-  }
-  const correlationId = delivery.deliveryId;
-  const claimResult = await dependencies.withDatabase(
-    { correlationId },
-    'async-provider-worker',
-    (client) =>
-      claimProviderDelivery(
-        client,
-        delivery,
-        dependencies.now(),
-        dependencies.createAttemptToken,
-      ),
-  );
-  if (claimResult.outcome === 'conflict') {
-    dependencies.logger.error('Provider delivery idempotency conflict', {
-      attributes: { deliveryIdDigest: asyncWorkDigest(delivery.deliveryId) },
-      context: { correlationId },
-      outcome: 'failure',
-    });
-    return { errorCode: 'idempotency-payload-conflict', outcome: 'terminal' as const };
-  }
-  if (claimResult.outcome === 'duplicate') {
-    dependencies.logger.info('Provider delivery deduplicated', {
-      attributes: { deliveryIdDigest: asyncWorkDigest(delivery.deliveryId) },
-      context: { correlationId },
-      outcome: 'success',
-    });
-    return { outcome: 'succeeded' as const };
-  }
-  if (claimResult.outcome === 'terminal-permanent') {
-    return {
-      errorCode: 'provider-permanent-failure',
-      outcome: 'terminal' as const,
-    };
-  }
-  if (claimResult.outcome === 'terminal-reconciliation') {
-    dependencies.logger.error('Provider delivery requires reconciliation', {
-      attributes: { deliveryIdDigest: asyncWorkDigest(delivery.deliveryId) },
-      context: { correlationId },
-      outcome: 'failure',
-    });
-    return {
-      errorCode: 'provider-reconciliation-required',
-      outcome: 'terminal' as const,
-    };
-  }
-  if (claimResult.outcome === 'retry') {
-    return { errorCode: 'idempotency-claim-active', outcome: 'retry' as const };
-  }
-  if (claimResult.outcome !== 'claimed') {
-    throw new Error('provider-delivery-claim-outcome-unhandled');
-  }
-  const attemptToken = claimResult.attemptToken;
-  let rollout;
-  try {
-    rollout = await dependencies.evaluateRollout(
-      configurationProvider,
-      providerWorkerRolloutStableKey,
-    );
-  } catch (error) {
-    await dependencies.withDatabase(
-      { correlationId },
-      'async-provider-worker',
-      (client) =>
-        finishProviderDelivery(
-          client,
-          delivery.deliveryId,
-          attemptToken,
-          {
-          expectedState: 'prepared',
-          resultReference: 'configuration-invalid',
-          status: 'failed',
-          },
-        ),
-    );
-    dependencies.logger.error('Provider delivery configuration failed', {
-      context: { correlationId },
-      error,
-      outcome: 'failure',
-    });
-    return {
-      errorCode: 'provider-delivery-configuration-invalid',
-      outcome: 'retry' as const,
-    };
-  }
-  if (!rollout.assigned) {
-    await dependencies.withDatabase(
-      { correlationId },
-      'async-provider-worker',
-      (client) =>
-        finishProviderDelivery(
-          client,
-          delivery.deliveryId,
-          attemptToken,
-          {
-          expectedState: 'prepared',
-          resultReference: 'configuration-disabled',
-          status: 'failed',
-          },
-        ),
-    );
-    return {
-      errorCode: 'provider-delivery-disabled',
-      outcome: 'retry' as const,
-    };
-  }
-  const effectStarted = await dependencies.withDatabase(
-    { correlationId },
-    'async-provider-worker',
-    (client) =>
-      markProviderEffectStarted(
-        client,
-        delivery.deliveryId,
-        attemptToken,
-        dependencies.now(),
-      ),
-  );
-  if (!effectStarted) {
-    return {
-      errorCode: 'idempotency-claim-lost',
-      outcome: 'retry' as const,
-    };
-  }
-  const result = await dependencies.deliver({
-    adapter: createAsyncRecoveryAdapters().providerDelivery,
-    delivery,
-  });
-  if (result.outcome === 'confirmed') {
-    const persisted = await dependencies.withDatabase(
-      { correlationId },
-      'async-provider-worker',
-      (client) =>
-        finishProviderDelivery(
-          client,
-          delivery.deliveryId,
-          attemptToken,
-          {
-            resultReference: result.providerReference,
-            status: 'succeeded',
-          },
-        ),
-    );
-    if (!persisted) {
-      throw new Error('provider-delivery-confirmation-state-lost');
-    }
-    dependencies.logger.info('Provider delivery completed', {
-      attributes: {
-        attempts: result.attempts,
-        deliveryIdDigest: asyncWorkDigest(delivery.deliveryId),
-      },
-      context: { correlationId },
-      outcome: 'success',
-    });
-    return { outcome: 'succeeded' as const };
-  }
-  await dependencies.withDatabase(
-    { correlationId },
-    'async-provider-worker',
-    (client) =>
-      finishProviderDelivery(
-        client,
-        delivery.deliveryId,
-        attemptToken,
-        {
-        resultReference:
-          result.outcome === 'permanent-failure'
-            ? 'terminal-permanent-' + result.reconciliationId
-            : 'terminal-reconciliation-' + result.reconciliationId,
-        status: 'failed',
-        },
-      ),
-  );
-  dependencies.logger.error('Provider delivery terminated', {
-    attributes: {
-      deliveryIdDigest: asyncWorkDigest(delivery.deliveryId),
-      errorCode: result.errorCode,
-      requiresReconciliation:
-        result.outcome === 'reconciliation-required',
-    },
-    context: { correlationId },
-    outcome: 'failure',
-  });
-  return {
-    errorCode: result.errorCode,
-    outcome: 'terminal' as const,
-  };
-  };
-
-  return async (event: QueueEvent) => {
-    if (!asyncAdapterDeclaration.configured) {
-      throw new Error('async-provider-adapter-disabled');
-    }
-    const result = await processSqsBatch({
-      handler: async (record) => {
-        try {
-          return await processRecord(record);
-        } catch (error) {
-          dependencies.logger.error('Provider delivery handler failed', {
-            attributes: {
-              messageIdDigest: asyncWorkDigest(record.messageId),
-            },
-            error,
-            outcome: 'failure',
-          });
-          throw error;
-        }
-      },
-      records: event.Records,
-    });
-    return result.response;
-  };
-}
-
-const logger = createLogger({
-  component: 'provider-worker',
-  feature: 'async-work',
-  operation: 'provider-delivery',
-  slice: '${name}',
-  stage: process.env.EBK_STAGE ?? 'local',
-  workspace: process.env.EBK_WORKSPACE ?? '${name}',
-});
-
-export const handler = createProviderWorkerHandler({
-  createAttemptToken: randomUUID,
-  deliver: runProviderDelivery,
-  evaluateRollout: evaluateLambdaProviderDelivery,
-  logger,
-  now: () => new Date().toISOString(),
-  withDatabase: withPrimaryDatabase,
-});
 `,
         'async/webhook-ingress.ts': `import {
   SendMessageCommand,
@@ -1774,771 +1251,6 @@ export async function handler(event: { time?: string }) {
   });
   return { accepted: true, scheduledAt };
 }
-`,
-        'async/outbox-relay.ts': `import { randomUUID } from 'node:crypto';
-import {
-  EventBridgeClient,
-  PutEventsCommand,
-  type PutEventsRequestEntry,
-} from '@aws-sdk/client-eventbridge';
-import { createLogger, type Logger } from '@empire-builder-kit/runtime/logging';
-import {
-  createMetricEmitter,
-  type MetricEmitter,
-} from '@empire-builder-kit/runtime/observability';
-import { withPrimaryDatabase } from '../database/runtime-client.js';
-
-interface OutboxRow {
-  eventJson: PutEventsRequestEntry;
-  idempotencyKey: string;
-}
-
-const eventBridge = new EventBridgeClient({ maxAttempts: 2 });
-
-function emitOutboxBacklog(metrics: MetricEmitter, value: number) {
-  metrics.emit({
-    dimensions: {
-      component: 'outbox-relay',
-      feature: 'async-work',
-      operation: 'outbox-relay',
-      slice: '${name}',
-      stage: process.env.EBK_STAGE ?? 'local',
-    },
-    metricName: 'OutboxBacklog',
-    namespace: 'EBK/Async',
-    unit: 'Count',
-    value,
-  });
-}
-
-interface OutboxRelayDependencies {
-  logger: Logger;
-  metrics: MetricEmitter;
-  publish(entries: PutEventsRequestEntry[]): Promise<{
-    Entries?: Array<{ ErrorCode?: string; EventId?: string }>;
-  }>;
-  withDatabase: typeof withPrimaryDatabase;
-}
-
-export function createOutboxRelayHandler(
-  dependencies: OutboxRelayDependencies,
-) {
-  return async (event: { id?: string } = {}) => {
-  const correlationId = event.id ?? randomUUID();
-  return dependencies.withDatabase(
-    { correlationId },
-    'async-outbox-relay',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        const isolatedPerformance = await client.query<{ effectId: string }>(
-          \`WITH claimed AS (
-             SELECT effect_id
-             FROM performance_load_async_effects
-             WHERE processed_at IS NULL AND expires_at > now()
-             ORDER BY created_at, effect_id
-             LIMIT 10
-             FOR UPDATE SKIP LOCKED
-           )
-           UPDATE performance_load_async_effects AS effects
-           SET processed_at = now()
-           FROM claimed
-           WHERE effects.effect_id = claimed.effect_id
-           RETURNING effects.effect_id AS "effectId"\`,
-        );
-        const processedPerformance = isolatedPerformance.rows.length;
-        const pending = await client.query<OutboxRow>(
-          \`SELECT idempotency_key AS "idempotencyKey",
-                  event_json AS "eventJson"
-           FROM data_lifecycle_outbox
-           WHERE published_at IS NULL AND expires_at > now()
-           ORDER BY created_at, idempotency_key
-           LIMIT 10
-           FOR UPDATE SKIP LOCKED\`,
-        );
-        if (pending.rows.length === 0) {
-          emitOutboxBacklog(dependencies.metrics, 0);
-          await client.query('COMMIT');
-          dependencies.logger.info('Outbox relay converged', {
-            attributes: { processedPerformance },
-            context: { correlationId },
-            outcome: 'success',
-          });
-          return {
-            failed: 0,
-            outcome: 'converged',
-            processedPerformance,
-            published: 0,
-          };
-        }
-        const result = await dependencies.publish(
-          pending.rows.map(({ eventJson }) => eventJson),
-        );
-        let failed = 0;
-        let published = 0;
-        for (const [index, row] of pending.rows.entries()) {
-          const entry = result.Entries?.[index];
-          if (!entry?.EventId || entry.ErrorCode) {
-            failed += 1;
-            await client.query(
-              \`UPDATE data_lifecycle_outbox
-               SET attempts = attempts + 1,
-                   last_error_code = $2
-               WHERE idempotency_key = $1\`,
-              [row.idempotencyKey, entry?.ErrorCode ?? 'event-publication-failed'],
-            );
-            continue;
-          }
-          published += 1;
-          await client.query(
-            \`UPDATE data_lifecycle_outbox
-             SET attempts = attempts + 1, last_error_code = NULL,
-                 published_at = now()
-             WHERE idempotency_key = $1 AND published_at IS NULL\`,
-            [row.idempotencyKey],
-          );
-        }
-        const remaining = await client.query<{ count: string }>(
-          \`SELECT count(*)::text AS count
-           FROM data_lifecycle_outbox
-           WHERE published_at IS NULL AND expires_at > now()\`,
-        );
-        emitOutboxBacklog(
-          dependencies.metrics,
-          Number(remaining.rows[0]?.count ?? 0),
-        );
-        await client.query('COMMIT');
-        dependencies.logger.info('Outbox relay batch completed', {
-          attributes: { failed, processedPerformance, published },
-          context: { correlationId },
-          outcome: failed === 0 ? 'success' : 'failure',
-        });
-        return {
-          failed,
-          outcome: failed === 0 ? 'converged' : 'retry-required',
-          processedPerformance,
-          published,
-        };
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        dependencies.logger.error('Outbox relay batch failed', {
-          context: { correlationId },
-          error,
-          outcome: 'failure',
-        });
-        throw error;
-      }
-    },
-  );
-  };
-}
-
-const logger = createLogger({
-  component: 'outbox-relay',
-  feature: 'async-work',
-  operation: 'outbox-relay',
-  slice: '${name}',
-  stage: process.env.EBK_STAGE ?? 'local',
-  workspace: process.env.EBK_WORKSPACE ?? '${name}',
-});
-
-export const handler = createOutboxRelayHandler({
-  logger,
-  metrics: createMetricEmitter(),
-  publish: (Entries) => eventBridge.send(new PutEventsCommand({ Entries })),
-  withDatabase: withPrimaryDatabase,
-});
-`,
-        'async/inbox-cleanup.ts': `import { randomUUID } from 'node:crypto';
-import { createLogger, type Logger } from '@empire-builder-kit/runtime/logging';
-import {
-  createMetricEmitter,
-  type MetricEmitter,
-} from '@empire-builder-kit/runtime/observability';
-import type { Client as PgClient } from 'pg';
-import { withPrimaryDatabase } from '../database/runtime-client.js';
-
-const CLEANUP_BATCH_SIZE = 1_000;
-const CLEANUP_MAXIMUM_ROWS = 10_000;
-const CLEANUP_MAXIMUM_RUNTIME_MILLISECONDS = 4 * 60_000;
-const PERFORMANCE_CLEANUP_BATCH_SIZE = 500;
-const PERFORMANCE_CLEANUP_MAXIMUM_ROWS = 5_000;
-const PERFORMANCE_CLEANUP_DEADLINE_HOURS = 24;
-const PERFORMANCE_CLEANUP_FEATURE = 'performance-load';
-const PERFORMANCE_CLEANUP_MAXIMUM_PENDING_REPORTS = 10_000;
-const PERFORMANCE_AUDIT_RETENTION_DAYS = 30;
-
-interface InboxCleanupDependencies {
-  logger: Logger;
-  metrics: MetricEmitter;
-  now(): number;
-  withDatabase: typeof withPrimaryDatabase;
-}
-
-function emitInboxCleanupBacklog(metrics: MetricEmitter, value: number) {
-  metrics.emit({
-    dimensions: {
-      component: 'inbox-cleanup',
-      feature: 'async-work',
-      operation: 'inbox-cleanup',
-      slice: '${name}',
-      stage: process.env.EBK_STAGE ?? 'local',
-    },
-    metricName: 'InboxCleanupBacklog',
-    namespace: 'EBK/Async',
-    unit: 'Count',
-    value,
-  });
-}
-
-function emitPerformanceCleanupBacklog(
-  metrics: MetricEmitter,
-  value: number,
-) {
-  metrics.emit({
-    dimensions: {
-      component: 'performance-load-cleanup',
-      feature: 'performance',
-      operation: 'expiry-cleanup',
-      slice: '${name}',
-      stage: process.env.EBK_STAGE ?? 'local',
-    },
-    metricName: 'PerformanceLoadCleanupBacklog',
-    namespace: 'EBK/Performance',
-    unit: 'Count',
-    value,
-  });
-}
-
-function emitPerformanceCleanupDeadlineBreaches(
-  metrics: MetricEmitter,
-  value: number,
-) {
-  return metrics.emit({
-    dimensions: {
-      component: 'performance-load-cleanup',
-      feature: 'performance',
-      operation: 'expiry-cleanup',
-      slice: '${name}',
-      stage: process.env.EBK_STAGE ?? 'local',
-    },
-    metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-    namespace: 'EBK/Performance',
-    unit: 'Count',
-    value,
-  });
-}
-
-async function reportPerformanceCleanupDeadlineBreaches(
-  client: PgClient,
-  metrics: MetricEmitter,
-): Promise<{ continuationRequired: boolean; reported: number }> {
-  await client.query('BEGIN');
-  try {
-    const pending = await client.query<{ resourceRef: string }>(
-      \`SELECT resource_ref AS "resourceRef"
-       FROM cleanup_deadline_reports
-       WHERE feature = $1
-       ORDER BY observed_at, resource_ref
-       LIMIT $2
-       FOR UPDATE\`,
-      [PERFORMANCE_CLEANUP_FEATURE, PERFORMANCE_CLEANUP_MAXIMUM_ROWS + 1],
-    );
-    const selected = pending.rows.slice(0, PERFORMANCE_CLEANUP_MAXIMUM_ROWS);
-    if (
-      emitPerformanceCleanupDeadlineBreaches(
-        metrics,
-        selected.length,
-      ) === undefined
-    ) {
-      throw new Error(
-        'Performance cleanup deadline metric delivery failed.',
-      );
-    }
-    if (selected.length > 0) {
-      await client.query(
-        \`DELETE FROM cleanup_deadline_reports
-         WHERE feature = $1 AND resource_ref = ANY($2::text[])\`,
-        [
-          PERFORMANCE_CLEANUP_FEATURE,
-          selected.map(({ resourceRef }) => resourceRef),
-        ],
-      );
-    }
-    await client.query('COMMIT');
-    return {
-      continuationRequired:
-        pending.rows.length > PERFORMANCE_CLEANUP_MAXIMUM_ROWS,
-      reported: selected.length,
-    };
-  } catch (error) {
-    await client.query('ROLLBACK').catch(() => undefined);
-    throw error;
-  }
-}
-
-async function recordPerformanceCleanupDeadlineReports(
-  client: PgClient,
-  resourceKind: 'async-effect' | 'record',
-  resources: readonly { expiresAt: Date; resourceId: string }[],
-): Promise<void> {
-  if (resources.length === 0) return;
-  const recorded = await client.query<{
-    candidateCount: string;
-    recordedCount: string;
-  }>(
-    \`WITH deadline_candidates AS (
-       SELECT
-         $1 || ':' || resource_id AS resource_ref,
-         expires_at + make_interval(hours => $2) AS deadline_at
-       FROM unnest($3::text[], $4::timestamptz[])
-         AS deleted(resource_id, expires_at)
-       WHERE expires_at + make_interval(hours => $2) <= clock_timestamp()
-     ), recorded AS (
-       INSERT INTO cleanup_deadline_reports
-         (deadline_at, feature, resource_ref)
-       SELECT deadline_at, $5, resource_ref
-       FROM deadline_candidates
-       ON CONFLICT (feature, resource_ref) DO UPDATE
-         SET deadline_at = cleanup_deadline_reports.deadline_at
-         WHERE cleanup_deadline_reports.deadline_at = EXCLUDED.deadline_at
-       RETURNING resource_ref
-     )
-     SELECT
-       (SELECT count(*)::text FROM deadline_candidates)
-         AS "candidateCount",
-       (SELECT count(*)::text FROM recorded) AS "recordedCount"\`,
-    [
-      resourceKind,
-      PERFORMANCE_CLEANUP_DEADLINE_HOURS,
-      resources.map(({ resourceId }) => resourceId),
-      resources.map(({ expiresAt }) => expiresAt),
-      PERFORMANCE_CLEANUP_FEATURE,
-    ],
-  );
-  if (
-    recorded.rows[0]?.candidateCount !== recorded.rows[0]?.recordedCount
-  ) {
-    throw new Error(
-      'Persisted performance cleanup deadline report is inconsistent.',
-    );
-  }
-  const pending = await client.query<{ count: string }>(
-    \`SELECT count(*)::text AS count
-     FROM (
-       SELECT 1
-       FROM cleanup_deadline_reports
-       WHERE feature = $1
-       LIMIT $2
-     ) AS bounded_pending_reports\`,
-    [
-      PERFORMANCE_CLEANUP_FEATURE,
-      PERFORMANCE_CLEANUP_MAXIMUM_PENDING_REPORTS + 1,
-    ],
-  );
-  if (
-    Number(pending.rows[0]?.count ?? 0) >
-    PERFORMANCE_CLEANUP_MAXIMUM_PENDING_REPORTS
-  ) {
-    throw new Error(
-      'Performance cleanup pending deadline report inventory was exceeded.',
-    );
-  }
-}
-
-export function createInboxCleanupHandler(
-  dependencies: InboxCleanupDependencies,
-) {
-  return async (event: { id?: string } = {}) => {
-    const correlationId = event.id ?? randomUUID();
-    const startedAt = dependencies.now();
-    return dependencies.withDatabase(
-      { correlationId },
-      'async-inbox-cleanup',
-      async (client) => {
-        let remainingExpired = 0;
-        let remainingPerformanceExpired = 0;
-        let reportedPerformanceDeadlineBreaches = 0;
-        let reportContinuationRequired = false;
-        let reportFailure: unknown;
-        let removedTotal = 0;
-        let removedPerformanceTotal = 0;
-        try {
-          const reportPendingBreaches = async () => {
-            try {
-              const result =
-                await reportPerformanceCleanupDeadlineBreaches(
-                  client,
-                  dependencies.metrics,
-                );
-              reportedPerformanceDeadlineBreaches += result.reported;
-              reportContinuationRequired ||=
-                result.continuationRequired;
-            } catch (error) {
-              reportFailure ??= error;
-            }
-          };
-          await reportPendingBreaches();
-          for (;;) {
-            await client.query('BEGIN');
-            const inboxLimit = Math.min(
-              CLEANUP_BATCH_SIZE,
-              CLEANUP_MAXIMUM_ROWS - removedTotal,
-            );
-            const removed =
-              inboxLimit > 0
-                ? await client.query<{ messageId: string }>(
-                    \`WITH expired AS (
-                 SELECT handler_id, message_id
-                 FROM ebk_inbox
-                 WHERE expires_at <= now()
-                   AND (
-                     status = 'succeeded'
-                     OR (
-                       status = 'failed'
-                       AND (
-                       result_reference LIKE 'terminal-permanent-%'
-                         OR result_reference LIKE 'terminal-reconciliation-%'
-                         OR result_reference IN (
-                           'configuration-disabled',
-                           'configuration-invalid'
-                         )
-                       )
-                     )
-                   )
-                 ORDER BY expires_at, handler_id, message_id
-                 LIMIT $1
-                 FOR UPDATE SKIP LOCKED
-               )
-               DELETE FROM ebk_inbox AS inbox
-               USING expired
-               WHERE inbox.handler_id = expired.handler_id
-                 AND inbox.message_id = expired.message_id
-               RETURNING inbox.message_id AS "messageId"\`,
-                    [inboxLimit],
-                  )
-                : { rowCount: 0, rows: [] };
-
-            let removedPerformanceThisPage = 0;
-            let performanceLimit = Math.min(
-              PERFORMANCE_CLEANUP_BATCH_SIZE,
-              PERFORMANCE_CLEANUP_MAXIMUM_ROWS -
-                removedPerformanceTotal -
-                removedPerformanceThisPage,
-            );
-            if (performanceLimit > 0) {
-              const expiredEffects = await client.query<{
-                expiresAt: Date;
-                resourceId: string;
-              }>(
-                \`WITH expired AS (
-                   SELECT effect_id, expires_at
-                   FROM performance_load_async_effects
-                   WHERE expires_at <= now()
-                   ORDER BY expires_at, effect_id
-                   LIMIT $1
-                   FOR UPDATE SKIP LOCKED
-                 )
-                 DELETE FROM performance_load_async_effects AS effects
-                 USING expired
-                 WHERE effects.effect_id = expired.effect_id
-                 RETURNING effects.effect_id AS "resourceId",
-                   effects.expires_at AS "expiresAt"\`,
-                [performanceLimit],
-              );
-              await recordPerformanceCleanupDeadlineReports(
-                client,
-                'async-effect',
-                expiredEffects.rows,
-              );
-              removedPerformanceThisPage += expiredEffects.rows.length;
-            }
-            performanceLimit = Math.min(
-              PERFORMANCE_CLEANUP_BATCH_SIZE,
-              PERFORMANCE_CLEANUP_MAXIMUM_ROWS -
-                removedPerformanceTotal -
-                removedPerformanceThisPage,
-            );
-            if (performanceLimit > 0) {
-              const expiredRecords = await client.query<{
-                expiresAt: Date;
-                resourceId: string;
-              }>(
-                \`WITH expired AS (
-                   SELECT id, test_expires_at
-                   FROM records
-                   WHERE owner_id = 'ebk-performance'
-                     AND name = 'ebk-protected-performance-load'
-                     AND test_expires_at <= now()
-                   ORDER BY test_expires_at, id
-                   LIMIT $1
-                   FOR UPDATE SKIP LOCKED
-                 )
-                 DELETE FROM records AS records
-                 USING expired
-                 WHERE records.id = expired.id
-                   AND records.owner_id = 'ebk-performance'
-                   AND records.name = 'ebk-protected-performance-load'
-                   AND records.test_expires_at <= now()
-                 RETURNING records.id::text AS "resourceId",
-                   records.test_expires_at AS "expiresAt"\`,
-                [performanceLimit],
-              );
-              await recordPerformanceCleanupDeadlineReports(
-                client,
-                'record',
-                expiredRecords.rows,
-              );
-              removedPerformanceThisPage += expiredRecords.rows.length;
-            }
-            performanceLimit = Math.min(
-              PERFORMANCE_CLEANUP_BATCH_SIZE,
-              PERFORMANCE_CLEANUP_MAXIMUM_ROWS -
-                removedPerformanceTotal -
-                removedPerformanceThisPage,
-            );
-            if (performanceLimit > 0) {
-              const expiredRequests = await client.query(
-                \`WITH expired AS (
-                   SELECT request.plan_digest, request.request_ordinal
-                   FROM performance_load_requests AS request
-                   INNER JOIN performance_load_runs AS run
-                     ON run.plan_digest = request.plan_digest
-                   WHERE run.expires_at <=
-                     now() - make_interval(days => $2)
-                   ORDER BY run.expires_at, request.plan_digest,
-                     request.request_ordinal
-                   LIMIT $1
-                   FOR UPDATE OF request SKIP LOCKED
-                 )
-                 DELETE FROM performance_load_requests AS request
-                 USING expired
-                 WHERE request.plan_digest = expired.plan_digest
-                   AND request.request_ordinal = expired.request_ordinal\`,
-                [performanceLimit, PERFORMANCE_AUDIT_RETENTION_DAYS],
-              );
-              removedPerformanceThisPage += expiredRequests.rowCount ?? 0;
-            }
-            performanceLimit = Math.min(
-              PERFORMANCE_CLEANUP_BATCH_SIZE,
-              PERFORMANCE_CLEANUP_MAXIMUM_ROWS -
-                removedPerformanceTotal -
-                removedPerformanceThisPage,
-            );
-            if (performanceLimit > 0) {
-              const expiredRuns = await client.query(
-                \`WITH expired AS (
-                   SELECT run.plan_digest
-                   FROM performance_load_runs AS run
-                   WHERE run.expires_at <=
-                       now() - make_interval(days => $2)
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM performance_load_requests AS request
-                       WHERE request.plan_digest = run.plan_digest
-                     )
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM performance_load_async_effects AS effects
-                       WHERE effects.plan_digest = run.plan_digest
-                     )
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM records AS performance_record
-                       WHERE performance_record.owner_id = 'ebk-performance'
-                         AND performance_record.name =
-                           'ebk-protected-performance-load'
-                         AND performance_record.run_scope = run.plan_digest
-                     )
-                   ORDER BY run.expires_at, run.plan_digest
-                   LIMIT $1
-                   FOR UPDATE OF run SKIP LOCKED
-                 )
-                 DELETE FROM performance_load_runs AS run
-                 USING expired
-                 WHERE run.plan_digest = expired.plan_digest\`,
-                [performanceLimit, PERFORMANCE_AUDIT_RETENTION_DAYS],
-              );
-              removedPerformanceThisPage += expiredRuns.rowCount ?? 0;
-            }
-            const remaining = await client.query<{ count: string }>(
-              \`SELECT count(*)::text AS count
-               FROM ebk_inbox
-               WHERE expires_at <= now()
-                 AND (
-                   status = 'succeeded'
-                   OR (
-                     status = 'failed'
-                     AND (
-                       result_reference LIKE 'terminal-permanent-%'
-                         OR result_reference LIKE 'terminal-reconciliation-%'
-                         OR result_reference IN (
-                           'configuration-disabled',
-                           'configuration-invalid'
-                         )
-                     )
-                   )
-                 )\`,
-            );
-            const remainingPerformance = await client.query<{
-              count: string;
-            }>(
-              \`SELECT count(*)::text AS count
-               FROM (
-                 SELECT 1
-                   FROM performance_load_async_effects
-                   WHERE expires_at <= now()
-                 UNION ALL
-                 SELECT 1
-                   FROM records
-                   WHERE owner_id = 'ebk-performance'
-                     AND name = 'ebk-protected-performance-load'
-                     AND test_expires_at <= now()
-                 UNION ALL
-                 SELECT 1
-                   FROM performance_load_requests AS request
-                   INNER JOIN performance_load_runs AS run
-                     ON run.plan_digest = request.plan_digest
-                   WHERE run.expires_at <=
-                     now() - make_interval(days => $1)
-                 UNION ALL
-                 SELECT 1
-                   FROM performance_load_runs AS run
-                   WHERE run.expires_at <=
-                     now() - make_interval(days => $1)
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM performance_load_requests AS request
-                       WHERE request.plan_digest = run.plan_digest
-                     )
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM performance_load_async_effects AS effects
-                       WHERE effects.plan_digest = run.plan_digest
-                     )
-                     AND NOT EXISTS (
-                       SELECT 1
-                       FROM records AS performance_record
-                       WHERE performance_record.owner_id = 'ebk-performance'
-                         AND performance_record.name =
-                           'ebk-protected-performance-load'
-                         AND performance_record.run_scope = run.plan_digest
-                     )
-                 LIMIT $2
-               ) AS bounded_backlog\`,
-              [
-                PERFORMANCE_AUDIT_RETENTION_DAYS,
-                PERFORMANCE_CLEANUP_MAXIMUM_ROWS + 1,
-              ],
-            );
-            await client.query('COMMIT');
-            const removedThisBatch = removed.rowCount ?? 0;
-            removedTotal += removedThisBatch;
-            removedPerformanceTotal += removedPerformanceThisPage;
-            remainingExpired = Number(remaining.rows[0]?.count ?? 0);
-            remainingPerformanceExpired = Number(
-              remainingPerformance.rows[0]?.count ?? 0,
-            );
-            const inboxCanContinue =
-              remainingExpired > 0 &&
-              removedTotal < CLEANUP_MAXIMUM_ROWS;
-            const performanceCanContinue =
-              remainingPerformanceExpired > 0 &&
-              removedPerformanceTotal <
-                PERFORMANCE_CLEANUP_MAXIMUM_ROWS;
-            if (
-              (!inboxCanContinue && !performanceCanContinue) ||
-              removedThisBatch + removedPerformanceThisPage === 0 ||
-              dependencies.now() - startedAt >=
-                CLEANUP_MAXIMUM_RUNTIME_MILLISECONDS
-            ) {
-              break;
-            }
-          }
-          emitInboxCleanupBacklog(dependencies.metrics, remainingExpired);
-          emitPerformanceCleanupBacklog(
-            dependencies.metrics,
-            remainingPerformanceExpired,
-          );
-          await reportPendingBreaches();
-          if (reportFailure !== undefined) {
-            throw reportFailure;
-          }
-          if (
-            reportedPerformanceDeadlineBreaches > 0 ||
-            reportContinuationRequired
-          ) {
-            throw new Error('performance-load-cleanup-deadline-breached');
-          }
-          dependencies.logger.info('Async inbox cleanup completed', {
-            attributes: {
-              batchLimit: CLEANUP_BATCH_SIZE,
-              invocationLimit: CLEANUP_MAXIMUM_ROWS,
-              performanceAuditRetentionDays:
-                PERFORMANCE_AUDIT_RETENTION_DAYS,
-              performanceBatchLimit: PERFORMANCE_CLEANUP_BATCH_SIZE,
-              performanceCleanupDeadlineHours:
-                PERFORMANCE_CLEANUP_DEADLINE_HOURS,
-              performanceInvocationLimit:
-                PERFORMANCE_CLEANUP_MAXIMUM_ROWS,
-              reportedPerformanceDeadlineBreaches,
-              remainingPerformanceExpired,
-              remainingExpired,
-              removedPerformance: removedPerformanceTotal,
-              removed: removedTotal,
-            },
-            context: { correlationId },
-            outcome:
-              remainingExpired === 0 &&
-              remainingPerformanceExpired === 0
-                ? 'success'
-                : 'unknown',
-          });
-          return {
-            batchLimit: CLEANUP_BATCH_SIZE,
-            invocationLimit: CLEANUP_MAXIMUM_ROWS,
-            performanceAuditRetentionDays:
-              PERFORMANCE_AUDIT_RETENTION_DAYS,
-            performanceBatchLimit: PERFORMANCE_CLEANUP_BATCH_SIZE,
-            performanceCleanupDeadlineHours:
-              PERFORMANCE_CLEANUP_DEADLINE_HOURS,
-            performanceInvocationLimit:
-              PERFORMANCE_CLEANUP_MAXIMUM_ROWS,
-            reportedPerformanceDeadlineBreaches,
-            remainingPerformanceExpired,
-            remainingExpired,
-            removedPerformance: removedPerformanceTotal,
-            removed: removedTotal,
-          };
-        } catch (error) {
-          await client.query('ROLLBACK').catch(() => undefined);
-          dependencies.logger.error('Async inbox cleanup failed', {
-            context: { correlationId },
-            error,
-            outcome: 'failure',
-          });
-          throw error;
-        }
-      },
-    );
-  };
-}
-
-const logger = createLogger({
-  component: 'inbox-cleanup',
-  feature: 'async-work',
-  operation: 'inbox-cleanup',
-  slice: '${name}',
-  stage: process.env.EBK_STAGE ?? 'local',
-  workspace: process.env.EBK_WORKSPACE ?? '${name}',
-});
-
-export const handler = createInboxCleanupHandler({
-  logger,
-  metrics: createMetricEmitter(),
-  now: Date.now,
-  withDatabase: withPrimaryDatabase,
-});
 `,
         'async/workflow-task.ts': `import {
   DeleteItemCommand,
@@ -3298,6 +2010,7 @@ describe('generated async failure fixture', () => {
   it,
   vi,
 } from 'vitest';
+${"import { DynamoDBClient, GetItemCommand, TransactWriteItemsCommand, type AttributeValue } from '@aws-sdk/client-dynamodb';\nimport { createDynamoPersistence } from '@empire-builder-kit/runtime/key-value';\nimport { markProviderEffectStarted } from '../async/provider-inbox.js';\n"}\
 import { createInboxCleanupHandler } from '../async/inbox-cleanup.js';
 import { createOutboxRelayHandler } from '../async/outbox-relay.js';
 import {
@@ -3335,175 +2048,7 @@ afterEach(() => {
 });
 
 describe('generated async handlers', () => {
-  it('routes a stale unproven provider effect to reconciliation without delivery', async () => {
-    const delivery = createQueuedProviderDelivery({
-      createdAt: '2026-01-01T00:00:00.000Z',
-      operationId: 'operation-one',
-      request: { value: true },
-    });
-    const deliver = vi.fn();
-    const client = {
-      async query(statement: string) {
-        if (statement === 'BEGIN' || statement === 'COMMIT') {
-          return { rowCount: null, rows: [] };
-        }
-        if (statement.includes('INSERT INTO ebk_inbox')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('SELECT attempts')) {
-          return {
-            rowCount: 1,
-            rows: [{
-              attempts: 1,
-              lastAttemptAt: new Date('2026-01-01T00:00:00.000Z'),
-              payloadDigest: delivery.requestDigest,
-              resultReference: 'effect-started-prior-attempt',
-              status: 'claimed',
-            }],
-          };
-        }
-        if (statement.includes("status = 'failed'")) {
-          return { rowCount: 1, rows: [] };
-        }
-        throw new Error('Unexpected provider query: ' + statement);
-      },
-    };
-    const handler = createProviderWorkerHandler({
-      createAttemptToken: () => 'new-attempt',
-      deliver: deliver as never,
-      evaluateRollout: vi.fn() as never,
-      logger: logger as never,
-      now: () => '2026-01-01T00:03:00.000Z',
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    const response = await handler({
-      Records: [{
-        body: JSON.stringify(delivery),
-        messageId: 'queue-message-one',
-      }],
-    });
-
-    expect(response.batchItemFailures).toEqual([
-      { itemIdentifier: 'queue-message-one' },
-    ]);
-    expect(deliver).not.toHaveBeenCalled();
-  });
-
-  it('rolls back when an unproven terminal reconciliation transition is lost', async () => {
-    const delivery = createQueuedProviderDelivery({
-      createdAt: '2026-01-01T00:00:00.000Z',
-      operationId: 'operation-transition-lost',
-      request: { value: true },
-    });
-    const statements: string[] = [];
-    const client = {
-      async query(statement: string) {
-        statements.push(statement);
-        if (statement === 'BEGIN' || statement === 'ROLLBACK') {
-          return { rowCount: null, rows: [] };
-        }
-        if (statement.includes('INSERT INTO ebk_inbox')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('SELECT attempts')) {
-          return {
-            rowCount: 1,
-            rows: [{
-              attempts: 1,
-              lastAttemptAt: new Date('2026-01-01T00:00:00.000Z'),
-              payloadDigest: delivery.requestDigest,
-              resultReference: 'effect-started-prior-attempt',
-              status: 'claimed',
-            }],
-          };
-        }
-        if (statement.includes("status = 'failed'")) {
-          return { rowCount: 0, rows: [] };
-        }
-        throw new Error('Unexpected provider query: ' + statement);
-      },
-    };
-
-    await expect(
-      claimProviderDelivery(
-        client as never,
-        delivery,
-        '2026-01-01T00:03:00.000Z',
-      ),
-    ).rejects.toThrow('provider-reconciliation-transition-lost');
-    expect(statements).toContain('ROLLBACK');
-    expect(statements).not.toContain('COMMIT');
-  });
-
-  it('retries a stale effect only when provider repeat safety is guaranteed', async () => {
-    const unproven = createQueuedProviderDelivery({
-      createdAt: '2026-01-01T00:00:00.000Z',
-      operationId: 'operation-guaranteed',
-      request: { value: true },
-    });
-    const delivery = {
-      ...unproven,
-      contract: {
-        ...unproven.contract,
-        idempotencyRepeatSafety: 'provider-guaranteed' as const,
-      },
-    };
-    const client = {
-      async query(statement: string) {
-        if (statement === 'BEGIN' || statement === 'COMMIT') {
-          return { rowCount: null, rows: [] };
-        }
-        if (statement.includes('INSERT INTO ebk_inbox')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('SELECT attempts')) {
-          return {
-            rowCount: 1,
-            rows: [{
-              attempts: 1,
-              lastAttemptAt: new Date('2026-01-01T00:00:00.000Z'),
-              payloadDigest: delivery.requestDigest,
-              resultReference: 'effect-started-prior-attempt',
-              status: 'claimed',
-            }],
-          };
-        }
-        if (statement.includes('UPDATE ebk_inbox')) {
-          return { rowCount: 1, rows: [] };
-        }
-        throw new Error('Unexpected provider query: ' + statement);
-      },
-    };
-    const deliver = vi.fn().mockResolvedValue({
-      attempts: 1,
-      deliveryId: delivery.deliveryId,
-      outcome: 'confirmed',
-      providerReference: 'provider-reference',
-      statusCode: 202,
-    });
-    const handler = createProviderWorkerHandler({
-      createAttemptToken: () => 'guaranteed-attempt',
-      deliver: deliver as never,
-      evaluateRollout: vi.fn().mockResolvedValue({ assigned: true }) as never,
-      logger: logger as never,
-      now: () => '2026-01-01T00:03:00.000Z',
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(
-      handler({
-        Records: [{
-          body: JSON.stringify(delivery),
-          messageId: 'queue-message-guaranteed',
-        }],
-      }),
-    ).resolves.toEqual({ batchItemFailures: [] });
-    expect(deliver).toHaveBeenCalledTimes(1);
-  });
-
+${(0, built_in_plan_key_value_provider_js_1.renderKeyValueProviderTestCases)(name)}
   it('treats a retry after a workflow effect marker as compensation-required', async () => {
     const runStep = vi.fn();
     const transition = vi.fn();
@@ -4093,446 +2638,8 @@ describe('generated async handlers', () => {
     );
   });
 
-  it('publishes and acknowledges an outbox row before converging', async () => {
-    const statements: string[] = [];
-    const client = {
-      async query(statement: string) {
-        statements.push(statement);
-        if (statement.includes('FROM data_lifecycle_outbox') &&
-            statement.includes('FOR UPDATE')) {
-          return {
-            rows: [{
-              eventJson: { Detail: '{}', DetailType: 'Fixture' },
-              idempotencyKey: 'outbox-one',
-            }],
-          };
-        }
-        if (statement.includes('count(*)')) {
-          return { rows: [{ count: '0' }] };
-        }
-        return { rowCount: 1, rows: [] };
-      },
-    };
-    const publish = vi.fn().mockResolvedValue({
-      Entries: [{ EventId: 'event-one' }],
-    });
-    const handler = createOutboxRelayHandler({
-      logger: logger as never,
-      metrics: { emit: vi.fn() },
-      publish: publish as never,
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(handler({ id: 'correlation-one' })).resolves.toMatchObject({
-      failed: 0,
-      outcome: 'converged',
-      published: 1,
-    });
-    expect(publish).toHaveBeenCalledTimes(1);
-    expect(statements.some((value) => value.includes('published_at = now()')))
-      .toBe(true);
-  });
-
-  it('processes protected performance work through an isolated sink', async () => {
-    const client = {
-      async query(statement: string) {
-        if (statement.includes('UPDATE performance_load_async_effects')) {
-          return { rows: [{ effectId: 'effect-one' }] };
-        }
-        if (
-          statement.includes('FROM data_lifecycle_outbox') &&
-          statement.includes('FOR UPDATE')
-        ) {
-          return { rows: [] };
-        }
-        return { rowCount: 1, rows: [] };
-      },
-    };
-    const publish = vi.fn();
-    const handler = createOutboxRelayHandler({
-      logger: logger as never,
-      metrics: { emit: vi.fn() },
-      publish: publish as never,
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(handler({ id: 'performance-one' })).resolves.toMatchObject({
-      failed: 0,
-      outcome: 'converged',
-      processedPerformance: 1,
-      published: 0,
-    });
-    expect(publish).not.toHaveBeenCalled();
-  });
-
-  it('drains terminal inbox rows in bounded pages and never selects active claims', async () => {
-    const metrics = { emit: vi.fn(() => ({} as never)) };
-    const deleteCounts = [1_000, 500];
-    const remainingCounts = ['500', '0'];
-    const performanceDeleteCounts = new Map([
-      ['performance_load_async_effects', [1, 0]],
-      ['records', [1, 0]],
-      ['performance_load_requests', [1, 0]],
-      ['performance_load_runs', [1, 0]],
-    ]);
-    const performanceStatements: string[] = [];
-    const client = {
-      async query(statement: string, parameters?: readonly unknown[]) {
-        if (
-          statement === 'BEGIN' ||
-          statement === 'COMMIT' ||
-          statement === 'ROLLBACK'
-        ) {
-          return { rowCount: null, rows: [] };
-        }
-        if (
-          statement.includes('SELECT resource_ref AS "resourceRef"') &&
-          statement.includes('FROM cleanup_deadline_reports')
-        ) {
-          return { rows: [] };
-        }
-        if (statement.includes('DELETE FROM cleanup_deadline_reports')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('WITH deadline_candidates AS')) {
-          expect(statement).toContain('clock_timestamp()');
-          expect(statement).toContain(
-            'ON CONFLICT (feature, resource_ref) DO UPDATE',
-          );
-          return {
-            rows: [{ candidateCount: '0', recordedCount: '0' }],
-          };
-        }
-        if (statement.includes('bounded_pending_reports')) {
-          return { rows: [{ count: '0' }] };
-        }
-        if (statement.includes('DELETE FROM ebk_inbox')) {
-          expect(statement).toContain("status = 'succeeded'");
-          expect(statement).toContain(
-            "result_reference LIKE 'terminal-permanent-%'",
-          );
-          expect(statement).toContain(
-            "result_reference LIKE 'terminal-reconciliation-%'",
-          );
-          expect(statement).toContain("'configuration-disabled'");
-          expect(statement).toContain("'configuration-invalid'");
-          return { rowCount: deleteCounts.shift() ?? 0, rows: [] };
-        }
-        if (
-          statement.includes('SELECT count(*)') &&
-          statement.includes('FROM ebk_inbox')
-        ) {
-          expect(statement).toContain("status = 'succeeded'");
-          expect(statement).toContain(
-            "result_reference LIKE 'terminal-permanent-%'",
-          );
-          expect(statement).toContain("'configuration-disabled'");
-          expect(statement).toContain("'configuration-invalid'");
-          expect(statement).not.toContain("status = 'claimed'");
-          return { rows: [{ count: remainingCounts.shift() ?? '0' }] };
-        }
-        if (
-          statement.includes('DELETE FROM performance_load_async_effects')
-        ) {
-          performanceStatements.push(statement);
-          expect(statement).toContain('expires_at <= now()');
-          const count =
-            performanceDeleteCounts
-              .get('performance_load_async_effects')
-              ?.shift() ?? 0;
-          return {
-            rowCount: count,
-            rows: Array.from({ length: count }, (_, index) => ({
-              expiresAt: new Date('2026-08-03T00:00:00.000Z'),
-              resourceId: 'effect-' + String(index),
-            })),
-          };
-        }
-        if (statement.includes('DELETE FROM records')) {
-          performanceStatements.push(statement);
-          expect(statement).toContain("owner_id = 'ebk-performance'");
-          expect(statement).toContain(
-            "name = 'ebk-protected-performance-load'",
-          );
-          expect(statement).toContain('test_expires_at <= now()');
-          const count =
-            performanceDeleteCounts.get('records')?.shift() ?? 0;
-          return {
-            rowCount: count,
-            rows: Array.from({ length: count }, (_, index) => ({
-              expiresAt: new Date('2026-08-03T00:00:00.000Z'),
-              resourceId: 'record-' + String(index),
-            })),
-          };
-        }
-        if (statement.includes('DELETE FROM performance_load_requests')) {
-          performanceStatements.push(statement);
-          expect(statement).toContain(
-            'now() - make_interval(days => $2)',
-          );
-          expect(parameters?.[1]).toBe(30);
-          return {
-            rowCount:
-              performanceDeleteCounts
-                .get('performance_load_requests')
-                ?.shift() ?? 0,
-            rows: [],
-          };
-        }
-        if (statement.includes('DELETE FROM performance_load_runs')) {
-          performanceStatements.push(statement);
-          expect(statement).toContain(
-            'FROM performance_load_requests AS request',
-          );
-          expect(statement).toContain(
-            'FROM performance_load_async_effects AS effects',
-          );
-          expect(statement).toContain('FROM records AS performance_record');
-          expect(parameters?.[1]).toBe(30);
-          return {
-            rowCount:
-              performanceDeleteCounts
-                .get('performance_load_runs')
-                ?.shift() ?? 0,
-            rows: [],
-          };
-        }
-        if (
-          statement.includes('AS count') &&
-          statement.includes('performance_load_async_effects')
-        ) {
-          expect(statement).toContain("owner_id = 'ebk-performance'");
-          expect(statement).toContain(
-            "name = 'ebk-protected-performance-load'",
-          );
-          expect(statement).toContain('FROM records AS performance_record');
-          expect(statement).toContain('LIMIT $2');
-          expect(parameters).toEqual([30, 5_001]);
-          return { rows: [{ count: '0' }] };
-        }
-        throw new Error('Unexpected cleanup query: ' + statement);
-      },
-    };
-    const handler = createInboxCleanupHandler({
-      logger: logger as never,
-      metrics,
-      now: () => 0,
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(handler({ id: 'cleanup-one' })).resolves.toMatchObject({
-      performanceCleanupDeadlineHours: 24,
-      remainingExpired: 0,
-      reportedPerformanceDeadlineBreaches: 0,
-      remainingPerformanceExpired: 0,
-      removed: 1_500,
-      removedPerformance: 4,
-    });
-    expect(metrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'InboxCleanupBacklog',
-        value: 0,
-      }),
-    );
-    expect(metrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupBacklog',
-        value: 0,
-      }),
-    );
-    expect(metrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 0,
-      }),
-    );
-    expect(performanceStatements).toHaveLength(8);
-  });
-
-  it('fails the scheduled invocation when protected load residue exceeds the cleanup deadline', async () => {
-    const metrics = { emit: vi.fn(() => ({} as never)) };
-    const pendingReports = new Set(['async-effect:effect-one']);
-    const client = {
-      async query(statement: string, parameters?: readonly unknown[]) {
-        if (
-          statement === 'BEGIN' ||
-          statement === 'COMMIT' ||
-          statement === 'ROLLBACK'
-        ) {
-          return { rowCount: null, rows: [] };
-        }
-        if (statement.includes('SELECT resource_ref AS "resourceRef"')) {
-          return {
-            rows: [...pendingReports].map((resourceRef) => ({ resourceRef })),
-          };
-        }
-        if (statement.includes('DELETE FROM cleanup_deadline_reports')) {
-          for (const resourceRef of parameters?.[1] as readonly string[]) {
-            pendingReports.delete(resourceRef);
-          }
-          return { rowCount: 1, rows: [] };
-        }
-        if (
-          statement.includes('DELETE FROM performance_load_async_effects') ||
-          statement.includes('DELETE FROM records')
-        ) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('DELETE FROM')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('SELECT count(*)')) {
-          return { rows: [{ count: '0' }] };
-        }
-        throw new Error('Unexpected cleanup deadline query: ' + statement);
-      },
-    };
-    const handler = createInboxCleanupHandler({
-      logger: { error: vi.fn(), info: vi.fn() } as never,
-      metrics,
-      now: () => 0,
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(handler({ id: 'cleanup-deadline' })).rejects.toThrow(
-      'performance-load-cleanup-deadline-breached',
-    );
-    expect(metrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 1,
-      }),
-    );
-    expect(pendingReports.size).toBe(0);
-  });
-
-  it('retries deadline telemetry when its post-emission commit fails', async () => {
-    const pendingReports = new Set(['record:record-one']);
-    let failReportCommits = true;
-    let reportTransaction = false;
-    let snapshot = new Set<string>();
-    const client = {
-      async query(statement: string, parameters?: readonly unknown[]) {
-        if (statement === 'BEGIN') {
-          snapshot = new Set(pendingReports);
-          reportTransaction = false;
-          return { rowCount: null, rows: [] };
-        }
-        if (statement === 'COMMIT') {
-          if (reportTransaction && failReportCommits) {
-            throw new Error('simulated report commit crash');
-          }
-          return { rowCount: null, rows: [] };
-        }
-        if (statement === 'ROLLBACK') {
-          pendingReports.clear();
-          for (const resourceRef of snapshot) pendingReports.add(resourceRef);
-          return { rowCount: null, rows: [] };
-        }
-        if (statement.includes('SELECT resource_ref AS "resourceRef"')) {
-          reportTransaction = true;
-          return {
-            rows: [...pendingReports].map((resourceRef) => ({ resourceRef })),
-          };
-        }
-        if (statement.includes('DELETE FROM cleanup_deadline_reports')) {
-          for (const resourceRef of parameters?.[1] as readonly string[]) {
-            pendingReports.delete(resourceRef);
-          }
-          return { rowCount: 1, rows: [] };
-        }
-        if (
-          statement.includes('DELETE FROM performance_load_async_effects') ||
-          statement.includes('DELETE FROM records')
-        ) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('DELETE FROM')) {
-          return { rowCount: 0, rows: [] };
-        }
-        if (statement.includes('SELECT count(*)')) {
-          return { rows: [{ count: '0' }] };
-        }
-        throw new Error('Unexpected cleanup retry query: ' + statement);
-      },
-    };
-    const firstMetrics = { emit: vi.fn(() => ({} as never)) };
-    const createHandler = (metrics: typeof firstMetrics) =>
-      createInboxCleanupHandler({
-        logger: { error: vi.fn(), info: vi.fn() } as never,
-        metrics,
-        now: () => 0,
-        withDatabase: (async (_context, _workload, work) =>
-          work(client as never)) as never,
-      });
-
-    await expect(
-      createHandler(firstMetrics)({ id: 'cleanup-report-crash' }),
-    ).rejects.toThrow('simulated report commit crash');
-    expect(pendingReports.size).toBe(1);
-    expect(firstMetrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 1,
-      }),
-    );
-
-    failReportCommits = false;
-    const retryMetrics = { emit: vi.fn(() => ({} as never)) };
-    await expect(
-      createHandler(retryMetrics)({ id: 'cleanup-report-retry' }),
-    ).rejects.toThrow('performance-load-cleanup-deadline-breached');
-    expect(pendingReports.size).toBe(0);
-    expect(retryMetrics.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 1,
-      }),
-    );
-  });
-
-  it('surfaces publish-before-database-ack as retryable at-least-once work', async () => {
-    const client = {
-      async query(statement: string) {
-        if (statement.includes('FROM data_lifecycle_outbox') &&
-            statement.includes('FOR UPDATE')) {
-          return {
-            rows: [{
-              eventJson: { Detail: '{}', DetailType: 'Fixture' },
-              idempotencyKey: 'outbox-crash',
-            }],
-          };
-        }
-        if (statement.includes('published_at = now()')) {
-          throw new Error('database unavailable after publish');
-        }
-        return { rowCount: 1, rows: [] };
-      },
-    };
-    const publish = vi.fn().mockResolvedValue({
-      Entries: [{ EventId: 'event-one' }],
-    });
-    const handler = createOutboxRelayHandler({
-      logger: logger as never,
-      metrics: { emit: vi.fn() },
-      publish: publish as never,
-      withDatabase: (async (_context, _workload, work) =>
-        work(client as never)) as never,
-    });
-
-    await expect(handler({ id: 'correlation-crash' })).rejects.toThrow(
-      'database unavailable after publish',
-    );
-    await expect(handler({ id: 'correlation-retry' })).rejects.toThrow(
-      'database unavailable after publish',
-    );
-    expect(publish).toHaveBeenCalledTimes(2);
-  });
-
+${(0, built_in_plan_key_value_performance_js_1.renderKeyValueOutboxTests)()}
+${(0, built_in_plan_key_value_cleanup_js_1.renderKeyValueCleanupTests)()}
   it('enforces archive hard caps and cancels an active unsafe replay', async () => {
     expect(() =>
       assertReplayArchiveHardCaps({
@@ -4579,9 +2686,9 @@ if (contract.schemaVersion !== 1 || contract.slice !== '${name}') {
   fail('work contract identity is invalid.');
 }
 if (
-  contract.consistency?.inboxTable !== 'ebk_inbox' ||
-  !contract.consistency?.outboxTable ||
-  contract.consistency?.transactionBoundary !== 'injected-adapter'
+  contract.consistency?.inboxTable !== '${'slice-key-value'}' ||
+  contract.consistency?.outboxTable !== '${'slice-key-value'}' ||
+  contract.consistency?.transactionBoundary !== '${'native-dynamodb-transaction'}'
 ) {
   fail('the explicit inbox/outbox transaction contract is missing.');
 }
@@ -4589,7 +2696,7 @@ if (
   contract.queue?.batchItemFailures !== true ||
   contract.queue?.conflictPolicy !== 'same-id-different-payload-fails' ||
   contract.queue?.idempotencyWindowSeconds !== 2_592_000 ||
-  contract.queue?.inboxCleanupBatchSize !== 1_000 ||
+  contract.queue?.inboxCleanupBatchSize !== ${20} ||
   contract.queue?.inboxCleanupIntervalSeconds !== 3_600 ||
   contract.queue?.inboxCleanupInvocationLimit !== 10_000 ||
   contract.queue?.performanceCleanupDeadlineSeconds !== 86_400 ||