deepline 0.1.224 → 0.1.226

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

@@ -7836,6 +7836,9 @@ async function executeRunRequest(
         occurredAt: event.at,
         stepId: event.nodeId,
         kind: event.type,
+        ...(event.transition === 'failed' && event.error
+          ? { error: event.error }
+          : {}),
       },
     ];
     flushLedgerEvents(false);
@@ -8317,7 +8320,8 @@ async function executeRunRequest(
       durationMs: nowMs() - startedAt,
     };
   } catch (error) {
-    stepLifecycle?.markStartedFailed(nowMs());
+    const failure = normalizePlayRunFailure(error);
+    stepLifecycle?.markStartedFailed(nowMs(), failure.message);
     // A runtime-limit abort is a timeout failure, not a user cancellation, so
     // it should be reported as run.failed with the limit message rather than
     // run.cancelled.
@@ -8329,7 +8333,6 @@ async function executeRunRequest(
         error instanceof Error ? error.message : 'Play run cancelled.',
       );
     }
-    const failure = normalizePlayRunFailure(error);
     const message = failure.message;
     // Controlled run-fatal teardown: release the runtime-sheet row leases and
     // work-receipt leases this attempt still holds so an immediate rerun is not
@@ -8369,6 +8372,9 @@ async function executeRunRequest(
             retryable: failure.retryable,
             ...(errorBilling ? { billing: errorBilling } : {}),
             ...(failure.cause ? { cause: failure.cause } : {}),
+            ...(failure.name ? { name: failure.name } : {}),
+            ...(failure.stack ? { stack: failure.stack } : {}),
+            ...(failure.causes ? { causes: failure.causes } : {}),
           },
         ],
       });

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

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.224',
+  version: '0.1.226',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.224',
+    latest: '0.1.226',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/observability/tracing.ts

@@ -1,4 +1,5 @@
 import {
+  INVALID_SPAN_CONTEXT,
   SpanKind,
   SpanStatusCode,
   trace,
@@ -10,6 +11,97 @@ type PrimitiveAttribute = string | number | boolean | null | undefined;
 
 type TraceAttributes = Record<string, PrimitiveAttribute>;
 
+const NOOP_SPAN: Span = {
+  spanContext: () => INVALID_SPAN_CONTEXT,
+  setAttribute: () => NOOP_SPAN,
+  setAttributes: () => NOOP_SPAN,
+  addEvent: () => NOOP_SPAN,
+  addLink: () => NOOP_SPAN,
+  addLinks: () => NOOP_SPAN,
+  setStatus: () => NOOP_SPAN,
+  updateName: () => NOOP_SPAN,
+  end: () => undefined,
+  isRecording: () => false,
+  recordException: () => undefined,
+};
+
+function discardTelemetryResult(invoke: () => unknown): void {
+  try {
+    const result = invoke();
+    if (
+      result === null ||
+      (typeof result !== 'object' && typeof result !== 'function')
+    ) {
+      return;
+    }
+    let then: unknown;
+    try {
+      then = Reflect.get(result, 'then');
+    } catch {
+      return;
+    }
+    if (typeof then === 'function') {
+      void Promise.resolve(result).catch(() => undefined);
+    }
+  } catch {}
+}
+
+function nonBlockingSpan(span: Span): Span {
+  const safeSpan: Span = {
+    spanContext() {
+      try {
+        return span.spanContext();
+      } catch {
+        return INVALID_SPAN_CONTEXT;
+      }
+    },
+    setAttribute(key, value) {
+      discardTelemetryResult(() => span.setAttribute(key, value));
+      return safeSpan;
+    },
+    setAttributes(attributes) {
+      discardTelemetryResult(() => span.setAttributes(attributes));
+      return safeSpan;
+    },
+    addEvent(name, attributesOrStartTime, startTime) {
+      discardTelemetryResult(() =>
+        span.addEvent(name, attributesOrStartTime, startTime),
+      );
+      return safeSpan;
+    },
+    addLink(link) {
+      discardTelemetryResult(() => span.addLink(link));
+      return safeSpan;
+    },
+    addLinks(links) {
+      discardTelemetryResult(() => span.addLinks(links));
+      return safeSpan;
+    },
+    setStatus(status) {
+      discardTelemetryResult(() => span.setStatus(status));
+      return safeSpan;
+    },
+    updateName(name) {
+      discardTelemetryResult(() => span.updateName(name));
+      return safeSpan;
+    },
+    end(endTime) {
+      discardTelemetryResult(() => span.end(endTime));
+    },
+    isRecording() {
+      try {
+        return span.isRecording();
+      } catch {
+        return false;
+      }
+    },
+    recordException(exception, time) {
+      discardTelemetryResult(() => span.recordException(exception, time));
+    },
+  };
+  return safeSpan;
+}
+
 function normalizeAttributes(
   attributes: TraceAttributes | undefined,
 ): Attributes | undefined {
@@ -60,34 +152,67 @@ export async function withActiveSpan<T>(
   },
   fn: (span: Span) => Promise<T> | T,
 ): Promise<T> {
-  const tracer = trace.getTracer(options.tracer ?? 'deepline');
-  return await tracer.startActiveSpan(
-    name,
-    {
-      kind: options.kind,
-      attributes: normalizeAttributes(options.attributes),
-    },
-    async (span) => {
+  let operationPromise: Promise<T> | null = null;
+  const runOperation = async (span: Span): Promise<T> => {
+    const safeSpan = nonBlockingSpan(span);
+    try {
+      const result = await fn(safeSpan);
+      safeSpan.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (error) {
       try {
-        const result = await fn(span);
-        span.setStatus({ code: SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        recordError(span, error);
-        throw error;
-      } finally {
-        span.end();
+        recordError(safeSpan, error);
+      } catch {
+        // Error telemetry must not replace the operation's real error.
       }
-    },
-  );
+      throw error;
+    } finally {
+      safeSpan.end();
+    }
+  };
+  const startOperation = (span: Span): Promise<T> => {
+    if (operationPromise) return operationPromise;
+    let resolveOperation!: (value: T | PromiseLike<T>) => void;
+    let rejectOperation!: (reason?: unknown) => void;
+    operationPromise = new Promise<T>((resolve, reject) => {
+      resolveOperation = resolve;
+      rejectOperation = reject;
+    });
+    void runOperation(span).then(resolveOperation, rejectOperation);
+    return operationPromise;
+  };
+
+  let tracerResult: unknown;
+  try {
+    const tracer = trace.getTracer(options.tracer ?? 'deepline');
+    tracerResult = tracer.startActiveSpan(
+      name,
+      {
+        kind: options.kind,
+        attributes: normalizeAttributes(options.attributes),
+      },
+      (span) => startOperation(span),
+    );
+  } catch {}
+
+  // A non-conforming exporter may return work unrelated to the callback.
+  // Drain its rejection without awaiting it; only execution owns latency and
+  // the returned success/failure contract.
+  discardTelemetryResult(() => tracerResult);
+
+  // A broken tracer may return without invoking the callback. Execution is
+  // authoritative, so run it once without telemetry in that case.
+  return await startOperation(NOOP_SPAN);
 }
 
 export function setSpanAttributes(
   span: Span,
   attributes: TraceAttributes,
 ): void {
-  const normalized = normalizeAttributes(attributes);
-  if (normalized) {
-    span.setAttributes(normalized);
-  }
+  try {
+    const normalized = normalizeAttributes(attributes);
+    if (normalized) {
+      discardTelemetryResult(() => span.setAttributes(normalized));
+    }
+  } catch {}
 }

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

@@ -33,6 +33,8 @@ import { createRuntimeReceiptHeartbeatSupervisor } from './receipt-heartbeat-sup
 import { dispatchBoundedSettled } from './bounded-dispatch';
 import type { PlayQueueHint } from './governor/rate-state-backend';
 import type { MapRowOutcome } from './durability-store';
+import { stringifyPostgresJson } from './postgres-json';
+import { RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE } from './runtime-sheet-row-transition';
 import type { WorkReceiptFailureKind } from './work-receipts';
 import {
   completedMapRowOutcome,
@@ -3090,9 +3092,19 @@ export class PlayContextImpl {
   // are no-ops for any value that is not a tool result.
 
   private serializeCellValue(value: unknown): unknown {
-    return isToolExecuteResult(value)
+    const serialized = isToolExecuteResult(value)
       ? serializeToolExecuteResult(value)
       : value;
+    try {
+      stringifyPostgresJson(serialized);
+    } catch (error) {
+      throw new Error(
+        `${RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE}: Dataset cell output is not JSON-serializable: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+    return serialized;
   }
 
   private rehydrateCellValue(value: unknown): unknown {
@@ -5391,6 +5403,7 @@ export class PlayContextImpl {
           });
 
           let value: unknown;
+          let cellValue: unknown;
           try {
             value = await rowContext.run(
               {
@@ -5411,6 +5424,7 @@ export class PlayContextImpl {
                   this.previousCellForField(baseRow, fieldName),
                 ),
             );
+            cellValue = this.serializeCellValue(value);
           } catch (error) {
             if (
               isPlayRowExecutionSuspendedError(error) ||
@@ -5482,7 +5496,6 @@ export class PlayContextImpl {
             });
             return FAILED_ROW;
           }
-          const cellValue = this.serializeCellValue(value);
           computedFields[fieldName] = cellValue;
           this.rowStates.get(idx)?.results.set(fieldName, cellValue);
           const currentCellMeta =

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -35,6 +35,7 @@ export type PlayVisualNodeProgressSnapshot = {
 export type PlayVisualNodeStateSnapshot = {
   nodeId: string;
   status: PlayVisualNodeStatus;
+  error?: string | null;
   artifactTableNamespace?: string | null;
   progress?: PlayVisualNodeProgressSnapshot | null;
   startedAt?: number | null;

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

@@ -1,9 +1,71 @@
-const POSTGRES_UNSUPPORTED_NUL_RE = /\u0000/g;
+const POSTGRES_JSON_REPLACEMENT_CHARACTER = '\uFFFD';
+const POSTGRES_JSON_SUSPECT_CODE_UNIT_RE = /[\u0000\uD800-\uDFFF]/;
+
+function sanitizePostgresJsonString(value: string): string {
+  if (!POSTGRES_JSON_SUSPECT_CODE_UNIT_RE.test(value)) return value;
+
+  let sanitized = '';
+  let changed = false;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0) {
+      changed = true;
+      continue;
+    }
+
+    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const nextCodeUnit = value.charCodeAt(index + 1);
+      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {
+        sanitized += value[index] + value[index + 1];
+        index += 1;
+        continue;
+      }
+      sanitized += POSTGRES_JSON_REPLACEMENT_CHARACTER;
+      changed = true;
+      continue;
+    }
+
+    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+      sanitized += POSTGRES_JSON_REPLACEMENT_CHARACTER;
+      changed = true;
+      continue;
+    }
+
+    sanitized += value[index];
+  }
+
+  return changed ? sanitized : value;
+}
 
 function postgresJsonReplacer(_key: string, value: unknown): unknown {
-  return typeof value === 'string'
-    ? value.replace(POSTGRES_UNSUPPORTED_NUL_RE, '')
-    : value;
+  if (typeof value === 'string') {
+    return sanitizePostgresJsonString(value);
+  }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return value;
+  }
+
+  const keys = Object.keys(value);
+  if (!keys.some((key) => sanitizePostgresJsonString(key) !== key)) {
+    return value;
+  }
+  const sanitizedEntries: Array<[string, unknown]> = [];
+  const sanitizedKeys = new Set<string>();
+  for (const key of keys) {
+    const sanitizedKey = sanitizePostgresJsonString(key);
+    if (sanitizedKeys.has(sanitizedKey)) {
+      throw new TypeError(
+        'Postgres JSON key normalization produced a duplicate object key.',
+      );
+    }
+    sanitizedKeys.add(sanitizedKey);
+    sanitizedEntries.push([
+      sanitizedKey,
+      (value as Record<string, unknown>)[key],
+    ]);
+  }
+  return Object.fromEntries(sanitizedEntries);
 }
 
 export function sanitizePostgresJsonValue<T>(value: T): T {

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

@@ -12,6 +12,7 @@ import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
 import type { PlayRunInputPayload } from './play-input';
+import type { PlayRunFailureDetails } from './run-failure';
 
 export type PlayRunnerRateStateBackendConfig =
   | {
@@ -165,6 +166,7 @@ export interface PlayRunnerExecutionConfig {
   artifactTransport?: {
     bundledCodePath?: string | null;
     bundledCodeEncoding?: 'utf8' | 'gzip';
+    sourceMapPath?: string | null;
   } | null;
   input: PlayRunInputPayload;
   checkpoint?: PlayCheckpoint | null;
@@ -241,6 +243,7 @@ export type PlayRunnerResult =
   | {
       status: 'failed';
       error: string;
+      errors?: PlayRunFailureDetails[];
       logs: string[];
       stats: Record<string, unknown>;
       steps: PlayStep[];

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

@@ -6,6 +6,7 @@ const CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE =
   /The requested endpoint could not be found, or you don't have access to it\. Please check the provided ID and try again\./i;
 const VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE =
   /runtime API 404:[\s\S]*(?:DeploymentNotFound|DEPLOYMENT_NOT_FOUND|requested deployment .*exist|deployment could not be found on Vercel)/i;
+const RUNTIME_SANDBOX_LOST_RE = /\bRUNTIME_SANDBOX_LOST\b/i;
 
 export const PLATFORM_DEPLOY_INTERRUPTED_MESSAGE =
   'Run interrupted by a platform deploy. Deepline retries this automatically when possible; if this error is still visible, re-run the same command.';
@@ -16,6 +17,8 @@ export const PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED_MESSAGE =
 
 export const INTERNAL_RUNTIME_STORAGE_ERROR_MESSAGE =
   'Internal play runtime storage failed. Please retry the run; if this keeps happening, contact Deepline support with the run ID.';
+export const RUNTIME_SANDBOX_LOST_MESSAGE =
+  'The execution sandbox became unreachable before returning a terminal result. Re-run the same command; if this keeps happening, contact Deepline support with the run ID.';
 
 export const WORKSPACE_STORAGE_NOT_READY_CODE = 'WORKSPACE_STORAGE_NOT_READY';
 
@@ -90,11 +93,7 @@ export class ProviderExhaustedError extends Error {
   readonly provider: string;
   /** ISO 8601 retry deadline (from the server Retry-After / cooldown). */
   readonly retryAt: string;
-  constructor(input: {
-    provider: string;
-    retryAtMs: number;
-    cause?: unknown;
-  }) {
+  constructor(input: { provider: string; retryAtMs: number; cause?: unknown }) {
     // Prefix the code token so `String(error)` and any persisted error string
     // carry it across the serialization boundary back to the CLI, exactly like
     // WorkspaceStorageNotReadyError.
@@ -124,8 +123,7 @@ export class ProviderExhaustedError extends Error {
  */
 export function providerNameFromBucketId(bucketId: string): string {
   const separator = bucketId.indexOf(':');
-  const provider =
-    separator >= 0 ? bucketId.slice(separator + 1) : bucketId;
+  const provider = separator >= 0 ? bucketId.slice(separator + 1) : bucketId;
   return provider.startsWith('tool:')
     ? provider.slice('tool:'.length)
     : provider;
@@ -137,8 +135,66 @@ export type PlayRunFailureDetails = {
   message: string;
   retryable: boolean | null;
   cause?: string;
+  name?: string;
+  stack?: string;
+  causes?: string[];
 };
 
+const PUBLIC_FAILURE_STACK_LINE_LIMIT = 12;
+const PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+const PUBLIC_FAILURE_CAUSE_LIMIT = 8;
+const PUBLIC_FAILURE_CAUSE_LENGTH_LIMIT = 1_000;
+
+function boundedFailureText(value: string): string {
+  const encoder = new TextEncoder();
+  if (encoder.encode(value).byteLength <= PUBLIC_FAILURE_TEXT_BYTE_LIMIT) {
+    return value;
+  }
+  let bytes = 0;
+  let output = '';
+  for (const character of value) {
+    const characterBytes = encoder.encode(character).byteLength;
+    if (bytes + characterBytes > PUBLIC_FAILURE_TEXT_BYTE_LIMIT) break;
+    output += character;
+    bytes += characterBytes;
+  }
+  return `${output}\n[truncated]`;
+}
+
+function boundedFailureStack(error: Error): string | undefined {
+  if (typeof error.stack !== 'string' || !error.stack.trim()) return undefined;
+  return boundedFailureText(
+    error.stack.split('\n').slice(0, PUBLIC_FAILURE_STACK_LINE_LIMIT).join('\n'),
+  );
+}
+
+function failureCauseTexts(error: Error): string[] {
+  const queue: unknown[] = [];
+  const seen = new Set<unknown>([error]);
+  const causes: string[] = [];
+  const withCause = error as Error & { cause?: unknown };
+  if (withCause.cause !== undefined) queue.push(withCause.cause);
+  if (error instanceof AggregateError) queue.push(...error.errors);
+
+  while (queue.length > 0 && causes.length < PUBLIC_FAILURE_CAUSE_LIMIT) {
+    const current = queue.shift();
+    if (current === undefined || current === null || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    const text = toErrorText(current).trim();
+    if (text && text !== error.message && !causes.includes(text)) {
+      causes.push(text.slice(0, PUBLIC_FAILURE_CAUSE_LENGTH_LIMIT));
+    }
+    if (current instanceof Error) {
+      const nested = current as Error & { cause?: unknown };
+      if (nested.cause !== undefined) queue.push(nested.cause);
+      if (current instanceof AggregateError) queue.push(...current.errors);
+    }
+  }
+  return causes;
+}
+
 function toErrorText(error: unknown): string {
   if (error instanceof Error) {
     return error.message;
@@ -147,8 +203,23 @@ function toErrorText(error: unknown): string {
 }
 
 export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
-  const cause = toErrorText(error);
-  if (CLOUDFLARE_DURABLE_OBJECT_RESET_RE.test(cause)) {
+  const rawCause = toErrorText(error);
+  const cause = boundedFailureText(rawCause);
+  if (RUNTIME_SANDBOX_LOST_RE.test(rawCause)) {
+    const stack = error instanceof Error ? boundedFailureStack(error) : null;
+    const causes = error instanceof Error ? failureCauseTexts(error) : [];
+    return {
+      code: 'RUNTIME_SANDBOX_LOST',
+      phase: 'infrastructure',
+      message: RUNTIME_SANDBOX_LOST_MESSAGE,
+      retryable: true,
+      cause,
+      ...(error instanceof Error ? { name: error.name || 'Error' } : {}),
+      ...(stack ? { stack } : {}),
+      ...(causes.length > 0 ? { causes } : {}),
+    };
+  }
+  if (CLOUDFLARE_DURABLE_OBJECT_RESET_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_DEPLOY_INTERRUPTED',
       phase: 'runtime',
@@ -157,7 +228,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE.test(cause)) {
+  if (VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_DEPLOY_INTERRUPTED',
       phase: 'runtime',
@@ -166,7 +237,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (CLOUDFLARE_WORKER_SUBREQUEST_LIMIT_RE.test(cause)) {
+  if (CLOUDFLARE_WORKER_SUBREQUEST_LIMIT_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED',
       phase: 'runtime',
@@ -175,7 +246,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE.test(cause)) {
+  if (CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED',
       phase: 'runtime',
@@ -184,7 +255,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  const playDepthBudgetMatch = cause.match(
+  const playDepthBudgetMatch = rawCause.match(
     /Play execution playDepth budget exceeded \((\d+)\/(\d+)\)\./,
   );
   if (playDepthBudgetMatch) {
@@ -198,7 +269,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
   }
   if (
     error instanceof ProviderExhaustedError ||
-    /\bPROVIDER_EXHAUSTED\b/.test(cause)
+    /\bPROVIDER_EXHAUSTED\b/.test(rawCause)
   ) {
     // The human message (provider + retry time) already lives in `cause` after
     // the code token prefix; surface it verbatim minus the token so the run
@@ -218,7 +289,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
   }
   if (
     error instanceof WorkspaceStorageNotReadyError ||
-    /\bWORKSPACE_STORAGE_NOT_READY\b/.test(cause)
+    /\bWORKSPACE_STORAGE_NOT_READY\b/.test(rawCause)
   ) {
     return {
       code: WORKSPACE_STORAGE_NOT_READY_CODE,
@@ -242,10 +313,27 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       retryable: true,
     };
   }
+  const diagnostics =
+    error instanceof Error
+      ? {
+          name: error.name || 'Error',
+          stack: boundedFailureStack(error),
+          causes: failureCauseTexts(error),
+        }
+      : null;
   return {
     code: 'RUN_FAILED',
     phase: 'runtime',
     message: cause,
     retryable: null,
+    ...(diagnostics
+      ? {
+          name: diagnostics.name,
+          ...(diagnostics.stack ? { stack: diagnostics.stack } : {}),
+          ...(diagnostics.causes.length > 0
+            ? { causes: diagnostics.causes }
+            : {}),
+        }
+      : {}),
   };
 }

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

@@ -78,6 +78,7 @@ export type PlayRunLedgerStepSnapshot = {
   label?: string;
   kind?: string;
   status: PlayRunLedgerStepStatus;
+  error?: string | null;
   artifactTableNamespace?: string | null;
   startedAt?: number | null;
   completedAt?: number | null;
@@ -480,6 +481,7 @@ export function normalizePlayRunLedgerSnapshot(
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace,
       ),
@@ -1255,6 +1257,7 @@ export function reducePlayRunLedgerEvent(
         label: event.label ?? current?.label,
         kind: event.kind ?? current?.kind,
         status,
+        error: current?.error ?? null,
         artifactTableNamespace:
           progress?.artifactTableNamespace ??
           current?.artifactTableNamespace ??
@@ -1308,6 +1311,12 @@ export function reducePlayRunLedgerEvent(
         label: event.label ?? current?.label,
         kind: event.kind ?? current?.kind,
         status,
+        error:
+          event.type === 'step.failed'
+            ? (event.error ?? current?.error ?? null)
+            : preserveFailedStatus
+              ? (current?.error ?? null)
+              : null,
         artifactTableNamespace:
           event.artifactTableNamespace ??
           current?.artifactTableNamespace ??

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

@@ -46,6 +46,7 @@ export type PlayRunStreamNodeProgress = {
 export type PlayRunStreamNodeState = {
   nodeId: string;
   status: 'idle' | 'running' | 'completed' | 'failed' | 'skipped';
+  error?: string | null;
   artifactTableNamespace?: string | null;
   progress?: PlayRunStreamNodeProgress | null;
   startedAt?: number | null;
@@ -167,6 +168,7 @@ function buildSnapshotFromLedger(
     .map((step) => ({
       nodeId: step.stepId,
       status: step.status,
+      error: step.error ?? null,
       artifactTableNamespace: step.artifactTableNamespace ?? null,
       progress: step.progress
         ? {

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-payload-transport.ts

@@ -19,6 +19,7 @@ type DaytonaPayloadEnvelope = {
   schemaVersion: 1;
   runnerCode: string;
   artifactBundledCode: string;
+  artifactSourceMap: string;
   config: PlayRunnerExecutionConfig;
   /** Crash-containment epilogue script (see buildDaytonaCrashTerminalPusherSource). */
   crashPusherCode: string;
@@ -50,10 +51,11 @@ function nodeMaterializePayloadCommand(input: {
   runnerPath: string;
   configPath: string;
   artifactCodePath: string;
+  artifactSourceMapPath: string;
   crashPusherPath: string;
 }): string {
   const script =
-    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.crashPusherCode);";
+    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.artifactSourceMap);fs.writeFileSync(process.argv[6],p.crashPusherCode);";
   return [
     'node',
     '-e',
@@ -62,6 +64,7 @@ function nodeMaterializePayloadCommand(input: {
     shellQuote(input.runnerPath),
     shellQuote(input.configPath),
     shellQuote(input.artifactCodePath),
+    shellQuote(input.artifactSourceMapPath),
     shellQuote(input.crashPusherPath),
   ].join(' ');
 }
@@ -236,6 +239,7 @@ export async function stageDaytonaRunnerPayload(input: {
   const envelopePath = `${workDir}/deepline-play-payload-${randomUUID()}.json.gz`;
   const configPath = `${workDir}/deepline-play-config-${randomUUID()}.json`;
   const artifactCodePath = `${workDir}/deepline-play-artifact-${randomUUID()}.cjs`;
+  const artifactSourceMapPath = `${artifactCodePath}.map`;
   const crashPusherPath = `${workDir}/deepline-play-crash-terminal-${randomUUID()}.cjs`;
 
   const remoteMaterializedFiles: Record<string, string> = {};
@@ -306,6 +310,7 @@ export async function stageDaytonaRunnerPayload(input: {
     artifactTransport: {
       bundledCodePath: artifactCodePath,
       bundledCodeEncoding: 'utf8',
+      sourceMapPath: artifactSourceMapPath,
     },
     workspaceRoot: input.workDir,
     csvSourcePath: hasInlineCsv
@@ -330,6 +335,7 @@ export async function stageDaytonaRunnerPayload(input: {
         schemaVersion: 1,
         runnerCode: bundle,
         artifactBundledCode: compactedArtifact.bundledCode,
+        artifactSourceMap: input.config.artifact.sourceMap,
         config: remoteConfig,
         crashPusherCode: buildDaytonaCrashTerminalPusherSource(),
       }),
@@ -355,6 +361,7 @@ export async function stageDaytonaRunnerPayload(input: {
     runnerPath,
     configPath,
     artifactCodePath,
+    artifactSourceMapPath,
     crashPusherPath,
   })} && DEEPLINE_PLAY_RUNNER_READY_PATH=${shellQuote(readyPath)} DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact ${runnerTraceEnv}node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
   // Crash-containment epilogue: runs UNCONDITIONALLY after the runner exits and

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

@@ -80,6 +80,7 @@ import {
 import type { MapRowOutcome } from './durability-store';
 import {
   normalizeRuntimeMapInputIndex,
+  prepareRuntimeSheetRowsForJsonTransport,
   prepareRuntimeSheetRowTransitions,
   type RuntimePreparedCompletedRow,
   type RuntimePreparedFailedRow,
@@ -614,10 +615,22 @@ async function postRuntimeApi<TResponse>(
       typeof parsed?.error === 'string'
         ? parsed.error
         : `Runtime API request failed with status ${response.status}.`;
+    const errorCode = typeof parsed?.code === 'string' ? parsed.code : null;
+    const errorAction =
+      typeof parsed?.action === 'string' ? parsed.action : body.action;
+    const requestId = response.headers.get('x-deepline-request-id');
+    const diagnosticContext = [
+      `status ${response.status}`,
+      errorCode ? `code=${errorCode}` : null,
+      errorAction ? `action=${errorAction}` : null,
+      requestId ? `request_id=${requestId}` : null,
+    ]
+      .filter((value): value is string => Boolean(value))
+      .join(', ');
     throw new Error(
       details
-        ? `${errorMessage} (status ${response.status}): ${details}`
-        : `${errorMessage} (status ${response.status}).`,
+        ? `${errorMessage} (${diagnosticContext}): ${details}`
+        : `${errorMessage} (${diagnosticContext}).`,
     );
   }
 
@@ -6151,12 +6164,8 @@ async function completeRuntimeMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const targetChangedPatchedCellSql = changedPatchedCellSql(
       'target',
       'updates.data_patch',
@@ -6418,12 +6427,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const targetChangedPatchedCellSql = changedPatchedCellSql(
       'target',
       'updates.data_patch',
@@ -6661,12 +6666,8 @@ async function insertMissingCompletedMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const { rows } = await client.query<{ inserted: number }>(
       `WITH input_rows AS (
          SELECT key_values._key,
@@ -6833,12 +6834,8 @@ async function failRuntimeMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const chunkErrors = chunk.map((row) => row.error);
     // Per-field failed-cell counts for the column summary, computed from the
     // cell meta patches (a failed row records exactly which cell failed).
@@ -7064,9 +7061,21 @@ export async function completeRuntimeMapRows(
   },
 ): Promise<RuntimeMapRowsWriteResult> {
   if (context.dbSessionStrategy === 'gateway_only') {
+    const keyedRows = input.rows.map((row) => {
+      if (row.key) return row;
+      const key = resolveMapRowOutcomeKey(
+        row as unknown as Record<string, unknown>,
+      );
+      return key ? { ...row, key } : row;
+    });
+    const rows = prepareRuntimeSheetRowsForJsonTransport({
+      rows: keyedRows,
+      runId: input.runId,
+      outputFields: input.outputFields ?? [],
+    });
     return await postRuntimeApi<RuntimeMapRowsWriteResult>(context, {
       action: 'runtime_sheet_complete_map_rows',
-      input,
+      input: { ...input, rows },
     });
   }
   if (input.rows.length === 0) {

package/dist/bundling-sources/shared_libs/play-runtime/runtime-sheet-row-transition.ts

@@ -1,10 +1,22 @@
 import type { MapRowOutcome } from './durability-store';
+import { stringifyPostgresJson } from './postgres-json';
+
+export const RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE =
+  'RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE';
+
+const RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE_MESSAGE =
+  `${RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE}: Row output is not JSON-serializable. ` +
+  'Remove BigInt values, circular references, and throwing toJSON implementations.';
 
 export type RuntimePreparedCompletedRow = {
   key: string;
   input_index: number | null;
   data_patch: Record<string, unknown>;
   cell_meta_patch: Record<string, unknown>;
+  /** Serialized once at the row boundary so SQL batching cannot re-run toJSON. */
+  data_patch_json: string;
+  /** Serialized once at the row boundary so SQL batching cannot re-run toJSON. */
+  cell_meta_patch_json: string;
 };
 
 export type RuntimePreparedFailedRow = RuntimePreparedCompletedRow & {
@@ -50,6 +62,51 @@ export function completedRuntimeCellMetaPatch(input: {
   return patch;
 }
 
+function serializeRuntimeRowPatch(value: Record<string, unknown>): string {
+  const serialized = stringifyPostgresJson(value);
+  if (serialized === undefined) {
+    throw new TypeError('JSON.stringify returned undefined.');
+  }
+  return serialized;
+}
+
+function unserializableRuntimeRowFailure(input: {
+  key: string;
+  inputIndex: number | null;
+  runId: string;
+  outputFields: readonly string[];
+}): RuntimePreparedFailedRow {
+  let cellMetaPatch = Object.fromEntries(
+    input.outputFields.map((field) => [
+      field,
+      {
+        status: 'failed',
+        runId: input.runId,
+        error: RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE_MESSAGE,
+      },
+    ]),
+  );
+  let cellMetaPatchJson: string;
+  try {
+    cellMetaPatchJson = serializeRuntimeRowPatch(cellMetaPatch);
+  } catch {
+    // Authored output field names can themselves collide after PostgreSQL JSON
+    // normalization. Preserve the explicit row failure instead of allowing
+    // diagnostic metadata to turn it back into a batch-fatal exception.
+    cellMetaPatch = {};
+    cellMetaPatchJson = '{}';
+  }
+  return {
+    key: input.key,
+    input_index: input.inputIndex,
+    data_patch: {},
+    cell_meta_patch: cellMetaPatch,
+    data_patch_json: '{}',
+    cell_meta_patch_json: cellMetaPatchJson,
+    error: RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE_MESSAGE,
+  };
+}
+
 export function prepareRuntimeSheetRowTransitions(input: {
   rows: Iterable<MapRowOutcome>;
   runId: string;
@@ -62,12 +119,40 @@ export function prepareRuntimeSheetRowTransitions(input: {
   const failedRows: RuntimePreparedFailedRow[] = [];
   for (const row of input.rows) {
     if (!row.key) continue;
+    const inputIndex = normalizeRuntimeMapInputIndex(row.inputIndex);
+    let cellMetaPatch: Record<string, unknown>;
+    let dataPatchJson: string;
+    let cellMetaPatchJson: string;
+    try {
+      cellMetaPatch =
+        row.status === 'failed'
+          ? (row.cellMetaPatch ?? {})
+          : completedRuntimeCellMetaPatch({
+              runId: input.runId,
+              outputFields: input.outputFields,
+              rowPatch: row.cellMetaPatch,
+            });
+      dataPatchJson = serializeRuntimeRowPatch(row.data);
+      cellMetaPatchJson = serializeRuntimeRowPatch(cellMetaPatch);
+    } catch {
+      failedRows.push(
+        unserializableRuntimeRowFailure({
+          key: row.key,
+          inputIndex,
+          runId: input.runId,
+          outputFields: input.outputFields,
+        }),
+      );
+      continue;
+    }
     if (row.status === 'failed') {
       failedRows.push({
         key: row.key,
-        input_index: normalizeRuntimeMapInputIndex(row.inputIndex),
+        input_index: inputIndex,
         data_patch: row.data,
-        cell_meta_patch: row.cellMetaPatch ?? {},
+        cell_meta_patch: cellMetaPatch,
+        data_patch_json: dataPatchJson,
+        cell_meta_patch_json: cellMetaPatchJson,
         error:
           typeof row.error === 'string' && row.error.trim()
             ? row.error
@@ -77,14 +162,47 @@ export function prepareRuntimeSheetRowTransitions(input: {
     }
     completedRows.push({
       key: row.key,
-      input_index: normalizeRuntimeMapInputIndex(row.inputIndex),
+      input_index: inputIndex,
       data_patch: row.data,
-      cell_meta_patch: completedRuntimeCellMetaPatch({
-        runId: input.runId,
-        outputFields: input.outputFields,
-        rowPatch: row.cellMetaPatch,
-      }),
+      cell_meta_patch: cellMetaPatch,
+      data_patch_json: dataPatchJson,
+      cell_meta_patch_json: cellMetaPatchJson,
     });
   }
   return { completedRows, failedRows };
 }
+
+/**
+ * Apply the row serialization boundary before a gateway-only runtime request.
+ * This prevents JSON.stringify on the transport envelope from turning one
+ * malformed row into a batch-fatal error before the gateway can persist the
+ * healthy siblings.
+ */
+export function prepareRuntimeSheetRowsForJsonTransport(input: {
+  rows: Iterable<MapRowOutcome>;
+  runId: string;
+  outputFields: readonly string[];
+}): MapRowOutcome[] {
+  const rows: MapRowOutcome[] = [];
+  for (const row of input.rows) {
+    const { completedRows, failedRows } = prepareRuntimeSheetRowTransitions({
+      rows: [row],
+      runId: input.runId,
+      outputFields: input.outputFields,
+    });
+    const prepared = completedRows[0] ?? failedRows[0];
+    if (!prepared) continue;
+    const failed = failedRows[0];
+    rows.push({
+      key: prepared.key,
+      inputIndex: prepared.input_index,
+      data: JSON.parse(prepared.data_patch_json) as Record<string, unknown>,
+      cellMetaPatch: JSON.parse(prepared.cell_meta_patch_json) as Record<
+        string,
+        unknown
+      >,
+      ...(failed ? { status: 'failed' as const, error: failed.error } : {}),
+    });
+  }
+  return rows;
+}

package/dist/bundling-sources/shared_libs/play-runtime/step-lifecycle-tracker.ts

@@ -13,6 +13,7 @@ export type PlayStepLifecycleEvent = {
   type: string;
   transition: 'started' | 'completed' | 'failed';
   at: number;
+  error?: string;
 };
 
 function isAutoStartedSetupNode(type: string): boolean {
@@ -191,7 +192,7 @@ export class PlayStepLifecycleTracker {
     }
   }
 
-  markStartedFailed(at = this.now()): void {
+  markStartedFailed(at = this.now(), error?: string): void {
     for (let index = this.nodes.length - 1; index >= 0; index -= 1) {
       const node = this.nodes[index]!;
       const existing = this.getProgress()[node.nodeId];
@@ -202,6 +203,7 @@ export class PlayStepLifecycleTracker {
           type: node.type,
           transition: 'failed',
           at,
+          ...(error?.trim() ? { error: error.trim() } : {}),
         });
         return;
       }

package/dist/cli/index.js

@@ -625,10 +625,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.224",
+  version: "0.1.226",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.224",
+    latest: "0.1.226",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -1348,6 +1348,9 @@ function resolveTimingWindow(input2) {
   };
 }
 
+// ../shared_libs/play-runtime/run-failure.ts
+var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+
 // ../shared_libs/play-runtime/run-terminal-source.ts
 var PLAY_RUN_LEDGER_EVENT_SOURCES = [
   "worker",
@@ -1576,6 +1579,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace
       ),
@@ -1752,6 +1756,7 @@ function buildSnapshotFromLedger(snapshot) {
   const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
     nodeId: step.stepId,
     status: step.status,
+    error: step.error ?? null,
     artifactTableNamespace: step.artifactTableNamespace ?? null,
     progress: step.progress ? {
       completed: step.progress.completed,
@@ -13758,6 +13763,13 @@ function formatPackageValueOutputLines(packaged) {
   }
   return lines;
 }
+function authoredPackageStackFrames(packaged) {
+  const stack = readRecordArray(packaged.errors).map((entry) => typeof entry.stack === "string" ? entry.stack : null).find((candidate) => Boolean(candidate?.trim()));
+  if (!stack) return [];
+  return stack.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("at ")).filter(
+    (line) => !line.includes("/virtual/deepline-plays/") && !line.includes("/apps/play-runner/") && !line.includes("/shared_libs/play-runtime/") && !line.includes("node:internal")
+  ).slice(0, 5);
+}
 function buildRunPackageTextLines(packaged) {
   const run = readRunPackageRun(packaged);
   const runId = typeof run.id === "string" ? run.id : "unknown";
@@ -13769,6 +13781,11 @@ function buildRunPackageTextLines(packaged) {
   const runError = typeof run.error === "string" && run.error.trim() ? run.error.trim() : null;
   if (runError && (status === "failed" || status === "cancelled")) {
     lines.push(`  error: ${truncateErrorForDisplay(runError, runId)}`);
+    const stackFrames = authoredPackageStackFrames(packaged);
+    if (stackFrames.length > 0) {
+      lines.push("  stack:");
+      lines.push(...stackFrames.map((frame) => `    ${frame}`));
+    }
   }
   const failedLogs = readRecord(packaged.failedLogs);
   const failedLogEntries = Array.isArray(failedLogs?.entries) ? failedLogs.entries.filter(
@@ -17820,12 +17837,12 @@ function normalizeAlias(value) {
 function renderExecuteStep(command, options = {
   force: false
 }) {
-  if (command.play) {
-    return renderPlayStep(command, options);
-  }
   if (command.tool === "run_javascript" && options.inlineRunJavascript && canInlineRunJavascript(command)) {
     return renderInlineJavascriptStep(command, options);
   }
+  if (command.play) {
+    return renderPlayStep(command, options);
+  }
   if (options.idiomaticGetters) {
     return renderIdiomaticExecuteStep(command, options);
   }

package/dist/cli/index.mjs

@@ -610,10 +610,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.224",
+  version: "0.1.226",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.224",
+    latest: "0.1.226",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -1333,6 +1333,9 @@ function resolveTimingWindow(input2) {
   };
 }
 
+// ../shared_libs/play-runtime/run-failure.ts
+var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+
 // ../shared_libs/play-runtime/run-terminal-source.ts
 var PLAY_RUN_LEDGER_EVENT_SOURCES = [
   "worker",
@@ -1561,6 +1564,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace
       ),
@@ -1737,6 +1741,7 @@ function buildSnapshotFromLedger(snapshot) {
   const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
     nodeId: step.stepId,
     status: step.status,
+    error: step.error ?? null,
     artifactTableNamespace: step.artifactTableNamespace ?? null,
     progress: step.progress ? {
       completed: step.progress.completed,
@@ -13787,6 +13792,13 @@ function formatPackageValueOutputLines(packaged) {
   }
   return lines;
 }
+function authoredPackageStackFrames(packaged) {
+  const stack = readRecordArray(packaged.errors).map((entry) => typeof entry.stack === "string" ? entry.stack : null).find((candidate) => Boolean(candidate?.trim()));
+  if (!stack) return [];
+  return stack.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("at ")).filter(
+    (line) => !line.includes("/virtual/deepline-plays/") && !line.includes("/apps/play-runner/") && !line.includes("/shared_libs/play-runtime/") && !line.includes("node:internal")
+  ).slice(0, 5);
+}
 function buildRunPackageTextLines(packaged) {
   const run = readRunPackageRun(packaged);
   const runId = typeof run.id === "string" ? run.id : "unknown";
@@ -13798,6 +13810,11 @@ function buildRunPackageTextLines(packaged) {
   const runError = typeof run.error === "string" && run.error.trim() ? run.error.trim() : null;
   if (runError && (status === "failed" || status === "cancelled")) {
     lines.push(`  error: ${truncateErrorForDisplay(runError, runId)}`);
+    const stackFrames = authoredPackageStackFrames(packaged);
+    if (stackFrames.length > 0) {
+      lines.push("  stack:");
+      lines.push(...stackFrames.map((frame) => `    ${frame}`));
+    }
   }
   const failedLogs = readRecord(packaged.failedLogs);
   const failedLogEntries = Array.isArray(failedLogs?.entries) ? failedLogs.entries.filter(
@@ -17849,12 +17866,12 @@ function normalizeAlias(value) {
 function renderExecuteStep(command, options = {
   force: false
 }) {
-  if (command.play) {
-    return renderPlayStep(command, options);
-  }
   if (command.tool === "run_javascript" && options.inlineRunJavascript && canInlineRunJavascript(command)) {
     return renderInlineJavascriptStep(command, options);
   }
+  if (command.play) {
+    return renderPlayStep(command, options);
+  }
   if (options.idiomaticGetters) {
     return renderIdiomaticExecuteStep(command, options);
   }

package/dist/index.js

@@ -424,10 +424,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.224",
+  version: "0.1.226",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.224",
+    latest: "0.1.226",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -1147,6 +1147,9 @@ function resolveTimingWindow(input) {
   };
 }
 
+// ../shared_libs/play-runtime/run-failure.ts
+var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+
 // ../shared_libs/play-runtime/run-terminal-source.ts
 var PLAY_RUN_LEDGER_EVENT_SOURCES = [
   "worker",
@@ -1375,6 +1378,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace
       ),
@@ -1551,6 +1555,7 @@ function buildSnapshotFromLedger(snapshot) {
   const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
     nodeId: step.stepId,
     status: step.status,
+    error: step.error ?? null,
     artifactTableNamespace: step.artifactTableNamespace ?? null,
     progress: step.progress ? {
       completed: step.progress.completed,

package/dist/index.mjs

@@ -354,10 +354,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.224",
+  version: "0.1.226",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.224",
+    latest: "0.1.226",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -1077,6 +1077,9 @@ function resolveTimingWindow(input) {
   };
 }
 
+// ../shared_libs/play-runtime/run-failure.ts
+var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+
 // ../shared_libs/play-runtime/run-terminal-source.ts
 var PLAY_RUN_LEDGER_EVENT_SOURCES = [
   "worker",
@@ -1305,6 +1308,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace
       ),
@@ -1481,6 +1485,7 @@ function buildSnapshotFromLedger(snapshot) {
   const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
     nodeId: step.stepId,
     status: step.status,
+    error: step.error ?? null,
     artifactTableNamespace: step.artifactTableNamespace ?? null,
     progress: step.progress ? {
       completed: step.progress.completed,

package/package.json

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