deepline 0.3.247 → 0.3.249

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

@@ -25,6 +25,7 @@ import type {
   PlayRunnerRuntimeTiming,
 } from '../protocol';
 import { PROD_DEFAULT_RUNTIME_SCHEDULER_SCHEMA } from '../runtime-scheduler-topology';
+import { RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER } from './runtime-event-search';
 import type { PlayRunnerRuntimeResource } from '../runner-backends/types';
 import {
   RuntimeSandboxOperationState,
@@ -76,6 +77,10 @@ import {
   type DocflowObservationUpsert,
 } from '../docflow-observation';
 import { normalizePlayDocflowNodeIoState } from '../docflow-node-io';
+import {
+  normalizePlayLogContext,
+  type PlayLogContext,
+} from '../log-context';
 import {
   workReceiptFailureKindCodeForWrite,
   workReceiptFailureKindFromCode,
@@ -299,7 +304,11 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // v46 adds a bounded provider-scope Retry-After hold with shared adaptive-rate
 // state. The scope owns learning and dispatch across runs and tool rules;
 // existing deadline rows expand additively and initialize on their first seed.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 46;
+// v47 attaches the append-only runtime event projection to durable outbox and
+// receipt transitions; no existing runtime wire field changes.
+// v48 expands optional compact-log columns and readers before writer enablement.
+// v49 installs transactional compact-log writers; only new admissions opt in.
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 49;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -885,6 +894,8 @@ const OUTBOX_RETRY_MAX_MS = 15 * 60 * 1_000;
 // diagnostic window, then delete in small, independently committed batches.
 export const POSTGRES_SCHEDULER_OUTBOX_DELIVERED_RETENTION_MS =
   30 * 24 * 60 * 60 * 1_000;
+export const POSTGRES_SCHEDULER_OUTBOX_LOG_BODY_RETENTION_MS =
+  7 * 24 * 60 * 60 * 1_000;
 export const POSTGRES_SCHEDULER_OUTBOX_DELIVERED_RETENTION_BATCH_LIMIT = 1_000;
 const RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
 const COMPUTE_BILLING_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
@@ -928,6 +939,20 @@ function schemaName(
   );
 }
 
+/** Only new immutable admissions opt into the fully installed recorder. */
+function newRunLogStoreSql(
+  launchSql: 'launch_payload.launch_json',
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): string {
+  return `CASE WHEN ${launchSql} ? 'playReference' AND EXISTS (
+    SELECT 1 FROM pg_proc AS proc
+    JOIN pg_namespace AS namespace ON namespace.oid = proc.pronamespace
+    WHERE namespace.nspname = '${schemaName(options).replace(/'/g, "''")}'
+      AND proc.proname = 'search_outbox_event'
+      AND obj_description(proc.oid, 'pg_proc') = '${RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER}'
+  ) THEN 'planet_scale' END`;
+}
+
 function tableName(
   table: string,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -1101,6 +1126,8 @@ export type PostgresSchedulerSchemaShapeRequirements = Readonly<{
   rateRequesterFairShare?: boolean;
   /** v45 added durable Retry-After holds shared across rules and runs. */
   rateScopeRetryAfter?: boolean;
+  /** v48 expands compact log storage; prior readers ignore these columns. */
+  runtimeLogStorage?: boolean;
 }>;
 
 export async function hasCurrentPostgresSchedulerSchemaShape(
@@ -1718,6 +1745,22 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
               AND index_row.indisvalid
           )
         )
+        AND (
+          $38::boolean = false
+          OR (
+            EXISTS (
+              SELECT 1 FROM information_schema.columns
+               WHERE table_schema = $1 AND table_name = 'runs'
+                 AND column_name = 'run_log_store' AND is_nullable = 'YES'
+            )
+            AND (
+              SELECT count(*) FROM information_schema.columns
+               WHERE table_schema = $1 AND table_name = 'attempts'
+                 AND column_name IN ('runner_result_digest', 'runner_log_payload_json')
+                 AND is_nullable = 'YES'
+            ) = 2
+          )
+        )
         AS ready
     `,
     [
@@ -1758,6 +1801,7 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
       `${quotedSchema}.${quoteIdent('rate_requesters')}`,
       requirements.rateScopeRetryAfter !== false,
       `${quotedSchema}.${quoteIdent('rate_scope_holds')}`,
+      requirements.runtimeLogStorage !== false,
     ],
   );
   if (currentShape.rows[0]?.ready !== true) return false;
@@ -1980,6 +2024,19 @@ export async function ensurePostgresSchedulerOnlineAdditiveExpansion(
         options,
       )} (state, updated_at)
   `);
+  await ensurePostgresSchedulerRunLogStorageExpansion(client, options);
+}
+
+/** Deployment-only expansion; absent values keep legacy storage authoritative. */
+async function ensurePostgresSchedulerRunLogStorageExpansion(
+  client: PostgresSchedulerQueryClient,
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<void> {
+  await client.query(`ALTER TABLE ${tableName('runs', options)}
+    ADD COLUMN IF NOT EXISTS run_log_store text`);
+  await client.query(`ALTER TABLE ${tableName('attempts', options)}
+    ADD COLUMN IF NOT EXISTS runner_result_digest text,
+    ADD COLUMN IF NOT EXISTS runner_log_payload_json jsonb`);
 }
 
 /** Read the highest deployment-owned scheduler schema marker. */
@@ -2546,6 +2603,7 @@ export async function ensurePostgresSchedulerSchema(
     ALTER TABLE ${tableName('attempts', options)}
       ADD COLUMN IF NOT EXISTS runner_terminal_received_at timestamptz
   `);
+    await ensurePostgresSchedulerRunLogStorageExpansion(client, options);
     // Authoritative provenance for terminal reporting. Do not infer this from
     // the completed/cleanup state shape: direct ingress and compatibility wake
     // can both produce those rows.
@@ -4882,7 +4940,8 @@ async function submitPostgresSchedulerRunTransaction(
           input_json,
           status,
           absurd_task_id,
-          admission_json
+          admission_json,
+          run_log_store
         )
         SELECT $1, $2, $3, $4, $5, $6, $7, launch_payload.launch_json, coalesce(nullif(launch_payload.launch_json -> 'input', 'null'::jsonb), '{}'::jsonb), 'queued',
                (SELECT task_id FROM task_spawn),
@@ -4894,7 +4953,8 @@ async function submitPostgresSchedulerRunTransaction(
                  'runtimeDeployVersion',
                  'coordinatorInternalToken',
                  'vercelProtectionBypassToken'
-               ]::text[]
+               ]::text[],
+               ${newRunLogStoreSql('launch_payload.launch_json', options)}
         FROM admission
         CROSS JOIN launch_payload
         WHERE NOT existing_run
@@ -4902,7 +4962,7 @@ async function submitPostgresSchedulerRunTransaction(
           AND parent_accepting
           AND NOT ${existingOnlySql}
         ON CONFLICT (run_id) DO NOTHING
-        RETURNING run_id, absurd_task_id
+        RETURNING run_id, absurd_task_id, run_log_store
       ), run_recovery AS (
         UPDATE ${tableName('runs', options)} AS runs
         SET absurd_task_id = (SELECT task_id FROM task_spawn),
@@ -4949,7 +5009,8 @@ async function submitPostgresSchedulerRunTransaction(
             'graphHash', $5::text,
             'runtimeBackend', $6::text,
             'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
-            'schedulerSchema', launch_payload.launch_json ->> 'schedulerSchema',
+            'schedulerSchema', COALESCE(launch_payload.launch_json ->> 'schedulerSchema', '${schemaName(options)}'),
+            'runLogStore', run_insert.run_log_store,
             'executionProfile', launch_payload.launch_json ->> 'executionProfile',
             'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
             'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
@@ -5951,7 +6012,7 @@ export async function firePostgresSchedulerCronSchedule(
         INSERT INTO ${tableName('runs', options)} (
           run_id, org_id, play_id, play_name, graph_hash, runtime_profile,
           artifact_storage_key, launch_json, input_json, status,
-          absurd_task_id, admission_json
+          absurd_task_id, admission_json, run_log_store
         )
         SELECT $5::text,
                launch_payload.launch_json ->> 'orgId',
@@ -5972,12 +6033,13 @@ export async function firePostgresSchedulerCronSchedule(
                  'runtimeDeployVersion',
                  'coordinatorInternalToken',
                  'vercelProtectionBypassToken'
-               ]::text[]
+               ]::text[],
+               ${newRunLogStoreSql('launch_payload.launch_json', options)}
         FROM occurrence
         CROSS JOIN launch_payload
         WHERE occurrence.schedule_current
           AND NOT occurrence.existing_run
-        RETURNING run_id
+        RETURNING run_id, run_log_store
       ), occurrence_admitted AS MATERIALIZED (
         SELECT true AS admitted
         FROM occurrence
@@ -6023,7 +6085,8 @@ export async function firePostgresSchedulerCronSchedule(
             'graphHash', launch_payload.launch_json ->> 'graphHash',
             'runtimeBackend', launch_payload.launch_json ->> 'runtimeBackend',
             'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
-            'schedulerSchema', launch_payload.launch_json ->> 'schedulerSchema',
+            'schedulerSchema', COALESCE(launch_payload.launch_json ->> 'schedulerSchema', '${schemaName(options)}'),
+            'runLogStore', run_insert.run_log_store,
             'executionProfile', launch_payload.launch_json ->> 'executionProfile',
             'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
             'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
@@ -8472,6 +8535,36 @@ export type PostgresSchedulerAttemptAuthority = Pick<
   (typeof POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS)[number]
 >;
 
+type PostgresSchedulerAuthorityRow = PostgresSchedulerAttemptAuthority & {
+  launch_required_fields_valid: boolean;
+};
+
+// Keep JSON types intact: text columns would coerce malformed launch scalars.
+const POSTGRES_SCHEDULER_AUTHORITY_COLUMNS = [
+  ...POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS,
+  'playId',
+  'executorToken',
+]
+  .map((field) => `${quoteIdent(field)} jsonb`)
+  .join(', ');
+const POSTGRES_SCHEDULER_AUTHORITY_SELECT = `${POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS.map((field) => `launch.${quoteIdent(field)}`).join(', ')},
+  ${['runId', 'playId', 'playName', 'executorToken', 'baseUrl']
+    .map((field) => `jsonb_typeof(launch.${quoteIdent(field)}) = 'string'`)
+    .join(' AND ')} AS launch_required_fields_valid`;
+
+function parsePostgresSchedulerAuthorityRow(
+  row: PostgresSchedulerAuthorityRow | undefined,
+): PostgresSchedulerAttemptAuthority | null {
+  if (!row) return null;
+  const { launch_required_fields_valid, ...authority } = row;
+  if (launch_required_fields_valid !== true) {
+    throw new Error(
+      'Postgres scheduler launch_json is missing required fields.',
+    );
+  }
+  return authority;
+}
+
 /**
  * Prove the same attempt lease as the full execution reader, returning only
  * the token issuer's authority. Input, graph, and artifact bytes never cross
@@ -8484,29 +8577,13 @@ export async function readPostgresSchedulerAttemptAuthorityForLease(
   input: { runId: string; attempt: number; leaseToken: string },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<PostgresSchedulerAttemptAuthority | null> {
-  const fields = POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS;
-  // Keep JSON types intact. A text record column would coerce malformed launch
-  // scalars into strings, bypassing the full reader's required-field checks.
-  const columns = [...fields, 'playId', 'executorToken']
-    .map((field) => `${quoteIdent(field)} jsonb`)
-    .join(', ');
-  const result = await client.query<
-    PostgresSchedulerAttemptAuthority & {
-      launch_required_fields_valid: boolean;
-    }
-  >(
+  const result = await client.query<PostgresSchedulerAuthorityRow>(
     `
-      SELECT ${fields.map((field) => `launch.${quoteIdent(field)}`).join(', ')},
-             ${['runId', 'playId', 'playName', 'executorToken', 'baseUrl']
-               .map(
-                 (field) =>
-                   `jsonb_typeof(launch.${quoteIdent(field)}) = 'string'`,
-               )
-               .join(' AND ')} AS launch_required_fields_valid
+      SELECT ${POSTGRES_SCHEDULER_AUTHORITY_SELECT}
       FROM ${tableName('runs', options)} AS runs
       JOIN ${tableName('attempts', options)} AS attempts
         ON attempts.run_id = runs.run_id
-      CROSS JOIN LATERAL jsonb_to_record(runs.launch_json) AS launch(${columns})
+      CROSS JOIN LATERAL jsonb_to_record(runs.launch_json) AS launch(${POSTGRES_SCHEDULER_AUTHORITY_COLUMNS})
       WHERE runs.run_id = $1
         AND runs.status IN ('queued', 'running', 'waiting')
         AND attempts.attempt = $2
@@ -8516,15 +8593,7 @@ export async function readPostgresSchedulerAttemptAuthorityForLease(
     `,
     [input.runId, input.attempt, input.leaseToken],
   );
-  const row = result.rows[0];
-  if (!row) return null;
-  const { launch_required_fields_valid, ...authority } = row;
-  if (launch_required_fields_valid !== true) {
-    throw new Error(
-      'Postgres scheduler launch_json is missing required fields.',
-    );
-  }
-  return authority;
+  return parsePostgresSchedulerAuthorityRow(result.rows[0]);
 }
 
 /**
@@ -9655,16 +9724,29 @@ export async function settlePostgresSchedulerRuntimeResources(
  */
 export async function recordPostgresSchedulerRunnerTerminal(
   client: PostgresSchedulerQueryClient,
-  input: { runId: string; attempt: number; result: unknown },
+  input: {
+    runId: string;
+    attempt: number;
+    result: unknown;
+    terminalProgressEvents?: readonly unknown[];
+  },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
   const recorded = await client.query<{ run_id: string }>(
     `
       WITH accepted AS MATERIALIZED (
+        -- Match direct completion's Run -> attempt lock order. The log
+        -- acceptance trigger also locks the Run for sequence assignment.
         SELECT clock_timestamp() AS accepted_at
-      )
+          FROM ${tableName('runs', options)}
+         WHERE run_id = $1
+       )
       UPDATE ${tableName('attempts', options)} AS target
       SET runner_result_json = COALESCE(target.runner_result_json, $3::jsonb),
+          runner_log_payload_json = CASE WHEN EXISTS (
+            SELECT 1 FROM ${tableName('runs', options)} AS log_run
+             WHERE log_run.run_id = target.run_id AND log_run.run_log_store = 'planet_scale'
+          ) THEN $4::jsonb ELSE NULL END,
           runner_terminal_received_at = COALESCE(
             target.runner_terminal_received_at,
             accepted.accepted_at
@@ -9722,7 +9804,12 @@ export async function recordPostgresSchedulerRunnerTerminal(
         AND target.attempt = $2
       RETURNING target.run_id
     `,
-    [input.runId, input.attempt, stringifyPostgresJson(input.result ?? null)],
+    [
+      input.runId,
+      input.attempt,
+      stringifyPostgresJson(input.result ?? null),
+      stringifyPostgresJson(runnerTerminalLogPayload(input)),
+    ],
   );
   return recorded.rows.length > 0;
 }
@@ -9817,10 +9904,11 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
   const ledgerTerminalResult = terminalRunResultForLedger(terminalResult, {
     content: 'full',
   });
-  const terminalLogLines = terminalLogLinesForOutbox(
+  const terminalLogProjection = terminalLogProjectionForOutbox(
     input.result,
     input.terminalLogOutbox,
   );
+  const terminalLogLines = terminalLogProjection.lines;
   const runtimeTiming = extractRunnerRuntimeTiming(input.result);
   const terminalWorkCounterSegment = terminalWorkCounterSegmentFromRunnerResult(
     input.result,
@@ -9855,6 +9943,10 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
         SET status = 'completed',
             terminalization_mode = 'direct',
             runner_result_json = COALESCE(target.runner_result_json, $3::jsonb),
+            runner_log_payload_json = CASE WHEN EXISTS (
+              SELECT 1 FROM ${tableName('runs', options)} AS log_run
+               WHERE log_run.run_id = target.run_id AND log_run.run_log_store = 'planet_scale'
+            ) THEN $19::jsonb ELSE NULL END,
             runner_terminal_received_at = COALESCE(
               target.runner_terminal_received_at,
               run.accepted_at
@@ -9910,7 +10002,13 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
           AND target.attempt = $2
           AND target.status IN ('running', 'waiting')
           AND target.lease_token = $11
-          AND (target.runner_result_json IS NULL OR target.runner_result_json = $3::jsonb)
+          AND (
+            target.runner_result_json IS NULL
+            OR target.runner_result_json = $3::jsonb
+            OR target.runner_result_digest = encode(
+              sha256(convert_to(($3::jsonb)::text, 'UTF8')), 'hex'
+            )
+          )
           AND run.run_id = target.run_id
           AND NOT EXISTS (
             SELECT 1
@@ -9923,7 +10021,8 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
           target.run_id,
           target.attempt,
           target.runner_terminal_received_at,
-          target.resource_json
+          target.resource_json,
+          target.runner_log_payload_json
       ),
       settled_attempt_resources AS (
         UPDATE ${tableName('attempts', options)} AS attempt_resources
@@ -10069,10 +10168,16 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
           'run.completed',
           jsonb_build_object(
             'output', $6::jsonb,
+            'producerAttempt', $2::integer,
             'terminalLogLines', $7::jsonb,
-            'terminalProgressEvents', $8::jsonb,
+            'terminalLogContexts', $17::jsonb,
+            'terminalProgressEvents', coalesce((
+              SELECT accepted.runner_log_payload_json->'terminalProgressEvents'
+              FROM completed_attempt AS accepted
+              WHERE accepted.run_id = run_terminal.run_id
+            ), $8::jsonb),
             'resultSummary', $16::jsonb,
-            'terminalWorkCounterSegment', $17::jsonb
+            'terminalWorkCounterSegment', $18::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -10107,7 +10212,9 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
       input.engineWake.wakeChannel,
       input.allowCappedCompletion === true,
       stringifyPostgresJson(resultSummary),
+      JSON.stringify(terminalLogProjection.lineContexts),
       stringifyPostgresJson(terminalWorkCounterSegment ?? null),
+      stringifyPostgresJson(runnerTerminalLogPayload(input)),
     ],
   );
   if (completed.rows.length > 0) return 'completed';
@@ -10618,6 +10725,36 @@ export async function claimPostgresSchedulerComputeBillingJobs(
   }));
 }
 
+/**
+ * Issue terminal compute-billing authority under the same settlement lease as
+ * the full worker reader, without hydrating execution input or retained graphs.
+ * Historical launches keep their absent-descriptor fallback in the issuer.
+ */
+export async function readComputeBillingDispatchAuthorityForLease(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string; leaseOwner: string; attemptCount?: number },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<PostgresSchedulerAttemptAuthority | null> {
+  const result = await client.query<PostgresSchedulerAuthorityRow>(
+    `
+      SELECT ${POSTGRES_SCHEDULER_AUTHORITY_SELECT}
+      FROM ${tableName('compute_billing_jobs_v2', options)} AS job
+      JOIN ${tableName('runs', options)} AS runs ON runs.run_id = job.run_id
+      CROSS JOIN LATERAL jsonb_to_record(runs.launch_json)
+        AS launch(${POSTGRES_SCHEDULER_AUTHORITY_COLUMNS})
+      WHERE job.run_id = $1
+        AND job.status = 'settling'
+        AND job.lease_owner = $2
+        AND job.lease_expires_at > now()
+        AND ($3::integer IS NULL OR job.attempt_count = $3)
+        AND runs.status IN ('completed', 'failed', 'cancelled')
+      LIMIT 1
+    `,
+    [input.runId, input.leaseOwner, input.attemptCount ?? null],
+  );
+  return parsePostgresSchedulerAuthorityRow(result.rows[0]);
+}
+
 export async function readComputeBillingDispatchLaunchForLease(
   client: PostgresSchedulerQueryClient,
   input: { runId: string; leaseOwner: string; attemptCount?: number },
@@ -12075,7 +12212,8 @@ export async function isPostgresSchedulerRunnerProgressAttemptCurrent(
  * Bumps `heartbeat_at` on the runner's attempt row (the same liveness column
  * the worker's own state transitions maintain — no new schema) and returns the
  * play-level run status so the gateway can put cancellation on the heartbeat
- * channel. Returns null when the run does not exist.
+ * channel. Returns null when the run is missing or this attempt is no longer
+ * current while the run remains active.
  */
 export async function heartbeatPostgresSchedulerDetachedRunner(
   client: PostgresSchedulerQueryClient,
@@ -12125,7 +12263,26 @@ export async function heartbeatPostgresSchedulerDetachedRunner(
     `,
     [input.runId, input.attempt],
   );
-  return heartbeat.rows[0]?.status ?? null;
+  const status = heartbeat.rows[0]?.status;
+  if (status) return status;
+
+  // A terminal writer can commit while the UPDATE waits for its attempt lock.
+  // PostgreSQL then rechecks the changed attempt and skips it, but the UNION
+  // still reads the statement's earlier snapshot. Read terminal state with a
+  // fresh snapshot after that wait; never acknowledge a replacement's active
+  // state without renewing this exact attempt through the fence above.
+  const terminal = await client.query<{
+    status: 'completed' | 'failed' | 'cancelled';
+  }>(
+    `
+      SELECT status
+      FROM ${tableName('runs', options)}
+      WHERE run_id = $1
+        AND status IN ('completed', 'failed', 'cancelled')
+    `,
+    [input.runId],
+  );
+  return terminal.rows[0]?.status ?? null;
 }
 
 export async function claimPostgresSchedulerSignal(
@@ -12214,6 +12371,7 @@ export async function completePostgresSchedulerAttempt(
     rowOutcomes?: unknown;
     runtimeTiming?: PlayRunnerRuntimeTiming | null;
     terminalLogLines?: readonly string[] | null;
+    terminalLogContexts?: readonly (PlayLogContext | null)[] | null;
     terminalWorkCounterSegment?: PlayRunLedgerTerminalWorkCounterSegment;
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -12223,10 +12381,25 @@ export async function completePostgresSchedulerAttempt(
     content: 'full',
   });
   const resultSummary = terminalRowOutcomesSummary(input.rowOutcomes);
-  const terminalLogLines = (input.terminalLogLines ?? [])
-    .map((line) => line.trim())
-    .filter(Boolean)
+  if (
+    input.terminalLogContexts != null &&
+    input.terminalLogContexts.length !== (input.terminalLogLines ?? []).length
+  ) {
+    throw new TypeError(
+      'Terminal log contexts must align with terminal log lines.',
+    );
+  }
+  const terminalLogEntries = (input.terminalLogLines ?? [])
+    .map((line, index) => ({
+      line: line.trim(),
+      context: input.terminalLogContexts?.[index] ?? null,
+    }))
+    .filter((entry) => entry.line.length > 0)
     .slice(-LOG_TAIL_LIMIT);
+  const terminalLogLines = terminalLogEntries.map((entry) => entry.line);
+  const terminalLogContexts = terminalLogEntries.map((entry) =>
+    normalizePlayLogContext(entry.context),
+  );
   const completed = await client.query<{ run_id: string }>(
     `
       WITH completed AS (
@@ -12401,9 +12574,11 @@ export async function completePostgresSchedulerAttempt(
           'run.completed',
           jsonb_build_object(
             'output', $9::jsonb,
+            'producerAttempt', $2::integer,
             'terminalLogLines', $8::jsonb,
+            'terminalLogContexts', $11::jsonb,
             'resultSummary', $10::jsonb,
-            'terminalWorkCounterSegment', $11::jsonb
+            'terminalWorkCounterSegment', $12::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -12425,6 +12600,7 @@ export async function completePostgresSchedulerAttempt(
       JSON.stringify(terminalLogLines),
       stringifyPostgresJson(ledgerTerminalResult ?? null),
       stringifyPostgresJson(resultSummary),
+      JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(input.terminalWorkCounterSegment ?? null),
     ],
   );
@@ -12443,6 +12619,7 @@ export async function failPostgresSchedulerAttempt(
     error: string;
     result?: unknown;
     terminalLogLines?: readonly string[] | null;
+    terminalLogContexts?: readonly (PlayLogContext | null)[] | null;
     /** Refuse to overwrite an authoritative detached runner terminal that won
      * after claim. Resumable `suspended` receipts may be superseded by the
      * hard ceiling in the same fenced statement. */
@@ -12478,10 +12655,25 @@ export async function failPostgresSchedulerAttempt(
   );
   // Keep the recovery tail separate from result: large failures are represented
   // by a result reference, but their customer guidance must still be logged.
-  const terminalLogLines = (input.terminalLogLines ?? [])
-    .map((line) => line.trim())
-    .filter(Boolean)
+  if (
+    input.terminalLogContexts != null &&
+    input.terminalLogContexts.length !== (input.terminalLogLines ?? []).length
+  ) {
+    throw new TypeError(
+      'Terminal log contexts must align with terminal log lines.',
+    );
+  }
+  const terminalLogEntries = (input.terminalLogLines ?? [])
+    .map((line, index) => ({
+      line: line.trim(),
+      context: input.terminalLogContexts?.[index] ?? null,
+    }))
+    .filter((entry) => entry.line.length > 0)
     .slice(-LOG_TAIL_LIMIT);
+  const terminalLogLines = terminalLogEntries.map((entry) => entry.line);
+  const terminalLogContexts = terminalLogEntries.map((entry) =>
+    normalizePlayLogContext(entry.context),
+  );
   const failed = await client.query<{ run_id: string }>(
     `
       WITH failed AS (
@@ -12716,9 +12908,11 @@ export async function failPostgresSchedulerAttempt(
           jsonb_build_object(
             'error', $4::jsonb ->> 'message',
             'result', $8::jsonb,
+            'producerAttempt', $2::integer,
             'terminalLogLines', $12::jsonb,
+            'terminalLogContexts', $14::jsonb,
             'resultSummary', $13::jsonb,
-            'terminalWorkCounterSegment', $14::jsonb
+            'terminalWorkCounterSegment', $15::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -12743,6 +12937,7 @@ export async function failPostgresSchedulerAttempt(
       input.preserveRunnerTerminal === true,
       JSON.stringify(terminalLogLines),
       stringifyPostgresJson(resultSummary),
+      JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(terminalWorkCounterSegment ?? null),
     ],
   );
@@ -13431,37 +13626,93 @@ function boundedRunLogTailMetadata(logs: string[]): {
   return tail.length > 0 ? { tail, totalLogCount: logs.length } : null;
 }
 
-function terminalLogLinesForOutbox(
+/** Full carrier exists only in the statement that consumes its observations. */
+function runnerTerminalLogPayload(input: {
+  attempt: number;
+  result: unknown;
+  terminalProgressEvents?: readonly unknown[];
+}): Record<string, unknown> {
+  const projection = terminalLogProjectionForOutbox(
+    input.result,
+    'ctx_log_tail',
+  );
+  return {
+    producerAttempt: input.attempt,
+    terminalLogLines: projection.lines,
+    terminalLogContexts: projection.lineContexts,
+    terminalProgressEvents: input.terminalProgressEvents ?? [],
+    // Older runner envelopes conveyed these diagnostics only in tagged log
+    // text. Preserve their small structured facts before removing that text.
+    recoveredRuntimeDiagnostics:
+      input.result &&
+      typeof input.result === 'object' &&
+      'logs' in input.result &&
+      Array.isArray(input.result.logs)
+        ? input.result.logs
+            .filter((line): line is string => typeof line === 'string')
+            .map(parseCtxFetchHttpFailureDiagnostic)
+            .filter((diagnostic) => diagnostic !== null)
+            .slice(0, 16)
+        : [],
+  };
+}
+
+function terminalLogProjectionForOutbox(
   runnerResult: unknown,
   mode: PostgresSchedulerTerminalLogOutbox | undefined,
-): string[] {
+): { lines: string[]; lineContexts: Array<PlayLogContext | null> } {
   if (
     mode !== 'ctx_log_tail' ||
     !runnerResult ||
     typeof runnerResult !== 'object'
   ) {
-    return [];
+    return { lines: [], lineContexts: [] };
   }
-  const logs = (runnerResult as { logs?: unknown }).logs;
+  const result = runnerResult as {
+    logs?: unknown;
+    logContexts?: unknown;
+  };
+  const logs = result.logs;
   if (!Array.isArray(logs)) {
-    return [];
+    return { lines: [], lineContexts: [] };
   }
-  return logs
-    .filter((line): line is string => {
-      if (typeof line !== 'string') return false;
+  if (
+    result.logContexts !== undefined &&
+    (!Array.isArray(result.logContexts) ||
+      result.logContexts.length !== logs.length)
+  ) {
+    throw new TypeError('Terminal log contexts must align with runner logs.');
+  }
+  const logContexts = Array.isArray(result.logContexts)
+    ? result.logContexts
+    : undefined;
+  const entries = logs
+    .map((line, index) => {
+      if (typeof line !== 'string') return null;
       const normalized = readProvenanceTag(line).line.trim();
       // Retain bounded terminal measurement summaries alongside timestamped
       // customer/recovery lines after a detached runner has exited.
-      return (
+      const retained =
         CTX_LOG_TIMESTAMP_PREFIX_RE.test(normalized) ||
         normalized.startsWith('[runtime.failure_diagnostic] ') ||
         normalized.startsWith('[runtime.phase_summary] ') ||
         normalized.startsWith('[runtime.logs] ') ||
-        normalized.startsWith('[runtime.log_transport] ')
-      );
+        normalized.startsWith('[runtime.log_transport] ');
+      if (!retained) return null;
+      return {
+        line: line.trim(),
+        context: normalizePlayLogContext(logContexts?.[index]),
+      };
     })
-    .map((line) => line.trim())
+    .filter(
+      (entry): entry is { line: string; context: PlayLogContext | null } =>
+        entry !== null,
+    )
     .slice(-LOG_TAIL_LIMIT);
+  return {
+    lines: entries.map((entry) => entry.line),
+    lineContexts: entries.map((entry) => entry.context),
+  };
 }
 
 export function attachRunnerWorkProgressMetadata(
@@ -13694,6 +13945,10 @@ export async function executePostgresSchedulerClaim(
             { logMetadata: options.completionLogMetadata ?? 'attach' },
           )
         : output;
+    const terminalLogProjection = terminalLogProjectionForOutbox(
+      output,
+      options.terminalLogOutbox,
+    );
     const completed = await completePostgresSchedulerAttempt(
       client,
       {
@@ -13703,14 +13958,12 @@ export async function executePostgresSchedulerClaim(
         output: terminalOutput,
         rowOutcomes: (output as { rowOutcomes?: unknown } | null)?.rowOutcomes,
         runtimeTiming: extractRunnerRuntimeTiming(output),
+        terminalLogLines: terminalLogProjection.lines,
+        terminalLogContexts: terminalLogProjection.lineContexts,
         terminalWorkCounterSegment: terminalWorkCounterSegmentFromRunnerResult(
           output,
           claim.attempt,
         ),
-        terminalLogLines: terminalLogLinesForOutbox(
-          output,
-          options.terminalLogOutbox,
-        ),
       },
       options,
     );
@@ -13754,6 +14007,10 @@ export async function executePostgresSchedulerClaim(
       checkpoint: null,
       tableNamespace: null,
     };
+    const terminalLogProjection = terminalLogProjectionForOutbox(
+      terminalFailureResult,
+      options.terminalLogOutbox,
+    );
     const failed = await failPostgresSchedulerAttempt(
       client,
       {
@@ -13762,10 +14019,8 @@ export async function executePostgresSchedulerClaim(
         leaseToken: claim.leaseToken,
         error: message,
         result: terminalFailureResult,
-        terminalLogLines: terminalLogLinesForOutbox(
-          terminalFailureResult,
-          options.terminalLogOutbox,
-        ),
+        terminalLogLines: terminalLogProjection.lines,
+        terminalLogContexts: terminalLogProjection.lineContexts,
         sandboxCrashDiagnostic: options.sandboxCrashDiagnostic,
       },
       options,
@@ -17032,9 +17287,101 @@ export async function listPostgresSchedulerDeliveredOutboxRetentionCandidates(
  */
 export async function purgePostgresSchedulerDeliveredOutboxRetentionBatch(
   client: PostgresSchedulerQueryClient,
-  input: { olderThan: Date; limit?: number },
+  input: {
+    olderThan: Date;
+    logBodiesOlderThan?: Date;
+    limit?: number;
+  },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<PostgresSchedulerDeliveredOutboxRow[]> {
+  if (input.logBodiesOlderThan) {
+    const logCutoff = input.logBodiesOlderThan.getTime();
+    if (
+      !Number.isFinite(logCutoff) ||
+      logCutoff > Date.now() - 60 * 60 * 1_000
+    ) {
+      throw new TypeError(
+        'Delivered outbox log-body cleanup cutoff must be at least one hour old.',
+      );
+    }
+    const limit = normalizeOutboxRetentionLimit(input.limit);
+    await client.query(
+      `WITH candidates AS (
+         SELECT event_id
+           FROM ${tableName('outbox', options)} AS outbox
+          WHERE delivered_at IS NOT NULL
+            AND failed_at IS NULL
+            AND delivered_at < $1::timestamptz
+            AND (
+              (event_type = 'run.events'
+               AND jsonb_typeof(payload_json->'events') = 'array'
+               AND EXISTS (
+                 SELECT 1
+                   FROM jsonb_array_elements(
+                     CASE WHEN jsonb_typeof(payload_json->'events') = 'array'
+                       THEN payload_json->'events' ELSE '[]'::jsonb END
+                 ) AS item
+                  WHERE item->>'type' = 'log.appended'
+                    AND (item ? 'lines' OR item ? 'lineContexts')
+               ))
+              OR (event_type IN ('run.completed', 'run.failed')
+                  AND (
+                    payload_json ? 'terminalLogLines'
+                    OR (jsonb_typeof(payload_json->'terminalProgressEvents') = 'array'
+                        AND EXISTS (
+                          SELECT 1
+                            FROM jsonb_array_elements(
+                              CASE WHEN jsonb_typeof(payload_json->'terminalProgressEvents') = 'array'
+                                THEN payload_json->'terminalProgressEvents' ELSE '[]'::jsonb END
+                            ) AS item
+                           WHERE item->>'type' = 'log.appended'
+                             AND (item ? 'lines' OR item ? 'lineContexts')
+                        ))
+                  ))
+            )
+          ORDER BY delivered_at ASC, event_id ASC
+          LIMIT $2::integer
+          FOR UPDATE SKIP LOCKED
+       )
+       UPDATE ${tableName('outbox', options)} AS outbox
+          SET payload_json = CASE
+            WHEN outbox.event_type = 'run.events' THEN jsonb_set(
+              outbox.payload_json,
+              '{events}',
+              (SELECT jsonb_agg(
+                 CASE WHEN item.value->>'type' = 'log.appended'
+                   THEN item.value - 'lines' - 'lineContexts'
+                   ELSE item.value
+                 END ORDER BY item.ordinality
+               )
+                 FROM jsonb_array_elements(
+                      CASE WHEN jsonb_typeof(outbox.payload_json->'events') = 'array'
+                        THEN outbox.payload_json->'events' ELSE '[]'::jsonb END
+                    )
+                      WITH ORDINALITY AS item(value, ordinality)),
+              false
+            )
+            WHEN jsonb_typeof(outbox.payload_json->'terminalProgressEvents') = 'array'
+              THEN jsonb_set(
+                outbox.payload_json - 'terminalLogLines' - 'terminalLogContexts',
+                '{terminalProgressEvents}',
+                coalesce((SELECT jsonb_agg(
+                   CASE WHEN item.value->>'type' = 'log.appended'
+                     THEN item.value - 'lines' - 'lineContexts'
+                     ELSE item.value
+                   END ORDER BY item.ordinality
+                 )
+                   FROM jsonb_array_elements(outbox.payload_json->'terminalProgressEvents')
+                     WITH ORDINALITY AS item(value, ordinality)), '[]'::jsonb),
+                false
+              )
+            ELSE outbox.payload_json - 'terminalLogLines' - 'terminalLogContexts'
+          END
+         FROM candidates
+        WHERE outbox.event_id = candidates.event_id`,
+      [input.logBodiesOlderThan.toISOString(), limit],
+    );
+  }
   const result = await client.query<{
     event_id: string;
     run_id: string;
@@ -17317,9 +17664,11 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
   const occurredAt = event.createdAt.getTime();
   if (event.eventType === 'run.events') {
     const events = payloadField(event.payload, 'events');
+    const logsStored =
+      payloadField(event.payload, 'logBodyStore') === 'planet_scale';
     if (
       !Array.isArray(events) ||
-      events.length === 0 ||
+      (events.length === 0 && !logsStored) ||
       events.some(
         (value) =>
           !recordPayload(value) ||
@@ -17364,6 +17713,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       event.runId,
     );
     const lines = stringArrayPayloadField(event.payload, 'terminalLogLines');
+    const lineContexts = terminalLogContextsPayloadField(event.payload, lines);
     const resultSummary = payloadField(event.payload, 'resultSummary');
     return [
       ...progressEvents.map(normalizeOutboxIngressPreview),
@@ -17376,6 +17726,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
               occurredAt,
               source: 'worker',
               lines,
+              ...(lineContexts ? { lineContexts } : {}),
             } as PlayRunLedgerEvent,
           ]),
       {
@@ -17404,6 +17755,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       event.runId,
     );
     const lines = stringArrayPayloadField(event.payload, 'terminalLogLines');
+    const lineContexts = terminalLogContextsPayloadField(event.payload, lines);
     const result = terminalRunResultForLedger(
       payloadField(event.payload, 'result'),
     );
@@ -17419,6 +17771,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
               occurredAt,
               source: 'worker',
               lines,
+              ...(lineContexts ? { lineContexts } : {}),
             } as PlayRunLedgerEvent,
           ]),
       {
@@ -18236,6 +18589,9 @@ async function projectPostgresSchedulerCreatedEvent(
     runtimeBackend: value('runtimeBackend'),
     schedulerBackend: value('schedulerBackend'),
     schedulerSchema: value('schedulerSchema'),
+    ...(value('runLogStore') === 'planet_scale'
+      ? { runLogStore: 'planet_scale' as const }
+      : {}),
     executionProfile: value('executionProfile'),
     runtimeReleaseId: value('runtimeReleaseId'),
     runtimeDeployVersion: value('runtimeDeployVersion'),
@@ -18666,6 +19022,20 @@ function stringArrayPayloadField(payload: unknown, key: string): string[] {
     : [];
 }
 
+function terminalLogContextsPayloadField(
+  payload: unknown,
+  lines: readonly string[],
+): Array<PlayLogContext | null> | null {
+  const value = payloadField(payload, 'terminalLogContexts');
+  if (value === undefined) return null;
+  if (!Array.isArray(value) || value.length !== lines.length) {
+    throw new TypeError(
+      'Terminal log contexts must align with terminal log lines.',
+    );
+  }
+  return value.map(normalizePlayLogContext);
+}
+
 function ledgerEventsPayloadField(
   payload: unknown,
   key: string,