deepline 0.3.248 → 0.3.250

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.248',
+  version: '0.3.250',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/play-runtime/child-execution-strategy.ts

@@ -1,5 +1,7 @@
 import {
   flattenStaticPipeline,
+  getCompiledPipelineSubsteps,
+  type PlayStaticSubstep,
   type PlayStaticPipeline,
 } from '../plays/static-pipeline';
 import type { PlayCallExecution } from './play-call-execution';
@@ -21,6 +23,8 @@ export type CtxRunPlayInlineOnlyReason =
   | 'dataset_child'
   | 'event_wait_child'
   | 'suspending_child'
+  | 'row_sleep'
+  | 'concurrent_sleep'
   | 'explicit_timeout'
   | 'explicit_child_workflow';
 
@@ -46,7 +50,9 @@ export function ctxRunPlayInlineOnlyMessage(
     missing_static_contract: 'its static contract could not be resolved',
     dataset_child: 'it uses ctx.dataset(), ctx.csv(), or a Runtime Sheet',
     event_wait_child: 'it waits for an event',
-    suspending_child: 'it attempted to suspend the parent execution',
+    suspending_child: 'it attempted an unsupported parent suspension',
+    row_sleep: 'it calls ctx.sleep from a Dataset column resolver',
+    concurrent_sleep: 'it calls ctx.sleep while sibling inline calls overlap',
     explicit_timeout: 'it sets an explicit timeout',
     explicit_child_workflow: 'it requests execution: "child-workflow"',
   };
@@ -57,6 +63,10 @@ export function ctxRunPlayInlineOnlyMessage(
       'Trigger it as a top-level play. Event waits need their own run lifecycle and cannot be awaited through ctx.runPlay().',
     suspending_child:
       'Trigger it as a top-level play. Work that can suspend needs its own run lifecycle and cannot be awaited through ctx.runPlay().',
+    row_sleep:
+      'Sleep before or after Dataset.run(), or launch a scalar waiting Play with rowCtx.runPlayAsync and put its follow-up work there. runPlayAsync returns a Run reference, not the child result.',
+    concurrent_sleep:
+      'Await sleeping inline children sequentially outside Dataset callbacks, or use ctx.runPlayAsync for independent waits. A sequential sleep parks and replays the parent Run.',
     missing_static_contract:
       'Use a published play with a resolvable static contract, or move lifecycle-owning work into a top-level play.',
     explicit_timeout:
@@ -72,7 +82,8 @@ export function ctxRunPlayInlineOnlyMessage(
 
 /**
  * Resolve an authored child contract. Any shape that would need a second run,
- * durable scheduler state, or a suspension is rejected before invocation.
+ * independent scheduler state is rejected before invocation. Sequential authored
+ * sleep may suspend the existing parent Run.
  */
 export function resolveChildExecutionStrategy(input: {
   pipeline: PlayStaticPipeline | null | undefined;
@@ -142,3 +153,52 @@ export function resolveChildExecutionStrategy(input: {
     reason: input.execution === 'inline' ? 'explicit_inline' : 'scalar_child',
   };
 }
+
+/** Authored sleep may park one sequential inline chain, never a row or sibling fanout. */
+export function assertInlineChildSleepPlacement(input: {
+  childPlayName: string;
+  rowScoped: boolean;
+  concurrent: boolean;
+}): void {
+  if (input.rowScoped || input.concurrent) {
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(
+        input.childPlayName,
+        input.rowScoped ? 'row_sleep' : 'concurrent_sleep',
+      ),
+    );
+  }
+}
+
+/** Transitive authored sleep facts; independent launches do not suspend their caller. */
+export function findInlineChildSleep(
+  pipeline: PlayStaticPipeline | null | undefined,
+  seen = new Set<PlayStaticPipeline>(),
+): {
+  path: string[];
+  source: NonNullable<PlayStaticPipeline['authoredSleep']>;
+} | null {
+  if (!pipeline || seen.has(pipeline)) return null;
+  seen.add(pipeline);
+  if (pipeline.authoredSleep)
+    return { path: [], source: pipeline.authoredSleep };
+  function visit(
+    steps: PlayStaticSubstep[],
+  ): ReturnType<typeof findInlineChildSleep> {
+    for (const step of steps) {
+      if (step.type === 'play_call') {
+        const found = findInlineChildSleep(step.pipeline, seen);
+        if (found) return { ...found, path: [step.playId, ...found.path] };
+      } else if (
+        step.type === 'dataset' ||
+        step.type === 'step_suite' ||
+        step.type === 'control_flow'
+      ) {
+        const found = visit(step.steps ?? []);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return visit(getCompiledPipelineSubsteps(pipeline));
+}

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -481,6 +481,7 @@ import { executionGatewayDecodedBodyBytes } from './execution-gateway-response-s
 import {
   ctxRunPlayInlineOnlyMessage,
   resolveChildExecutionStrategy,
+  assertInlineChildSleepPlacement,
 } from './child-execution-strategy';
 
 type ResolvedPlayExecutor = (
@@ -531,6 +532,7 @@ type RowResolverGapTracker = {
   openedAtMs: number | null;
 };
 type InlineCompositionStore = {
+  invocationPath: readonly symbol[];
   context: PlayContextImpl;
   executionScope: RunExecutionScope;
   governor: PlayExecutionGovernor;
@@ -2758,6 +2760,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    */
   private sleepBoundaryIndexByScope = new Map<string, number>();
   private sleepBoundaryIndex = 0;
+  private readonly activeInlineInvocations = new Set<symbol>();
   private nextDocflowInvocationSequence = 0;
   /**
    * Whether this run captures the docflow trace at all (ADR 0019), decided at
@@ -14105,8 +14108,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     input: Record<string, unknown>,
     options?: PlayCallOptions,
   ): Promise<TOutput> {
-    if (!rowContext.getStore()) this.assertRowAdmissionOpen();
-    this.assertNoPendingDurableSuspension();
     if (
       arguments.length === 3 &&
       typeof playRef === 'object' &&
@@ -14116,6 +14117,36 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         'ctx.runPlay(...) signature is ctx.runPlay(key, playRef, input, { description }). Add a stable call key as the first argument.',
       );
     }
+    const invocation = Symbol('inline-play');
+    const invocationPath = [
+      ...(this.activeInlineComposition?.invocationPath ?? []),
+      invocation,
+    ];
+    // Register before resolver/governor awaits so Promise.all siblings cannot
+    // slip through while one sibling is still preparing its artifact.
+    this.activeInlineInvocations.add(invocation);
+    try {
+      return await this.runInlinePlay<TOutput>(
+        key,
+        playRef,
+        input,
+        options,
+        invocationPath,
+      );
+    } finally {
+      this.activeInlineInvocations.delete(invocation);
+    }
+  }
+
+  private async runInlinePlay<TOutput>(
+    key: string,
+    playRef: string | { playName?: string; name?: string },
+    input: Record<string, unknown>,
+    options: PlayCallOptions | undefined,
+    invocationPath: readonly symbol[],
+  ): Promise<TOutput> {
+    if (!rowContext.getStore()) this.assertRowAdmissionOpen();
+    this.assertNoPendingDurableSuspension();
     const resolvedName = resolvePlayReferenceName(playRef);
 
     if (!resolvedName.trim()) {
@@ -14230,6 +14261,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         const result = await inlineCompositionContext.run(
           {
             context: this,
+            invocationPath,
             executionScope: childExecutionScope,
             governor: inlineChildGovernor,
             playName: resolvedName,
@@ -14749,7 +14781,19 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   async sleep(ms: number): Promise<void> {
     if (!rowContext.getStore()) this.assertRowAdmissionOpen();
     this.assertNoPendingDurableSuspension();
-    this.assertInlineChildContract('suspending_child');
+    const composition = this.activeInlineComposition;
+    if (composition) {
+      assertInlineChildSleepPlacement({
+        childPlayName: composition.playName,
+        rowScoped: Boolean(rowContext.getStore()),
+        concurrent:
+          this.pureMapExecutionActive ||
+          this.activeMapCellMeta !== null ||
+          [...this.activeInlineInvocations].some(
+            (invocation) => !composition.invocationPath.includes(invocation),
+          ),
+      });
+    }
     const delayMs =
       this.currentRuntimeSemantics.validation === 'strict'
         ? (validatePlayAuthoringField('ctx.sleep.ms', ms), ms)
@@ -19188,6 +19232,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             if (
               transportAttempt < TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS &&
               (input.knownNotDispatched === true ||
+                usesDurableInvocationFence ||
                 ambiguousTransportReplayAllowed ||
                 fixtureReplaySafe)
             ) {
@@ -20126,6 +20171,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               // this exact body deadline caused the abort.
               const transportReplaySafe =
                 !ambiguousDispatchedFailure ||
+                usesDurableInvocationFence ||
                 ambiguousTransportReplayAllowed ||
                 fixtureReplaySafe;
               if (!transportReplaySafe) {

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/job.ts

@@ -65,6 +65,7 @@ export function createPlayRunTerminalJob(
         runId: input.runId,
         attempt: input.attempt,
         result: input.result,
+        terminalProgressEvents: input.terminalProgressEvents,
       });
       if (!recorded) {
         return { kind: 'not_found_or_fence_rejected' };

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/ports.ts

@@ -38,6 +38,7 @@ export type CompatibilityTerminalRecorder = {
     runId: string;
     attempt: number;
     result: unknown;
+    terminalProgressEvents?: readonly unknown[];
   }): Promise<boolean>;
 };
 

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

@@ -236,7 +236,8 @@ export type PostgresSchedulerProgressReporter = {
 };
 
 export type PostgresSchedulerDurableLogMode =
-  'progress_reporter' | 'direct_worker';
+  | 'progress_reporter'
+  | 'direct_worker';
 
 function shouldPublishDurableLogEvent(
   mode: PostgresSchedulerDurableLogMode,
@@ -418,7 +419,8 @@ export function createPostgresSchedulerProgressReporter(input: {
   let workCounters: RuntimeStatusUpdate['workCounters'];
   let workCountersDirty = false;
   let lastFlushAt = 0;
-  let delayedFlushTimer: ReturnType<typeof setTimeout> | null = null;
+  let lastProgressFlushAt = 0;
+  let deferredFlushTimer: ReturnType<typeof setTimeout> | null = null;
   let totalRows = 0;
   let activeMapNodeId: string | null = null;
   let pendingDatasetLifecycleEvents: Array<
@@ -431,6 +433,7 @@ export function createPostgresSchedulerProgressReporter(input: {
 
   type ProgressFlushRequest = {
     status: 'running' | 'completed' | 'failed';
+    force: boolean;
     required: boolean;
     terminalLogReplay: TerminalLogReplayPayload | null;
     waiters: Array<{
@@ -451,6 +454,7 @@ export function createPostgresSchedulerProgressReporter(input: {
       next.status !== 'running'
         ? next.status
         : (current?.status ?? next.status),
+    force: next.force || current?.force === true,
     required: next.required || current?.required === true,
     terminalLogReplay:
       next.terminalLogReplay ?? current?.terminalLogReplay ?? null,
@@ -487,18 +491,32 @@ export function createPostgresSchedulerProgressReporter(input: {
           const request = pendingProgressUpload;
           pendingProgressUpload = null;
 
-          const nextProgress = { ...liveNodeProgress };
+          // Customer log latency is independent of row-count progress sampling.
+          const includeProgress =
+            request.force ||
+            request.required ||
+            request.status !== 'running' ||
+            Date.now() - lastProgressFlushAt >=
+              getAdaptiveRunEventIntervalMs(totalRows);
+          const nextProgress = includeProgress
+            ? { ...liveNodeProgress }
+            : undefined;
           const nextLogs = liveLogs.slice();
           const nextLogContexts = liveLogContexts.slice();
           const nextLogTotalCount = liveLogsTotalCount;
-          const nextDatasetLifecycleEvents = pendingDatasetLifecycleEvents;
-          pendingDatasetLifecycleEvents = [];
-          const nextActivityObservations = [
-            ...pendingActivityObservations.values(),
-          ];
+          const nextDatasetLifecycleEvents = includeProgress
+            ? pendingDatasetLifecycleEvents
+            : [];
+          const nextActivityObservations = includeProgress
+            ? [...pendingActivityObservations.values()]
+            : [];
           const nextWorkCounters = workCountersDirty ? workCounters : undefined;
-          pendingActivityObservations.clear();
-          liveNodeProgressDirty = false;
+          if (includeProgress) {
+            pendingDatasetLifecycleEvents = [];
+            pendingActivityObservations.clear();
+            liveNodeProgressDirty = false;
+            lastProgressFlushAt = Date.now();
+          }
           liveLogsDirty = false;
           workCountersDirty = false;
 
@@ -561,30 +579,31 @@ export function createPostgresSchedulerProgressReporter(input: {
       pendingDatasetLifecycleEvents.length === 0 &&
       pendingActivityObservations.size === 0
     ) {
-      if (delayedFlushTimer) {
-        clearTimeout(delayedFlushTimer);
-        delayedFlushTimer = null;
+      if (deferredFlushTimer) {
+        clearTimeout(deferredFlushTimer);
+        deferredFlushTimer = null;
       }
       return activeProgressUpload ?? Promise.resolve();
     }
     const now = Date.now();
-    const intervalMs = getAdaptiveRunEventIntervalMs(totalRows);
-    if (!force && now - lastFlushAt < intervalMs) {
-      if (!delayedFlushTimer) {
-        delayedFlushTimer = setTimeout(
-          () => {
-            delayedFlushTimer = null;
-            void flush().catch(() => undefined);
-          },
-          Math.max(1, intervalMs - (now - lastFlushAt)),
-        );
-        delayedFlushTimer.unref?.();
-      }
+    const interval = liveLogsDirty
+      ? 1_500
+      : getAdaptiveRunEventIntervalMs(totalRows);
+    const remaining = interval - (now - lastFlushAt);
+    if (!force && remaining > 0) {
+      // Quiet runs must flush too: waiting for another event can retain one
+      // customer log until a long-running operation finally completes.
+      if (deferredFlushTimer !== null) clearTimeout(deferredFlushTimer);
+      deferredFlushTimer = setTimeout(() => {
+        deferredFlushTimer = null;
+        void flush().catch(() => undefined);
+      }, remaining);
+      deferredFlushTimer.unref?.();
       return activeProgressUpload ?? Promise.resolve();
     }
-    if (delayedFlushTimer) {
-      clearTimeout(delayedFlushTimer);
-      delayedFlushTimer = null;
+    if (deferredFlushTimer !== null) {
+      clearTimeout(deferredFlushTimer);
+      deferredFlushTimer = null;
     }
     lastFlushAt = now;
     const requested = new Promise<void>((resolve, reject) => {
@@ -592,6 +611,7 @@ export function createPostgresSchedulerProgressReporter(input: {
         pendingProgressUpload,
         {
           status,
+          force,
           required,
           terminalLogReplay: input?.terminalLogReplay ?? null,
         },
@@ -1411,7 +1431,8 @@ export function createPostgresSchedulerProgressReporter(input: {
   ): Promise<void> => {
     const terminalCounters = runtimeWorkCountersFromStats(result?.stats);
     const terminalSegment = result?.stats?.runtimeWorkCounterSegment as
-      { invocationSeq?: unknown; segmentId?: unknown } | undefined;
+      | { invocationSeq?: unknown; segmentId?: unknown }
+      | undefined;
     if (
       terminalCounters &&
       terminalCounters.provider429s !== undefined &&

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

@@ -307,7 +307,8 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // 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.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 48;
+// 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 =
@@ -938,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'>,
@@ -4925,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),
@@ -4937,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
@@ -4945,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),
@@ -4993,13 +5010,7 @@ async function submitPostgresSchedulerRunTransaction(
             'runtimeBackend', $6::text,
             'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
             'schedulerSchema', COALESCE(launch_payload.launch_json ->> 'schedulerSchema', '${schemaName(options)}'),
-            'runLogStore', CASE WHEN EXISTS (
-              SELECT 1 FROM pg_proc AS proc
-              JOIN pg_namespace AS namespace ON namespace.oid = proc.pronamespace
-              WHERE namespace.nspname = '${schemaName(options)}'
-                AND proc.proname = 'search_outbox_event'
-                AND obj_description(proc.oid, 'pg_proc') = '${RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER}'
-            ) THEN 'planet_scale' END,
+            'runLogStore', run_insert.run_log_store,
             'executionProfile', launch_payload.launch_json ->> 'executionProfile',
             'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
             'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
@@ -6001,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',
@@ -6022,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
@@ -6074,13 +6086,7 @@ export async function firePostgresSchedulerCronSchedule(
             'runtimeBackend', launch_payload.launch_json ->> 'runtimeBackend',
             'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
             'schedulerSchema', COALESCE(launch_payload.launch_json ->> 'schedulerSchema', '${schemaName(options)}'),
-            'runLogStore', CASE WHEN EXISTS (
-              SELECT 1 FROM pg_proc AS proc
-              JOIN pg_namespace AS namespace ON namespace.oid = proc.pronamespace
-              WHERE namespace.nspname = '${schemaName(options)}'
-                AND proc.proname = 'search_outbox_event'
-                AND obj_description(proc.oid, 'pg_proc') = '${RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER}'
-            ) THEN 'planet_scale' END,
+            'runLogStore', run_insert.run_log_store,
             'executionProfile', launch_payload.launch_json ->> 'executionProfile',
             'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
             'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
@@ -9718,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
@@ -9785,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;
 }
@@ -9919,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
@@ -9993,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
@@ -10139,9 +10168,14 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
           'run.completed',
           jsonb_build_object(
             'output', $6::jsonb,
+            'producerAttempt', $2::integer,
             'terminalLogLines', $7::jsonb,
             'terminalLogContexts', $17::jsonb,
-            'terminalProgressEvents', $8::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', $18::jsonb
           ),
@@ -10180,6 +10214,7 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
       stringifyPostgresJson(resultSummary),
       JSON.stringify(terminalLogProjection.lineContexts),
       stringifyPostgresJson(terminalWorkCounterSegment ?? null),
+      stringifyPostgresJson(runnerTerminalLogPayload(input)),
     ],
   );
   if (completed.rows.length > 0) return 'completed';
@@ -12539,6 +12574,7 @@ export async function completePostgresSchedulerAttempt(
           'run.completed',
           jsonb_build_object(
             'output', $9::jsonb,
+            'producerAttempt', $2::integer,
             'terminalLogLines', $8::jsonb,
             'terminalLogContexts', $11::jsonb,
             'resultSummary', $10::jsonb,
@@ -12872,6 +12908,7 @@ 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,
@@ -13589,6 +13626,37 @@ function boundedRunLogTailMetadata(logs: string[]): {
   return tail.length > 0 ? { tail, totalLogCount: logs.length } : null;
 }
 
+/** 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,