deepline 0.1.177 → 0.1.179

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -2281,6 +2281,7 @@ function runRequestFromPlayWorkflowParams(
     inlineChildRunRegistered:
       params.runtimeBackend === 'cf_workflows_dynamic_worker_inline_child',
     coordinatorUrl: params.coordinatorUrl ?? null,
+    coordinatorInternalToken: params.coordinatorInternalToken ?? null,
     totalRows: params.totalRows,
   };
 }

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -181,6 +181,10 @@ import {
   setHarnessBinding,
 } from '../../../sdk/src/plays/harness-stub';
 import { createHarnessWorkerReceiptStore } from './runtime/harness-receipt-store';
+import {
+  createCoordinatorProgressPublisher,
+  isCoordinatorProgressAuthorizationError,
+} from './runtime/coordinator-progress';
 import {
   hydrateSerializedResultDatasets,
   projectTerminalResultDatasets,
@@ -1735,7 +1739,9 @@ function isRuntimeReceiptPersistenceError(error: unknown): boolean {
 
 function isRunFatalWorkerRowError(error: unknown): boolean {
   return (
-    isRowIsolationExemptError(error) || isRuntimeReceiptPersistenceError(error)
+    isCoordinatorProgressAuthorizationError(error) ||
+    isRowIsolationExemptError(error) ||
+    isRuntimeReceiptPersistenceError(error)
   );
 }
 
@@ -1858,9 +1864,7 @@ class WorkerToolBatchScheduler {
         id,
         cacheKey: receiptKey,
         receiptKey,
-        force:
-          options?.force === true ||
-          !!this.req.force,
+        force: options?.force === true || !!this.req.force,
         receiptWaitMaxAttempts: resolveRuntimeToolReceiptWaitMaxAttempts(
           typeof runtimeOptions?.receiptWaitMs === 'number'
             ? { max_wait_ms: runtimeOptions.receiptWaitMs }
@@ -4147,10 +4151,15 @@ async function prepareMapRows(input: {
 
 function assertNotAborted(signal: AbortSignal | undefined): void {
   if (signal?.aborted) {
+    if (isCoordinatorProgressAuthorizationError(signal.reason)) {
+      throw signal.reason;
+    }
     throw new WorkflowAbortError(
-      typeof signal.reason === 'string' && signal.reason
-        ? signal.reason
-        : 'Play run cancelled.',
+      signal.reason instanceof Error && signal.reason.message
+        ? signal.reason.message
+        : typeof signal.reason === 'string' && signal.reason
+          ? signal.reason
+          : 'Play run cancelled.',
     );
   }
 }
@@ -5370,9 +5379,7 @@ function createMinimalWorkerCtx(
                         request.input,
                         workflowStep,
                         {
-                          force:
-                            request.force === true ||
-                            !!req.force,
+                          force: request.force === true || !!req.force,
                           staleAfterSeconds: request.staleAfterSeconds,
                         },
                       );
@@ -5872,7 +5879,7 @@ function createMinimalWorkerCtx(
           ? ` cells=${totalStepCells}/${totalStepCellsCompleted}/${totalStepCellsSkipped}`
           : '';
       callbacks?.onMapCompleted?.(mapNodeId, completedAt);
-      void updateMapProgress({
+      await updateMapProgress({
         completed: totalRowsWritten,
         total: totalRowsWritten + totalRowsFailed,
         failed: totalRowsFailed,
@@ -6360,9 +6367,7 @@ function createMinimalWorkerCtx(
           request.input,
           workflowStep,
           {
-            force:
-              request.force === true ||
-              !!req.force,
+            force: request.force === true || !!req.force,
             staleAfterSeconds: request.staleAfterSeconds,
           },
           {
@@ -7196,9 +7201,6 @@ async function executeRunRequest(
   let lastLedgerFlushAt = startedAt;
   let ledgerFlushInFlight: Promise<void> = Promise.resolve();
   let ledgerFlushQueueDepth = 0;
-  let lastCoordinatorProgressPublishAt = 0;
-  let coordinatorProgressPublishInFlight: Promise<void> = Promise.resolve();
-  let coordinatorProgressPublishQueueDepth = 0;
 
   const appendRunLogLine = (line: string) => {
     const trimmed = redactSecretsFromLogString(line.trim());
@@ -7225,130 +7227,24 @@ async function executeRunRequest(
   };
 
   const stepProgressSnapshot = () => ({ ...stepProgressByNodeId });
-
-  const publishCoordinatorProgressEvent = async (
-    occurredAt: number,
-  ): Promise<void> => {
-    const coordinatorUrl = req.coordinatorUrl?.trim();
-    if (!coordinatorUrl) {
-      recordRunnerPerfTrace({
-        req,
-        phase: 'runner.coordinator_progress_publish',
-        ms: 0,
-        extra: { status: 'skipped_no_url' },
-      });
-      return;
-    }
-    const publishStartedAt = nowMs();
-    const liveNodeProgress = stepProgressSnapshot();
-    const activeEntry =
-      Object.entries(liveNodeProgress).find(
-        ([, progress]) => typeof progress.completedAt !== 'number',
-      ) ?? Object.entries(liveNodeProgress).at(-1);
-    const activeNodeId = activeEntry?.[0] ?? null;
-    const activeProgress = activeEntry?.[1] ?? null;
-    const activeArtifactTableNamespace =
-      typeof activeProgress?.artifactTableNamespace === 'string'
-        ? activeProgress.artifactTableNamespace
-        : null;
-    const activeCompleted =
-      typeof activeProgress?.completed === 'number'
-        ? activeProgress.completed
-        : null;
-    const activeTotal =
-      typeof activeProgress?.total === 'number' ? activeProgress.total : null;
-    const activeMessage =
-      typeof activeProgress?.message === 'string'
-        ? activeProgress.message
-        : null;
-    const response = await fetch(
-      `${coordinatorUrl.replace(/\/$/, '')}/dedup/${encodeURIComponent(
-        req.runId,
-      )}/event-add`,
-      {
-        method: 'POST',
-        headers: {
-          'x-deepline-request-id': makeRequestId(),
-          ...coordinatorRequestHeaders({
-            runId: req.runId,
-            contentType: 'application/json',
-            internalToken: req.coordinatorInternalToken,
-          }),
-        },
-        body: JSON.stringify({
-          runId: req.runId,
-          type: 'progress',
-          status: 'running',
-          ts: occurredAt,
-          logs: runLogBuffer,
-          activeNodeId,
-          activeArtifactTableNamespace,
-          updatedAt: occurredAt,
-          liveNodeProgress,
-        }),
-      },
-    );
-    if (!response.ok) {
+  const coordinatorProgressPublisher = createCoordinatorProgressPublisher({
+    runId: req.runId,
+    coordinatorUrl: req.coordinatorUrl,
+    coordinatorInternalToken: req.coordinatorInternalToken,
+    abortController,
+    getRunLogBuffer: () => runLogBuffer,
+    getLiveNodeProgress: stepProgressSnapshot,
+    makeRequestId,
+    nowMs,
+    heartbeatIntervalMs: MAP_EXECUTION_HEARTBEAT_INTERVAL_MS,
+    recordTrace: (trace) =>
       recordRunnerPerfTrace({
         req,
-        phase: 'runner.coordinator_progress_publish',
-        ms: nowMs() - publishStartedAt,
-        extra: {
-          status: 'failed',
-          httpStatus: response.status,
-          activeNodeId,
-          activeArtifactTableNamespace,
-          activeCompleted,
-          activeTotal,
-          activeMessage,
-        },
-      });
-      throw new Error(`coordinator progress event failed ${response.status}`);
-    }
-    recordRunnerPerfTrace({
-      req,
-      phase: 'runner.coordinator_progress_publish',
-      ms: nowMs() - publishStartedAt,
-      extra: {
-        status: 'ok',
-        activeNodeId,
-        activeArtifactTableNamespace,
-        activeCompleted,
-        activeTotal,
-        activeMessage,
-      },
-    });
-  };
-
-  const flushCoordinatorProgressEvent = (force: boolean): Promise<void> => {
-    const now = nowMs();
-    if (
-      !force &&
-      now - lastCoordinatorProgressPublishAt <
-        MAP_EXECUTION_HEARTBEAT_INTERVAL_MS
-    ) {
-      return Promise.resolve();
-    }
-    if (!force && coordinatorProgressPublishQueueDepth > 0) {
-      return Promise.resolve();
-    }
-    lastCoordinatorProgressPublishAt = now;
-    coordinatorProgressPublishQueueDepth += 1;
-    coordinatorProgressPublishInFlight = coordinatorProgressPublishInFlight
-      .catch(() => undefined)
-      .then(async () => {
-        try {
-          await publishCoordinatorProgressEvent(now);
-        } finally {
-          coordinatorProgressPublishQueueDepth = Math.max(
-            0,
-            coordinatorProgressPublishQueueDepth - 1,
-          );
-        }
-      })
-      .catch(() => undefined);
-    return force ? coordinatorProgressPublishInFlight : Promise.resolve();
-  };
+        phase: trace.phase,
+        ms: trace.ms,
+        extra: trace.extra,
+      }),
+  });
 
   const appendStepLifecycleEvent = (event: PlayStepLifecycleEvent) => {
     updateStepProgress({
@@ -7537,7 +7433,7 @@ async function executeRunRequest(
       updateStepProgress(input);
       const force = Boolean(input.forceFlush);
       const ledgerFlush = flushLedgerEvents(force);
-      const progressFlush = flushCoordinatorProgressEvent(force);
+      const progressFlush = coordinatorProgressPublisher.flush(force);
       return force
         ? Promise.all([ledgerFlush, progressFlush]).then(() => undefined)
         : Promise.resolve();

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/coordinator-progress.ts

@@ -0,0 +1,289 @@
+import { coordinatorRequestHeaders } from '../../../../shared_libs/play-runtime/coordinator-headers';
+import type {
+  LiveNodeProgressMap,
+  LiveNodeProgressSnapshot,
+} from './live-progress';
+
+type CoordinatorProgressTraceExtra = {
+  status: 'ok' | 'failed' | 'skipped_no_url';
+  httpStatus?: number;
+  activeNodeId?: string | null;
+  activeArtifactTableNamespace?: string | null;
+  activeCompleted?: number | null;
+  activeTotal?: number | null;
+  activeMessage?: string | null;
+};
+
+type CoordinatorProgressTrace = {
+  phase: 'runner.coordinator_progress_publish';
+  ms: number;
+  extra: CoordinatorProgressTraceExtra;
+};
+
+export class CoordinatorProgressAuthorizationError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+    this.name = 'CoordinatorProgressAuthorizationError';
+  }
+}
+
+export function isCoordinatorProgressAuthorizationError(
+  error: unknown,
+): error is CoordinatorProgressAuthorizationError {
+  return (
+    error instanceof CoordinatorProgressAuthorizationError ||
+    (typeof error === 'object' &&
+      error !== null &&
+      'name' in error &&
+      'status' in error &&
+      (error as { name?: unknown }).name ===
+        'CoordinatorProgressAuthorizationError' &&
+      typeof (error as { status?: unknown }).status === 'number')
+  );
+}
+
+function activeProgressFields(liveNodeProgress: LiveNodeProgressMap): {
+  activeNodeId: string | null;
+  activeProgress: LiveNodeProgressSnapshot | null;
+  activeArtifactTableNamespace: string | null;
+  activeCompleted: number | null;
+  activeTotal: number | null;
+  activeMessage: string | null;
+} {
+  const activeEntry =
+    Object.entries(liveNodeProgress).find(
+      ([, progress]) => typeof progress.completedAt !== 'number',
+    ) ?? Object.entries(liveNodeProgress).at(-1);
+  const activeNodeId = activeEntry?.[0] ?? null;
+  const activeProgress = activeEntry?.[1] ?? null;
+  const activeArtifactTableNamespace =
+    typeof activeProgress?.artifactTableNamespace === 'string'
+      ? activeProgress.artifactTableNamespace
+      : null;
+  const activeCompleted =
+    typeof activeProgress?.completed === 'number'
+      ? activeProgress.completed
+      : null;
+  const activeTotal =
+    typeof activeProgress?.total === 'number' ? activeProgress.total : null;
+  const activeMessage =
+    typeof activeProgress?.message === 'string' ? activeProgress.message : null;
+  return {
+    activeNodeId,
+    activeProgress,
+    activeArtifactTableNamespace,
+    activeCompleted,
+    activeTotal,
+    activeMessage,
+  };
+}
+
+async function publishCoordinatorProgressEvent(input: {
+  runId: string;
+  coordinatorUrl?: string | null;
+  coordinatorInternalToken?: string | null;
+  occurredAt: number;
+  runLogBuffer: string[];
+  liveNodeProgress: LiveNodeProgressMap;
+  fetchFn: typeof fetch;
+  makeRequestId: () => string;
+  nowMs: () => number;
+  recordTrace: (trace: CoordinatorProgressTrace) => void;
+}): Promise<void> {
+  const coordinatorUrl = input.coordinatorUrl?.trim();
+  if (!coordinatorUrl) {
+    input.recordTrace({
+      phase: 'runner.coordinator_progress_publish',
+      ms: 0,
+      extra: { status: 'skipped_no_url' },
+    });
+    return;
+  }
+
+  const publishStartedAt = input.nowMs();
+  const {
+    activeNodeId,
+    activeArtifactTableNamespace,
+    activeCompleted,
+    activeTotal,
+    activeMessage,
+  } = activeProgressFields(input.liveNodeProgress);
+
+  const response = await input.fetchFn(
+    `${coordinatorUrl.replace(/\/$/, '')}/dedup/${encodeURIComponent(
+      input.runId,
+    )}/event-add`,
+    {
+      method: 'POST',
+      headers: {
+        'x-deepline-request-id': input.makeRequestId(),
+        ...coordinatorRequestHeaders({
+          runId: input.runId,
+          contentType: 'application/json',
+          internalToken: input.coordinatorInternalToken,
+        }),
+      },
+      body: JSON.stringify({
+        runId: input.runId,
+        type: 'progress',
+        status: 'running',
+        ts: input.occurredAt,
+        logs: input.runLogBuffer,
+        activeNodeId,
+        activeArtifactTableNamespace,
+        updatedAt: input.occurredAt,
+        liveNodeProgress: input.liveNodeProgress,
+      }),
+    },
+  );
+
+  if (response.status === 401 || response.status === 403) {
+    input.recordTrace({
+      phase: 'runner.coordinator_progress_publish',
+      ms: input.nowMs() - publishStartedAt,
+      extra: {
+        status: 'failed',
+        httpStatus: response.status,
+        activeNodeId,
+        activeArtifactTableNamespace,
+        activeCompleted,
+        activeTotal,
+        activeMessage,
+      },
+    });
+    throw new CoordinatorProgressAuthorizationError(
+      `Coordinator progress publish was rejected with ${response.status}; ` +
+        'the play runner no longer has authority to update its coordinator state. ' +
+        'Stopping before more provider work can execute with stale coordinator authority.',
+      response.status,
+    );
+  }
+
+  if (!response.ok) {
+    input.recordTrace({
+      phase: 'runner.coordinator_progress_publish',
+      ms: input.nowMs() - publishStartedAt,
+      extra: {
+        status: 'failed',
+        httpStatus: response.status,
+        activeNodeId,
+        activeArtifactTableNamespace,
+        activeCompleted,
+        activeTotal,
+        activeMessage,
+      },
+    });
+    throw new Error(`coordinator progress event failed ${response.status}`);
+  }
+
+  input.recordTrace({
+    phase: 'runner.coordinator_progress_publish',
+    ms: input.nowMs() - publishStartedAt,
+    extra: {
+      status: 'ok',
+      activeNodeId,
+      activeArtifactTableNamespace,
+      activeCompleted,
+      activeTotal,
+      activeMessage,
+    },
+  });
+}
+
+export function createCoordinatorProgressPublisher(input: {
+  runId: string;
+  coordinatorUrl?: string | null;
+  coordinatorInternalToken?: string | null;
+  abortController: AbortController;
+  getRunLogBuffer: () => string[];
+  getLiveNodeProgress: () => LiveNodeProgressMap;
+  recordTrace: (trace: CoordinatorProgressTrace) => void;
+  fetchFn?: typeof fetch;
+  makeRequestId: () => string;
+  nowMs: () => number;
+  heartbeatIntervalMs: number;
+}): {
+  assertHealthy: () => void;
+  flush: (force: boolean) => Promise<void>;
+  fatalError: () => Error | null;
+} {
+  let lastPublishAt = 0;
+  let publishInFlight: Promise<void> = Promise.resolve();
+  let publishQueueDepth = 0;
+  let fatalError: Error | null = null;
+  const abortSignal = input.abortController.signal;
+  const fetchFn = input.fetchFn ?? fetch;
+
+  const markFatal = (error: Error): void => {
+    fatalError ??= error;
+    if (!abortSignal.aborted) {
+      input.abortController.abort(error);
+    }
+  };
+
+  const assertHealthy = (): void => {
+    if (fatalError) {
+      throw fatalError;
+    }
+  };
+
+  const publish = async (occurredAt: number): Promise<void> => {
+    assertHealthy();
+    await publishCoordinatorProgressEvent({
+      runId: input.runId,
+      coordinatorUrl: input.coordinatorUrl,
+      coordinatorInternalToken: input.coordinatorInternalToken,
+      occurredAt,
+      runLogBuffer: input.getRunLogBuffer(),
+      liveNodeProgress: input.getLiveNodeProgress(),
+      fetchFn,
+      makeRequestId: input.makeRequestId,
+      nowMs: input.nowMs,
+      recordTrace: input.recordTrace,
+    });
+  };
+
+  const flush = (force: boolean): Promise<void> => {
+    if (fatalError) {
+      return force ? Promise.reject(fatalError) : Promise.resolve();
+    }
+
+    const now = input.nowMs();
+    if (!force && now - lastPublishAt < input.heartbeatIntervalMs) {
+      return Promise.resolve();
+    }
+    if (!force && publishQueueDepth > 0) {
+      return Promise.resolve();
+    }
+
+    lastPublishAt = now;
+    publishQueueDepth += 1;
+    const publishTask = publishInFlight
+      .catch(() => undefined)
+      .then(async () => {
+        try {
+          await publish(now);
+        } finally {
+          publishQueueDepth = Math.max(0, publishQueueDepth - 1);
+        }
+      });
+
+    const handledPublishTask = publishTask.catch((error) => {
+      if (isCoordinatorProgressAuthorizationError(error)) {
+        markFatal(error);
+        throw error;
+      }
+    });
+    publishInFlight = handledPublishTask.catch(() => undefined);
+    return force ? handledPublishTask : Promise.resolve();
+  };
+
+  return {
+    assertHealthy,
+    flush,
+    fatalError: () => fatalError,
+  };
+}

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

@@ -105,10 +105,10 @@ export const SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: '0.1.177',
+  version: '0.1.179',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.177',
+    latest: '0.1.179',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -303,7 +303,7 @@ function isRetryableAppRuntimeResponse(input: {
 }
 
 function isTransientAppRuntimeFailureBody(body: string): boolean {
-  return /WorkerOverloaded|"\s*code\s*"\s*:\s*"\s*InternalServerError\s*"|Your request couldn't be completed\. Try again later\.|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT/i.test(
+  return /WorkerOverloaded|"\s*code\s*"\s*:\s*"\s*InternalServerError\s*"|Your request couldn't be completed\. Try again later\.|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT|tuple concurrently updated/i.test(
     body,
   );
 }
@@ -329,7 +329,15 @@ function isRetryableAppRuntimeAction(
     action === 'append_run_events' ||
     action === 'create_db_session' ||
     action === 'create_signed_artifact_url' ||
-    action === 'create_signed_staged_file_url'
+    action === 'create_signed_staged_file_url' ||
+    action === 'get_runtime_step_receipt' ||
+    action === 'get_runtime_step_receipts' ||
+    action === 'claim_runtime_step_receipt' ||
+    action === 'claim_runtime_step_receipts' ||
+    action === 'complete_runtime_step_receipt' ||
+    action === 'complete_runtime_step_receipts' ||
+    action === 'fail_runtime_step_receipt' ||
+    action === 'fail_runtime_step_receipts'
   );
 }
 

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

@@ -1,4 +1,7 @@
-import { normalizePlayRunFailure } from './run-failure';
+import {
+  normalizePlayRunFailure,
+  PLATFORM_DEPLOY_INTERRUPTED_MESSAGE,
+} from './run-failure';
 
 export type PlayRunLedgerStatus =
   | 'queued'
@@ -530,6 +533,25 @@ const TERMINAL_STATUS_BY_EVENT_TYPE = {
   'run.cancelled': 'cancelled',
 } as const satisfies Partial<Record<string, PlayRunLedgerStatus>>;
 
+function isRawPlatformDeployResetText(
+  error: string | null | undefined,
+): boolean {
+  return Boolean(
+    error &&
+    normalizePlayRunFailure(error).code === 'PLATFORM_DEPLOY_INTERRUPTED',
+  );
+}
+
+function isPlatformDeployFailureText(
+  error: string | null | undefined,
+): boolean {
+  return Boolean(
+    error &&
+    (isRawPlatformDeployResetText(error) ||
+      error.includes(PLATFORM_DEPLOY_INTERRUPTED_MESSAGE)),
+  );
+}
+
 /**
  * Append already-deduplicated log lines to the snapshot tail.
  *
@@ -566,31 +588,29 @@ function appendLogLines(
 }
 
 /**
- * Terminal-status precedence. Re-delivery of the same terminal status is a
- * benign no-op handled by the regular reduction. Conflicting terminal events
- * use newest-terminal-wins by event time: older events are ignored and logged,
- * newer events reconcile the snapshot. This is the idempotency model callers
- * expect when duplicate/retried work completes out of order. It also preserves
- * post-completion billing cap demotion because that denial arrives as a newer
- * run.failed event.
+ * Terminal-status precedence. Conflicting terminal events use
+ * newest-terminal-wins by event time: older events are ignored and logged,
+ * newer events reconcile the snapshot. Same-status terminal events continue to
+ * the reducer so recovery/transport paths can fill in canonical payloads after
+ * an earlier partial terminal snapshot. Retryable platform-deploy failures are
+ * the narrow exception: they are never allowed to replace a real terminal
+ * result from the runtime.
  */
 function conflictingTerminalSnapshot(
   base: PlayRunLedgerSnapshot,
   eventType: keyof typeof TERMINAL_STATUS_BY_EVENT_TYPE,
   occurredAt: number,
   eventError?: string | null,
+  options?: { allowStaleSameStatusPayloadMerge?: boolean },
 ): PlayRunLedgerSnapshot | null {
   if (!isTerminalPlayRunLedgerStatus(base.status)) {
     return null;
   }
-  if (TERMINAL_STATUS_BY_EVENT_TYPE[eventType] === base.status) {
-    return null;
-  }
+  const terminalAt = base.finishedAt ?? base.updatedAt ?? 0;
   if (
     base.status === 'completed' &&
     eventType === 'run.failed' &&
-    eventError &&
-    normalizePlayRunFailure(eventError).code === 'PLATFORM_DEPLOY_INTERRUPTED'
+    isPlatformDeployFailureText(eventError)
   ) {
     return withTiming(
       appendLogLines(base, [
@@ -598,7 +618,22 @@ function conflictingTerminalSnapshot(
       ]),
     );
   }
-  const terminalAt = base.finishedAt ?? base.updatedAt ?? 0;
+  if (
+    base.status === 'failed' &&
+    eventType === 'run.failed' &&
+    isPlatformDeployFailureText(eventError)
+  ) {
+    return withTiming(base);
+  }
+  if (TERMINAL_STATUS_BY_EVENT_TYPE[eventType] === base.status) {
+    if (
+      options?.allowStaleSameStatusPayloadMerge !== true ||
+      occurredAt < terminalAt
+    ) {
+      return withTiming(base);
+    }
+    return null;
+  }
   if (occurredAt > terminalAt) {
     // Newer terminal evidence reconciles the run. This covers replay/receipt
     // races where an earlier attempt failed but a later attempt recovered and
@@ -619,7 +654,7 @@ function retryablePlatformDeployFailureSnapshot(
   if (
     isTerminalPlayRunLedgerStatus(base.status) ||
     !eventError ||
-    normalizePlayRunFailure(eventError).code !== 'PLATFORM_DEPLOY_INTERRUPTED'
+    !isRawPlatformDeployResetText(eventError)
   ) {
     return null;
   }
@@ -717,7 +752,12 @@ export function reducePlayRunLedgerEvent(
       });
     case 'run.completed':
       return (
-        conflictingTerminalSnapshot(base, event.type, occurredAt) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, null, {
+          allowStaleSameStatusPayloadMerge:
+            (base.result === undefined && event.result !== undefined) ||
+            (base.resultSummary === undefined &&
+              event.resultSummary !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'completed', occurredAt),
           status: 'completed',
@@ -733,16 +773,18 @@ export function reducePlayRunLedgerEvent(
     case 'run.failed':
       return (
         retryablePlatformDeployFailureSnapshot(base, event.error) ??
-        conflictingTerminalSnapshot(
-          base,
-          event.type,
-          occurredAt,
-          event.error,
-        ) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {
+          allowStaleSameStatusPayloadMerge:
+            (base.error == null && event.error != null) ||
+            (base.result === undefined && event.result !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'failed',
-          error: event.error ?? base.error ?? null,
+          error:
+            base.status === 'failed'
+              ? (base.error ?? event.error ?? null)
+              : (event.error ?? base.error ?? null),
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,
@@ -752,16 +794,18 @@ export function reducePlayRunLedgerEvent(
       );
     case 'run.cancelled':
       return (
-        conflictingTerminalSnapshot(
-          base,
-          event.type,
-          occurredAt,
-          event.error,
-        ) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {
+          allowStaleSameStatusPayloadMerge:
+            (base.error == null && event.error != null) ||
+            (base.result === undefined && event.result !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'cancelled',
-          error: event.error ?? base.error ?? null,
+          error:
+            base.status === 'cancelled'
+              ? (base.error ?? event.error ?? null)
+              : (event.error ?? base.error ?? null),
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.177",
+  version: "0.1.179",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.177",
+    latest: "0.1.179",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -16929,7 +16929,8 @@ var HEAVY_ENRICH_AUTO_BATCH_PLAYS = /* @__PURE__ */ new Set([
 var HEAVY_ENRICH_AUTO_BATCH_TOOLS = /* @__PURE__ */ new Set([
   "ai_inference",
   "aiinference",
-  "deeplineagent"
+  "deeplineagent",
+  "exa_answer"
 ]);
 var ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER = "__deeplineTestAiInference";
 var PLAN_SHAPING_OPTION_NAMES = [

package/dist/cli/index.mjs

@@ -608,10 +608,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.177",
+  version: "0.1.179",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.177",
+    latest: "0.1.179",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -16956,7 +16956,8 @@ var HEAVY_ENRICH_AUTO_BATCH_PLAYS = /* @__PURE__ */ new Set([
 var HEAVY_ENRICH_AUTO_BATCH_TOOLS = /* @__PURE__ */ new Set([
   "ai_inference",
   "aiinference",
-  "deeplineagent"
+  "deeplineagent",
+  "exa_answer"
 ]);
 var ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER = "__deeplineTestAiInference";
 var PLAN_SHAPING_OPTION_NAMES = [

package/dist/index.js

@@ -422,10 +422,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.177",
+  version: "0.1.179",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.177",
+    latest: "0.1.179",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -352,10 +352,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.177",
+  version: "0.1.179",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.177",
+    latest: "0.1.179",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.177",
+  "version": "0.1.179",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {