deepline 0.1.77 → 0.1.79

package/dist/index.d.mts

@@ -16,6 +16,7 @@ type PlayArtifactKind = (typeof PLAY_ARTIFACT_KINDS)[keyof typeof PLAY_ARTIFACT_
 interface PlayStaticPipelineSnapshot {
     tableNamespace?: string;
     inputFields?: string[];
+    rowKeyFields?: string[];
     csvArg?: string;
     hasInlineData?: boolean;
     csvDescription?: string;
@@ -39,11 +40,30 @@ interface PlaySheetColumnContractSnapshot {
     outputSqlName?: string;
     stepId?: string;
     toolId?: string;
+    isRowKey?: boolean;
 }
 interface PlaySheetContractSnapshot {
     tableNamespace: string;
     columns: PlaySheetColumnContractSnapshot[];
 }
+type PlayStaticColumnProducerKindSnapshot = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'transform';
+interface PlayStaticColumnProducerSnapshot {
+    id: string;
+    kind: PlayStaticColumnProducerKindSnapshot;
+    field: string;
+    toolId?: string;
+    playId?: string;
+    conditional?: boolean;
+    sourceRange?: PlayStaticSourceRangeSnapshot;
+    steps?: PlayStaticColumnProducerSnapshot[];
+    substep: PlayStaticSubstepSnapshot;
+}
+interface PlayStaticDatasetColumnSnapshot {
+    id: string;
+    source: PlaySheetColumnSourceSnapshot;
+    sqlName?: string;
+    producers: PlayStaticColumnProducerSnapshot[];
+}
 interface PlayStaticSourceRangeSnapshot {
     sourcePath?: string;
     startLine: number;
@@ -68,8 +88,11 @@ type PlayStaticSubstepSnapshot = PlayStaticSubstepMetadataSnapshot & ({
     name?: string;
     tableNamespace?: string;
     inputFields?: string[];
+    rowKeyFields?: string[];
     outputFields?: string[];
+    columns?: PlayStaticDatasetColumnSnapshot[];
     waterfallIds?: string[];
+    steps?: PlayStaticSubstepSnapshot[];
     sheetContract?: PlaySheetContractSnapshot | null;
     description?: string;
     sourceRange?: PlayStaticSourceRangeSnapshot;
@@ -775,6 +798,9 @@ interface PlayListItem {
     isDraftDirty?: boolean;
     inputSchema?: Record<string, unknown> | null;
     outputSchema?: Record<string, unknown> | null;
+    staticPipeline?: unknown;
+    currentRevision?: PlayRevisionSummary | null;
+    liveRevision?: PlayRevisionSummary | null;
     aliases?: string[];
 }
 interface PlayDescription {
@@ -788,6 +814,7 @@ interface PlayDescription {
     aliases: string[];
     inputSchema?: Record<string, unknown> | null;
     outputSchema?: Record<string, unknown> | null;
+    staticPipeline?: Record<string, unknown> | null;
     csvInput?: Record<string, unknown> | null;
     rowOutputSchema?: Record<string, unknown> | null;
     runCommand: string;
@@ -1953,7 +1980,9 @@ type PlayDatasetTransformOptions = {
  * Deepline keeps row progress, retries, memory use, and table output under
  * runtime control. Use `count()` and `peek()` for bounded inspection. Use
  * `materialize(limit)` or async iteration only when the dataset is intentionally
- * small and bounded.
+ * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
+ * `.toArray()`, or other array aliases; those hide the runtime cost of loading
+ * persisted rows into memory.
  */
 interface PlayDataset<T> extends AsyncIterable<T> {
     readonly [PLAY_DATASET_BRAND]: true;
@@ -2467,7 +2496,7 @@ interface DeeplinePlayRuntimeContext {
      * @param options - Run options.
      * @returns Program output.
      */
-    runSteps<TInput extends Record<string, unknown>, TOutput>(program: StepProgram<TInput, unknown, TOutput>, input: TInput, options?: {
+    runSteps<TInput extends Record<string, unknown>, TOutput>(program: StepProgram<TInput, any, TOutput>, input: TInput, options?: {
         description?: string;
     }): Promise<TOutput>;
     /**

package/dist/index.d.ts

@@ -16,6 +16,7 @@ type PlayArtifactKind = (typeof PLAY_ARTIFACT_KINDS)[keyof typeof PLAY_ARTIFACT_
 interface PlayStaticPipelineSnapshot {
     tableNamespace?: string;
     inputFields?: string[];
+    rowKeyFields?: string[];
     csvArg?: string;
     hasInlineData?: boolean;
     csvDescription?: string;
@@ -39,11 +40,30 @@ interface PlaySheetColumnContractSnapshot {
     outputSqlName?: string;
     stepId?: string;
     toolId?: string;
+    isRowKey?: boolean;
 }
 interface PlaySheetContractSnapshot {
     tableNamespace: string;
     columns: PlaySheetColumnContractSnapshot[];
 }
+type PlayStaticColumnProducerKindSnapshot = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'transform';
+interface PlayStaticColumnProducerSnapshot {
+    id: string;
+    kind: PlayStaticColumnProducerKindSnapshot;
+    field: string;
+    toolId?: string;
+    playId?: string;
+    conditional?: boolean;
+    sourceRange?: PlayStaticSourceRangeSnapshot;
+    steps?: PlayStaticColumnProducerSnapshot[];
+    substep: PlayStaticSubstepSnapshot;
+}
+interface PlayStaticDatasetColumnSnapshot {
+    id: string;
+    source: PlaySheetColumnSourceSnapshot;
+    sqlName?: string;
+    producers: PlayStaticColumnProducerSnapshot[];
+}
 interface PlayStaticSourceRangeSnapshot {
     sourcePath?: string;
     startLine: number;
@@ -68,8 +88,11 @@ type PlayStaticSubstepSnapshot = PlayStaticSubstepMetadataSnapshot & ({
     name?: string;
     tableNamespace?: string;
     inputFields?: string[];
+    rowKeyFields?: string[];
     outputFields?: string[];
+    columns?: PlayStaticDatasetColumnSnapshot[];
     waterfallIds?: string[];
+    steps?: PlayStaticSubstepSnapshot[];
     sheetContract?: PlaySheetContractSnapshot | null;
     description?: string;
     sourceRange?: PlayStaticSourceRangeSnapshot;
@@ -775,6 +798,9 @@ interface PlayListItem {
     isDraftDirty?: boolean;
     inputSchema?: Record<string, unknown> | null;
     outputSchema?: Record<string, unknown> | null;
+    staticPipeline?: unknown;
+    currentRevision?: PlayRevisionSummary | null;
+    liveRevision?: PlayRevisionSummary | null;
     aliases?: string[];
 }
 interface PlayDescription {
@@ -788,6 +814,7 @@ interface PlayDescription {
     aliases: string[];
     inputSchema?: Record<string, unknown> | null;
     outputSchema?: Record<string, unknown> | null;
+    staticPipeline?: Record<string, unknown> | null;
     csvInput?: Record<string, unknown> | null;
     rowOutputSchema?: Record<string, unknown> | null;
     runCommand: string;
@@ -1953,7 +1980,9 @@ type PlayDatasetTransformOptions = {
  * Deepline keeps row progress, retries, memory use, and table output under
  * runtime control. Use `count()` and `peek()` for bounded inspection. Use
  * `materialize(limit)` or async iteration only when the dataset is intentionally
- * small and bounded.
+ * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
+ * `.toArray()`, or other array aliases; those hide the runtime cost of loading
+ * persisted rows into memory.
  */
 interface PlayDataset<T> extends AsyncIterable<T> {
     readonly [PLAY_DATASET_BRAND]: true;
@@ -2467,7 +2496,7 @@ interface DeeplinePlayRuntimeContext {
      * @param options - Run options.
      * @returns Program output.
      */
-    runSteps<TInput extends Record<string, unknown>, TOutput>(program: StepProgram<TInput, unknown, TOutput>, input: TInput, options?: {
+    runSteps<TInput extends Record<string, unknown>, TOutput>(program: StepProgram<TInput, any, TOutput>, input: TInput, options?: {
         description?: string;
     }): Promise<TOutput>;
     /**

package/dist/index.js

@@ -241,10 +241,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.77",
+  version: "0.1.79",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.77",
+    latest: "0.1.79",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -820,6 +820,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
+      staticPipeline: isRecord(play.staticPipeline) ? play.staticPipeline : isRecord(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand,

package/dist/index.mjs

@@ -179,10 +179,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.77",
+  version: "0.1.79",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.77",
+    latest: "0.1.79",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -758,6 +758,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
+      staticPipeline: isRecord(play.staticPipeline) ? play.staticPipeline : isRecord(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand,

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

@@ -53,6 +53,14 @@ import {
   decideWorkflowPlatformRetry,
   PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
 } from './workflow-retry';
+import {
+  WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES,
+  WORKFLOW_RETRY_PARAMS_MAX_BYTES,
+  buildWorkflowRetryParams,
+  jsonByteLength,
+  workflowRetryParamsStorageKey,
+  type WorkflowRetryParamsRef,
+} from './workflow-retry-state';
 import { sanitizeLiveLogLines } from './runtime/live-progress';
 
 export { DynamicWorkflowBinding };
@@ -563,7 +571,7 @@ const WORKFLOW_POOL_PROTOCOL_VERSION =
 const WORKFLOW_POOL_DO_NAME = 'workflow-pool:v2';
 const WORKFLOW_POOL_START_EVENT_TYPE = 'play_start';
 const WORKFLOW_POOL_TTL_MS = 8 * 60 * 1000;
-const WORKFLOW_POOL_TARGET_SIZE = 0;
+const WORKFLOW_POOL_TARGET_SIZE = 4;
 const WORKFLOW_POOL_READY_TIMEOUT_MS = 1_500;
 const WORKFLOW_POOL_READY_POLL_MS = 250;
 const WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS = 2_500;
@@ -571,6 +579,8 @@ const WORKFLOW_POOL_REFILL_ON_MISS_MIN_AVAILABLE = 4;
 const WORKFLOW_POOL_CONTROL_TIMEOUT_MS = 750;
 const WORKFLOW_POOL_START_ACK_TIMEOUT_MS = 750;
 const WORKFLOW_POOL_START_ACK_POLL_MS = 25;
+const WORKFLOW_POOL_MISS_CLAIM_RETRY_TIMEOUT_MS = 3_000;
+const WORKFLOW_POOL_MISS_CLAIM_RETRY_POLL_MS = 50;
 const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
 const SUBMIT_INITIAL_STATE_POLL_MS = 50;
 const WORKFLOW_RETRY_STATE_TTL_MS = 60 * 60 * 1000;
@@ -1117,6 +1127,115 @@ async function leaseWorkflowPoolId(
   return typeof body.id === 'string' && body.id ? body.id : null;
 }
 
+async function leaseWorkflowPoolIdWithMissRecovery(input: {
+  env: CoordinatorEnv;
+  runId: string;
+  recordSubmitTiming: (timing: CoordinatorTiming) => void;
+  graphHash?: string | null;
+}): Promise<{
+  pooledInstanceId: string | null;
+  missCounts: WorkflowPoolCounts | null;
+  leaseError: string | null;
+}> {
+  let leaseError: string | null = null;
+  let pooledInstanceId = await leaseWorkflowPoolId(
+    input.env,
+    input.runId,
+  ).catch((error) => {
+    leaseError = error instanceof Error ? error.message : String(error);
+    return null;
+  });
+  let missCounts = pooledInstanceId
+    ? null
+    : await workflowPoolCount(input.env).catch(() => null);
+  if (
+    pooledInstanceId ||
+    leaseError ||
+    !missCounts ||
+    missCounts.available + missCounts.warming <= 0
+  ) {
+    return { pooledInstanceId, missCounts, leaseError };
+  }
+
+  const recoveryStartedAt = Date.now();
+  const refill = await refillWorkflowPool(input.env, {
+    minAvailable: 1,
+    waitReady: true,
+    waitTimeoutMs: WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS,
+  }).catch((error) => {
+    input.recordSubmitTiming({
+      phase: 'coordinator.workflow_pool_refill_on_miss',
+      ms: Date.now() - recoveryStartedAt,
+      graphHash: input.graphHash ?? null,
+      extra: {
+        status: 'failed',
+        error: error instanceof Error ? error.message : String(error),
+        available: missCounts?.available ?? null,
+        warming: missCounts?.warming ?? null,
+      },
+    });
+    return null;
+  });
+  if (refill) {
+    input.recordSubmitTiming({
+      phase: 'coordinator.workflow_pool_refill_on_miss',
+      ms: Date.now() - recoveryStartedAt,
+      graphHash: input.graphHash ?? null,
+      extra: {
+        status: 'ok',
+        available: refill.available,
+        warming: refill.warming,
+        created: refill.created,
+        promoted: refill.promoted,
+        removed: refill.removed,
+        waitedMs: refill.waitedMs,
+        waitIterations: refill.waitIterations,
+      },
+    });
+  }
+
+  let retryCount = 0;
+  const retryStartedAt = Date.now();
+  while (
+    Date.now() - retryStartedAt <
+    WORKFLOW_POOL_MISS_CLAIM_RETRY_TIMEOUT_MS
+  ) {
+    retryCount += 1;
+    pooledInstanceId = await leaseWorkflowPoolId(input.env, input.runId).catch(
+      (error) => {
+        leaseError = error instanceof Error ? error.message : String(error);
+        return null;
+      },
+    );
+    if (pooledInstanceId || leaseError) {
+      break;
+    }
+    missCounts = await workflowPoolCount(input.env).catch(() => missCounts);
+    if (!missCounts || missCounts.available + missCounts.warming <= 0) {
+      break;
+    }
+    await sleep(WORKFLOW_POOL_MISS_CLAIM_RETRY_POLL_MS);
+  }
+  input.recordSubmitTiming({
+    phase: 'coordinator.workflow_pool_claim_retry',
+    ms: Date.now() - retryStartedAt,
+    graphHash: input.graphHash ?? null,
+    extra: {
+      pooled: Boolean(pooledInstanceId),
+      retries: retryCount,
+      ...(leaseError ? { error: leaseError } : {}),
+      ...(missCounts
+        ? {
+            availableAfterRetry: missCounts.available,
+            warmingAfterRetry: missCounts.warming,
+          }
+        : {}),
+    },
+  });
+
+  return { pooledInstanceId, missCounts, leaseError };
+}
+
 async function mapRunToWorkflowInstance(input: {
   env: CoordinatorEnv;
   runId: string;
@@ -1191,56 +1310,120 @@ async function persistWorkflowRetryState(input: {
   runId: string;
   params: PlayWorkflowParams;
 }): Promise<void> {
-  const retryParams: PlayWorkflowParams = {
-    ...input.params,
-    dynamicWorkerCode: null,
-    contractSnapshot: stripRetrySourceSnapshot(input.params.contractSnapshot),
-    childPlayManifests: stripRetryChildManifestCode(
-      input.params.childPlayManifests,
-    ),
-    packagedFiles:
-      input.params.packagedFiles?.map((file) => ({
-        playPath: file.playPath,
-        storageKey: file.storageKey,
-        contentType: file.contentType,
-        bytes: file.bytes,
-      })) ?? null,
+  const retryParams = buildWorkflowRetryParams(input.params);
+  const paramsBytes = jsonByteLength(retryParams);
+  if (paramsBytes > WORKFLOW_RETRY_PARAMS_MAX_BYTES) {
+    throw new Error(
+      `workflow retry params too large: ${paramsBytes} bytes exceeds ${WORKFLOW_RETRY_PARAMS_MAX_BYTES}. Pass large payloads as staged files or ctx.csv inputs instead of inline JSON.`,
+    );
+  }
+  let body: {
+    runId: string;
+    params?: PlayWorkflowParams;
+    paramsRef?: WorkflowRetryParamsRef;
+    paramsBytes: number;
+    ttlMs: number;
   };
-  await callWorkflowPool<{ ok?: unknown }>(input.env, '/run-retry-state-put', {
-    method: 'POST',
-    body: JSON.stringify({
+  if (paramsBytes > WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES) {
+    const serialized = JSON.stringify(retryParams);
+    const hash = stableHash(serialized);
+    const storageKey = workflowRetryParamsStorageKey({
       runId: input.runId,
-      params: retryParams,
+      hash,
+    });
+    await input.env.PLAYS_BUCKET.put(storageKey, serialized, {
+      httpMetadata: { contentType: 'application/json' },
+    });
+    body = {
+      runId: input.runId,
+      paramsRef: {
+        storageKind: 'r2',
+        storageKey,
+        bytes: paramsBytes,
+        hash,
+        expiresAt: Date.now() + WORKFLOW_RETRY_STATE_TTL_MS,
+      },
+      paramsBytes,
       ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-    }),
-  }).catch((error) => {
-    console.warn('[coordinator] workflow retry state persistence skipped', {
+    };
+  } else {
+    body = {
       runId: input.runId,
-      error: error instanceof Error ? error.message : String(error),
-    });
+      params: retryParams,
+      paramsBytes,
+      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+    };
+  }
+  await callWorkflowPool<{ ok?: unknown }>(input.env, '/run-retry-state-put', {
+    method: 'POST',
+    body: JSON.stringify(body),
   });
 }
 
-function stripRetrySourceSnapshot(snapshot: unknown): unknown {
-  if (!isRecord(snapshot)) return snapshot;
-  const rest = { ...snapshot };
-  delete rest.sourceCode;
-  delete rest.sourceFiles;
-  return rest;
+async function hydrateWorkflowRetryParams(input: {
+  env: CoordinatorEnv;
+  params: unknown;
+  paramsRef: unknown;
+}): Promise<PlayWorkflowParams | null> {
+  if (isRecord(input.params)) {
+    return input.params as PlayWorkflowParams;
+  }
+  if (!isRecord(input.paramsRef)) {
+    return null;
+  }
+  const storageKind = input.paramsRef.storageKind;
+  const storageKey = input.paramsRef.storageKey;
+  const expectedBytes = input.paramsRef.bytes;
+  const expectedHash = input.paramsRef.hash;
+  if (
+    storageKind !== 'r2' ||
+    typeof storageKey !== 'string' ||
+    !storageKey.startsWith('plays/workflow-retry-params/') ||
+    typeof expectedBytes !== 'number' ||
+    !Number.isFinite(expectedBytes) ||
+    typeof expectedHash !== 'string' ||
+    !expectedHash
+  ) {
+    throw new Error('Invalid workflow retry params reference.');
+  }
+  const object = await input.env.PLAYS_BUCKET.get(storageKey);
+  if (!object) {
+    throw new Error(`Workflow retry params missing from R2: ${storageKey}`);
+  }
+  const text = await object.text();
+  const actualBytes = new TextEncoder().encode(text).length;
+  if (actualBytes !== expectedBytes) {
+    throw new Error(
+      `Workflow retry params byte length mismatch: expected ${expectedBytes}, got ${actualBytes}.`,
+    );
+  }
+  const actualHash = stableHash(text);
+  if (actualHash !== expectedHash) {
+    throw new Error('Workflow retry params hash mismatch.');
+  }
+  const parsed = JSON.parse(text) as unknown;
+  return isRecord(parsed) ? (parsed as PlayWorkflowParams) : null;
 }
 
-function stripRetryChildManifestCode(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    const rest = { ...manifest };
-    delete rest.bundledCode;
-    delete rest.sourceCode;
-    stripped[key] = rest;
-  }
-  return stripped;
+function workflowRetryStatePersistenceErrorResponse(input: {
+  runId: string;
+  error: unknown;
+}): Response {
+  const message =
+    input.error instanceof Error ? input.error.message : String(input.error);
+  return Response.json(
+    {
+      error: {
+        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
+        message:
+          'Failed to persist workflow retry state before dispatching the play run.',
+        phase: 'coordinator_retry_state_persistence',
+        runId: input.runId,
+        cause: message,
+      },
+    },
+    { status: 503 },
+  );
 }
 
 async function claimWorkflowPlatformRetry(input: {
@@ -1255,6 +1438,7 @@ async function claimWorkflowPlatformRetry(input: {
     claimed?: unknown;
     attempts?: unknown;
     params?: unknown;
+    paramsRef?: unknown;
   }>(input.env, '/run-retry-claim', {
     method: 'POST',
     body: JSON.stringify({
@@ -1262,10 +1446,15 @@ async function claimWorkflowPlatformRetry(input: {
       maxAttempts: PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
     }),
   });
+  const params = await hydrateWorkflowRetryParams({
+    env: input.env,
+    params: body.params,
+    paramsRef: body.paramsRef,
+  });
   return {
     claimed: body.claimed === true,
     attempts: typeof body.attempts === 'number' ? body.attempts : 0,
-    params: isRecord(body.params) ? (body.params as PlayWorkflowParams) : null,
+    params,
   };
 }
 
@@ -1719,17 +1908,13 @@ async function submitViaPooledWorkflow(input: {
     return null;
   }
   const leaseStartedAt = Date.now();
-  let leaseError: string | null = null;
-  const pooledInstanceId = await leaseWorkflowPoolId(
-    input.env,
-    input.params.runId,
-  ).catch((error) => {
-    leaseError = error instanceof Error ? error.message : String(error);
-    return null;
-  });
-  const missCounts = pooledInstanceId
-    ? null
-    : await workflowPoolCount(input.env).catch(() => null);
+  const { pooledInstanceId, missCounts, leaseError } =
+    await leaseWorkflowPoolIdWithMissRecovery({
+      env: input.env,
+      runId: input.params.runId,
+      recordSubmitTiming: input.recordSubmitTiming,
+      graphHash: input.params.graphHash ?? null,
+    });
   input.recordSubmitTiming({
     phase: 'coordinator.workflow_pool_lease',
     ms: Date.now() - leaseStartedAt,
@@ -1746,30 +1931,6 @@ async function submitViaPooledWorkflow(input: {
     },
   });
 
-  if (!pooledInstanceId) {
-    // A pool miss must not block the user path. Refilling is handled by the
-    // caller's waitUntil after submit, so fall through to cold create now.
-    const counts =
-      missCounts ?? (await workflowPoolCount(input.env).catch(() => null));
-    input.recordSubmitTiming({
-      phase: 'coordinator.workflow_pool_refill_on_miss',
-      ms: 0,
-      graphHash: input.params.graphHash ?? null,
-      extra: {
-        skipped: true,
-        reason: 'pool_miss_does_not_block_submit',
-        ...(counts
-          ? {
-              available: counts.available,
-              warming: counts.warming,
-              waitedMs: 0,
-              waitIterations: 0,
-            }
-          : {}),
-      },
-    });
-  }
-
   if (!pooledInstanceId) {
     return null;
   }
@@ -3606,11 +3767,40 @@ async function handleWorkflowRoute(input: {
       params,
       recordSubmitTiming,
     });
-    await persistWorkflowRetryState({
-      env,
-      runId: submittedRunId,
-      params: workflowParams,
-    });
+    try {
+      const retryStateStartedAt = Date.now();
+      await persistWorkflowRetryState({
+        env,
+        runId: submittedRunId,
+        params: workflowParams,
+      });
+      recordSubmitTiming({
+        phase: 'coordinator.retry_state_persistence',
+        ms: Date.now() - retryStateStartedAt,
+        graphHash: params.graphHash ?? null,
+      });
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      console.error('[coordinator] workflow retry state persistence failed', {
+        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
+        runId: submittedRunId,
+        error: errorMessage,
+      });
+      recordSubmitTiming({
+        phase: 'coordinator.retry_state_persistence',
+        ms: 0,
+        graphHash: params.graphHash ?? null,
+        extra: {
+          status: 'failed',
+          error: errorMessage,
+        },
+      });
+      return workflowRetryStatePersistenceErrorResponse({
+        runId: submittedRunId,
+        error,
+      });
+    }
     let instance: WorkflowInstance | null = null;
     try {
       const statusEventStartedAt = Date.now();