deepline 0.3.313 → 0.3.315

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

@@ -1,5 +1,13 @@
 import type { CreateSandboxFromSnapshotParams, Sandbox } from '@daytonaio/sdk';
-import { DaytonaLaunchOutcomeUnknownError } from './daytona-launch-transport';
+import {
+  boundedDaytonaProviderTextForLog,
+  type DaytonaLaunchOutcomeDiagnostic,
+  DaytonaLaunchOutcomeUnknownError,
+  daytonaErrorClassForLog,
+  daytonaErrorCodeForLog,
+  daytonaErrorStatusForLog,
+  daytonaSandboxStateForLog,
+} from './daytona-launch-transport';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
@@ -110,7 +118,15 @@ export class DaytonaSandboxAcquisitionUnavailableError extends Error {
  * creating another sandbox could execute the Play twice.
  */
 export class DaytonaSandboxTransitionPendingError extends Error {
-  constructor(readonly sandboxName: string) {
+  constructor(
+    readonly sandboxName: string,
+    /**
+     * What Daytona reported when this decision was made. Log-only: a 404, a
+     * lookup error, and every non-started state all reach this same error, so
+     * the scheduler logs this to tell them apart. It never changes recovery.
+     */
+    readonly recoveryLogDetail: DaytonaSandboxTransitionPendingLogDetail | null = null,
+  ) {
     super(
       `Daytona sandbox ${sandboxName} is still transitioning after create timed out.`,
     );
@@ -118,6 +134,140 @@ export class DaytonaSandboxTransitionPendingError extends Error {
   }
 }
 
+/** One provider lookup of the named sandbox, reduced to bounded log facts. */
+type DaytonaNamedSandboxObservation = {
+  lookup: 'found' | 'not_found' | 'error' | 'unsupported';
+  sandboxState: string | null;
+  /** Not `sandboxId`: that key means an acquired sandbox to lifecycle tooling. */
+  observedSandboxId: string | null;
+  providerErrorReason: string | null;
+  lookupErrorClass: string | null;
+  lookupErrno: string | null;
+  lookupErrorStatus: number | null;
+};
+
+/**
+ * Flat, bounded scalars only: enumerated states and classes, one provider
+ * sandbox id, counts, durations, and one capped provider text field.
+ */
+export type DaytonaSandboxTransitionPendingLogDetail =
+  DaytonaNamedSandboxObservation & {
+    phase: 'create_reconcile' | 'resume';
+    /** Names the case; all of them map to the same recovery decision. */
+    reasonDetail: string;
+    providerAttempt: number;
+    /** Lookups issued by this decision's reconcile ladder (at most 7). */
+    lookups: number;
+    lookupErrors: number;
+    deleteConflicts: number;
+    elapsedMs: number;
+    /** Known only in the process that sent the create. */
+    createResponseReceived: boolean | null;
+    createLastObservedState: string | null;
+  };
+
+const NO_DAYTONA_NAMED_SANDBOX_LOOKUP: DaytonaNamedSandboxObservation = {
+  lookup: 'unsupported',
+  sandboxState: null,
+  observedSandboxId: null,
+  providerErrorReason: null,
+  lookupErrorClass: null,
+  lookupErrno: null,
+  lookupErrorStatus: null,
+};
+
+// Both observers are total: they run between a provider lookup and the
+// decision it feeds, so a failure to describe the lookup must not surface.
+function observeDaytonaNamedSandbox(
+  sandbox: DaytonaSandbox,
+): DaytonaNamedSandboxObservation {
+  try {
+    const record = sandbox as { id?: unknown; errorReason?: unknown };
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: 'found',
+      sandboxState: daytonaSandboxStateForLog(sandbox.state) ?? 'missing',
+      observedSandboxId:
+        typeof record.id === 'string' && record.id
+          ? record.id.slice(0, 64)
+          : null,
+      providerErrorReason: boundedDaytonaProviderTextForLog(record.errorReason),
+    };
+  } catch {
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: 'found',
+      sandboxState: 'unreadable',
+    };
+  }
+}
+
+function observeDaytonaNamedSandboxLookupFailure(
+  error: unknown,
+): DaytonaNamedSandboxObservation {
+  try {
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: isDaytonaSandboxNotFound(error) ? 'not_found' : 'error',
+      lookupErrorClass: daytonaErrorClassForLog(error),
+      lookupErrno: daytonaErrorCodeForLog(error),
+      lookupErrorStatus: daytonaErrorStatusForLog(error),
+    };
+  } catch {
+    return { ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP, lookup: 'error' };
+  }
+}
+
+function daytonaTransitionPendingReasonDetail(
+  phase: DaytonaSandboxTransitionPendingLogDetail['phase'],
+  observation: DaytonaNamedSandboxObservation,
+  deleteConflicts: number,
+): string {
+  if (observation.lookup !== 'found') {
+    return `${phase}:lookup_${observation.lookup}`;
+  }
+  // Reconcile reaches a pending decision with a visible sandbox only after
+  // every delete of it reported an in-progress state change.
+  return deleteConflicts > 0
+    ? `${phase}:delete_conflict:${observation.sandboxState}`
+    : `${phase}:sandbox_state:${observation.sandboxState}`;
+}
+
+/**
+ * The log detail for one pending decision. Total by construction: failing to
+ * describe a decision must never replace the decision.
+ */
+function daytonaTransitionPendingLogDetail(input: {
+  phase: DaytonaSandboxTransitionPendingLogDetail['phase'];
+  observed: TimedOutDaytonaSandboxReconcileObserved;
+  providerAttempt: number;
+  launchOutcome: DaytonaLaunchOutcomeDiagnostic | null;
+}): DaytonaSandboxTransitionPendingLogDetail | null {
+  try {
+    const { last, lookups, lookupErrors, deleteConflicts, elapsedMs } =
+      input.observed;
+    return {
+      ...last,
+      phase: input.phase,
+      reasonDetail: daytonaTransitionPendingReasonDetail(
+        input.phase,
+        last,
+        deleteConflicts,
+      ),
+      providerAttempt: input.providerAttempt,
+      lookups,
+      lookupErrors,
+      deleteConflicts,
+      elapsedMs,
+      createResponseReceived:
+        input.launchOutcome?.createResponseReceived ?? null,
+      createLastObservedState: input.launchOutcome?.lastObservedState ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
 export function resolveDaytonaSandboxAcquisitionUnavailableReason(
   errors: readonly string[],
 ): DaytonaSandboxAcquisitionUnavailableReason | null {
@@ -369,11 +519,21 @@ async function createOneShotDaytonaSandbox(input: {
   });
 }
 
-type TimedOutDaytonaSandboxReconciliation =
+/** Log-only tally of one reconcile ladder; it never selects the result. */
+type TimedOutDaytonaSandboxReconcileObserved = {
+  last: DaytonaNamedSandboxObservation;
+  lookups: number;
+  lookupErrors: number;
+  deleteConflicts: number;
+  elapsedMs: number;
+};
+
+type TimedOutDaytonaSandboxReconciliation = (
   | { kind: 'started'; sandbox: DaytonaSandbox }
   | { kind: 'deleted' }
   | { kind: 'not_found' }
-  | { kind: 'transition_pending' };
+  | { kind: 'transition_pending' }
+) & { observed: TimedOutDaytonaSandboxReconcileObserved };
 
 async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
@@ -386,7 +546,19 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     runId?: string;
   };
 }): Promise<TimedOutDaytonaSandboxReconciliation> {
-  if (!input.daytona.get) return { kind: 'not_found' };
+  const reconcileStartedAt = Date.now();
+  let last = NO_DAYTONA_NAMED_SANDBOX_LOOKUP;
+  let lookups = 0;
+  let lookupErrors = 0;
+  let deleteConflicts = 0;
+  const observed = (): TimedOutDaytonaSandboxReconcileObserved => ({
+    last,
+    lookups,
+    lookupErrors,
+    deleteConflicts,
+    elapsedMs: Date.now() - reconcileStartedAt,
+  });
+  if (!input.daytona.get) return { kind: 'not_found', observed: observed() };
   let lastDeleteConflict: unknown = null;
   for (const delayMs of DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS) {
     input.cancellationSignal?.throwIfAborted();
@@ -394,9 +566,11 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       await waitForAcquisitionRetry(delayMs, input.cancellationSignal);
     }
     let sandbox: DaytonaSandbox;
+    lookups += 1;
     try {
       sandbox = await input.daytona.get(input.sandboxName);
     } catch (error) {
+      last = observeDaytonaNamedSandboxLookupFailure(error);
       const providerStatus =
         error && typeof error === 'object' && 'statusCode' in error
           ? error.statusCode
@@ -410,7 +584,10 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       // A current absence is not proof that the sent create cannot commit.
       // Return it to the durable operation owner without another create or
       // releasing capacity; later recovery re-reads the same identity.
-      if (isDaytonaSandboxNotFound(error)) return { kind: 'not_found' };
+      if (isDaytonaSandboxNotFound(error)) {
+        return { kind: 'not_found', observed: observed() };
+      }
+      lookupErrors += 1;
       continue;
     }
     input.emitStage?.('create:reconcile_state', {
@@ -423,8 +600,9 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     // is safer and faster than attempting a conflicting delete or creating a
     // second sandbox.
     if (sandbox.state === 'started') {
-      return { kind: 'started', sandbox };
+      return { kind: 'started', sandbox, observed: observed() };
     }
+    last = observeDaytonaNamedSandbox(sandbox);
     if (input.operationIdentity) {
       const expected = input.operationIdentity;
       const configuredOrganizationId =
@@ -455,6 +633,7 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       // sandbox while the first one is still becoming ready.
       if (isDaytonaSandboxStateChangeConflict(error)) {
         lastDeleteConflict = error;
+        deleteConflicts += 1;
         continue;
       }
       throw new Error(
@@ -462,12 +641,12 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
         { cause: error },
       );
     }
-    return { kind: 'deleted' };
+    return { kind: 'deleted', observed: observed() };
   }
   if (lastDeleteConflict) {
-    return { kind: 'transition_pending' };
+    return { kind: 'transition_pending', observed: observed() };
   }
-  return { kind: 'not_found' };
+  return { kind: 'not_found', observed: observed() };
 }
 
 function daytonaSandboxName(providerOperationToken?: string | null): string {
@@ -553,8 +732,17 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         );
       }
       // Neither absence nor an ongoing transition proves that create cannot
-      // commit. Retain the durable identity and its capacity reservation.
-      throw new DaytonaSandboxTransitionPendingError(sandboxName);
+      // commit. Retain the durable identity and its capacity reservation. The
+      // detail only records which of the two Daytona reported, for the log.
+      throw new DaytonaSandboxTransitionPendingError(
+        sandboxName,
+        daytonaTransitionPendingLogDetail({
+          phase: 'resume',
+          observed: reconciliation.observed,
+          providerAttempt: attempt,
+          launchOutcome: null,
+        }),
+      );
     }
     let sandbox: DaytonaSandbox;
     try {
@@ -579,17 +767,29 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           errorClass: daytonaCreateErrorClass(error),
         });
       errors.push(message);
+      // Log-only: whether the create request returned before the deadline and
+      // what Daytona last reported, so an unknown outcome is attributable.
+      const launchOutcome =
+        error instanceof DaytonaLaunchOutcomeUnknownError
+          ? error.diagnostic
+          : null;
+      const createFailureLogDetail = {
+        createErrorClass: daytonaCreateErrorClass(error),
+        ...(launchOutcome ?? {}),
+      };
       input.emitStage('create:attempt_failed', {
         attempt,
         elapsedMs: Date.now() - input.startedAt,
         attemptElapsedMs: Date.now() - attemptStartedAt,
         error: message,
+        ...createFailureLogDetail,
       });
       console.warn('[play-runner.daytona.create_attempt_failed]', {
         workflowId: input.context.workflowId ?? null,
         runId: input.context.runId ?? null,
         attempt,
         error: message,
+        ...createFailureLogDetail,
       });
       const immediateFallbackReason =
         resolveDaytonaSandboxAcquisitionUnavailableReason([message]);
@@ -640,9 +840,21 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           };
         }
         await recordCreateFailure();
+        // Same decision as before; the detail records what the ladder saw.
+        const reconcileObserved = reconciliation.observed;
+        const reconcilePending = (): DaytonaSandboxTransitionPendingError =>
+          new DaytonaSandboxTransitionPendingError(
+            sandboxName,
+            daytonaTransitionPendingLogDetail({
+              phase: 'create_reconcile',
+              observed: reconcileObserved,
+              providerAttempt: attempt,
+              launchOutcome,
+            }),
+          );
         if (reconciliation.kind === 'transition_pending') {
           if (reservation?.providerOperationToken) {
-            throw new DaytonaSandboxTransitionPendingError(sandboxName);
+            throw reconcilePending();
           }
           throw new Error(
             `Daytona timed-out sandbox ${sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
@@ -663,7 +875,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           );
         }
         if (reservation?.providerOperationToken) {
-          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+          throw reconcilePending();
         }
         throw new Error(
           `${message} Daytona did not return a cleanup-addressable sandbox identity; Modal fallback suppressed. The named ephemeral sandbox retains Daytona's auto-delete-on-stop backstop.`,

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

@@ -1,4 +1,7 @@
-import { createDaytonaLaunchClient } from './daytona-launch-transport';
+import {
+  createDaytonaLaunchClient,
+  redactDaytonaErrorDetail,
+} from './daytona-launch-transport';
 import type { DaytonaClientOptions } from '../../daytona-runtime-config';
 import {
   createDaytonaControlClient,
@@ -328,23 +331,6 @@ function numberProperty(value: unknown, key: string): number | null {
     : null;
 }
 
-function redactDaytonaErrorDetail(value: string): string {
-  return value
-    .replace(
-      /authorization\s*[=:]\s*bearer\s+[^\s,;]+/gi,
-      'Authorization=Bearer [redacted]',
-    )
-    .replace(
-      /(authorization\s*[=:]\s*)(?!bearer\s+\[redacted\])[^\s,;]+/gi,
-      '$1[redacted]',
-    )
-    .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
-    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, 1_000);
-}
-
 /**
  * Preserve the actionable shape of a Daytona control-plane failure without
  * copying credentials or an arbitrarily large upstream response into logs.

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -48,6 +48,7 @@ import { RUNTIME_RELIABILITY_POLICY } from '../runtime-reliability-policy';
 import type { RuntimeTrafficPolicy } from '../runtime-traffic-policy';
 import { runtimeLimitExceededCause } from '../run-failure';
 import {
+  playRunRecoveryLogDetail,
   recoveryForDaytonaSandboxAcquisitionUnavailable,
   recoveryForRuntimeInitializationTransportFailure,
   recoveryForRuntimeSchedulerAdmissionFailure,
@@ -4359,6 +4360,9 @@ async function executeAssignedAbsurdAttempt(input: {
         }),
       );
       if (recovery.kind === 'deferred') {
+        // Log-only. The persisted reason groups several provider conditions
+        // into one decision; the detail names the one that was observed.
+        const detail = playRunRecoveryLogDetail(recoveryError);
         console.warn('[absurd-runtime.worker] pre_code_recovery_deferred', {
           runId,
           generation,
@@ -4367,6 +4371,7 @@ async function executeAssignedAbsurdAttempt(input: {
           deferCount: recovery.deferCount,
           deadlineAtMs: recovery.deadlineAtMs,
           delaySeconds: recovery.delaySeconds,
+          ...(detail ? { detail } : {}),
         });
         throw new DeferTask(
           `Platform recovery deferred for ${recovery.dependency}: ${recovery.reason}`,

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

@@ -15682,6 +15682,34 @@ export async function getPostgresSchedulerObservations(
   return result.rows.map(mapObservationRow);
 }
 
+/** Read the newest settled observation for one node across a bounded page of runs. */
+export async function getPostgresSchedulerObservationsForRuns(
+  client: PostgresSchedulerQueryClient,
+  input: { runIds: readonly string[]; nodeId: string },
+  options: PostgresSchedulerReceiptOptions,
+): Promise<DocflowObservationRecord[]> {
+  const runIds = [
+    ...new Set(input.runIds.map((runId) => runId.trim()).filter(Boolean)),
+  ];
+  if (runIds.length === 0) return [];
+  const result = await client.query<ObservationRow>(
+    `
+      SELECT DISTINCT ON (run_id)
+             run_id, attempt, node_id, invocation_seq, invocation_id, status,
+             inputs_json, outputs_json, inputs_truncated, outputs_truncated,
+             error, started_at, settled_at
+        FROM ${tableName('observations', options)}
+       WHERE org_id = $1
+         AND run_id = ANY($2::text[])
+         AND node_id = $3
+         AND status IN ('completed', 'failed')
+       ORDER BY run_id, attempt DESC, invocation_seq DESC
+    `,
+    [receiptOrgId(options), runIds, input.nodeId],
+  );
+  return result.rows.map(mapObservationRow);
+}
+
 export async function countPostgresSchedulerReceipts(
   client: PostgresSchedulerQueryClient,
   input: {
@@ -18151,6 +18179,20 @@ async function claimPostgresSchedulerOutboxPrefix(
         : supportsTerminalBatchMarker && input.allowIngressPrefix === true
           ? `(head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})`
           : 'false';
+    const findSearchBlockersOnce = seekRunHead && input.searchOnly === true;
+    const blockingPredecessorSql = (alias: string) => `(
+      (${alias}.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
+       AND NOT (${ingressPrefixSql}))
+      OR (${supportsTerminalBatchMarker && input.allowIngressPrefix === true ? `head.delivery_batch_started_at IS NOT NULL AND ${alias}.delivery_batch_started_at IS NULL` : 'false'})
+      OR ${alias}.failed_at IS NOT NULL
+      OR coalesce(${alias}.next_attempt_at, ${alias}.created_at) > now()
+      OR (
+        $3::text IS NOT NULL
+        AND ${alias}.lease_expires_at IS NOT NULL
+        AND ${alias}.lease_expires_at > now()
+        AND ${alias}.lease_owner IS DISTINCT FROM $3::text
+      )
+    )`;
     return await client.query<{
       row_kind: 'claimed' | 'delivered';
       event_id: string;
@@ -18193,6 +18235,7 @@ async function claimPostgresSchedulerOutboxPrefix(
           : ''
       } head AS MATERIALIZED (
         SELECT candidate.event_id, candidate.run_id, candidate.event_type,
+               ${findSearchBlockersOnce ? 'candidate.created_at,' : ''}
                ${supportsTerminalBatchMarker ? 'candidate.delivery_batch_started_at' : 'NULL::timestamptz'} AS delivery_batch_started_at
         FROM ${tableName('outbox', options)} AS candidate
         ${seekRunHead ? 'JOIN pending_head ON pending_head.event_id = candidate.event_id' : ''}
@@ -18274,7 +18317,41 @@ async function claimPostgresSchedulerOutboxPrefix(
         }
         FOR UPDATE SKIP LOCKED
         LIMIT 1
-      ), candidates AS MATERIALIZED (
+      ), ${
+        findSearchBlockersOnce
+          ? `first_blocker AS MATERIALIZED (
+        SELECT predecessor.event_type, predecessor.created_at, predecessor.event_id
+        FROM ${tableName('outbox', options)} AS predecessor
+        JOIN head ON head.run_id = predecessor.run_id
+        WHERE predecessor.run_id = $2::text
+          AND ${pending('predecessor')}
+          AND ${searchLaneSql('predecessor')} = true
+          -- The oldest pending head passed eligibility above. Only later
+          -- facts can introduce an ordinary blocker for this prefix.
+          AND ${runLedgerPositionSql('predecessor')} > (
+            (SELECT CASE head.event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END FROM head),
+            (SELECT head.created_at FROM head),
+            (SELECT head.event_id FROM head)
+          )
+          AND ${blockingPredecessorSql('predecessor')}
+        ORDER BY ${runLedgerOrderSql('predecessor')}
+        LIMIT 1
+      ), first_started_terminal AS MATERIALIZED (
+        SELECT terminal_predecessor.event_type, terminal_predecessor.created_at, terminal_predecessor.event_id
+        FROM ${tableName('outbox', options)} AS terminal_predecessor
+        JOIN head ON head.run_id = terminal_predecessor.run_id
+        WHERE terminal_predecessor.run_id = $2::text
+          AND ${pending('terminal_predecessor')}
+          AND ${searchLaneSql('terminal_predecessor')} = true
+          AND ${supportsTerminalBatchMarker ? 'terminal_predecessor.delivery_batch_started_at IS NOT NULL' : 'false'}
+          AND terminal_predecessor.event_type IN (
+            ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
+          )
+        ORDER BY ${runLedgerOrderSql('terminal_predecessor')}
+        LIMIT 1
+      ),`
+          : ''
+      }candidates AS MATERIALIZED (
         SELECT outbox.event_id
         FROM ${tableName('outbox', options)} AS outbox
         JOIN head ON head.run_id = outbox.run_id
@@ -18313,7 +18390,20 @@ async function claimPostgresSchedulerOutboxPrefix(
           -- that the replay included a new event.  A terminal which has not
           -- started a batch yet remains an ordinary causal event and can be
           -- claimed with its existing contiguous prefix.
+          ${
+            findSearchBlockersOnce
+              ? `-- Each cutoff reads this run's blockers once, even when stale
+          -- statistics make a broad pending scan look cheaper than a seek.
           AND NOT EXISTS (
+            SELECT 1 FROM first_started_terminal AS blocker
+            WHERE ${supportsTerminalBatchMarker ? 'outbox.delivery_batch_started_at IS NULL' : 'true'}
+              AND ${runLedgerPositionSql('blocker')} < ${runLedgerPositionSql('outbox')}
+          )
+          AND NOT EXISTS (
+            SELECT 1 FROM first_blocker AS blocker
+            WHERE ${runLedgerPositionSql('blocker')} < ${runLedgerPositionSql('outbox')}
+          )`
+              : `          AND NOT EXISTS (
             SELECT 1
             FROM ${tableName('outbox', options)} AS terminal_predecessor
             WHERE terminal_predecessor.run_id = outbox.run_id
@@ -18341,20 +18431,10 @@ async function claimPostgresSchedulerOutboxPrefix(
             WHERE predecessor.run_id = outbox.run_id
               AND ${pending('predecessor')}
               AND ${runLedgerPrecedesSql('predecessor', 'outbox', false, input.searchOnly === true)}
-              AND (
-                (predecessor.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
-                 AND NOT (${ingressPrefixSql}))
-                OR (${supportsTerminalBatchMarker && input.allowIngressPrefix === true ? 'head.delivery_batch_started_at IS NOT NULL AND predecessor.delivery_batch_started_at IS NULL' : 'false'})
-                OR predecessor.failed_at IS NOT NULL
-                OR coalesce(predecessor.next_attempt_at, predecessor.created_at) > now()
-                OR (
-                  $3::text IS NOT NULL
-                  AND predecessor.lease_expires_at IS NOT NULL
-                  AND predecessor.lease_expires_at > now()
-                  AND predecessor.lease_owner IS DISTINCT FROM $3::text
-                )
-              )
+              AND ${blockingPredecessorSql('predecessor')}
           )
+`
+          }
         ORDER BY ${runLedgerOrderSql('outbox')}
         FOR UPDATE OF outbox
         LIMIT $1