deepline 0.1.211 → 0.1.212

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.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 },
+    };
   }
 }
 

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

@@ -9,16 +9,25 @@ import type {
   PlayRunnerResult,
 } from '@shared_libs/play-runtime/protocol';
 
-export type PlayRunnerRuntimeResource =
-  | {
-      kind: 'daytona_sandbox';
-      sandboxId: string;
-      billingStartedAt: number;
-      billingEndedAt?: number | null;
-      cpu?: number | null;
-      memoryGiB?: number | null;
-      diskGiB?: number | null;
-    };
+export type PlayRunnerRuntimeResource = {
+  kind: 'daytona_sandbox';
+  sandboxId: string;
+  billingStartedAt: number;
+  billingEndedAt?: number | null;
+  terminalReason?: RuntimeResourceTerminalReason | null;
+  terminalAt?: number | null;
+  cpu?: number | null;
+  memoryGiB?: number | null;
+  diskGiB?: number | null;
+};
+
+export type RuntimeResourceTerminalReason =
+  | 'completed'
+  | 'runner_failed'
+  | 'sandbox_missing'
+  | 'sandbox_oom'
+  | 'cancelled'
+  | 'lease_expired';
 
 export class RuntimeResourceFenceLostError extends Error {
   constructor(message: string) {

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

@@ -127,6 +127,8 @@ type RuntimeApiContext = {
   postgresSessionUnwrapKey?: string | null;
 };
 
+const RUNTIME_RUN_DATASET_CATALOG_TABLE = '_deepline_run_datasets';
+
 type DirectRuntimeTestFaultState = {
   headerValue: string;
   counts: Partial<Record<RuntimeTestFaultName, number>>;
@@ -1572,8 +1574,17 @@ async function withRuntimePostgres<T>(
         requestLocalPool = pool;
       }
       client = await connectRuntimePostgresPool(pool);
+      if (session.executionRole) {
+        await client.query(
+          `SET ROLE ${quoteIdentifier(session.executionRole)}`,
+        );
+      }
       break;
     } catch (error) {
+      if (client) {
+        client.release();
+        client = null;
+      }
       if (cachePool) {
         const pool = postgresPools.get(session.postgresUrl);
         postgresPools.delete(session.postgresUrl);
@@ -1604,7 +1615,13 @@ async function withRuntimePostgres<T>(
   try {
     return await fn(client);
   } finally {
-    client.release();
+    try {
+      if (session.executionRole) {
+        await client.query('RESET ROLE');
+      }
+    } finally {
+      client.release();
+    }
     if (requestLocalPool) {
       await Promise.resolve(requestLocalPool.end()).catch(() => {});
     }
@@ -1833,6 +1850,38 @@ function columnSummaryTable(session: RuntimePostgresSession): string {
   return fqRuntimeTable(session, session.postgres.columnSummaryTable);
 }
 
+function runDatasetCatalogTable(session: RuntimePostgresSession): string {
+  return fqRuntimeTable(session, RUNTIME_RUN_DATASET_CATALOG_TABLE);
+}
+
+async function registerRuntimeDataset(
+  session: RuntimePostgresSession,
+  input: { playName: string; tableNamespace: string; runId: string },
+): Promise<void> {
+  const tableNamespace = normalizeTableNamespace(input.tableNamespace);
+  const playName = normalizePlayNameForSheet(input.playName);
+  const datasetId = createRuntimeDatasetId(playName, tableNamespace);
+  await withRuntimePostgres(session, async (client) => {
+    await client.query(
+      `INSERT INTO ${runDatasetCatalogTable(session)} (
+         run_id, dataset_id, play_name, table_namespace, public_path
+       ) VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (run_id, dataset_id) DO UPDATE SET
+         play_name = EXCLUDED.play_name,
+         table_namespace = EXCLUDED.table_namespace,
+         public_path = EXCLUDED.public_path,
+         updated_at = now()`,
+      [
+        input.runId,
+        datasetId,
+        playName,
+        tableNamespace,
+        `datasets.${tableNamespace}`,
+      ],
+    );
+  });
+}
+
 function workReceiptTable(session: RuntimePostgresSession): string {
   return fqRuntimeTable(
     session,
@@ -2022,8 +2071,11 @@ async function withRuntimeWorkReceiptClient<T>(
 ): Promise<T> {
   // Receipt tables are part of customer Postgres bootstrap, so the hot path
   // should not pay DDL on every fresh runtime isolate. Try the receipt query
-  // first, then self-heal once on a missing relation/column. A genuinely
-  // missing schema, permission error, or second failure still rethrows loudly.
+  // first, then self-heal once on a missing relation/column. Permission loss
+  // during an operational receipt query must fail loud: silently repairing it
+  // can let provider work continue after durable receipt persistence is gone.
+  // Only the schema-migration branch below may repair ownership before its
+  // retry. A genuinely missing schema or second failure also rethrows loudly.
   const runWithSelfHeal = async (client: RuntimeQueryClient): Promise<T> => {
     try {
       return await operation(client);
@@ -2048,10 +2100,6 @@ async function withRuntimeWorkReceiptClient<T>(
             playName: context.playName?.trim() || session.playName,
           });
         }
-      } else if (isPostgresPermissionDeniedError(error)) {
-        await repairRuntimeStorageGrants(context, {
-          playName: context.playName?.trim() || session.playName,
-        });
       } else {
         throw error;
       }
@@ -5188,6 +5236,14 @@ export async function startRuntimeSheetDataset(
     ms: Date.now() - sessionStartedAt,
     rows: input.rows.length,
   });
+  // Register the exact run-scoped Dataset Handle before any row can become
+  // durable. A crash after a later sheet write can therefore never leave
+  // customer data discoverable only through static pipeline inference.
+  await registerRuntimeDataset(session, {
+    playName,
+    tableNamespace: input.tableNamespace,
+    runId: input.runId,
+  });
   const normalizeStartedAt = Date.now();
   const uniqueRows = new Map<
     string,

package/dist/bundling-sources/shared_libs/play-runtime/secret-capability.ts

@@ -39,10 +39,24 @@ export function isSecretAuth(value: unknown): value is SecretAuth {
 }
 
 export function valueContainsSecret(value: unknown): boolean {
-  if (isSecretHandle(value) || isSecretAuth(value)) return true;
-  if (typeof value === 'string') return SECRET_HANDLE_MARKER_RE.test(value);
-  if (Array.isArray(value)) return value.some(valueContainsSecret);
-  if (isRecord(value)) return Object.values(value).some(valueContainsSecret);
+  const pending: unknown[] = [value];
+  const seen = new WeakSet<object>();
+  while (pending.length > 0) {
+    const candidate = pending.pop();
+    if (isSecretHandle(candidate) || isSecretAuth(candidate)) return true;
+    if (typeof candidate === 'string') {
+      if (SECRET_HANDLE_MARKER_RE.test(candidate)) return true;
+      continue;
+    }
+    if (!candidate || typeof candidate !== 'object') continue;
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (Array.isArray(candidate)) {
+      for (const entry of candidate) pending.push(entry);
+    } else if (isRecord(candidate)) {
+      for (const entry of Object.values(candidate)) pending.push(entry);
+    }
+  }
   return false;
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -88,14 +88,15 @@ function decideToolExecuteHttpRetry(input: {
   hasRetryAfterHeader?: boolean;
   transientHttpRetrySafe?: boolean;
 }): ToolExecuteHttpRetryDecision {
+  if (input.hardBillingFailure) {
+    return {
+      retryable: false,
+      attemptCap:
+        input.status === 429 ? TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS : 1,
+      reason: 'hard_billing_error',
+    };
+  }
   if (input.status === 429) {
-    if (input.hardBillingFailure) {
-      return {
-        retryable: false,
-        attemptCap: TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS,
-        reason: 'hard_billing_error',
-      };
-    }
     if (!input.hasRetryAfterHeader) {
       return {
         retryable: true,
@@ -178,6 +179,7 @@ export function classifyToolExecuteHttpFailure(input: {
   bodyText: string;
   retryAfterHeader?: string | null;
   transientHttpRetrySafe?: boolean;
+  providerLatencyMs?: number;
   nowMs?: number;
 }): ToolExecuteHttpFailureOutcome {
   const transientHttpRetrySafe = input.transientHttpRetrySafe === true;
@@ -196,15 +198,33 @@ export function classifyToolExecuteHttpFailure(input: {
     maxAttempts: initialRetryDecision.attemptCap,
     bodyText: input.bodyText,
   });
+  if (
+    typeof input.providerLatencyMs === 'number' &&
+    Number.isFinite(input.providerLatencyMs) &&
+    input.providerLatencyMs >= 0
+  ) {
+    error.message = `${error.message} (provider call ${Math.round(input.providerLatencyMs)}ms)`;
+  }
+  const hardBillingFailure = isHardBillingToolHttpError(error);
   const retryDecision = decideToolExecuteHttpRetry({
     status: input.status,
-    hardBillingFailure: isHardBillingToolHttpError(error),
+    hardBillingFailure,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
   });
   const shouldRetry =
     retryDecision.retryable && input.attempt < retryDecision.attemptCap;
-  if (retryDecision.retryable) error.receiptFailureKind = 'repairable';
+  // In-attempt retry safety and later-run repairability are different
+  // decisions. A non-idempotent 5xx must not be repeated automatically inside
+  // this execution attempt, but an explicit later `plays run` must be able to
+  // repair that failed work while completed calls remain reusable. Otherwise
+  // one provider gateway failure poisons the semantic call forever.
+  if (
+    !hardBillingFailure &&
+    (retryDecision.retryable || (input.status >= 500 && input.status < 600))
+  ) {
+    error.receiptFailureKind = 'repairable';
+  }
   const retryAfterMs = parseToolExecuteRetryAfterMs(
     input.retryAfterHeader,
     input.nowMs,

package/dist/bundling-sources/shared_libs/play-runtime/work-receipt-state-machine.ts

@@ -9,6 +9,7 @@ export type WorkReceiptStateStatus =
 export type WorkReceiptStateInput = {
   status: WorkReceiptStateStatus;
   runId?: string | null;
+  error?: string | null;
   failureKind?: 'terminal' | 'repairable' | null;
   leaseId?: string | null;
   leaseOwnerRunId?: string | null;
@@ -16,6 +17,25 @@ export type WorkReceiptStateInput = {
   leaseExpiresAt?: string | null;
 };
 
+export function isLegacyRepairableWorkReceiptError(
+  error: string | null | undefined,
+): boolean {
+  const message = error?.trim().toLowerCase() ?? '';
+  if (!message) return false;
+  if (
+    message.includes('billing cap') ||
+    message.includes('insufficient credits') ||
+    message.includes('monthly billing limit')
+  ) {
+    return false;
+  }
+  return (
+    /(?:^|\D)5\d\d(?:\D|$)/.test(message) ||
+    message.includes('transport failed calling') ||
+    message.includes('runtime api call timed out')
+  );
+}
+
 export type WorkReceiptLeaseState =
   | { kind: 'none' }
   | {
@@ -254,7 +274,8 @@ export function decideWorkReceiptClaim(input: {
     const claimantRunAttempt = normalizeAttempt(input.claimantRunAttempt);
     const ownerAttempt = normalizeAttempt(input.receipt.leaseOwnerAttempt);
     if (
-      input.receipt.failureKind === 'repairable' &&
+      (input.receipt.failureKind === 'repairable' ||
+        isLegacyRepairableWorkReceiptError(input.receipt.error)) &&
       claimantRunId !== null &&
       ownerRunId !== null &&
       (claimantRunId !== ownerRunId || ownerAttempt < claimantRunAttempt)