deepline 0.3.408 → 0.3.410

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

@@ -15,7 +15,7 @@
  * seam (Daytona sandbox / local subprocess), never in this worker process.
  *
  * ADR-0011 attempt fencing: each handler invocation requests
- * `allocatePostgresSchedulerNextAttempt` (max attempt + 1) and a fresh lease
+ * `max(attempt) + 1` from its preparation snapshot and a fresh lease
  * token. The store's assign/mark/complete guards ensure only the highest
  * generation with a matching lease token writes terminals; a reclaimed or
  * lease-lost handler observes `idle` and abandons WITHOUT writing a terminal.
@@ -45,8 +45,11 @@ import {
 } from '../app-runtime-api';
 import { RUNTIME_CAPACITY_POLICY } from '../runtime-capacity-policy';
 import { RUNTIME_RELIABILITY_POLICY } from '../runtime-reliability-policy';
+import {
+  isRuntimeTrafficPolicy,
+  type RuntimeTrafficPolicy,
+} from '../runtime-traffic-policy';
 import { RUNTIME_CLAIM_HEARTBEAT_DIVISOR } from '../runtime-constants';
-import type { RuntimeTrafficPolicy } from '../runtime-traffic-policy';
 import { runtimeLimitExceededCause } from '../run-failure';
 import {
   playRunRecoveryLogDetail,
@@ -74,7 +77,10 @@ import {
   releaseRuntimeWorkReceipts,
 } from '../runtime-api';
 import { PLAY_RUNTIME_ATTEMPT_EXECUTOR_TOKEN_PATH } from '../runtime-api-paths';
-import { vercelProtectionBypassHeaders } from '../vercel-protection';
+import {
+  fetchWithVercelProtectionBypass,
+  vercelProtectionBypassHeaders,
+} from '../vercel-protection';
 import {
   isManagedSandboxRuntimeBackend,
   normalizePlayRuntimeBackend,
@@ -122,7 +128,6 @@ import {
 } from '../runner-backends/runtime-sandbox-reconciliation';
 import { readPersistedRuntimeSandboxRef } from '../runtime-sandbox-contract';
 import {
-  allocatePostgresSchedulerNextAttempt,
   assignPostgresSchedulerRunAttempt,
   blockPostgresSchedulerComputeBillingJob,
   buildPostgresSchedulerRunnerConfig,
@@ -168,11 +173,11 @@ import {
   recordPostgresSchedulerRunnerTerminal,
   resumePostgresSchedulerDetachedRunnerAttempt,
   retryPostgresSchedulerComputeBillingJob,
+  readPostgresSchedulerAttemptPreparation,
+  readPostgresSchedulerAttemptAuthorityForLease,
   readPostgresSchedulerLaunch,
-  readPostgresSchedulerOutboxDeliveryStatus,
   readComputeBillingDispatchLaunchForLease,
   readPostgresSchedulerResult,
-  readPostgresSchedulerRunLaneState,
   listPostgresSchedulerAdoptableReleaseLanes,
   readPostgresSchedulerRunnerTerminal,
   readPostgresSchedulerRunnerLiveness,
@@ -249,6 +254,7 @@ import {
   ABSURD_PLAY_RUN_TASK,
   ABSURD_RUNS_QUEUE,
   absurdRunnerTerminalEventName,
+  absurdRunCreatedProjectionEventName,
   absurdCheckpointBase,
   absurdCheckpointWithIntegrationEvent,
   absurdCheckpointWithSleep,
@@ -781,6 +787,9 @@ export type AbsurdRuntimeWorkerDeps = {
     attempt: number;
     leaseToken: string;
     schedulerSchema?: string | null;
+    initializeComputeSession?: boolean;
+    onComputeSessionInitialized?: () => void;
+    onRuntimeTrafficPolicy?: (policy: RuntimeTrafficPolicy) => void;
   }) => Promise<string>;
   /** This worker's release lane id. Seam so tests can drive the belt-and-
    * suspenders lane-mismatch guard without mutating process env. Defaults to
@@ -1006,6 +1015,9 @@ export async function requestAttemptExecutorToken(input: {
   attempt: number;
   leaseToken: string;
   schedulerSchema?: string | null;
+  initializeComputeSession?: boolean;
+  onComputeSessionInitialized?: () => void;
+  onRuntimeTrafficPolicy?: (policy: RuntimeTrafficPolicy) => void;
 }): Promise<string> {
   const internalToken = process.env.DEEPLINE_INTERNAL_TOKEN?.trim();
   if (!internalToken) {
@@ -1014,13 +1026,6 @@ export async function requestAttemptExecutorToken(input: {
     );
   }
   const url = `${runtimeApiBaseUrlFromLaunch(input.launch).replace(/\/$/, '')}${PLAY_RUNTIME_ATTEMPT_EXECUTOR_TOKEN_PATH}`;
-  const vercelProtectionHeaders = await vercelProtectionBypassHeaders({
-    baseUrl: runtimeApiBaseUrlFromLaunch(input.launch),
-    token:
-      input.launch.vercelProtectionBypassToken ??
-      process.env.VERCEL_PROTECTION_BYPASS_TOKEN ??
-      null,
-  });
   const traceId = randomUUID();
   const startedAt = performance.now();
   console.info('[runtime-attempt-token.request_started]', {
@@ -1033,26 +1038,38 @@ export async function requestAttemptExecutorToken(input: {
   );
   let response: Response;
   try {
-    response = await fetch(url, {
+    response = await fetchWithVercelProtectionBypass({
+      baseUrl: runtimeApiBaseUrlFromLaunch(input.launch),
+      token:
+        input.launch.vercelProtectionBypassToken ??
+        process.env.VERCEL_PROTECTION_BYPASS_TOKEN ??
+        null,
       signal: requestSignal,
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-deepline-internal-token': internalToken,
-        'x-deepline-runtime-trace-id': traceId,
-        ...vercelProtectionHeaders,
-      },
-      body: JSON.stringify({
-        runId: input.launch.runId,
-        attempt: input.attempt,
-        leaseToken: input.leaseToken,
-        schedulerSchema: input.schedulerSchema ?? null,
-        // Expand-before-enable rollout fence. An old worker never sends this,
-        // so a newly deployed app cannot activate direct terminal reduction
-        // before the owning Fly lane has the cleanup controller.
-        terminalReducerContract: DIRECT_COMPLETED_TERMINAL_CONTRACT,
-      }),
-      redirect: 'manual',
+      send: (protectionHeaders) =>
+        fetch(url, {
+          signal: requestSignal,
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+            'x-deepline-internal-token': internalToken,
+            'x-deepline-runtime-trace-id': traceId,
+            ...protectionHeaders,
+          },
+          body: JSON.stringify({
+            runId: input.launch.runId,
+            attempt: input.attempt,
+            leaseToken: input.leaseToken,
+            schedulerSchema: input.schedulerSchema ?? null,
+            ...(input.initializeComputeSession
+              ? { initializeComputeSession: true }
+              : {}),
+            // Expand-before-enable rollout fence. An old worker never sends this,
+            // so a newly deployed app cannot activate direct terminal reduction
+            // before the owning Fly lane has the cleanup controller.
+            terminalReducerContract: DIRECT_COMPLETED_TERMINAL_CONTRACT,
+          }),
+          redirect: 'manual',
+        }),
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1076,6 +1093,12 @@ export async function requestAttemptExecutorToken(input: {
     error?: unknown;
     code?: unknown;
     capacitySource?: unknown;
+    computeSessionInitialized?: { sessionId?: unknown; attempt?: unknown };
+    runtimeTrafficPolicy?: {
+      runId?: unknown;
+      attempt?: unknown;
+      policy?: unknown;
+    };
   } | null;
   if (!response.ok || typeof body?.executorToken !== 'string') {
     const frontDoorTitle = body
@@ -1129,6 +1152,21 @@ export async function requestAttemptExecutorToken(input: {
       response.headers.get('x-request-id') ??
       null,
   });
+  if (
+    input.initializeComputeSession === true &&
+    body.computeSessionInitialized?.sessionId === input.launch.runId &&
+    body.computeSessionInitialized.attempt === input.attempt
+  ) {
+    input.onComputeSessionInitialized?.();
+    const policyAcknowledgement = body.runtimeTrafficPolicy;
+    if (
+      policyAcknowledgement?.runId === input.launch.runId &&
+      policyAcknowledgement.attempt === input.attempt &&
+      isRuntimeTrafficPolicy(policyAcknowledgement.policy)
+    ) {
+      input.onRuntimeTrafficPolicy?.(policyAcknowledgement.policy);
+    }
+  }
   return body.executorToken;
 }
 
@@ -2433,13 +2471,13 @@ async function prepareAbsurdAttempt(input: {
 }) {
   return input.deps.runWithClient(
     async (client) => {
-      const launch = await readPostgresSchedulerLaunch(
+      const preparation = await readPostgresSchedulerAttemptPreparation(
         client,
         input.runId,
         input.options,
-        { caller: 'runtime_worker_execute' },
       );
-      if (!launch) return { kind: 'missing' as const };
+      if (!preparation) return { kind: 'missing' as const };
+      const { launch, existing, laneState } = preparation;
 
       const configuredBackend = input.deps.configuredRuntimeBackend;
       const launchBackend = normalizePlayRuntimeBackend(
@@ -2464,11 +2502,6 @@ async function prepareAbsurdAttempt(input: {
         );
       }
 
-      const existing = await readPostgresSchedulerResult(
-        client,
-        input.runId,
-        input.options,
-      );
       if (
         existing &&
         (existing.status === 'completed' ||
@@ -2483,17 +2516,12 @@ async function prepareAbsurdAttempt(input: {
       // One durable read decides own/adopt/defer/refuse (lane handoff). A run on a
       // retired lane resumes here on the newest release; anything else foreign
       // either parks for its owning lane or fails loudly.
-      const laneState = await readPostgresSchedulerRunLaneState(
-        client,
-        { runId: input.runId },
-        input.options,
-      );
       const disposition = resolveAbsurdReleaseLaneDisposition({
         runId: input.runId,
         runReleaseId,
         workerReleaseId,
-        laneClaiming: laneState?.laneClaiming ?? true,
-        parkedInAdoptableWait: laneState?.parkedInAdoptableWait ?? false,
+        laneClaiming: laneState.laneClaiming,
+        parkedInAdoptableWait: laneState.parkedInAdoptableWait,
       });
       if (disposition.kind === 'refuse') {
         // Reuse the one operator-actionable message and remediation.
@@ -2512,17 +2540,13 @@ async function prepareAbsurdAttempt(input: {
               runId: input.runId,
               adoptedReleaseId: disposition.adoptedReleaseId,
               workerReleaseId,
-              waitKind: laneState?.waitKind ?? null,
+              waitKind: laneState.waitKind,
             }
           : null;
 
       if (launch.requiresRunCreatedProjection) {
         const eventId = `run-created:${input.runId}`;
-        const projection = await readPostgresSchedulerOutboxDeliveryStatus(
-          client,
-          { runId: input.runId, eventId },
-          input.options,
-        );
+        const projection = preparation.createdProjection;
         if (!projection.delivered) {
           // This is intentionally before allocating or assigning an attempt:
           // app-runtime routes authorize artifacts against the projected run,
@@ -2547,55 +2571,69 @@ async function prepareAbsurdAttempt(input: {
             delaySeconds: projection.blocked ? 5 : 1,
             attemptAllocated: false,
           });
-          throw new DeferTask(
-            `Run-created projection is not yet delivered for ${input.runId}.`,
-            projection.blocked ? 5 : 1,
-          );
+          return {
+            kind: 'created_projection_pending' as const,
+            launch,
+            delaySeconds: projection.blocked ? 5 : 1,
+          };
         }
       }
 
-      // A detached heartbeat wake is not ordinary continuation or fresh
-      // work. It retains its existing fence before any fresh allocation.
+      // A queued run with no persisted attempt cannot have a detached runner.
+      // Its assignment still locks the run and rejects a racing first writer.
+      // Every later generation keeps detached recovery's original fence.
       const resumedDetached =
-        await resumePostgresSchedulerDetachedRunnerAttempt(
-          client,
-          { runId: input.runId },
-          input.options,
-        );
-      const generation =
-        resumedDetached?.attempt ??
-        (await allocatePostgresSchedulerNextAttempt(
-          client,
-          input.runId,
-          input.options,
-        ));
-      const leaseToken = resumedDetached?.leaseToken ?? randomUUID();
-      const assigned =
-        resumedDetached ??
-        (await assignPostgresSchedulerRunAttempt(
-          client,
-          { runId: input.runId, attempt: generation, taskToken: leaseToken },
-          input.options,
-        ));
-      if (!assigned) return { kind: 'claim_rejected' as const, launch };
+        preparation.nextAttempt === 1 && laneState.status === 'queued'
+          ? null
+          : await resumePostgresSchedulerDetachedRunnerAttempt(
+              client,
+              { runId: input.runId },
+              input.options,
+            );
 
-      return resumedDetached
+      if (resumedDetached) {
+        return {
+          kind: 'detached_recovery_claimed' as const,
+          launch,
+          generation: resumedDetached.attempt,
+          leaseToken: resumedDetached.leaseToken,
+          assigned: resumedDetached,
+          adoptedParkedWake,
+        };
+      }
+
+      const generation = preparation.nextAttempt;
+      const leaseToken = randomUUID();
+      const initialRuntimeResource = isManagedSandboxRuntimeBackend(
+        launch.runtimeBackend,
+      )
         ? {
-            kind: 'detached_recovery_claimed' as const,
-            launch,
-            generation,
-            leaseToken,
-            assigned,
-            adoptedParkedWake,
+            kind: 'compute_session',
+            runtimeBackend: launch.runtimeBackend,
+            billingStartedAt: Date.now(),
           }
-        : {
-            kind: 'fresh_claimed' as const,
-            launch,
-            generation,
-            leaseToken,
-            assigned,
-            adoptedParkedWake,
-          };
+        : undefined;
+      const assigned = await assignPostgresSchedulerRunAttempt(
+        client,
+        {
+          runId: input.runId,
+          attempt: generation,
+          taskToken: leaseToken,
+          ...(initialRuntimeResource ? { initialRuntimeResource } : {}),
+        },
+        input.options,
+      );
+      if (!assigned) return { kind: 'claim_rejected' as const, launch };
+
+      return {
+        kind: 'fresh_claimed' as const,
+        launch,
+        generation,
+        leaseToken,
+        assigned,
+        computeSessionIntentPersisted: assigned.initialRuntimeResourcePersisted,
+        adoptedParkedWake,
+      };
     },
     { runId: input.runId, phase: 'attempt_prepare' },
   );
@@ -2612,7 +2650,30 @@ async function executeAbsurdAttemptAdapter(
     schedulerOptions.schema ? { schema: schedulerOptions.schema } : {};
   const runId = params.runId;
 
-  const prepared = await prepareAbsurdAttempt({ deps, options, runId });
+  let prepared = await prepareAbsurdAttempt({ deps, options, runId });
+  while (prepared.kind === 'created_projection_pending') {
+    const delaySeconds = prepared.delaySeconds;
+    // The preparation checkout is already released. Absurd retains a winning
+    // ACK before park, and re-arming this same native wait closes the race at a
+    // timeout; a fixed DeferTask would miss a signal arriving after the recheck.
+    // Older projectors still wake at the bounded deadline and re-read their ACK.
+    let signalled = false;
+    try {
+      signalled =
+        (await ctx.awaitEvent(absurdRunCreatedProjectionEventName(runId), {
+          timeout: delaySeconds,
+          stepName: 'run-created-projection',
+        })) === true;
+    } catch (error) {
+      if (!(error instanceof TimeoutError)) throw error;
+    }
+    prepared = await prepareAbsurdAttempt({ deps, options, runId });
+    if (signalled && prepared.kind === 'created_projection_pending') {
+      throw new Error(
+        `Run-created wake has no durable projection acknowledgement for ${runId}.`,
+      );
+    }
+  }
   if (prepared.kind === 'missing') {
     throw new Error(
       `absurd runtime worker: no launch row for run ${runId} (schema=${
@@ -2696,18 +2757,48 @@ async function executeAbsurdAttemptAdapter(
   // durable start projection be the single writer here.
 
   let executionLaunch = launch;
+  const computeSessionIntentPersisted =
+    prepared.kind === 'fresh_claimed' && prepared.computeSessionIntentPersisted;
+  let computeSessionInitialized = false;
+  let runtimeTrafficPolicy: RuntimeTrafficPolicy | null = null;
   try {
     const tokenStartedAt = performance.now();
     const executorToken = await runWithAbsurdExecutionLeaseHeartbeat({
       ctx,
       runId,
-      operation: () =>
-        deps.mintAttemptExecutorToken({
+      operation: async () => {
+        // Own finalization before the app can open the session. A lost token
+        // response or a later configuration failure still has a durable owner.
+        const initializeComputeSession =
+          prepared.kind === 'fresh_claimed' &&
+          assigned.checkpoint == null &&
+          assigned.suspension == null &&
+          isManagedSandboxRuntimeBackend(launch.runtimeBackend);
+        if (initializeComputeSession) {
+          if (!computeSessionIntentPersisted) {
+            throw new Error(
+              `Postgres scheduler failed to atomically record compute session for ${runId}/${generation}.`,
+            );
+          }
+        }
+        return deps.mintAttemptExecutorToken({
           launch,
           attempt: generation,
           leaseToken,
           schedulerSchema: options?.schema ?? null,
-        }),
+          ...(initializeComputeSession
+            ? {
+                initializeComputeSession: true,
+                onComputeSessionInitialized: () => {
+                  computeSessionInitialized = true;
+                },
+                onRuntimeTrafficPolicy: (policy: RuntimeTrafficPolicy) => {
+                  runtimeTrafficPolicy = policy;
+                },
+              }
+            : {}),
+        });
+      },
     }).finally(() => {
       console.info(
         '[absurd-runtime.worker.phase] ' +
@@ -2735,6 +2826,9 @@ async function executeAbsurdAttemptAdapter(
       initialCheckpoint: assigned.checkpoint ?? null,
       initialSuspension: assigned.suspension ?? null,
       initialAttemptAlreadyWaiting: isDetachedRecovery,
+      computeSessionIntentPersisted,
+      computeSessionInitialized,
+      runtimeTrafficPolicy,
       runtimeApi,
     });
   } catch (error) {
@@ -2979,6 +3073,9 @@ async function executeAssignedAbsurdAttempt(input: {
   initialSuspension: unknown;
   /** A live detached runner wake keeps its attempt parked until resolution. */
   initialAttemptAlreadyWaiting: boolean;
+  computeSessionIntentPersisted: boolean;
+  computeSessionInitialized: boolean;
+  runtimeTrafficPolicy: RuntimeTrafficPolicy | null;
   runtimeApi: WorkerRuntimeApiContext;
 }): Promise<AbsurdRuntimeResult> {
   const {
@@ -2992,6 +3089,29 @@ async function executeAssignedAbsurdAttempt(input: {
     leaseToken,
     runtimeApi,
   } = input;
+  const measureLaunchPhase = async <T>(
+    phase: string,
+    operation: () => Promise<T>,
+  ): Promise<T> => {
+    const startedAt = performance.now();
+    let ok = false;
+    try {
+      const result = await operation();
+      ok = true;
+      return result;
+    } finally {
+      console.info(
+        '[absurd-runtime.worker.phase] ' +
+          JSON.stringify({
+            runId,
+            attempt: generation,
+            phase,
+            totalMs: performance.now() - startedAt,
+            ok,
+          }),
+      );
+    }
+  };
   const runtimeBackend = normalizePlayRuntimeBackend(
     launch.runtimeBackend || deps.configuredRuntimeBackend,
   );
@@ -3809,11 +3929,15 @@ async function executeAssignedAbsurdAttempt(input: {
     }
 
     const progressReporter = deps.createProgressReporter(launch, generation);
-    const preparedRunnerConfig = await runWithAbsurdExecutionLeaseHeartbeat({
-      ctx,
-      runId,
-      operation: () => prepareRunnerConfig(claim),
-    });
+    const preparedRunnerConfig = await measureLaunchPhase(
+      'runner_config_prepare',
+      () =>
+        runWithAbsurdExecutionLeaseHeartbeat({
+          ctx,
+          runId,
+          operation: () => prepareRunnerConfig(claim),
+        }),
+    );
     const runnerConfig = preparedRunnerConfig.runnerConfig;
 
     let runnerResult: PlayRunnerResult;
@@ -3868,41 +3992,74 @@ async function executeAssignedAbsurdAttempt(input: {
           );
         }
         backendExecutions += 1;
+        // Read the policy while preparing durable billing state, then enforce
+        // it at the existing pre-create barrier. Observe both outcomes now so
+        // a failed read cannot become an unhandled rejection during setup.
+        const trafficPolicyRead =
+          isManagedSandboxRuntimeBackend(launch.runtimeBackend) &&
+          checkpoint === null &&
+          pendingDetachedRunner === null
+            ? input.runtimeTrafficPolicy
+              ? Promise.resolve({
+                  ok: true as const,
+                  policy: input.runtimeTrafficPolicy,
+                })
+              : measureLaunchPhase('traffic_policy_read', () =>
+                  getRuntimeTrafficPolicyViaAppRuntime(runtimeApi),
+                ).then(
+                  (policy) => ({ ok: true as const, policy }),
+                  (error: unknown) => ({ ok: false as const, error }),
+                )
+            : null;
         // Every backend profile enters through this runner-start seam. Open the
         // zero-credit compute session once before any sandbox/provider work so
         // later item writes can be a session-only patch and fail loudly when
         // the lifecycle contract is violated.
-        await upsertComputeBillingSessionViaAppRuntime(
-          deps.runtimeApiFromLaunch(launch),
-          {
-            sessionId: launch.runId,
-            orgId: launch.orgId,
-            ...(launch.userId ? { userId: launch.userId } : {}),
-            operation: 'workflow_run',
-            workflowId: launch.runId,
-            runId: launch.runId,
-          },
-        );
-        // The session exists before any provider work, whereas a sandbox
-        // resource exists only after acquisition. Persist that fact so every
-        // opened session — including local-process and a provider-create
-        // failure — receives durable finalization. A queued run never passes
-        // this seam, so it still creates no zero-cost finalization job.
-        const recordedComputeSession = await deps.runWithClient((client) =>
-          recordPostgresSchedulerAttemptRuntimeResource(
-            client,
-            {
-              runId,
-              attempt: generation,
-              leaseToken,
-              resource: {
-                kind: 'compute_session',
-                runtimeBackend,
-                billingStartedAt: Date.now(),
+        if (!input.computeSessionInitialized) {
+          await measureLaunchPhase('compute_session_open', () =>
+            upsertComputeBillingSessionViaAppRuntime(
+              deps.runtimeApiFromLaunch(launch),
+              {
+                sessionId: launch.runId,
+                orgId: launch.orgId,
+                ...(launch.userId ? { userId: launch.userId } : {}),
+                operation: 'workflow_run',
+                workflowId: launch.runId,
+                runId: launch.runId,
               },
-            },
-            options,
-          ),
+            ),
+          );
+        }
+        // Retain the pre-provider lease fence even when intent was recorded
+        // before token issuance: cancellation can win during that request.
+        // Legacy setup still records its cleanup owner here.
+        const recordedComputeSession = await measureLaunchPhase(
+          'compute_session_record',
+          () =>
+            deps.runWithClient(
+              (client) =>
+                input.computeSessionIntentPersisted
+                  ? readPostgresSchedulerAttemptAuthorityForLease(
+                      client,
+                      { runId, attempt: generation, leaseToken },
+                      options,
+                    ).then(Boolean)
+                  : recordPostgresSchedulerAttemptRuntimeResource(
+                      client,
+                      {
+                        runId,
+                        attempt: generation,
+                        leaseToken,
+                        resource: {
+                          kind: 'compute_session',
+                          runtimeBackend,
+                          billingStartedAt: Date.now(),
+                        },
+                      },
+                      options,
+                    ),
+              { runId, phase: 'compute_session_record' },
+            ),
         );
         if (!recordedComputeSession) {
           throw new Error(
@@ -3933,15 +4090,12 @@ async function executeAssignedAbsurdAttempt(input: {
             // sandbox can exist. A resumed/checkpointed run may already have
             // external-effect evidence, so holding it here could turn a safe
             // resume into an unsafe fresh-retry decision.
-            if (
-              isManagedSandboxRuntimeBackend(launch.runtimeBackend) &&
-              checkpoint === null &&
-              pendingDetachedRunner === null
-            ) {
+            if (trafficPolicyRead) {
               let trafficPolicy: RuntimeTrafficPolicy;
               try {
-                trafficPolicy =
-                  await getRuntimeTrafficPolicyViaAppRuntime(runtimeApi);
+                const policyRead = await trafficPolicyRead;
+                if (!policyRead.ok) throw policyRead.error;
+                trafficPolicy = policyRead.policy;
               } catch (error) {
                 const fallback =
                   fallbackRuntimeTrafficPolicyForUnavailableControlPlane(error);
@@ -7990,6 +8144,8 @@ export type AbsurdWorkerWakeHook = ((
   wake: () => void,
 ) => (() => void) | void) & {
   isListening: () => boolean;
+  wake: () => boolean;
+  idlePollFallbackMs: number;
   close: () => void;
 };
 
@@ -7997,9 +8153,7 @@ export function resolveAbsurdIdlePollFallbackMs(
   onWake: AbsurdWorkerWakeHook | undefined,
 ): number | null {
   if (onWake?.isListening() === true) return null;
-  return onWake
-    ? ABSURD_ACTIVE_STANDBY_POLL_INTERVAL_MS
-    : ABSURD_WAKE_UNAVAILABLE_POLL_INTERVAL_MS;
+  return onWake?.idlePollFallbackMs ?? ABSURD_WAKE_UNAVAILABLE_POLL_INTERVAL_MS;
 }
 
 export function createAbsurdWorkerWakeHook(input: {
@@ -8008,6 +8162,8 @@ export function createAbsurdWorkerWakeHook(input: {
   draining: boolean;
   /** Isolated preview schemas use durable polling instead of a direct LISTEN session. */
   useDirectNotify?: boolean;
+  /** Accept local wake hints without allocating a direct database session. */
+  enableWakeHints?: boolean;
   acquireNotifyHub?: (input: {
     url: string;
     channel: string;
@@ -8015,12 +8171,26 @@ export function createAbsurdWorkerWakeHook(input: {
     leaderLockKey?: string;
   }) => PgNotifyHubLease | null;
 }): AbsurdWorkerWakeHook | undefined {
-  if (input.draining || input.useDirectNotify === false) return undefined;
+  if (
+    input.draining ||
+    (input.useDirectNotify === false && !input.enableWakeHints)
+  )
+    return undefined;
   let listening = false;
   let closed = false;
   const subscriptions = new Set<() => void>();
+  const wakeHandlers = new Set<() => void>();
   const hook: AbsurdWorkerWakeHook = (wake) => {
     if (closed) return;
+    wakeHandlers.add(wake);
+    if (input.useDirectNotify === false) {
+      const release = () => {
+        wakeHandlers.delete(wake);
+        subscriptions.delete(release);
+      };
+      subscriptions.add(release);
+      return release;
+    }
     const acquireNotifyHub =
       input.acquireNotifyHub ??
       ((notifyInput: {
@@ -8035,7 +8205,7 @@ export function createAbsurdWorkerWakeHook(input: {
       applicationName: 'deepline-absurd-worker-wake',
       leaderLockKey: `deepline:absurd-wake:${input.queue}`,
     });
-    if (!lease) return;
+    if (!lease) return () => wakeHandlers.delete(wake);
     const unsubscribeNotify = lease.hub.subscribe((payload) => {
       if (payload === input.queue) wake();
     });
@@ -8052,6 +8222,7 @@ export function createAbsurdWorkerWakeHook(input: {
       released = true;
       unsubscribeNotify();
       unsubscribeState();
+      wakeHandlers.delete(wake);
       lease.release();
       subscriptions.delete(release);
     };
@@ -8059,10 +8230,22 @@ export function createAbsurdWorkerWakeHook(input: {
     return release;
   };
   hook.isListening = () => listening;
+  hook.wake = () => {
+    if (closed || wakeHandlers.size === 0) return false;
+    for (const wake of wakeHandlers) wake();
+    return true;
+  };
+  // A local hint does not establish LISTEN health. Preserve the fast durable
+  // fallback on isolated workers, including when a hint is lost or unavailable.
+  hook.idlePollFallbackMs =
+    input.useDirectNotify === false
+      ? ABSURD_WAKE_UNAVAILABLE_POLL_INTERVAL_MS
+      : ABSURD_ACTIVE_STANDBY_POLL_INTERVAL_MS;
   hook.close = () => {
     closed = true;
     listening = false;
     for (const release of subscriptions) release();
+    wakeHandlers.clear();
   };
   return hook;
 }
@@ -8091,6 +8274,8 @@ export type RuntimeWorkerHostConfig = {
 
 export type RuntimeWorkerHost = {
   close(): Promise<void>;
+  /** A lossy hint to re-read this host's durable queue, never task admission. */
+  wake?(): boolean;
 };
 
 /** Own shutdown ordering across the primary queue, listener and maintenance.
@@ -8099,13 +8284,17 @@ export type RuntimeWorkerHost = {
 export function createAbsurdRuntimeWorkerHostLifecycle(input: {
   worker: RuntimeWorkerHost;
   closeWake: () => void;
+  wake?: () => boolean;
   stopControllers: () => void;
   controllers: readonly (Promise<unknown> | null)[];
 }): RuntimeWorkerHost {
   let closing: Promise<void> | null = null;
+  let wake = input.wake;
   return {
+    ...(wake ? { wake: () => wake?.() ?? false } : {}),
     close: () => {
       if (closing) return closing;
+      wake = undefined;
       const start = (operation: () => unknown): Promise<unknown> => {
         try {
           return Promise.resolve(operation());
@@ -8242,6 +8431,7 @@ export async function startRuntimeWorkerHost(
     useDirectNotify: shouldUseRuntimeSchedulerDirectNotify(
       schedulerOptions.schema,
     ),
+    enableWakeHints: true,
   });
   const reportCancellationProgress = createRateLimitedRuntimeLogger({
     log: (...args) => console.info(...args),
@@ -8508,6 +8698,7 @@ export async function startRuntimeWorkerHost(
 
   return createAbsurdRuntimeWorkerHostLifecycle({
     worker,
+    ...(onWake ? { wake: () => onWake.wake() } : {}),
     // Release LISTEN before joining accepted work, so a replacement can elect
     // its listener without exhausting primary scheduler sessions.
     closeWake: () => onWake?.close(),