deepline 0.3.289 → 0.3.291

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -17,6 +17,9 @@ export const DEFAULT_ADVISORY_PROVIDER_MAX_RPS = 100;
 /** Cold-start rate for an unknown provider bucket shared across a fleet key. */
 export const DEFAULT_UNKNOWN_PROVIDER_COLD_START_RPS = 10;
 
+/** Learned-rate floor, independent of the unknown provider's starting guess. */
+export const DEFAULT_UNKNOWN_PROVIDER_MIN_RPS = 2;
+
 /** AIMD state cooldown cap; provider Retry-After holds remain uncapped. */
 export const PROVIDER_AIMD_COOLDOWN_CAP_MS = 45 * 60 * 1_000;
 

package/dist/bundling-sources/shared_libs/play-runtime/launch-identity.ts

@@ -52,6 +52,7 @@ export const PLAY_LAUNCH_ENVELOPE_FIELD_ROLES: {
   playId: 'detail',
   schedulerSchema: 'detail',
   requiresRunCreatedProjection: 'detail',
+  runtimeLogIdentity: 'detail',
   runtimeArtifact: 'detail',
   runtimeProtocolVersion: 'detail',
   staticPipeline: 'detail',

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

@@ -5,6 +5,42 @@
 export type PlayLogContextValue = string | number | boolean;
 export type PlayLogContext = Readonly<Record<string, PlayLogContextValue>>;
 
+/** Producer-owned facts for one line, separate from authored context. */
+export type PlayLogMetadata = {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  occurredAt: number;
+  stepId?: string;
+};
+
+export function normalizePlayLogMetadata(
+  value: unknown,
+): PlayLogMetadata | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('Run log metadata must be an object.');
+  }
+  const entry = value as Record<string, unknown>;
+  if (
+    !['debug', 'info', 'warn', 'error'].includes(String(entry.level)) ||
+    typeof entry.occurredAt !== 'number' ||
+    !Number.isSafeInteger(entry.occurredAt) ||
+    entry.occurredAt <= 0 ||
+    (entry.stepId !== undefined &&
+      (typeof entry.stepId !== 'string' ||
+        !entry.stepId.trim() ||
+        entry.stepId.length > 256))
+  ) {
+    throw new TypeError(
+      'Run log metadata requires a severity, timestamp and optional step ID.',
+    );
+  }
+  return {
+    level: entry.level as PlayLogMetadata['level'],
+    occurredAt: entry.occurredAt,
+    ...(typeof entry.stepId === 'string' ? { stepId: entry.stepId } : {}),
+  };
+}
+
 export const PLAY_LOG_CONTEXT_LIMITS = {
   fields: 8,
   keyBytes: 64,

package/dist/bundling-sources/shared_libs/play-runtime/log-provenance.ts

@@ -117,6 +117,23 @@ export const LOG_PROVENANCE_POLICY: Record<
   receipt: { watch: false, ui: false, debug: true },
 };
 
+/**
+ * Shared retention rule for the detached runner's positional log channel.
+ * Sender offsets and gateway persistence must count the same events. Host
+ * lifecycle output stays in worker logs; bounded performance markers also
+ * reach the durable stream for dispatcher throughput diagnostics.
+ */
+export function isDurableDirectRunnerLog(event: {
+  source?: unknown;
+  line?: unknown;
+}): boolean {
+  return (
+    typeof event.line === 'string' &&
+    event.line.length > 0 &&
+    (event.source !== 'worker' || event.line.startsWith('[perf-trace] '))
+  );
+}
+
 /** True when a line of the given provenance should render on the surface. */
 export function logProvenanceReaches(
   provenance: LogProvenance,
@@ -324,7 +341,8 @@ export function classifyLegacyLogLine(line: string): LogProvenance {
 
   // Scheduler / sandbox / worker internals.
   if (
-    /^\[perf\] runtime (?:map|state)\b/i.test(message) ||
+    /^\[perf\]/i.test(message) ||
+    /^\[runtime\.(?:phase_summary|logs|log_transport)\]/i.test(message) ||
     /\[worker\] picked up run\b/.test(message) ||
     /\[worker\] heartbeat\b/.test(message) ||
     /\[worker\] progress completedRows=\d+ totalRows=\d+ rowUpdates=\d+/.test(

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/attempts/worker-terminal-projection.ts

@@ -39,10 +39,11 @@ export type PlayRunAttemptWorkerTerminalProjectionPorts = {
 };
 
 /**
- * Builds the worker projection Module. The ordering is its Interface:
- * reconcile durable truth, release failed-attempt leases, then enqueue
- * best-effort progress/outbox projection. A stale terminal fence observes the
- * winner only; it never emits a second projection sequence.
+ * Request delivery of the already committed terminal before awaited
+ * reconciliation or cleanup can delay it. Progress finalization still follows
+ * durable-truth reconciliation and failed-attempt lease release. A stale
+ * terminal fence observes the winner only; it never emits a second projection
+ * sequence.
  */
 export function createPlayRunAttemptWorkerTerminalProjection(
   ports: PlayRunAttemptWorkerTerminalProjectionPorts,
@@ -50,6 +51,7 @@ export function createPlayRunAttemptWorkerTerminalProjection(
   return {
     observeFenceLost: ports.observeFenceLost,
     async projectCommitted(input) {
+      ports.requestTerminalProjection({ terminal: input.terminal });
       await ports.reconcileTerminalTruth(input);
       if (input.terminal.status === 'failed') {
         await ports.releaseFailedAttempt({
@@ -58,7 +60,6 @@ export function createPlayRunAttemptWorkerTerminalProjection(
         });
       }
       ports.queueProgressFinalization(input);
-      ports.requestTerminalProjection({ terminal: input.terminal });
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/play-runtime-batching-registry.ts

@@ -6,6 +6,7 @@ import { fullenrichBatchStrategies } from './fullenrich-batching';
 import { opensosdataBatchStrategies } from './opensosdata-batching';
 import { zerobounceBatchStrategies } from './zerobounce-batching';
 import { testAsyncBatchStrategies } from './test-async-batching';
+import { testAdmissionBatchStrategies } from './test-admission-batching';
 
 export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
   string,
@@ -17,6 +18,7 @@ export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
   ...fullenrichBatchStrategies,
   ...opensosdataBatchStrategies,
   ...testAsyncBatchStrategies,
+  ...testAdmissionBatchStrategies,
   ...zerobounceBatchStrategies,
 };
 

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

@@ -14,7 +14,7 @@ import type {
 import type { PlayExecutionSuspension } from './suspension';
 import type { PlayStaticPipeline } from '../plays/static-pipeline';
 import type { PlayLiveEventSource } from './live-events';
-import type { PlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
 import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
@@ -185,6 +185,8 @@ export type PlayRunnerBudgetChargeResult = {
 };
 
 export interface PlayRunnerContextConfig extends RetainedPipelineCarrier {
+  /** Reader-first logging cutover, frozen at admission; absent stays legacy. */
+  runtimeLogIdentity?: 'origin';
   executorToken?: string;
   baseUrl?: string;
   /**
@@ -320,8 +322,11 @@ export type PlayRunnerLogEvent = {
   at: string;
   source: PlayLiveEventSource;
   line: string;
+  /** Origin identity, preserved across live and terminal transports. */
+  entryId?: string;
   /** Search-only context; omitted before the compatible Convex projection. */
   context?: PlayLogContext;
+  metadata?: PlayLogMetadata;
 };
 
 export type PlayRunnerEvent =
@@ -411,8 +416,10 @@ export type PlayRunnerResult =
       outputRowCount?: number;
       rowOutcomes?: PlayRunnerRowOutcomeSummary;
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -426,8 +433,10 @@ export type PlayRunnerResult =
       status: 'suspended';
       suspension: PlayExecutionSuspension;
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -442,8 +451,10 @@ export type PlayRunnerResult =
       error: string;
       errors?: PlayRunFailureDetails[];
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint?: PlayCheckpoint | null;

package/dist/bundling-sources/shared_libs/play-runtime/run-event-catalog.ts

@@ -387,6 +387,7 @@ export const RUN_SCHEDULER_OUTBOX_EVENT_TYPE = {
   runCancelled: RUN_EVENT_KIND.runCancelled,
   runEvents: 'run.events',
   runnerLogs: 'runner.logs',
+  receiptEvent: 'receipt.event',
   runWaitTimeout: 'run.wait_timeout',
 } as const;
 
@@ -549,6 +550,7 @@ export const RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL = {
   runCancelled: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled),
   runEvents: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents),
   runnerLogs: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runnerLogs),
+  receiptEvent: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.receiptEvent),
   runWaitTimeout: sqlStringLiteral(
     RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout,
   ),

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger-event-transport.ts

@@ -1,6 +1,6 @@
+import { normalizeRunLogIds } from './run-log-buffer';
 import { RUN_EVENT_KIND } from './run-event-catalog';
 import type { PlayRunLedgerIngressEvent } from './run-ledger';
-import type { PlayLogContext } from './log-context';
 import type { RunLedgerProjectionChunk } from './run-ledger-projection-contract';
 
 const APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES = 128 * 1024;
@@ -29,25 +29,35 @@ function splitRunEventForAppRuntime(
     : [];
   if (eventType !== RUN_EVENT_KIND.logAppended || lines.length === 0)
     return [event];
-  const payloadOwnsLineContexts =
-    payload !== null && Object.hasOwn(payload, 'lineContexts');
-  const eventOwnsLineContexts = Object.hasOwn(event, 'lineContexts');
-  if (payloadOwnsLineContexts && eventOwnsLineContexts) {
-    throw new TypeError('Run log contexts must have one event owner.');
-  }
-  const rawLineContexts = payloadOwnsLineContexts
-    ? payload?.lineContexts
-    : event.lineContexts;
-  const hasLineContexts = payloadOwnsLineContexts || eventOwnsLineContexts;
-  if (
-    hasLineContexts &&
-    (!Array.isArray(rawLineContexts) || rawLineContexts.length !== lines.length)
-  ) {
-    throw new TypeError('Run log contexts must align with their lines.');
-  }
-  const lineContexts = hasLineContexts
-    ? (rawLineContexts as Array<PlayLogContext | null>)
-    : null;
+  const alignedFields = ['lineContexts', 'lineMetadata'] as const;
+  const aligned = alignedFields.map((key) => {
+    const label = key === 'lineContexts' ? 'contexts' : 'metadata';
+    const inPayload = payload !== null && Object.hasOwn(payload, key);
+    const inEvent = Object.hasOwn(event, key);
+    if (inPayload && inEvent)
+      throw new TypeError(`Run log ${label} must have one event owner.`);
+    const value = inPayload ? payload?.[key] : event[key];
+    if (
+      (inPayload || inEvent) &&
+      (!Array.isArray(value) || value.length !== lines.length)
+    ) {
+      throw new TypeError(`Run log ${label} must align with their lines.`);
+    }
+    return {
+      key,
+      inPayload,
+      inEvent,
+      value: Array.isArray(value) ? value : undefined,
+    };
+  });
+  const payloadOwnsLineIds =
+    payload !== null && Object.hasOwn(payload, 'lineIds');
+  if (payloadOwnsLineIds && Object.hasOwn(event, 'lineIds'))
+    throw new TypeError('Run log identities must have one event owner.');
+  const lineIds = normalizeRunLogIds(
+    payloadOwnsLineIds ? payload?.lineIds : event.lineIds,
+    lines,
+  );
   const payloadChannelOffset =
     typeof payload?.channelOffset === 'number'
       ? payload.channelOffset
@@ -58,6 +68,8 @@ function splitRunEventForAppRuntime(
   const {
     lines: _outerLines,
     lineContexts: _outerLineContexts,
+    lineMetadata: _outerLineMetadata,
+    lineIds: _outerLineIds,
     ...eventWithoutOuterLines
   } = event;
   let index = 0;
@@ -65,37 +77,65 @@ function splitRunEventForAppRuntime(
     const start = index;
     let bytes = 2;
     while (index < lines.length) {
-      const lineBytes = appRuntimeTextEncoder.encode(
-        JSON.stringify(lines[index]!),
-      ).length;
+      const lineBytes =
+        appRuntimeTextEncoder.encode(JSON.stringify(lines[index]!)).length +
+        aligned.reduce(
+          (total, field) =>
+            total +
+            (field.value
+              ? appRuntimeTextEncoder.encode(JSON.stringify(field.value[index]))
+                  .length + 1
+              : 0),
+          0,
+        );
+      const metadataBytes = lineIds
+        ? appRuntimeTextEncoder.encode(JSON.stringify(lineIds[index])).length + 1
+        : 0;
       if (
         index > start &&
-        bytes + lineBytes + 1 > APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES
+        bytes + lineBytes + metadataBytes + 1 >
+          APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES
       ) {
         break;
       }
-      bytes += lineBytes + 1;
+      bytes += lineBytes + metadataBytes + 1;
       index += 1;
     }
     const batchLines = lines.slice(start, index);
-    const batchLineContexts = lineContexts?.slice(start, index);
+    const batchLineIds = lineIds?.slice(start, index);
+    const eventFields = Object.fromEntries(
+      aligned
+        .filter((field) => field.inEvent)
+        .map((field) => [field.key, field.value!.slice(start, index)]),
+    );
+    const payloadFields = Object.fromEntries(
+      aligned
+        .filter((field) => field.inPayload)
+        .map((field) => [field.key, field.value!.slice(start, index)]),
+    );
     split.push(
       payload
         ? {
             ...eventWithoutOuterLines,
-            ...(eventOwnsLineContexts && batchLineContexts
-              ? { lineContexts: batchLineContexts }
-              : {}),
+            ...eventFields,
             ...(payloadOwnsLines ? {} : { lines: batchLines }),
+            ...(!payloadOwnsLineIds && batchLineIds
+              ? { lineIds: batchLineIds }
+              : {}),
             payload: {
               ...Object.fromEntries(
                 Object.entries(payload).filter(
-                  ([key]) => key !== 'lineContexts',
+                  ([key]) =>
+                    key !== 'lineIds' &&
+                    !alignedFields.includes(
+                      key as (typeof alignedFields)[number],
+                    ),
                 ),
               ),
               ...(payloadOwnsLines ? { lines: batchLines } : {}),
-              ...(payloadOwnsLineContexts && batchLineContexts
-                ? { lineContexts: batchLineContexts }
+              ...payloadFields,
+              ...(payloadOwnsLineIds && batchLineIds
+                ? { lineIds: batchLineIds }
                 : {}),
               ...(payloadChannelOffset === undefined
                 ? {}
@@ -108,7 +148,8 @@ function splitRunEventForAppRuntime(
         : {
             ...eventWithoutOuterLines,
             lines: batchLines,
-            ...(batchLineContexts ? { lineContexts: batchLineContexts } : {}),
+            ...eventFields,
+            ...(batchLineIds ? { lineIds: batchLineIds } : {}),
             ...(eventChannelOffset === undefined
               ? {}
               : { channelOffset: eventChannelOffset + start }),

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -24,7 +24,7 @@ import {
   type PlayConditionCounts,
 } from './cell-provenance';
 import { isLedgerTerminalResultRef } from './output-size-limits';
-import type { PlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
 import { RUN_EVENT_KIND, type RunEventSource } from './run-event-catalog';
 
 export type PlayRunLedgerStatus =
@@ -100,6 +100,8 @@ export type PlayRunLedgerStepProgress = {
   completedAt?: number | null;
   updatedAt?: number | null;
   nodeIo?: PlayDocflowNodeIoState;
+  /** Error reported by this step, distinct from a run stopping other work. */
+  error?: string;
   conditionCounts?: PlayConditionCounts;
 };
 
@@ -320,6 +322,8 @@ export type PlayRunLedgerEvent =
       lines: string[];
       /** Search-only context aligned to `lines`; stripped before Convex. */
       lineContexts?: Array<PlayLogContext | null>;
+      lineMetadata?: Array<PlayLogMetadata | null>;
+      lineIds?: Array<string | null>;
       /**
        * Absolute per-run sequence (1-based) of `lines[0]`. Assigned by Run
        * Log Stream ingestion in Convex only; producers never set it.
@@ -430,6 +434,8 @@ export type PlayRunLedgerStatusPatch = {
   liveLogs?: readonly string[] | null;
   /** Search-only context aligned to `liveLogs`; stripped before Convex. */
   liveLogContexts?: readonly (PlayLogContext | null)[] | null;
+  liveLogMetadata?: readonly (PlayLogMetadata | null)[] | null;
+  liveLogIds?: readonly (string | null)[] | null;
   /**
    * Positional cursor for `liveLogs[0]` on this producer's log channel (the
    * count of lines emitted before it). Computed by the producer-side cursor
@@ -1381,6 +1387,9 @@ function normalizeStepProgress(
     ...(optionalFiniteNumber(value.supersededRows) !== undefined
       ? { supersededRows: optionalFiniteNumber(value.supersededRows) }
       : {}),
+    ...(optionalString(value.error)
+      ? { error: optionalString(value.error) }
+      : {}),
     ...(optionalString(value.message)
       ? { message: optionalString(value.message) }
       : {}),
@@ -2327,6 +2336,7 @@ function progressSignature(
     completedRows: progress?.completedRows ?? null,
     supersededRows: progress?.supersededRows ?? null,
     message: progress?.message ?? null,
+    error: progress?.error ?? null,
     artifactTableNamespace: progress?.artifactTableNamespace ?? null,
     startedAt: progress?.startedAt ?? null,
     completedAt: progress?.completedAt ?? null,
@@ -2369,12 +2379,16 @@ function terminalEventTypeForStatus(
 export function slicePositionalLogLines(input: {
   bufferLines: readonly string[];
   bufferContexts?: readonly (PlayLogContext | null)[];
+  bufferMetadata?: readonly (PlayLogMetadata | null)[];
+  bufferIds?: readonly (string | null)[];
   bufferTotalCount: number;
   sentCount: number;
 }): {
   lines: string[];
   channelOffset: number;
   lineContexts?: Array<PlayLogContext | null>;
+  lineMetadata?: Array<PlayLogMetadata | null>;
+  lineIds?: Array<string | null>;
 } | null {
   if (
     input.bufferContexts !== undefined &&
@@ -2382,6 +2396,14 @@ export function slicePositionalLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with the retained lines.');
   }
+  if (
+    input.bufferMetadata !== undefined &&
+    input.bufferMetadata.length !== input.bufferLines.length
+  )
+    throw new TypeError('Run log metadata must align with lines.');
+  if (input.bufferIds && input.bufferIds.length !== input.bufferLines.length) {
+    throw new TypeError('Run log identities must align with retained lines.');
+  }
   const total = Math.max(input.bufferTotalCount, input.bufferLines.length);
   const sent = Math.max(0, input.sentCount);
   if (total <= sent) {
@@ -2395,10 +2417,13 @@ export function slicePositionalLogLines(input: {
   }
   const start = sendFromOffset - bufferFirstOffset;
   const lineContexts = input.bufferContexts?.slice(start);
+  const lineMetadata = input.bufferMetadata?.slice(start);
   return {
     lines: [...lines],
     channelOffset: sendFromOffset,
+    ...(input.bufferIds ? { lineIds: input.bufferIds.slice(start) } : {}),
     ...(lineContexts?.some(Boolean) ? { lineContexts: [...lineContexts] } : {}),
+    ...(lineMetadata?.some(Boolean) ? { lineMetadata: [...lineMetadata] } : {}),
   };
 }
 
@@ -2427,6 +2452,8 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineMetadata?: readonly (PlayLogMetadata | null)[];
+  lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   channelOffset?: number | null;
@@ -2448,10 +2475,20 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with their lines.');
   }
+  if (
+    input.lineMetadata !== undefined &&
+    input.lineMetadata.length !== input.lines.length
+  )
+    throw new TypeError('Run log metadata must align with lines.');
+  if (input.lineIds && input.lineIds.length !== input.lines.length) {
+    throw new TypeError('Run log identities must align with their lines.');
+  }
   const entries = input.lines
     .map((line, index) => ({
       line: positional ? line.trim() || '(blank log line)' : line.trim(),
       context: input.lineContexts?.[index] ?? null,
+      metadata: input.lineMetadata?.[index] ?? null,
+      entryId: input.lineIds?.[index] ?? null,
     }))
     .filter((entry) => positional || entry.line.length > 0);
   const newLines = entries.map((entry) => entry.line);
@@ -2470,6 +2507,13 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
       source,
       occurredAt,
       lines: newLines.slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT),
+      ...(input.lineIds
+        ? {
+            lineIds: entries
+              .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+              .map((entry) => entry.entryId),
+          }
+        : {}),
       ...(entries
         .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
         .some((entry) => entry.context)
@@ -2479,6 +2523,15 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
               .map((entry) => entry.context),
           }
         : {}),
+      ...(entries
+        .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+        .some((entry) => entry.metadata)
+        ? {
+            lineMetadata: entries
+              .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+              .map((entry) => entry.metadata),
+          }
+        : {}),
       ...(positional ? { channelOffset: input.channelOffset! + index } : {}),
       ...(positional &&
       typeof input.producerAttempt === 'number' &&
@@ -2507,6 +2560,8 @@ export function buildTerminalLogReplayEvents(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineMetadata?: readonly (PlayLogMetadata | null)[];
+  lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   liveLogTotalCount?: number;
@@ -2521,6 +2576,8 @@ export function buildTerminalLogReplayEvents(input: {
     runId: input.runId,
     lines: input.lines,
     lineContexts: input.lineContexts,
+    lineMetadata: input.lineMetadata,
+    lineIds: input.lineIds,
     source: 'coordinator',
     occurredAt: input.occurredAt,
     channelOffset,
@@ -2562,6 +2619,8 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         runId: patch.runId,
         lines: patch.liveLogs,
         lineContexts: patch.liveLogContexts ?? undefined,
+        lineMetadata: patch.liveLogMetadata ?? undefined,
+        lineIds: patch.liveLogIds ?? undefined,
         source,
         occurredAt: checkpointAt,
         channelOffset: patch.liveLogsChannelOffset ?? null,
@@ -2643,6 +2702,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         ? { supersededRows: progress.supersededRows }
         : {}),
       ...(progress.message !== undefined ? { message: progress.message } : {}),
+      ...(progress.error !== undefined ? { error: progress.error } : {}),
       ...(progress.artifactTableNamespace !== undefined
         ? { artifactTableNamespace: progress.artifactTableNamespace }
         : {}),
@@ -2669,6 +2729,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         occurredAt: progress.updatedAt ?? checkpointAt,
         stepId,
         status:
+          typeof progress.error === 'string' ||
           typeof progress.nodeIo?.error === 'string'
             ? 'failed'
             : typeof progress.completedAt === 'number'
@@ -2680,9 +2741,18 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
       });
     }
 
-    if (progress.completedAt && !previousStep?.completedAt) {
+    const stepError = progress.error ?? progress.nodeIo?.error;
+    if (
+      progress.completedAt &&
+      (!previousStep?.completedAt ||
+        (typeof stepError === 'string' && previousStep.status !== 'failed'))
+    ) {
       events.push({
-        type: RUN_EVENT_KIND.stepCompleted,
+        type:
+          typeof stepError === 'string'
+            ? RUN_EVENT_KIND.stepFailed
+            : RUN_EVENT_KIND.stepCompleted,
+        ...(typeof stepError === 'string' ? { error: stepError } : {}),
         runId: patch.runId,
         source,
         occurredAt: progress.completedAt,

package/dist/bundling-sources/shared_libs/play-runtime/run-log-buffer.ts

@@ -1,5 +1,8 @@
-import type { PlayLogContext } from './log-context';
-import { normalizePlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
+import {
+  normalizePlayLogContext,
+  normalizePlayLogMetadata,
+} from './log-context';
 
 /** Limits apply before logs enter runner memory or a transport request. */
 export const RUNNER_LOG_MAX_CHARS = 2_000;
@@ -25,7 +28,10 @@ export function boundRunLogLine(line: string): string {
  */
 export class RunLogBuffer {
   readonly lines: string[] = [];
+  readonly ids: string[] = [];
+  private readonly origin = crypto.randomUUID();
   readonly contexts: Array<PlayLogContext | null> = [];
+  readonly metadata: Array<PlayLogMetadata | null> = [];
   private bytes = 0;
   private contextBytes = 0;
   private omittedContexts = 0;
@@ -36,10 +42,12 @@ export class RunLogBuffer {
     raw: string,
     terminal = false,
     context?: PlayLogContext | null,
+    metadata?: PlayLogMetadata | null,
   ): string[] {
     const line = boundRunLogLine(raw);
     const bytes = encoder.encode(line).byteLength;
     const normalizedContext = normalizePlayLogContext(context);
+    const normalizedMetadata = normalizePlayLogMetadata(metadata);
     const contextBytes = normalizedContext
       ? encoder.encode(JSON.stringify(normalizedContext)).byteLength
       : 0;
@@ -56,7 +64,9 @@ export class RunLogBuffer {
         true,
       );
     }
+    this.ids.push(`${this.origin}:${this.lines.length}`);
     this.lines.push(line);
+    this.metadata.push(normalizedMetadata);
     const retainContext =
       normalizedContext !== null &&
       this.contextBytes + contextBytes <= RUNNER_LOG_CONTEXT_MAX_BYTES;
@@ -80,3 +90,30 @@ export class RunLogBuffer {
     };
   }
 }
+
+/** Optional origin identities: old producers omit them; never infer them from text. */
+export function normalizeRunLogIds(
+  value: unknown,
+  lines: readonly unknown[],
+): Array<string | null> | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (
+    !Array.isArray(value) ||
+    value.length !== lines.length ||
+    value.some(
+      (id) =>
+        id !== null &&
+        (typeof id !== 'string' || !/^[A-Za-z0-9:_-]{1,128}$/.test(id)),
+    )
+  ) {
+    throw new TypeError(
+      'Run log identities must be bounded strings aligned with their lines.',
+    );
+  }
+  const ids = value.filter((id): id is string => id !== null);
+  if (new Set(ids).size !== ids.length)
+    throw new TypeError(
+      'Run log identities must identify distinct occurrences.',
+    );
+  return value;
+}