deepline 0.3.270 → 0.3.272

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -98,6 +98,15 @@ import {
   type PlayRunLedgerIngressEvent,
   type PlayRunLedgerTerminalWorkCounterSegment,
 } from '../run-ledger';
+import {
+  RUN_EVENT_KIND_SQL_LITERAL,
+  RUN_EVENT_KIND,
+  RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL,
+  RUN_SCHEDULER_OUTBOX_PREFIX_STOP_EVENT_TYPES,
+  RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES,
+} from '../run-event-catalog';
 import { stableStringify } from '../../plays/row-identity';
 import {
   runtimeWorkCountersFromResources,
@@ -322,7 +331,9 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // v54 expands the optional per-run canonical event-store marker.
 // v55 refreshes the unified event journal projection. The canonical retention
 // index stays operator-prepared concurrently before marked-run admission.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 55;
+// v56 adds a release-leading index for fixed-controller runner-terminal
+// recovery, which scans only active runs for each release lane.
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 56;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -926,13 +937,13 @@ export const POSTGRES_SCHEDULER_OUTBOX_DELIVERED_RETENTION_BATCH_LIMIT = 1_000;
 // eligibility test, including present-but-null log fields.
 const DELIVERED_OUTBOX_RAW_LOG_BODY_PREDICATE = `
   (
-    (event_type = 'run.events'
+    (event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
       AND jsonb_typeof(payload_json->'events') = 'array'
-      AND payload_json @? 'strict $.events[*] ? (@.type == "log.appended" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)
-    OR (event_type IN ('run.completed', 'run.failed')
+      AND payload_json @? 'strict $.events[*] ? (@.type == "${RUN_EVENT_KIND.logAppended}" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)
+    OR (event_type IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed})
       AND (payload_json ? 'terminalLogLines'
         OR (jsonb_typeof(payload_json->'terminalProgressEvents') = 'array'
-          AND payload_json @? 'strict $.terminalProgressEvents[*] ? (@.type == "log.appended" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)))
+          AND payload_json @? 'strict $.terminalProgressEvents[*] ? (@.type == "${RUN_EVENT_KIND.logAppended}" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)))
   )`;
 const RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
 const COMPUTE_BILLING_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
@@ -2034,6 +2045,15 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
             AND index_row.indrelid = to_regclass($4)
             AND index_row.indisready AND index_row.indisvalid
         )
+        AND EXISTS (
+          SELECT 1 FROM pg_index AS index_row
+          JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
+          JOIN pg_namespace AS index_namespace ON index_namespace.oid = index_class.relnamespace
+          WHERE index_namespace.nspname = $1
+            AND index_class.relname = 'runtime_scheduler_runs_absurd_release_active_idx'
+            AND index_row.indrelid = to_regclass($4)
+            AND index_row.indisready AND index_row.indisvalid
+        )
         AND EXISTS (
           SELECT 1 FROM pg_index AS index_row
           JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
@@ -2241,7 +2261,7 @@ async function ensurePostgresSchedulerTerminalComputeBillingOutboxTrigger(
     LANGUAGE plpgsql
     AS $$
     BEGIN
-      IF NEW.event_type NOT IN ('run.completed', 'run.failed', 'run.cancelled') THEN
+      IF NEW.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}) THEN
         RETURN NEW;
       END IF;
 
@@ -3896,7 +3916,7 @@ export async function ensurePostgresSchedulerSchema(
       await client.query(`
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_admission_pending_idx
           ON ${tableName('outbox', options)} (
-            (CASE WHEN event_type = 'run.created' THEN 0 ELSE 1 END),
+            (CASE WHEN event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 ELSE 1 END),
             coalesce(next_attempt_at, created_at),
             created_at,
             event_id
@@ -3912,7 +3932,7 @@ export async function ensurePostgresSchedulerSchema(
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_run_pending_order_idx
           ON ${tableName('outbox', options)} (
             run_id,
-            (CASE event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END),
+            (CASE event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END),
             created_at,
             event_id
           )
@@ -3990,6 +4010,11 @@ export async function ensurePostgresSchedulerSchema(
           WHERE status IN ('completed', 'failed', 'cancelled')
             AND started_at IS NOT NULL
       `);
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS runtime_scheduler_runs_absurd_release_active_idx
+          ON ${tableName('runs', options)} ((launch_json ->> 'absurdReleaseId'), run_id)
+          WHERE status IN ('queued', 'running', 'waiting')
+      `);
     }
     await client.query(`
     CREATE INDEX IF NOT EXISTS runtime_scheduler_receipts_run_idx
@@ -4059,7 +4084,7 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
     name: 'runtime_scheduler_outbox_run_pending_order_idx',
     table: 'outbox',
     definition: `(run_id,
-      (CASE event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END),
+      (CASE event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END),
       created_at, event_id)
       WHERE delivered_at IS NULL`,
   },
@@ -4089,7 +4114,7 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
     name: 'runtime_scheduler_outbox_admission_pending_idx',
     table: 'outbox',
     definition: `(
-      (CASE WHEN event_type = 'run.created' THEN 0 ELSE 1 END),
+      (CASE WHEN event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 ELSE 1 END),
       coalesce(next_attempt_at, created_at),
       created_at,
       event_id
@@ -4165,6 +4190,12 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
       WHERE status IN ('completed', 'failed', 'cancelled')
         AND started_at IS NOT NULL`,
   },
+  {
+    name: 'runtime_scheduler_runs_absurd_release_active_idx',
+    table: 'runs',
+    definition: `((launch_json ->> 'absurdReleaseId'), run_id)
+      WHERE status IN ('queued', 'running', 'waiting')`,
+  },
   {
     name: 'runtime_scheduler_rate_reservation_bucket_expiry_idx',
     table: 'rate_reservations',
@@ -5123,7 +5154,7 @@ async function submitPostgresSchedulerRunTransaction(
         SELECT
           'run-created:' || run_insert.run_id,
           run_insert.run_id,
-          'run.created',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCreated},
           jsonb_strip_nulls(jsonb_build_object(
             'orgId', $2::text,
             'playId', $3::text,
@@ -6210,7 +6241,7 @@ export async function firePostgresSchedulerCronSchedule(
         SELECT
           'run-created:' || run_insert.run_id,
           run_insert.run_id,
-          'run.created',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCreated},
           jsonb_strip_nulls(jsonb_build_object(
             'orgId', launch_payload.launch_json ->> 'orgId',
             'playId', launch_payload.launch_json ->> 'playId',
@@ -7225,7 +7256,7 @@ export async function resumePostgresSchedulerDetachedRunnerAttempt(
         INSERT INTO ${tableName('outbox', options)} (
           event_id, run_id, event_type, payload_json, created_at
         )
-        SELECT $4, run_id, 'run.waiting', jsonb_build_object('kind', 'detached_runner'),
+        SELECT $4, run_id, ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}, jsonb_build_object('kind', 'detached_runner'),
                ${causalOutboxCreatedAt('restored_run.run_id', options)}
         FROM restored_run
         RETURNING run_id
@@ -7364,7 +7395,7 @@ export async function markPostgresSchedulerAttemptWaiting(
         SELECT
           $6,
           waiting_run.run_id,
-          'run.waiting',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim($4::jsonb ->> 'kind'), ''),
             'eventKey', NULLIF($7::text, ''),
@@ -7510,7 +7541,7 @@ export async function markPostgresSchedulerAttemptRunning(
         SELECT
           $4,
           running_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim(running_run.suspension_json ->> 'kind'), ''),
             'eventKey',
@@ -7608,7 +7639,7 @@ export async function claimPostgresSchedulerCompletedDetachedRunnerTerminal(
         SELECT
           $3,
           run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_terminal'
@@ -7754,7 +7785,7 @@ export async function claimPostgresSchedulerOverdueDetachedRunnerCeilings(
         SELECT
           $3 || ':' || running_runs.run_id,
           running_runs.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_hard_ceiling'
@@ -8015,7 +8046,7 @@ export async function failPostgresSchedulerScheduledChildWaits(
         SELECT
           'run-terminal:' || run_id,
           terminal_runs.run_id,
-          'run.failed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runFailed},
           jsonb_build_object('error', $2::text),
           ${causalOutboxCreatedAt('terminal_runs.run_id', options)}
         FROM terminal_runs
@@ -8281,7 +8312,7 @@ export async function claimPostgresSchedulerWaitingDetachedAttemptForTerminal(
         SELECT
           $4,
           running_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_terminal_salvage'
@@ -8690,7 +8721,7 @@ export async function handoffPostgresSchedulerAttemptContinuation(
         SELECT
           $6,
           continuation_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim(continuation_run.suspension_json ->> 'kind'), ''),
             'eventKey',
@@ -10610,7 +10641,7 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.completed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted},
           jsonb_build_object(
             'output', $6::jsonb,
             'producerAttempt', $2::integer,
@@ -12521,6 +12552,7 @@ async function readPostgresSchedulerRunnerTerminalReceivedAtMs(
  * there is no release stamp.
  */
 export type PostgresSchedulerCompletedRunnerTerminal = {
+  releaseId: string | null;
   runId: string;
   attempt: number;
   leaseToken: string;
@@ -12532,45 +12564,95 @@ export async function listPostgresSchedulerCompletedRunnerTerminals(
   input: {
     limit?: number;
     absurdReleaseId?: string | null;
+    absurdReleaseIds?: readonly string[];
     includeFailed?: boolean;
   } = {},
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<PostgresSchedulerCompletedRunnerTerminal[]> {
   const limit = Math.min(500, Math.max(1, Math.floor(input.limit ?? 100)));
+  const releaseIds = input.absurdReleaseIds
+    ? [
+        ...new Set(
+          input.absurdReleaseIds.map((id) => id.trim()).filter(Boolean),
+        ),
+      ]
+    : null;
+  if (releaseIds && releaseIds.length === 0) return [];
+  const activeAttemptStatus = input.includeFailed
+    ? `attempts.status IN ('running', 'waiting')`
+    : `attempts.status = 'running'`;
+  const runnerTerminalStatus = input.includeFailed
+    ? `attempts.runner_result_json ->> 'status' IN ('completed', 'failed')`
+    : `attempts.runner_result_json ->> 'status' = 'completed'`;
+  const terminalQuery = releaseIds
+    ? {
+        sql: `
+          WITH requested_lanes AS (
+            SELECT DISTINCT btrim(release_id) AS release_id
+            FROM unnest($1::text[]) AS requested(release_id)
+            WHERE btrim(release_id) <> ''
+          )
+          SELECT terminals.release_id,
+                 terminals.run_id,
+                 terminals.attempt,
+                 terminals.lease_token,
+                 terminals.runner_result_json
+          FROM requested_lanes AS lanes
+          CROSS JOIN LATERAL (
+            SELECT runs.launch_json ->> 'absurdReleaseId' AS release_id,
+                   attempts.run_id,
+                   attempts.attempt,
+                   attempts.lease_token,
+                   attempts.runner_result_json
+            FROM ${tableName('runs', options)} AS runs
+            JOIN ${tableName('attempts', options)} AS attempts
+              ON attempts.run_id = runs.run_id
+            WHERE runs.launch_json ->> 'absurdReleaseId' = lanes.release_id
+              AND runs.status IN ('queued', 'running', 'waiting')
+              AND ${activeAttemptStatus}
+              AND attempts.lease_token IS NOT NULL
+              AND ${runnerTerminalStatus}
+            ORDER BY attempts.updated_at ASC, attempts.run_id ASC
+            LIMIT $2
+          ) AS terminals
+        `,
+        params: [releaseIds, limit],
+      }
+    : (() => {
+        const releaseId = input.absurdReleaseId?.trim() || null;
+        const releasePredicate = releaseId
+          ? `AND runs.launch_json ->> 'absurdReleaseId' = $1::text`
+          : '';
+        return {
+          sql: `
+            SELECT runs.launch_json ->> 'absurdReleaseId' AS release_id,
+                   attempts.run_id,
+                   attempts.attempt,
+                   attempts.lease_token,
+                   attempts.runner_result_json
+            FROM ${tableName('attempts', options)} AS attempts
+            JOIN ${tableName('runs', options)} AS runs
+              ON runs.run_id = attempts.run_id
+            WHERE ${activeAttemptStatus}
+              AND attempts.lease_token IS NOT NULL
+              AND ${runnerTerminalStatus}
+              AND runs.status IN ('queued', 'running', 'waiting')
+              ${releasePredicate}
+            ORDER BY attempts.updated_at ASC, attempts.run_id ASC
+            LIMIT $${releaseId ? 2 : 1}
+          `,
+          params: releaseId ? [releaseId, limit] : [limit],
+        };
+      })();
   const terminals = await client.query<{
+    release_id: string | null;
     run_id: string;
     attempt: number;
     lease_token: string;
     runner_result_json: unknown;
-  }>(
-    `
-      SELECT
-        attempts.run_id,
-        attempts.attempt,
-        attempts.lease_token,
-        attempts.runner_result_json
-      FROM ${tableName('attempts', options)} AS attempts
-      JOIN ${tableName('runs', options)} AS runs
-        ON runs.run_id = attempts.run_id
-      WHERE attempts.status = ANY($4::text[])
-        AND attempts.lease_token IS NOT NULL
-        AND attempts.runner_result_json ->> 'status' = ANY($3::text[])
-        AND runs.status IN ('queued', 'running', 'waiting')
-        AND (
-          $1::text IS NULL
-          OR runs.launch_json ->> 'absurdReleaseId' = $1::text
-        )
-      ORDER BY attempts.updated_at ASC, attempts.run_id ASC
-      LIMIT $2
-    `,
-    [
-      input.absurdReleaseId?.trim() || null,
-      limit,
-      input.includeFailed ? ['completed', 'failed'] : ['completed'],
-      input.includeFailed ? ['running', 'waiting'] : ['running'],
-    ],
-  );
+  }>(terminalQuery.sql, terminalQuery.params);
   return terminals.rows.map((row) => ({
+    releaseId: row.release_id,
     runId: row.run_id,
     attempt: row.attempt,
     leaseToken: row.lease_token,
@@ -13016,7 +13098,7 @@ export async function completePostgresSchedulerAttempt(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.completed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted},
           jsonb_build_object(
             'output', $9::jsonb,
             'producerAttempt', $2::integer,
@@ -13352,7 +13434,7 @@ export async function failPostgresSchedulerAttempt(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.failed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runFailed},
           jsonb_build_object(
             'error', $4::jsonb ->> 'message',
             'result', $8::jsonb,
@@ -13610,7 +13692,7 @@ export async function cancelPostgresSchedulerRun(
         SELECT
           'run-terminal:' || run_id,
           cancelled_run.run_id,
-          'run.cancelled',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled},
           jsonb_build_object('error', $5::text),
           ${causalOutboxCreatedAt('cancelled_run.run_id', options)},
           NULL,
@@ -16998,7 +17080,12 @@ export async function appendPostgresRunLedgerEvents(
   const eventId = `run-events:${input.runId}:${createHash('sha256').update(payload).digest('hex')}`;
   return appendRunLedgerOutboxFact(
     client,
-    { ...input, eventId, eventType: 'run.events', payload },
+    {
+      ...input,
+      eventId,
+      eventType: RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents,
+      payload,
+    },
     options,
   );
 }
@@ -17023,7 +17110,7 @@ export async function appendPostgresRunLedgerStart(
       orgId: input.orgId,
       runId: input.runId,
       eventId: `run-start-callback:${input.runId}`,
-      eventType: 'run.started',
+      eventType: RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted,
       payload: stableStringify(
         prepareRetainedPlayPipelinesForTransport(input.start),
       ),
@@ -17038,7 +17125,9 @@ async function appendRunLedgerOutboxFact(
     orgId: string;
     runId: string;
     eventId: string;
-    eventType: 'run.events' | 'run.started';
+    eventType:
+      | typeof RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
+      | typeof RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted;
     payload: string;
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -17176,14 +17265,16 @@ export async function assertPostgresRunLedgerDelivery(
       prefixStopReason = 'predecessor_failed';
       break;
     }
-    if (prefix.length > 0 && row.event_type === 'run.events') break;
+    if (
+      prefix.length > 0 &&
+      row.event_type === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
+    )
+      break;
     prefix.push(row);
 
     const first = prefix[0]!;
     const terminal = prefix.find((candidate) =>
-      ['run.completed', 'run.failed', 'run.cancelled'].includes(
-        candidate.event_type,
-      ),
+      RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES.includes(candidate.event_type),
     );
     const prefixDigest = createHash('sha256')
       .update(prefix.map((candidate) => candidate.delivery_key).join('\n'))
@@ -17196,7 +17287,7 @@ export async function assertPostgresRunLedgerDelivery(
       });
     } else if (
       prefix.length === 1 &&
-      ['run.created', 'run.started'].includes(first.event_type)
+      RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES.includes(first.event_type)
     ) {
       expectedKey = buildRunLedgerStartIdempotencyKey({
         runId: input.runId,
@@ -17219,7 +17310,7 @@ export async function assertPostgresRunLedgerDelivery(
     // Preserve the old singleton key for non-start, nonterminal facts.
     const legacySingletonKey =
       prefix.length === 1 &&
-      !['run.created', 'run.started'].includes(first.event_type) &&
+      !RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES.includes(first.event_type) &&
       input.idempotencyKey ===
         buildRunLedgerTerminalIdempotencyKey({
           runId: input.runId,
@@ -17270,7 +17361,7 @@ export async function assertPostgresRunLedgerDelivery(
 
     if (
       prefix.length === 1 &&
-      ['run.created', 'run.started', 'run.events'].includes(first.event_type)
+      RUN_SCHEDULER_OUTBOX_PREFIX_STOP_EVENT_TYPES.includes(first.event_type)
     ) {
       break;
     }
@@ -17297,7 +17388,7 @@ function runLedgerPositionSql(alias: string): string {
 }
 
 function runLedgerOrderSql(alias: string): string {
-  return `CASE ${alias}.event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END, ${alias}.created_at, ${alias}.event_id`;
+  return `CASE ${alias}.event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END, ${alias}.created_at, ${alias}.event_id`;
 }
 
 /**
@@ -17380,7 +17471,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
         -- commit to first claim while the projector drained continuously).
         ORDER BY
           CASE
-            WHEN candidate.event_type = 'run.created' THEN 0
+            WHEN candidate.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
             WHEN candidate.event_id LIKE 'run-terminal:%' THEN 1
             ELSE 2
           END,
@@ -17398,12 +17489,12 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           -- Admission is causally first and must be projected alone. A later
           -- start/terminal append may not leapfrog a delayed queued row.
           AND (
-            head.event_type NOT IN ('run.created', 'run.started', 'run.events')
+            head.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCreated}, ${RUN_EVENT_KIND_SQL_LITERAL.runStarted}, ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})
             OR outbox.event_id = head.event_id
           )
           -- An ingress row already contains a producer's bounded batch. Keep
           -- its receipt stable independently of the recovery caller's limit.
-          AND (outbox.event_type <> 'run.events' OR outbox.event_id = head.event_id)
+          AND (outbox.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} OR outbox.event_id = head.event_id)
           AND coalesce(outbox.next_attempt_at, outbox.created_at) <= now()
           AND (
             $3::text IS NULL
@@ -17433,7 +17524,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
                   : 'true'
               }
               AND terminal_predecessor.event_type IN (
-                'run.completed', 'run.failed', 'run.cancelled'
+                ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
               )
               AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox')}
           )
@@ -17446,7 +17537,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
               AND predecessor.delivered_at IS NULL
               AND ${runLedgerPrecedesSql('predecessor', 'outbox')}
               AND (
-                predecessor.event_type = 'run.events'
+                predecessor.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
                 OR predecessor.failed_at IS NOT NULL
                 OR coalesce(predecessor.next_attempt_at, predecessor.created_at) > now()
                 OR (
@@ -17465,7 +17556,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           SELECT 1
           FROM ${tableName('outbox', options)} AS candidate
           JOIN candidates ON candidates.event_id = candidate.event_id
-          WHERE candidate.event_type IN ('run.completed', 'run.failed', 'run.cancelled')
+          WHERE candidate.event_type IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled})
         ) AS has_terminal
       ), claimed AS (
         UPDATE ${tableName('outbox', options)} outbox
@@ -17788,11 +17879,11 @@ export async function purgePostgresSchedulerDeliveredOutboxRetentionBatch(
        )
        UPDATE ${tableName('outbox', options)} AS outbox
           SET payload_json = CASE
-            WHEN outbox.event_type = 'run.events' THEN jsonb_set(
+            WHEN outbox.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} THEN jsonb_set(
               outbox.payload_json,
               '{events}',
               (SELECT jsonb_agg(
-                 CASE WHEN item.value->>'type' = 'log.appended'
+                 CASE WHEN item.value->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
                    THEN item.value - 'lines' - 'lineContexts'
                    ELSE item.value
                  END ORDER BY item.ordinality
@@ -17809,7 +17900,7 @@ export async function purgePostgresSchedulerDeliveredOutboxRetentionBatch(
                 outbox.payload_json - 'terminalLogLines' - 'terminalLogContexts',
                 '{terminalProgressEvents}',
                 coalesce((SELECT jsonb_agg(
-                   CASE WHEN item.value->>'type' = 'log.appended'
+                   CASE WHEN item.value->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
                      THEN item.value - 'lines' - 'lineContexts'
                      ELSE item.value
                    END ORDER BY item.ordinality
@@ -18164,7 +18255,10 @@ export async function releasePostgresSchedulerOutboxLease(
 function normalizeOutboxIngressPreview(
   event: PlayRunLedgerIngressEvent,
 ): PlayRunLedgerIngressEvent {
-  if (event.type !== 'step.progress' && event.key !== 'step.progress') {
+  if (
+    event.type !== RUN_EVENT_KIND.stepProgress &&
+    event.key !== RUN_EVENT_KIND.stepProgress
+  ) {
     return event;
   }
   const progress = recordPayload(event.progress);
@@ -18180,7 +18274,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
   event: PostgresSchedulerOutboxEvent,
 ): PlayRunLedgerIngressEvent[] {
   const occurredAt = event.createdAt.getTime();
-  if (event.eventType === 'run.events') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents) {
     const events = payloadField(event.payload, 'events');
     const logsStored =
       payloadField(event.payload, 'logBodyStore') === 'planet_scale';
@@ -18208,10 +18302,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       normalizeOutboxIngressPreview,
     );
   }
-  if (event.eventType === 'run.started') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted) {
     return [
       {
-        type: 'run.started',
+        type: RUN_EVENT_KIND.runStarted,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18220,7 +18314,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.completed') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCompleted) {
     const terminalWorkCounterSegment =
       normalizePlayRunLedgerTerminalWorkCounterSegment(
         payloadField(event.payload, 'terminalWorkCounterSegment'),
@@ -18239,7 +18333,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         ? []
         : [
             {
-              type: 'log.appended',
+              type: RUN_EVENT_KIND.logAppended,
               runId: event.runId,
               occurredAt,
               source: 'worker',
@@ -18248,7 +18342,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
             } as PlayRunLedgerEvent,
           ]),
       {
-        type: 'run.completed',
+        type: RUN_EVENT_KIND.runCompleted,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18262,7 +18356,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.failed') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runFailed) {
     const terminalWorkCounterSegment =
       normalizePlayRunLedgerTerminalWorkCounterSegment(
         payloadField(event.payload, 'terminalWorkCounterSegment'),
@@ -18284,7 +18378,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         ? []
         : [
             {
-              type: 'log.appended',
+              type: RUN_EVENT_KIND.logAppended,
               runId: event.runId,
               occurredAt,
               source: 'worker',
@@ -18293,7 +18387,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
             } as PlayRunLedgerEvent,
           ]),
       {
-        type: 'run.failed',
+        type: RUN_EVENT_KIND.runFailed,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18306,10 +18400,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.cancelled') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled) {
     return [
       {
-        type: 'run.cancelled',
+        type: RUN_EVENT_KIND.runCancelled,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18317,7 +18411,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       } as PlayRunLedgerEvent,
     ];
   }
-  if (event.eventType === 'run.waiting' || event.eventType === 'run.resumed') {
+  if (
+    event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting ||
+    event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runResumed
+  ) {
     const waitKind = stringPayloadField(event.payload, 'kind');
     // A detached runner is still actively executing in a managed sandbox.
     // The scheduler parks its worker claim as an internal transport detail;
@@ -18331,10 +18428,12 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       runId: event.runId,
       occurredAt,
       source: 'system',
-      ...(event.eventType === 'run.waiting' && waitKind !== null
+      ...(event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting &&
+      waitKind !== null
         ? { waitKind }
         : {}),
-      ...(event.eventType === 'run.waiting' && waitUntil !== null
+      ...(event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting &&
+      waitUntil !== null
         ? { waitUntil }
         : {}),
     } as PlayRunLedgerEvent;
@@ -18353,13 +18452,13 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
     if (waitKind !== null && !eventKey) return [lifecycle];
     const renderedEventKey = eventKey ?? 'event';
     const line =
-      event.eventType === 'run.waiting'
+      event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting
         ? `Waiting for integration_event:${renderedEventKey}.`
         : `Resumed integration_event:${renderedEventKey}.`;
     return [
       lifecycle,
       {
-        type: 'log.appended',
+        type: RUN_EVENT_KIND.logAppended,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18367,11 +18466,11 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       } as PlayRunLedgerEvent,
     ];
   }
-  if (event.eventType === 'run.wait_timeout') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout) {
     const eventKey = stringPayloadField(event.payload, 'eventKey') ?? 'event';
     return [
       {
-        type: 'log.appended',
+        type: RUN_EVENT_KIND.logAppended,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18409,15 +18508,15 @@ export type PostgresSchedulerOutboxMaterializationPlan = {
   failureCode: string | null;
 };
 
-const RUN_LEDGER_KNOWN_OUTBOX_EVENT_TYPES = new Set([
-  'run.events',
-  'run.started',
-  'run.completed',
-  'run.failed',
-  'run.cancelled',
-  'run.waiting',
-  'run.resumed',
-  'run.wait_timeout',
+const RUN_LEDGER_KNOWN_OUTBOX_EVENT_TYPES: ReadonlySet<string> = new Set([
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCompleted,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runFailed,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runResumed,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout,
 ]);
 
 /**
@@ -18435,7 +18534,8 @@ export function planPostgresSchedulerOutboxMaterialization(
   const projected = buildRunLedgerEventsFromPostgresSchedulerOutbox(event);
   const terminalRef = projected.some(
     (candidate) =>
-      (candidate.type === 'run.completed' || candidate.type === 'run.failed') &&
+      (candidate.type === RUN_EVENT_KIND.runCompleted ||
+        candidate.type === RUN_EVENT_KIND.runFailed) &&
       isLedgerTerminalResultRef(candidate.result),
   );
   const delivery = terminalRef
@@ -18894,7 +18994,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
               input.headPriority === 'oldest_ready'
                 ? ''
                 : `CASE
-                       WHEN head.event_type = 'run.created' THEN 0
+                       WHEN head.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
                        WHEN head.event_id LIKE 'run-terminal:%' THEN 1
                        ELSE 2
                      END,`
@@ -19007,9 +19107,9 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
     // A pending start is always claimed alone because later events require its
     // snapshot. It cannot share the append endpoint, so retain that mutation
     // as its own exact delivery.
-    if (first.eventType === 'run.created') {
+    if (first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCreated) {
       await projectPostgresSchedulerCreatedEvent(runtimeApi, first);
-    } else if (first.eventType === 'run.started') {
+    } else if (first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted) {
       const leaseOwner = first.leaseOwner;
       const launch = leaseOwner
         ? await withClient((client) =>
@@ -19033,9 +19133,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
         const terminal = [...events]
           .reverse()
           .find((event) =>
-            ['run.completed', 'run.failed', 'run.cancelled'].includes(
-              event.eventType,
-            ),
+            RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES.includes(event.eventType),
           );
         const batchDeliveryKey = createHash('sha256')
           .update(events.map((event) => event.deliveryKey).join('\n'))