deepline 0.1.238 → 0.1.240

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

@@ -365,6 +365,9 @@ function datasetAvailableLog(
   dataset: ReturnType<typeof runtimeDatasetIdentity>,
   count: number,
 ): string {
+  if (count === 0) {
+    return `Dataset ${dataset.path} available: 0 persisted rows; export unavailable: empty dataset`;
+  }
   return `Dataset ${dataset.path} available: ${count} persisted rows; export: deepline runs export ${runId} --dataset ${dataset.path} --out ${dataset.tableNamespace}.csv`;
 }
 

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

@@ -405,6 +405,7 @@ export type PlaySheetRow = {
 /** Runtime-sheet rows and aggregate progress for one dataset/table namespace. */
 export type PlaySheetRowsResult = {
   rows: PlaySheetRow[];
+  scope?: { kind: 'database' } | { kind: 'run'; runId: string };
   summary?: {
     stats?: {
       total?: number;
@@ -470,6 +471,15 @@ export type RunsNamespace = {
   stopAll: (options?: { reason?: string }) => Promise<StopAllPlayRunsResult>;
 };
 
+/** Current mutable customer database namespace exposed as `client.db`. */
+export type DbNamespace = {
+  /** Run a bounded SQL query against the current customer data plane. */
+  query: (input: {
+    sql: string;
+    maxRows?: number;
+  }) => Promise<CustomerDbQueryResult>;
+};
+
 /** One credit grant pool reported by the billing subscription status endpoint. */
 export type BillingCreditPool = {
   pool: string;
@@ -1077,6 +1087,8 @@ export class DeeplineClient {
   private readonly config: ResolvedConfig;
   /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   readonly runs: RunsNamespace;
+  /** Current mutable customer database namespace backed by `/api/v2/db/query`. */
+  readonly db: DbNamespace;
   /** Billing namespace: subscription status/cancel and invoice history. */
   readonly billing: BillingNamespace;
 
@@ -1101,6 +1113,9 @@ export class DeeplineClient {
       stop: (runId, options) => this.stopRun(runId, options),
       stopAll: (options) => this.stopAllRuns(options),
     };
+    this.db = {
+      query: (input) => this.queryDb(input),
+    };
     this.billing = {
       topUp: (options) => this.topUpBillingBalance(options),
       plans: () => this.getBillingPlans(),
@@ -1460,20 +1475,36 @@ export class DeeplineClient {
     return this.executeTool<TData, TMeta>(toolId, input, options);
   }
 
+  private async queryDb(input: {
+    sql: string;
+    maxRows?: number;
+  }): Promise<CustomerDbQueryResult> {
+    const result = await this.http.post<CustomerDbQueryResult>(
+      '/api/v2/db/query',
+      {
+        sql: input.sql,
+        ...(input.maxRows ? { max_rows: input.maxRows } : {}),
+      },
+    );
+    return {
+      ...result,
+      scope: { kind: 'database', mutability: 'current' },
+    };
+  }
+
   /**
-   * Run a bounded SQL query against the customer data plane.
+   * Run a bounded SQL query against the current mutable customer database.
+   *
+   * This query is not scoped to one play run. Use `client.runs` export actions
+   * when the caller needs the rows produced by a specific run.
    *
-   * Use this from trusted backend or agent contexts only. The API enforces
-   * workspace scoping and row limits.
+   * @deprecated Use {@link DeeplineClient.db} `.query(...)`.
    */
   async queryCustomerDb(input: {
     sql: string;
     maxRows?: number;
   }): Promise<CustomerDbQueryResult> {
-    return this.http.post<CustomerDbQueryResult>('/api/v2/db/query', {
-      sql: input.sql,
-      ...(input.maxRows ? { max_rows: input.maxRows } : {}),
-    });
+    return this.db.query(input);
   }
 
   /**
@@ -3000,9 +3031,42 @@ export class DeeplineClient {
     if (input.rowMode === 'all') {
       params.set('rowMode', 'all');
     }
-    return await this.http.get<PlaySheetRowsResult>(
+    const result = await this.http.get<PlaySheetRowsResult>(
       `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet?${params.toString()}`,
     );
+    const requestedRunId = input.runId?.trim() || '';
+    if (requestedRunId) {
+      const confirmedRunId =
+        result.scope?.kind === 'run' ? result.scope.runId.trim() : '';
+      const foreignRowRunIds = [
+        ...new Set(
+          result.rows
+            .map((row) =>
+              typeof row.runId === 'string' ? row.runId.trim() : '',
+            )
+            .filter((runId) => runId && runId !== requestedRunId),
+        ),
+      ];
+      if (
+        result.scope?.kind !== 'run' ||
+        confirmedRunId !== requestedRunId ||
+        foreignRowRunIds.length > 0
+      ) {
+        throw new DeeplineError(
+          `Run-scoped dataset export was not confirmed for ${requestedRunId}; no rows were returned to the caller. Update Deepline, then retry the same export command. Do not rerun the play.`,
+          undefined,
+          'RUN_EXPORT_SCOPE_MISMATCH',
+          {
+            requestedRunId,
+            confirmedScope: result.scope ?? null,
+            foreignRowRunIds,
+            playName: input.playName,
+            tableNamespace: input.tableNamespace,
+          },
+        );
+      }
+    }
+    return result;
   }
 
   /**

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

@@ -218,6 +218,7 @@ export class HttpClient {
       'X-Deepline-CLI-Version': SDK_VERSION,
       'X-Deepline-SDK-Version': SDK_VERSION,
       'X-Deepline-API-Contract': SDK_API_CONTRACT,
+      'X-Deepline-Run-Result-Shape': 'canonical',
       ...extra,
     };
     const skillsVersion = this.readSkillsVersionHeader();

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

@@ -62,6 +62,7 @@ export type {
   BillingInvoiceEntry,
   BillingInvoicesResult,
   BillingNamespace,
+  DbNamespace,
   BillingPaymentMethodSummary,
   BillingSubscriptionCancelResult,
   BillingSubscriptionStatus,
@@ -141,6 +142,9 @@ export type {
   LiveEventEnvelope,
   PlayLiveEvent,
   PlayRunResult,
+  PlayRunActionPackage,
+  PlayRunDatasetActions,
+  PlayRunPackage,
   PlayRunStart,
   ClearPlayHistoryRequest,
   ClearPlayHistoryResult,

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

@@ -110,10 +110,10 @@ export const SDK_RELEASE = {
   // silently materializing them as unmatched results.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.238',
+  version: '0.1.240',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.238',
+    latest: '0.1.240',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

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

@@ -72,12 +72,14 @@ export interface CustomerDbColumn {
 }
 
 /**
- * Result returned by {@link DeeplineClient.queryCustomerDb}.
+ * Result returned by {@link DeeplineClient.db.query}.
  *
  * Rows are intentionally untyped because the schema depends on the caller's SQL
  * query and selected customer tables.
  */
 export interface CustomerDbQueryResult {
+  /** This query reads the current mutable customer database, not one run snapshot. */
+  scope?: { kind: 'database'; mutability: 'current' };
   /** Database command executed by the query endpoint. */
   command: string;
   /** Total affected row count when reported by the database. */
@@ -443,6 +445,19 @@ export type PlayRunActionPackage =
   | {
       kind: 'deepline_run_inspect';
       runId: string;
+      command?: string;
+      api: { method: 'GET'; path: string };
+    }
+  | {
+      kind: 'deepline_run_full';
+      runId: string;
+      command?: string;
+      api: { method: 'GET'; path: string };
+    }
+  | {
+      kind: 'deepline_run_billing';
+      runId: string;
+      command?: string;
       api: { method: 'GET'; path: string };
     }
   | {
@@ -453,6 +468,16 @@ export type PlayRunActionPackage =
       sqlQualifiedTableName?: string;
       sql: string;
       maxRows: number;
+      command?: string;
+      scope?:
+        | { kind: 'database'; mutability: 'current' }
+        | { kind: 'run'; runId: string };
+      note?: string;
+      deprecated?: {
+        replacement: 'queryCurrentTable';
+        removeAfter: string;
+        reason: string;
+      };
       api: {
         method: 'POST';
         path: '/api/v2/db/query';
@@ -463,6 +488,14 @@ export type PlayRunActionPackage =
       runId: string;
       datasetPath: string;
       format: 'csv';
+      command?: string;
+      scope?: { kind: 'run'; runId: string };
+      note?: string;
+      deprecated?: {
+        replacement: 'datasets[].actions.exportCsv';
+        removeAfter: string;
+        reason: string;
+      };
     }
   | {
       kind: 'deepline_run_logs';
@@ -473,6 +506,26 @@ export type PlayRunActionPackage =
       api: { method: 'GET'; path: string };
     };
 
+type PlayRunDbQueryAction = Extract<
+  PlayRunActionPackage,
+  { kind: 'deepline_db_query' }
+>;
+type PlayRunExportAction = Extract<
+  PlayRunActionPackage,
+  { kind: 'deepline_run_export' }
+>;
+
+export type PlayRunDatasetActions = {
+  /** @deprecated Use queryCurrentTable or exportCsv. Removed after 2026-08-18. */
+  query?: PlayRunDbQueryAction & { scope?: { kind: 'run'; runId: string } };
+  queryCurrentTable?: PlayRunDbQueryAction & {
+    scope?: { kind: 'database'; mutability: 'current' };
+  };
+  exportCsv?: PlayRunExportAction & {
+    scope?: { kind: 'run'; runId: string };
+  };
+};
+
 /**
  * Compact canonical package for an inspected play run.
  *
@@ -508,9 +561,15 @@ export interface PlayRunPackage {
     path: string;
     tableNamespace?: string;
     rowCount?: number;
+    sqlTableName?: string;
+    sqlQualifiedTableName?: string;
     recovered?: true;
+    exportUnavailable?: {
+      reason: 'empty_dataset' | 'shared_table_namespace';
+      message: string;
+    };
     preview?: Record<string, unknown>;
-    actions?: Record<string, PlayRunActionPackage>;
+    actions?: PlayRunDatasetActions;
   }>;
   /** Small retained tail of customer and runtime logs; fetch the full stream through `runs.logs`. */
   logs?: {
@@ -522,6 +581,8 @@ export interface PlayRunPackage {
   /** Follow-up actions a caller can perform against the run. */
   next?: {
     inspect?: PlayRunActionPackage;
+    full?: PlayRunActionPackage;
+    billing?: PlayRunActionPackage;
     export?: PlayRunActionPackage;
     query?: PlayRunActionPackage;
     logs?: PlayRunActionPackage;

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

@@ -1202,7 +1202,6 @@ export class PlayContextImpl {
   }> = [];
   private processedRowCount = 0;
   private sleepBoundaryIndex = 0;
-  private fetchCallIndex = 0;
   private readonly secretRedactor: SecretRedactionContext =
     createSecretRedactionContext();
   private mapInvocationIndex = 0;
@@ -5853,6 +5852,10 @@ export class PlayContextImpl {
     for (const wake of waiters) wake();
   }
 
+  private toolBatchDispatcherNowMs(): number {
+    return this.#options.toolBatchDispatcherClock?.nowMs() ?? Date.now();
+  }
+
   private enqueueToolCall(request: ToolCallRequest): void {
     if (this.toolDispatcherFailure != null) {
       const resolver = this.toolCallResolvers.get(request.callId);
@@ -5865,7 +5868,10 @@ export class PlayContextImpl {
     this.toolCallQueue.push(request);
     const batchKey = this.toolBatchCoalesceKey(request);
     if (batchKey && !this.toolBatchQueuedAtByKey.has(batchKey)) {
-      this.toolBatchQueuedAtByKey.set(batchKey, Date.now());
+      this.toolBatchQueuedAtByKey.set(
+        batchKey,
+        this.toolBatchDispatcherNowMs(),
+      );
     }
     this.wakeToolDispatcher();
   }
@@ -5908,7 +5914,10 @@ export class PlayContextImpl {
       if (!this.toolBatchQueuedAtByKey.has(batchKey)) {
         this.toolBatchQueuedAtByKey.set(batchKey, queuedAt);
       }
-      const deadline = queuedAt + TOOL_BATCH_COALESCE_WINDOW_MS;
+      const coalesceWindowMs =
+        this.#options.toolBatchCoalesceWindowMs ??
+        TOOL_BATCH_COALESCE_WINDOW_MS;
+      const deadline = queuedAt + coalesceWindowMs;
       const maxBatchSize = batchMaxSizes.get(batchKey) ?? 1;
       if (count >= maxBatchSize || deadline <= nowMs) {
         readyBatchKeys.add(batchKey);
@@ -5939,15 +5948,26 @@ export class PlayContextImpl {
 
   private waitForToolDispatcherWake(deadlineMs: number | null): Promise<void> {
     return new Promise((resolve) => {
-      let timer: ReturnType<typeof setTimeout> | null = null;
+      let cancelDeadline: (() => void) | null = null;
       const wake = () => {
-        if (timer) clearTimeout(timer);
+        cancelDeadline?.();
+        cancelDeadline = null;
         this.toolDispatcherWakeWaiters.delete(wake);
         resolve();
       };
       this.toolDispatcherWakeWaiters.add(wake);
       if (deadlineMs != null) {
-        timer = setTimeout(wake, Math.max(0, deadlineMs - Date.now()));
+        const delayMs = Math.max(
+          0,
+          deadlineMs - this.toolBatchDispatcherNowMs(),
+        );
+        const clock = this.#options.toolBatchDispatcherClock;
+        if (clock) {
+          cancelDeadline = clock.schedule(delayMs, wake);
+        } else {
+          const timer = setTimeout(wake, delayMs);
+          cancelDeadline = () => clearTimeout(timer);
+        }
       }
     });
   }
@@ -5975,7 +5995,9 @@ export class PlayContextImpl {
           throw this.toolDispatcherFailure;
         }
 
-        const dispatchable = this.takeDispatchableToolCalls(Date.now());
+        const dispatchable = this.takeDispatchableToolCalls(
+          this.toolBatchDispatcherNowMs(),
+        );
         if (dispatchable.requests.length > 0) {
           pass += 1;
           this.log(`  Batch pass ${pass}`);
@@ -6686,8 +6708,8 @@ export class PlayContextImpl {
       rowScopeKey ? `@${rowScopeKey}` : ''
     }`;
     if (rowScope) {
-      const namespaces =
-        rowScope.inlineChildInvocationNamespaces ??= new Set<string>();
+      const namespaces = (rowScope.inlineChildInvocationNamespaces ??=
+        new Set<string>());
       namespaces.add(namespace);
       if (namespaces.size > MAX_INLINE_CHILD_INVOCATIONS_PER_ROW) {
         throw new Error(
@@ -6818,11 +6840,15 @@ export class PlayContextImpl {
     options?: FetchOptions,
   ): Promise<PlayFetchResponse> {
     const normalizedKey = this.normalizeContextKey(key, 'fetch');
-    if (rowContext.getStore()) {
-      throw new Error(
-        'ctx.fetch() must run outside ctx.dataset(); use ctx.tools.execute(...) for row-level external requests so Deepline can batch and checkpoint them.',
-      );
-    }
+    const rowStore = rowContext.getStore();
+    const rowFetchScope = rowStore
+      ? {
+          tableNamespace: rowStore.tableNamespace ?? null,
+          rowKey: rowStore.rowKey ?? null,
+          rowId: rowStore.rowKey ? null : rowStore.rowId,
+          fieldName: rowStore.fieldName ?? null,
+        }
+      : null;
 
     if (valueContainsSecret(input) || valueContainsSecret(init.body)) {
       throw new Error(
@@ -6858,6 +6884,7 @@ export class PlayContextImpl {
               ...normalizeFetchHeaders(init.headers),
               ...secretHeaderMarkers,
             },
+            row: rowFetchScope,
           }),
         ),
         staleAfterSeconds: options?.staleAfterSeconds,
@@ -6872,7 +6899,7 @@ export class PlayContextImpl {
           const fetchInit = { ...init, headers };
           delete fetchInit.auth;
           const boundaryId = this.durableBoundaryId(
-            `fetch-${this.fetchCallIndex}-${stableDigest(
+            `fetch-${stableDigest(
               stableStringify({
                 url,
                 method,
@@ -6881,10 +6908,10 @@ export class PlayContextImpl {
                   ...secretHeaderMarkers,
                 },
                 body: typeof init.body === 'string' ? init.body : null,
+                row: rowFetchScope,
               }),
             )}`,
           );
-          this.fetchCallIndex += 1;
 
           const existing = this.checkpoint.resolvedBoundaries?.[boundaryId];
           if (existing?.kind === 'fetch' && 'output' in existing) {

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

@@ -680,6 +680,19 @@ export interface ContextOptions {
   getBatchOperationStrategy?: (
     operation: string,
   ) => AnyBatchOperationStrategy | null;
+  /**
+   * Internal deterministic clock for fixed-window dispatcher tests. Runtime
+   * adapters omit this and use the system clock.
+   */
+  toolBatchDispatcherClock?: {
+    nowMs: () => number;
+    schedule: (delayMs: number, wake: () => void) => () => void;
+  };
+  // How long batchable calls wait for same-key row continuations before
+  // dispatching, measured from the first queued item. Defaults to 5ms in
+  // production; tests override it to a large value to make coalescing
+  // deterministic instead of racing wall-clock milliseconds on slow CI.
+  toolBatchCoalesceWindowMs?: number;
   queryCustomerDb?: CustomerDbQueryHandler;
   executeStructuredPlayDefinition?: (input: {
     definition: PlayStructuredDefinition;

package/dist/bundling-sources/shared_libs/play-runtime/play-latency-trace.ts

@@ -127,14 +127,13 @@ export const PLAY_LATENCY_SUMMARY_COLUMNS: PlayLatencyPhaseDefinition[] = [
     phase: 'server.start_route_runtime_data_plane_ready',
     source: 'server',
     description:
-      'Start route Runtime Sheet Data Plane readiness check; active tenants use the cached or record fast path, new tenants may provision here.',
+      'Start route read-only Runtime Sheet Data Plane readiness check.',
   },
   {
     header: 'ready_plane',
-    phase: 'server.runtime_data_plane_ensure_plane',
+    phase: 'server.runtime_data_plane_read_plane',
     source: 'server',
-    description:
-      'Runtime Sheet readiness control-plane record lookup or first-workspace provisioning.',
+    description: 'Runtime Sheet readiness control-plane record lookup.',
   },
   {
     header: 'ready_markers',
@@ -143,20 +142,6 @@ export const PLAY_LATENCY_SUMMARY_COLUMNS: PlayLatencyPhaseDefinition[] = [
     description:
       'Single pooled tenant-Postgres read of the storage-contract fingerprint and runtime migration version.',
   },
-  {
-    header: 'ready_repair',
-    phase: 'server.runtime_data_plane_repair_contract',
-    source: 'server',
-    description:
-      'Exceptional stale storage-contract repair; absent from the healthy path.',
-  },
-  {
-    header: 'ready_migrate',
-    phase: 'server.runtime_data_plane_migrate',
-    source: 'server',
-    description:
-      'Exceptional stale Runtime Sheet migration; absent from the healthy path.',
-  },
   {
     header: 'route_wait',
     phase: 'server.start_route_wait_completion',

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

@@ -224,6 +224,20 @@ export type PlayRunnerRuntimeTiming = {
   daytonaExecuteMs?: number;
 };
 
+/**
+ * Why replay checkpoint state is present or absent on the detached-runner
+ * terminal wire. This describes checkpoint transport only; it never classifies
+ * the customer's returned output as oversized.
+ */
+export const RUNNER_TERMINAL_CHECKPOINT_DISPOSITION = {
+  OMITTED_TERMINAL_REPLAY: 'omitted_terminal_replay',
+  INCLUDED_RESUME_REQUIRED: 'included_resume_required',
+  ABSENT: 'absent',
+} as const;
+
+export type RunnerTerminalCheckpointDisposition =
+  (typeof RUNNER_TERMINAL_CHECKPOINT_DISPOSITION)[keyof typeof RUNNER_TERMINAL_CHECKPOINT_DISPOSITION];
+
 export type PlayRunnerResult =
   | {
       status: 'completed';

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

@@ -1055,7 +1055,12 @@ export function reducePlayRunLedgerEvent(
       if (ignoreNonTerminalAfterStickyTerminal) {
         return withTiming(base);
       }
-      const createdStatus = event.status ?? base.status;
+      // Scheduler wait/resume events own the active lifecycle once a run is
+      // parked. Worker registration can arrive later through an independent
+      // ledger append lane; replaying that older `run.created` fact must not
+      // make an externally-waiting run look active again.
+      const createdStatus =
+        base.status === 'waiting' ? 'waiting' : (event.status ?? base.status);
       return withTiming({
         ...base,
         playName: event.playName ?? base.playName ?? null,
@@ -1075,7 +1080,9 @@ export function reducePlayRunLedgerEvent(
         playName: event.playName ?? base.playName ?? null,
         status: isTerminalPlayRunLedgerStatus(base.status)
           ? base.status
-          : 'running',
+          : base.status === 'waiting'
+            ? 'waiting'
+            : 'running',
         startedAt: base.startedAt ?? occurredAt,
       });
     case 'run.waiting':
@@ -1200,7 +1207,9 @@ export function reducePlayRunLedgerEvent(
         ...base,
         status: isTerminalPlayRunLedgerStatus(base.status)
           ? base.status
-          : 'running',
+          : base.status === 'waiting'
+            ? 'waiting'
+            : 'running',
         startedAt: base.startedAt ?? occurredAt,
         orderedStepIds: appendOrderedStepId(base, event.stepId),
         stepsById: { ...base.stepsById, [event.stepId]: nextStep },

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

@@ -1,7 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { gzipSync } from 'node:zlib';
-import type { PlayRunnerExecutionConfig } from '@shared_libs/play-runtime/protocol';
+import {
+  RUNNER_TERMINAL_CHECKPOINT_DISPOSITION,
+  type PlayRunnerExecutionConfig,
+} from '@shared_libs/play-runtime/protocol';
 import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,
@@ -29,6 +32,7 @@ export type StagedDaytonaPayload = {
   workDir: string;
   command: string;
   readyPath: string;
+  startAckPath: string;
   outputPath: string;
   exitCodePath: string;
   progressEventPath: string;
@@ -126,6 +130,39 @@ function readResultFromOutput() {
   return null;
 }
 
+function terminalResultForTransport(result) {
+  if (
+    result &&
+    ${JSON.stringify(Object.values(RUNNER_TERMINAL_CHECKPOINT_DISPOSITION))}.includes(
+      result.checkpointDisposition,
+    )
+  ) {
+    return result;
+  }
+  if (result && result.status === 'suspended') {
+    return {
+      ...result,
+      checkpointDisposition: '${RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.INCLUDED_RESUME_REQUIRED}',
+      checkpointBytes: Buffer.byteLength(JSON.stringify(result.checkpoint)),
+    };
+  }
+  const checkpoint = result && result.checkpoint;
+  const terminal = { ...(result || {}) };
+  delete terminal.checkpoint;
+  if (checkpoint === null || checkpoint === undefined) {
+    return {
+      ...terminal,
+      checkpointDisposition: '${RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.ABSENT}',
+      checkpointBytes: 0,
+    };
+  }
+  return {
+    ...terminal,
+    checkpointDisposition: '${RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.OMITTED_TERMINAL_REPLAY}',
+    checkpointBytes: Buffer.byteLength(JSON.stringify(checkpoint)),
+  };
+}
+
 async function main() {
   const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
   const context = (config && config.context) || {};
@@ -136,7 +173,8 @@ async function main() {
     console.log('[crash-terminal] no push config; skipping');
     return;
   }
-  const result = readResultFromOutput() || {
+  const parsedResult = readResultFromOutput();
+  const result = terminalResultForTransport(parsedResult || {
     status: 'failed',
     error:
       'Daytona play runner exited with code ' +
@@ -146,9 +184,10 @@ async function main() {
     logs: [],
     stats: {},
     steps: [],
-    checkpoint: null,
+    checkpointDisposition: '${RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.ABSENT}',
+    checkpointBytes: 0,
     tableNamespace: null,
-  };
+  });
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     try {
       const controller = new AbortController();
@@ -351,6 +390,7 @@ export async function stageDaytonaRunnerPayload(input: {
   const outputPath = `${workDir}/deepline-play-output-${randomUUID()}.log`;
   const exitCodePath = `${workDir}/deepline-play-exit-${randomUUID()}.txt`;
   const readyPath = `${workDir}/deepline-play-ready-${randomUUID()}.json`;
+  const startAckPath = `${workDir}/deepline-play-start-ack-${randomUUID()}.json`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
   const runnerTraceEnv =
     process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1'
@@ -363,18 +403,19 @@ export async function stageDaytonaRunnerPayload(input: {
     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)}`;
+  })} && DEEPLINE_PLAY_RUNNER_READY_PATH=${shellQuote(readyPath)} DEEPLINE_PLAY_RUNNER_START_ACK_PATH=${shellQuote(startAckPath)} 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
   // SIGKILL, or a crash before the in-process push. Idempotent against a
   // successful in-runner push (terminals are first-write-wins).
-  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(exitCodePath)} ${shellQuote(readyPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} >> ${shellQuote(outputPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
+  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(exitCodePath)} ${shellQuote(readyPath)} ${shellQuote(startAckPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} >> ${shellQuote(outputPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,
     command,
     readyPath,
+    startAckPath,
     outputPath,
     exitCodePath,
     progressEventPath,