deepline 0.1.210 → 0.1.212

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -380,6 +380,18 @@ export interface MapExecutionScope {
 }
 
 export type PlayExecutionEvent =
+  | {
+      type: 'dataset.lifecycle';
+      datasetId: string;
+      path: string;
+      tableNamespace: string;
+      phase: 'registered' | 'available' | 'failed';
+      persistedRows?: number;
+      succeededRows?: number;
+      failedRows?: number;
+      complete?: boolean;
+      at: number;
+    }
   | {
       type: 'map.preparing';
       mapInvocationId: string;

package/dist/bundling-sources/shared_libs/play-runtime/dataset-id.ts

@@ -1,10 +1,16 @@
-import { createHash } from 'node:crypto';
+import {
+  normalizePlayNameForSheet,
+  normalizeTableNamespace,
+  sha256Hex,
+} from '../plays/row-identity';
 
 export function createRuntimeDatasetId(
   playName: string,
   tableNamespace: string,
 ): string {
-  return createHash('sha1')
-    .update(`${playName}:${tableNamespace}`)
-    .digest('hex');
+  const normalizedPlayName = normalizePlayNameForSheet(playName);
+  const normalizedTableNamespace = normalizeTableNamespace(tableNamespace);
+  return sha256Hex(
+    `${normalizedPlayName}:${normalizedTableNamespace}`,
+  ).slice(0, 40);
 }

package/dist/bundling-sources/shared_libs/play-runtime/db-session.ts

@@ -56,6 +56,7 @@ export type CreateDbSessionRequest = {
 
 export type CreateDbSessionResponse = {
   sessionId: string;
+  executionRole?: string;
   postgresUrl?: string;
   encryptedPostgresUrl?: EncryptedPostgresUrl;
   postgres?: {
@@ -398,6 +399,14 @@ export const createDbSessionResponseSchema =
     }
     return {
       sessionId: parseString(value.sessionId, 'sessionId'),
+      ...(value.executionRole !== undefined
+        ? {
+            executionRole: parseOptionalString(
+              value.executionRole,
+              'executionRole',
+            ),
+          }
+        : {}),
       ...(value.postgresUrl !== undefined
         ? { postgresUrl: parseOptionalString(value.postgresUrl, 'postgresUrl') }
         : {}),

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -243,9 +243,11 @@ async function executeWithDurableRuntimeReceiptHeartbeat<T>(input: {
       rejectLeaseLost(error as RuntimeReceiptLeaseLostError),
   });
 
-  if ((await heartbeatOnce()) === 'active') {
-    supervisor.start();
-  }
+  // markRunning is the authoritative pre-dispatch ownership fence. Renewal is
+  // only needed when the lease approaches expiry; an immediate read/renewal
+  // adds a round trip to every short tool call without extending ownership.
+  // Completion remains conditional on this lease, and long work still renews.
+  supervisor.start();
   try {
     return await Promise.race([input.execute(), leaseLost]);
   } finally {
@@ -294,6 +296,7 @@ export async function waitForCompletedRuntimeReceipts(input: {
   maxAttempts?: number;
   delayMs?: number;
   abortSignal?: AbortSignal;
+  log?: (message: string) => void;
 }): Promise<{
   completed: Map<string, RuntimeStepReceipt>;
   failed: Map<string, Error>;
@@ -326,6 +329,20 @@ export async function waitForCompletedRuntimeReceipts(input: {
       }
       throw error;
     }
+    const statuses = [...receipts.values()].reduce<Record<string, number>>(
+      (counts, receipt) => {
+        counts[receipt.status] = (counts[receipt.status] ?? 0) + 1;
+        return counts;
+      },
+      {},
+    );
+    input.log?.(
+      `[perf] runtime-receipt-wait attempt=${attempt} requested=${pending.size} indexed=${receipts.size} statuses=${
+        Object.entries(statuses)
+          .map(([status, count]) => `${status}:${count}`)
+          .join(',') || 'none'
+      }`,
+    );
     for (const key of [...pending]) {
       const receipt = receipts.get(key);
       if (receipt?.status === 'completed' || receipt?.status === 'skipped') {
@@ -343,6 +360,9 @@ export async function waitForCompletedRuntimeReceipts(input: {
         pending.delete(key);
       }
     }
+    input.log?.(
+      `[perf] runtime-receipt-wait attempt=${attempt} remaining=${pending.size}`,
+    );
   }
 
   return { completed, failed, timedOut: pending };
@@ -374,6 +394,16 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   log: (message: string) => void;
   execute: (context: { leaseId: string | null }) => Promise<T>;
 }): Promise<T> {
+  const lifecycleStartedAt = Date.now();
+  const logPhase = (phase: string, startedAt: number): void => {
+    // Keep this at the semantic receipt layer. Transport timing below this
+    // function explains HTTP cost; these markers expose gaps before/after the
+    // store calls and prove whether user code or receipt orchestration owns the
+    // elapsed time. Do not log receipt keys because they encode tool inputs.
+    input.log(
+      `[perf] durable receipt operation=${input.operation} id=${input.id} phase=${phase} elapsed_ms=${Date.now() - startedAt} lifecycle_ms=${Date.now() - lifecycleStartedAt}`,
+    );
+  };
   if (!input.store.enabled) {
     return await input.execute({ leaseId: null });
   }
@@ -382,9 +412,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     receipt: RuntimeStepReceipt,
     source: DurableReceiptRecoverySource = 'cache',
   ): Promise<T> => {
-    input.log(
-      `ctx.${input.operation}(${input.id}): recovered result from receipt`,
-    );
+    input.log(`ctx.${input.operation}(${input.id}): reused completed work`);
     if (receipt.output === undefined) {
       return receipt.output as T;
     }
@@ -417,7 +445,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     }
     if (reclaimed?.status === 'failed') {
       throw new Error(
-        `ctx.${input.operation}(${input.id}): receipt is failed and could not be reclaimed: ${reclaimed.error ?? 'unknown error'}.`,
+        `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused: ${reclaimed.error ?? 'unknown error'}.`,
       );
     }
     if (
@@ -479,16 +507,18 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     receipt: RuntimeStepReceipt,
   ): Promise<never> => {
     throw new Error(
-      `ctx.${input.operation}(${input.id}): receipt is failed and could not be claimed: ${receipt.error ?? 'unknown error'}.`,
+      `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused: ${receipt.error ?? 'unknown error'}.`,
     );
   };
 
+  const claimStartedAt = Date.now();
   const claimed = await input.store.claim(
     input.receiptKey,
     input.runId,
     input.reclaimRunning === true || input.force === true,
     input.force === true,
   );
+  logPhase('claim', claimStartedAt);
   if (
     input.force !== true &&
     (claimed?.status === 'completed' || claimed?.status === 'skipped')
@@ -525,11 +555,13 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   let result: T;
   try {
     if (input.markRunningBeforeExecute !== false && input.store.markRunning) {
+      const markRunningStartedAt = Date.now();
       const running = await input.store.markRunning(
         input.receiptKey,
         input.runId,
         ownedLeaseId,
       );
+      logPhase('mark_running', markRunningStartedAt);
       if (!running || running.status !== 'running') {
         throw new RuntimeReceiptLeaseLostError({
           receiptKey: input.receiptKey,
@@ -540,6 +572,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       ownedLeaseId = running.leaseId ?? ownedLeaseId;
       ownedLeaseExpiresAt = running.leaseExpiresAt ?? ownedLeaseExpiresAt;
     }
+    const executeStartedAt = Date.now();
     const executed =
       ownedLeaseId && input.store.heartbeat
         ? await executeWithDurableRuntimeReceiptHeartbeat({
@@ -561,6 +594,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
             execute: () => input.execute({ leaseId: ownedLeaseId }),
           })
         : await input.execute({ leaseId: ownedLeaseId });
+    logPhase('execute', executeStartedAt);
     result = input.onClaimedResult
       ? input.onClaimedResult(executed, input.receiptKey)
       : executed;
@@ -603,12 +637,14 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     throw error;
   }
 
+  const completeStartedAt = Date.now();
   const completed = await input.store.complete(
     input.receiptKey,
     input.runId,
     isToolExecuteResult(result) ? serializeToolExecuteResult(result) : result,
     ownedLeaseId,
   );
+  logPhase('complete', completeStartedAt);
   if (
     !completed ||
     (completed.status !== 'completed' && completed.status !== 'skipped')
@@ -633,6 +669,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     completed &&
     (completed.status === 'completed' || completed.status === 'skipped')
   ) {
+    logPhase('total', lifecycleStartedAt);
     return await recoverCompletedReceipt(completed, 'owner');
   }
   if (input.store.canPersistCompletion) {

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

@@ -1,7 +1,10 @@
 import { createSecretRedactionContext } from './secret-redaction';
-import { RUNTIME_RECEIPT_OUTPUT_MAX_BYTES } from './output-size-limits';
+import {
+  assertRuntimeReceiptOutputWithinLimit,
+  TERMINAL_RUN_RESULT_MAX_BYTES,
+} from './output-size-limits';
 
-export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = RUNTIME_RECEIPT_OUTPUT_MAX_BYTES;
+export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = TERMINAL_RUN_RESULT_MAX_BYTES;
 export const MAX_LEDGER_LOG_LINES_PER_EVENT = 500;
 export const MAX_LEDGER_LOG_LINE_LENGTH = 2_000;
 
@@ -21,6 +24,15 @@ export function sanitizeLedgerPayload(value: unknown): unknown {
   return ledgerIngressRedactor.redact(value);
 }
 
+/** Secret-redact a receipt payload without coupling its 10 MiB cell limit to the ledger. */
+export function sanitizeRuntimeReceiptPayload(value: unknown): unknown {
+  assertRuntimeReceiptOutputWithinLimit({
+    output: value,
+    path: 'runtime receipt output',
+  });
+  return ledgerIngressRedactor.redact(value);
+}
+
 export function sanitizeLedgerLogLines(value: unknown): string[] {
   if (!Array.isArray(value)) return [];
   return value

package/dist/bundling-sources/shared_libs/play-runtime/output-size-limits.ts

@@ -3,8 +3,10 @@ const encoder = typeof TextEncoder === 'undefined' ? null : new TextEncoder();
 export const TERMINAL_RUN_RESULT_MAX_BYTES = 2_500_000;
 export const CUSTOMER_OUTPUT_VALUE_MAX_BYTES = 1 * 1024 * 1024;
 export const CUSTOMER_OUTPUT_TOTAL_MAX_BYTES = 2 * 1024 * 1024;
-export const RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 2 * 1024 * 1024;
-export const RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+/** Inline Postgres receipt contract: one serialized output is at most 10 MiB. */
+export const RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 10 * 1024 * 1024;
+/** One completion request may contain multiple receipts up to 32 MiB total. */
+export const RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 32 * 1024 * 1024;
 
 export class OutputTooLargeError extends Error {
   readonly code = 'OUTPUT_TOO_LARGE';

package/dist/bundling-sources/shared_libs/play-runtime/receipt-sql.ts

@@ -1,6 +1,26 @@
 import { RECEIPT_STATUS_CODE } from './receipt-status';
 import { workReceiptFailureKindCode } from './work-receipts';
 
+export function workReceiptRepairableFailurePredicateSql(
+  receiptTable: string,
+): string {
+  return `(
+    ${receiptTable}.failure_kind = ${workReceiptFailureKindCode('repairable')}::smallint
+    OR (
+      ${receiptTable}.failure_kind = ${workReceiptFailureKindCode('terminal')}::smallint
+      AND ${receiptTable}.error IS NOT NULL
+      AND lower(${receiptTable}.error) NOT LIKE '%billing cap%'
+      AND lower(${receiptTable}.error) NOT LIKE '%insufficient credits%'
+      AND lower(${receiptTable}.error) NOT LIKE '%monthly billing limit%'
+      AND (
+        ${receiptTable}.error ~* '(^|[^0-9])5[0-9]{2}([^0-9]|$)'
+        OR lower(${receiptTable}.error) LIKE '%transport failed calling%'
+        OR lower(${receiptTable}.error) LIKE '%runtime api call timed out%'
+      )
+    )
+  )`;
+}
+
 export function workReceiptClaimableStatusCodes(input: {
   forceRefresh?: boolean;
   forceFailedRefresh?: boolean;
@@ -47,7 +67,7 @@ export function workReceiptClaimConflictPredicateSql(input: {
               )
               OR ${table}.status <> ${RECEIPT_STATUS_CODE.failed}::smallint
               OR (
-                ${table}.failure_kind = ${workReceiptFailureKindCode('repairable')}::smallint
+                ${workReceiptRepairableFailurePredicateSql(table)}
                 AND (
                   ${table}.run_id IS DISTINCT FROM ${input.claimantRunIdSql}
                   OR COALESCE(${table}.lease_owner_attempt, 0) < ${claimantRunAttemptSql}::integer

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

@@ -7,6 +7,7 @@ import {
   nextPlayRunLedgerTerminalSource,
   normalizePlayRunLedgerTerminalSource,
 } from './run-terminal-source';
+import { MAX_LEDGER_LOG_LINES_PER_EVENT } from './ledger-safe-payload';
 
 export type PlayRunLedgerStatus =
   | 'queued'
@@ -84,6 +85,18 @@ export type PlayRunLedgerStepSnapshot = {
   progress?: PlayRunLedgerStepProgress | null;
 };
 
+export type PlayRunLedgerDatasetSnapshot = {
+  datasetId: string;
+  path: string;
+  tableNamespace: string;
+  phase: 'registered' | 'available' | 'failed';
+  persistedRows: number;
+  succeededRows: number;
+  failedRows: number;
+  complete: boolean;
+  updatedAt: number;
+};
+
 export type PlayRunLedgerSnapshot = {
   runId: string;
   playName?: string | null;
@@ -96,6 +109,8 @@ export type PlayRunLedgerSnapshot = {
   durationMs?: number | null;
   orderedStepIds: string[];
   stepsById: Record<string, PlayRunLedgerStepSnapshot>;
+  orderedDatasetIds: string[];
+  datasetsById: Record<string, PlayRunLedgerDatasetSnapshot>;
   /**
    * Bounded tail of the run's log lines (last {@link LOG_TAIL_LIMIT}).
    * Full retention lives in the Run Log Stream (Convex `playRunLogChunks`);
@@ -217,10 +232,34 @@ export type PlayRunLedgerEvent =
        * repeated identical lines while absorbing redundant re-sends.
        */
       channelOffset?: number;
+      /** Scheduler attempt that owns this positional log channel. */
+      producerAttempt?: number;
+      /**
+       * Terminal transport replay normally matches ctx.log lines after
+       * removing timestamps. Detached-attempt recovery uses exact matching so
+       * the same message from a later attempt remains a distinct occurrence.
+       */
+      transportDedupe?: 'semantic' | 'exact';
       /** Set by ingestion when this append crossed the retention cap. */
       logsTruncated?: boolean;
     })
   | (PlayRunLedgerBaseEvent & {
+      type: 'dataset.lifecycle';
+      datasetId: string;
+      path: string;
+      tableNamespace: string;
+      phase: 'registered' | 'available' | 'failed';
+      persistedRows?: number;
+      succeededRows?: number;
+      failedRows?: number;
+      complete?: boolean;
+    })
+  | (PlayRunLedgerBaseEvent & {
+      /**
+       * @deprecated Mixed-version deploy seam only. Owner: Play Runtime.
+       * Remove after 2026-07-19, once pre-dataset-lifecycle workers have
+       * exceeded the maximum run duration plus the seven-day drain window.
+       */
       type: 'sheet.summary.updated';
       tableNamespace: string;
       deltaCursor?: number;
@@ -241,6 +280,7 @@ export type PlayRunLedgerStatusPatch = {
    * (see `slicePositionalLogLines`), forwarded onto the `log.appended` event.
    */
   liveLogsChannelOffset?: number | null;
+  liveLogsProducerAttempt?: number | null;
   liveNodeProgress?: unknown;
   result?: unknown;
 };
@@ -401,6 +441,8 @@ export function createEmptyPlayRunLedgerSnapshot(input: {
         : null,
     orderedStepIds: [],
     stepsById: {},
+    orderedDatasetIds: [],
+    datasetsById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
@@ -447,6 +489,26 @@ export function normalizePlayRunLedgerSnapshot(
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null,
     };
   }
+  const rawDatasets = isRecord(value.datasetsById) ? value.datasetsById : {};
+  const datasetsById: Record<string, PlayRunLedgerDatasetSnapshot> = {};
+  for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
+    if (!datasetId.trim() || !isRecord(rawDataset)) continue;
+    const phase =
+      rawDataset.phase === 'available' || rawDataset.phase === 'failed'
+        ? rawDataset.phase
+        : 'registered';
+    datasetsById[datasetId] = {
+      datasetId,
+      path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
+      tableNamespace: optionalString(rawDataset.tableNamespace) ?? datasetId,
+      phase,
+      persistedRows: Math.max(0, finiteNumber(rawDataset.persistedRows) ?? 0),
+      succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
+      failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
+      complete: rawDataset.complete === true,
+      updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0,
+    };
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt =
@@ -484,6 +546,14 @@ export function normalizePlayRunLedgerSnapshot(
         : finiteNumber(value.durationMs),
     orderedStepIds: orderedStepIds.filter((stepId) => stepsById[stepId]),
     stepsById,
+    orderedDatasetIds: (Array.isArray(value.orderedDatasetIds)
+      ? value.orderedDatasetIds
+      : Object.keys(datasetsById)
+    ).filter(
+      (datasetId): datasetId is string =>
+        typeof datasetId === 'string' && Boolean(datasetsById[datasetId]),
+    ),
+    datasetsById,
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -1269,6 +1339,34 @@ export function reducePlayRunLedgerEvent(
             : null,
       });
     }
+    case 'dataset.lifecycle': {
+      const current = base.datasetsById[event.datasetId];
+      const next: PlayRunLedgerDatasetSnapshot = {
+        datasetId: event.datasetId,
+        path: event.path,
+        tableNamespace: event.tableNamespace,
+        phase: event.phase,
+        persistedRows: Math.max(
+          current?.persistedRows ?? 0,
+          event.persistedRows ?? 0,
+        ),
+        succeededRows: Math.max(
+          current?.succeededRows ?? 0,
+          event.succeededRows ?? 0,
+        ),
+        failedRows: Math.max(current?.failedRows ?? 0, event.failedRows ?? 0),
+        complete: current?.complete === true || event.complete === true,
+        updatedAt: occurredAt,
+      };
+      return withTiming({
+        ...base,
+        orderedDatasetIds: current
+          ? base.orderedDatasetIds
+          : [...base.orderedDatasetIds, event.datasetId],
+        datasetsById: { ...base.datasetsById, [event.datasetId]: next },
+        resultTableNamespace: base.resultTableNamespace ?? event.tableNamespace,
+      });
+    }
     case 'sheet.summary.updated':
       return withTiming({
         ...base,
@@ -1376,6 +1474,8 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   channelOffset?: number | null;
+  producerAttempt?: number | null;
+  transportDedupe?: 'semantic' | 'exact';
   includeLogAppend?: boolean;
 }): PlayRunLedgerEvent[] {
   const source = input.source ?? 'worker';
@@ -1392,16 +1492,31 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   if (newLines.length === 0 || input.includeLogAppend === false) {
     return [];
   }
-  return [
-    {
+  const events: PlayRunLedgerEvent[] = [];
+  for (
+    let index = 0;
+    index < newLines.length;
+    index += MAX_LEDGER_LOG_LINES_PER_EVENT
+  ) {
+    events.push({
       type: 'log.appended',
       runId: input.runId,
       source,
       occurredAt,
-      lines: newLines,
-      ...(positional ? { channelOffset: input.channelOffset! } : {}),
-    },
-  ];
+      lines: newLines.slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT),
+      ...(positional ? { channelOffset: input.channelOffset! + index } : {}),
+      ...(positional &&
+      typeof input.producerAttempt === 'number' &&
+      Number.isFinite(input.producerAttempt) &&
+      input.producerAttempt >= 0
+        ? { producerAttempt: Math.trunc(input.producerAttempt) }
+        : {}),
+      ...(input.transportDedupe
+        ? { transportDedupe: input.transportDedupe }
+        : {}),
+    });
+  }
+  return events;
 }
 
 /**
@@ -1419,6 +1534,8 @@ export function buildTerminalLogReplayEvents(input: {
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   liveLogTotalCount?: number;
+  dedupeMode?: 'semantic' | 'exact';
+  producerAttempt?: number;
 }): PlayRunLedgerEvent[] {
   const channelOffset = terminalLogReplayChannelOffset({
     liveLogTotalCount: input.liveLogTotalCount,
@@ -1430,6 +1547,10 @@ export function buildTerminalLogReplayEvents(input: {
     source: 'coordinator',
     occurredAt: input.occurredAt,
     channelOffset,
+    producerAttempt: input.producerAttempt,
+    transportDedupe:
+      input.dedupeMode ??
+      (typeof input.producerAttempt === 'number' ? 'exact' : undefined),
   });
 }
 
@@ -1466,6 +1587,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         source,
         occurredAt: checkpointAt,
         channelOffset: patch.liveLogsChannelOffset ?? null,
+        producerAttempt: patch.liveLogsProducerAttempt ?? null,
       })
     : [];
   const earliestStartedAt =

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

@@ -4,6 +4,7 @@ import {
   normalizePlayRunLedgerSnapshot,
   summarizeRunRowOutcomes,
   type PlayRunLedgerSnapshot,
+  type PlayRunLedgerDatasetSnapshot,
   type PlayRunLedgerStepSnapshot,
   type PlayRunRowOutcomeSummary,
 } from './run-ledger';
@@ -76,6 +77,7 @@ export type PlayRunLiveSnapshot = {
   logsTruncated?: boolean;
   activeArtifactTableNamespace: string | null;
   resultTableNamespace: string | null;
+  datasets?: PlayRunLedgerDatasetSnapshot[];
   nodeStates: PlayRunStreamNodeState[];
   activeNodeId: string | null;
   /**
@@ -212,6 +214,11 @@ function buildSnapshotFromLedger(
     ...(snapshot.logsTruncated ? { logsTruncated: true } : {}),
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
+    datasets: snapshot.orderedDatasetIds
+      .map((datasetId) => snapshot.datasetsById[datasetId])
+      .filter((dataset): dataset is PlayRunLedgerDatasetSnapshot =>
+        Boolean(dataset),
+      ),
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...(rowOutcomes ? { rowOutcomes } : {}),

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

@@ -344,13 +344,17 @@ export async function stageDaytonaRunnerPayload(input: {
   const outputPath = `${workDir}/deepline-play-output-${randomUUID()}.log`;
   const exitCodePath = `${workDir}/deepline-play-exit-${randomUUID()}.txt`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
+  const runnerTraceEnv =
+    process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1'
+      ? 'DEEPLINE_RUNTIME_RECEIPT_TRACE=1 '
+      : '';
   const runnerCommand = `${nodeMaterializePayloadCommand({
     envelopePath,
     runnerPath,
     configPath,
     artifactCodePath,
     crashPusherPath,
-  })} && DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
+  })} && 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
   // pushes the parsed (or synthesized) terminal to the gateway so the parked
   // worker wakes within seconds of ANY runner death — process.exit abuse, OOM

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

@@ -122,19 +122,34 @@ export async function inspectDetachedDaytonaRunner(input: {
   cmdId: string;
   outputPath: string;
   exitCodePath: string;
-}): Promise<{ exitCode: number | null; result: PlayRunnerResult | null }> {
+}): Promise<{
+  exitCode: number | null;
+  result: PlayRunnerResult | null;
+  diagnosis: {
+    stage:
+      | 'salvaged'
+      | 'result_missing'
+      | 'command_inspection_failed'
+      | 'sandbox_lookup_failed';
+    detail: string | null;
+  };
+}> {
   try {
     const { clientOptions } = loadDaytonaRequiredConfig();
     const daytona = daytonaSdkClientFactory.createFull(clientOptions);
     const sandbox = (await daytona.get(input.sandboxId)) as DaytonaSandbox;
     let exitCode: number | null = null;
+    let commandInspectionError: string | null = null;
     try {
       const command = await sandbox.process.getSessionCommand(
         input.sessionId,
         input.cmdId,
       );
-      exitCode = typeof command?.exitCode === 'number' ? command.exitCode : null;
+      exitCode =
+        typeof command?.exitCode === 'number' ? command.exitCode : null;
     } catch (error) {
+      commandInspectionError =
+        error instanceof Error ? error.message : String(error);
       console.warn('[play-runner.daytona.detached_inspect_command_failed]', {
         sandboxId: input.sandboxId,
         cmdId: input.cmdId,
@@ -148,7 +163,16 @@ export async function inspectDetachedDaytonaRunner(input: {
       timeoutMs: 10_000,
     });
     if (!recovered.execution) {
-      return { exitCode, result: null };
+      return {
+        exitCode,
+        result: null,
+        diagnosis: commandInspectionError
+          ? {
+              stage: 'command_inspection_failed',
+              detail: commandInspectionError,
+            }
+          : { stage: 'result_missing', detail: null },
+      };
     }
     const result =
       findPlayRunnerResult(parsePlayRunnerEvents(recovered.execution.result)) ??
@@ -156,14 +180,22 @@ export async function inspectDetachedDaytonaRunner(input: {
     return {
       exitCode: exitCode ?? recovered.execution.exitCode,
       result,
+      diagnosis: result
+        ? { stage: 'salvaged', detail: null }
+        : { stage: 'result_missing', detail: null },
     };
   } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
     console.warn('[play-runner.daytona.detached_inspect_failed]', {
       sandboxId: input.sandboxId,
       cmdId: input.cmdId,
-      error: error instanceof Error ? error.message : String(error),
+      error: detail,
     });
-    return { exitCode: null, result: null };
+    return {
+      exitCode: null,
+      result: null,
+      diagnosis: { stage: 'sandbox_lookup_failed', detail },
+    };
   }
 }