deepline 0.3.289 → 0.3.291

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -36,7 +36,10 @@ import {
   DURABLE_INVOCATION_FENCE_ATTESTATION_VALUE,
 } from '../durable-invocation-fence';
 import type { PlayRunInputPayload } from '../play-input';
-import type { PlayLogContext } from '../log-context';
+import type {
+  PlayLogContext,
+  PlayLogMetadata,
+} from '../log-context';
 import { playRunInputObjectView } from '../play-input';
 import {
   normalizePlayRunFailure,
@@ -1737,6 +1740,13 @@ async function executeRuntimePlayCode(input: {
 }
 
 const CAPTURED_CONSOLE_MAX_CHARS = 2_000;
+const CAPTURED_CONSOLE_PREFIX_RESERVE_CHARS = 64;
+const CAPTURED_CONSOLE_SHORTENED_MARKER =
+  '… [log shortened; save complete values in a dataset and use runs export]';
+const CAPTURED_CONSOLE_MAX_MESSAGE_CHARS =
+  CAPTURED_CONSOLE_MAX_CHARS - CAPTURED_CONSOLE_PREFIX_RESERVE_CHARS;
+const CAPTURED_CONSOLE_FORMAT_TRUNCATION =
+  /(\.\.\.|…)\s*\d+\s+more\s+(?:characters?|items?)/i;
 
 function logLevelForCapturedConsoleMethod(
   method: string,
@@ -1763,14 +1773,20 @@ function createCapturedCustomerConsole(
           compact: true,
           depth: 4,
           maxArrayLength: 20,
-          maxStringLength: 2_000,
+          maxStringLength: CAPTURED_CONSOLE_MAX_MESSAGE_CHARS,
         },
         ...args,
       );
-      const message =
-        formatted.length > CAPTURED_CONSOLE_MAX_CHARS
-          ? `${formatted.slice(0, CAPTURED_CONSOLE_MAX_CHARS - 1)}…`
-          : formatted;
+      const shortened =
+        formatted.length > CAPTURED_CONSOLE_MAX_MESSAGE_CHARS ||
+        CAPTURED_CONSOLE_FORMAT_TRUNCATION.test(formatted);
+      const message = shortened
+        ? `${formatted.slice(
+            0,
+            CAPTURED_CONSOLE_MAX_MESSAGE_CHARS -
+              CAPTURED_CONSOLE_SHORTENED_MARKER.length,
+          )}${CAPTURED_CONSOLE_SHORTENED_MARKER}`
+        : formatted;
       ctx.log(`[console.${method}] ${message}`, {
         level: logLevelForCapturedConsoleMethod(method),
       });
@@ -1903,6 +1919,14 @@ async function releaseRuntimeLeasesOnAppRunnerSettlement(input: {
   }
 }
 
+function terminalLogIdsWithPhaseSummary(ctx: {
+  getLogIds(): string[];
+}): string[] {
+  // Summaries are new occurrences at result construction. Terminal retries
+  // reuse that result and its IDs, including the frozen summary bodies.
+  return [...ctx.getLogIds(), crypto.randomUUID(), crypto.randomUUID()];
+}
+
 function terminalLogsWithPhaseSummary(ctx: {
   getLogs(): string[];
   getRuntimeResourceSnapshot(): unknown;
@@ -1915,6 +1939,13 @@ function terminalLogsWithPhaseSummary(ctx: {
   ];
 }
 
+function terminalLogMetadataWithPhaseSummary(ctx: {
+  getLogMetadata(): Array<PlayLogMetadata | null>;
+}): Array<PlayLogMetadata | null> | undefined {
+  const metadata = ctx.getLogMetadata();
+  return metadata.some(Boolean) ? [...metadata, null, null] : undefined;
+}
+
 function terminalLogContextsWithPhaseSummary(ctx: {
   getLogContexts(): Array<PlayLogContext | null>;
 }): Array<PlayLogContext | null> | undefined {
@@ -2488,7 +2519,7 @@ async function run(
             });
           }
         : undefined,
-    onLog: (line, context) => {
+    onLog: (line, context, entryId, metadata) => {
       const timestampMatch = line.match(/^\[([^\]]+)\]/);
       const timestamp = timestampMatch?.[1];
       const at =
@@ -2501,7 +2532,11 @@ async function run(
           at,
           source: 'play',
           line,
+          ...(config.context.runtimeLogIdentity === 'origin' && entryId
+            ? { entryId }
+            : {}),
           ...(context ? { context } : {}),
+          ...(metadata ? { metadata } : {}),
         },
         options,
       );
@@ -3128,7 +3163,11 @@ async function run(
         error: runtimeLimitExceededCause(runtimeLimitSeconds),
         errors: [runtimeLimitExceededFailure(runtimeLimitSeconds)],
         logs: terminalLogsWithPhaseSummary(ctx),
+        ...(config.context.runtimeLogIdentity === 'origin'
+          ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+          : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
+        logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         tableNamespace: null,
@@ -3372,7 +3411,11 @@ async function run(
         : {}),
       outputRowCount,
       logs,
+      ...(config.context.runtimeLogIdentity === 'origin'
+        ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+        : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
+      logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
@@ -3427,7 +3470,11 @@ async function run(
         status: 'suspended',
         suspension: error.suspension,
         logs: terminalLogsWithPhaseSummary(ctx),
+        ...(config.context.runtimeLogIdentity === 'origin'
+          ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+          : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
+        logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         checkpoint: ctx.getCheckpoint(),
@@ -3463,7 +3510,11 @@ async function run(
       error: formatRunnerFailure(error),
       errors: [failure],
       logs: terminalLogsWithPhaseSummary(ctx),
+      ...(config.context.runtimeLogIdentity === 'origin'
+        ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+        : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
+      logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
       steps: ctx.getSteps(),
@@ -3483,11 +3534,23 @@ export async function executePlayRunner(
   config: PlayRunnerExecutionConfig,
   options?: ExecutePlayRunnerOptions,
 ): Promise<PlayRunnerResult> {
-  const result = await run(config, options);
+  const emissionOptions: ExecutePlayRunnerOptions = {
+    ...options,
+    emitEvent: (event) =>
+      emitRunnerEvent(
+        config.context.runtimeLogIdentity === 'origin' &&
+          event.type === 'log' &&
+          !event.entryId
+          ? { ...event, entryId: crypto.randomUUID() }
+          : event,
+        options,
+      ),
+  };
+  const result = await run(config, emissionOptions);
   // Inline-executor mirror of the child terminal drain: the caller's finalize
   // reads the observations table right after this returns, so land in-flight
   // observation posts first (bounded, best-effort, docflow-gated by emptiness).
-  await drainPendingDocflowObservationPosts(options);
+  await drainPendingDocflowObservationPosts(emissionOptions);
   return result;
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/runtime-progress-push.ts

@@ -1,4 +1,5 @@
 import type { PlayRunnerEvent } from '../protocol';
+import { isDurableDirectRunnerLog } from '../log-provenance';
 import { jsonByteLengthUpTo } from '../output-size-limits';
 import { RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS } from '../runtime-contract';
 
@@ -116,9 +117,7 @@ type PendingEvent = {
 };
 
 function isDurableLog(event: PlayRunnerEvent): boolean {
-  return (
-    event.type === 'log' && event.source !== 'worker' && event.line.length > 0
-  );
+  return event.type === 'log' && isDurableDirectRunnerLog(event);
 }
 
 export function createRunnerProgressPusher(

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/runtime-terminal-push.ts

@@ -3,7 +3,10 @@ import {
   type PlayRunnerEvent,
   type PlayRunnerResult,
 } from '../protocol';
-import type { PlayLogContext } from '../log-context';
+import type {
+  PlayLogContext,
+  PlayLogMetadata,
+} from '../log-context';
 import { parseCtxFetchHttpFailureDiagnostic } from '../log-provenance';
 import {
   RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES,
@@ -201,9 +204,14 @@ function retainArrayWithinJsonByteLimit<T>(
  * Retain the normal newest log tail, but reserve space for the canonical
  * ctx.fetch failure diagnostics first. `runtimeDiagnostics` powers the final
  * warning, while the matching raw log line is the durable evidence customers
- * see through `runs logs --debug` after progress events could not be pushed.
+ * see through `runs logs` after progress events could not be pushed.
  */
-function retainTerminalLogTailWithRuntimeDiagnostics(logs: readonly string[]): {
+function retainTerminalLogTailWithRuntimeDiagnostics(
+  logs: readonly string[],
+  logContexts?: readonly (PlayLogContext | null)[],
+  logMetadata?: readonly (PlayLogMetadata | null)[],
+  logIds?: readonly string[],
+): {
   values: string[];
   indexes: number[];
   truncated: boolean;
@@ -215,8 +223,16 @@ function retainTerminalLogTailWithRuntimeDiagnostics(logs: readonly string[]): {
     // array. Re-serializing the retained 128 KiB tail for every historical
     // line made large completed runs exhaust their terminal-flush deadline.
     const separatorBytes = retainedIndexes.size ? 1 : 0;
-    const measurement = jsonByteLengthUpTo(
+    // The aligned arrays cross this same transport. Counting their bytes
+    // preserves the existing diagnostic allowance and customer-output headroom.
+    const entry = [
       logs[index]!,
+      ...(logContexts ? [logContexts[index] ?? null] : []),
+      ...(logMetadata ? [logMetadata[index] ?? null] : []),
+      ...(logIds ? [logIds[index]] : []),
+    ];
+    const measurement = jsonByteLengthUpTo(
+      entry.length === 1 ? entry[0] : entry,
       TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES - retainedBytes - separatorBytes,
     );
     if (measurement.exceeded) return;
@@ -269,15 +285,30 @@ function appendTerminalDiagnosticsMarker(
   logs: string[],
   truncatedFields: string[],
   logContexts?: Array<PlayLogContext | null>,
-): { logs: string[]; logContexts?: Array<PlayLogContext | null> } {
+  logIds?: string[],
+  logMetadata?: Array<PlayLogMetadata | null>,
+): {
+  logs: string[];
+  logContexts?: Array<PlayLogContext | null>;
+  logIds?: string[];
+  logMetadata?: Array<PlayLogMetadata | null>;
+} {
   const marker =
     `[deepline] terminal diagnostic metadata was bounded (${truncatedFields.join(', ')}); ` +
     'the authored play output is complete.';
   const marked = [marker, ...logs];
   const markedContexts = logContexts ? [null, ...logContexts] : undefined;
+  const markedMetadata = logMetadata ? [null, ...logMetadata] : undefined;
+  const markedIds = logIds ? [crypto.randomUUID(), ...logIds] : undefined;
+  const logPayload = () => ({
+    logs: marked,
+    ...(markedContexts ? { logContexts: markedContexts } : {}),
+    ...(markedMetadata ? { logMetadata: markedMetadata } : {}),
+    ...(markedIds ? { logIds: markedIds } : {}),
+  });
   while (
     marked.length > 1 &&
-    !fitsJsonByteLimit(marked, TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES)
+    !fitsJsonByteLimit(logPayload(), TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES)
   ) {
     // Preserve canonical ctx.fetch evidence when a marker itself needs room.
     // Other tail lines are diagnostic context, but this line is the durable
@@ -289,15 +320,23 @@ function appendTerminalDiagnosticsMarker(
     const removeAt = removableIndex === -1 ? 1 : removableIndex;
     marked.splice(removeAt, 1);
     markedContexts?.splice(removeAt, 1);
+    markedMetadata?.splice(removeAt, 1);
+    markedIds?.splice(removeAt, 1);
   }
   const logsFit = fitsJsonByteLimit(
-    marked,
+    logPayload(),
     TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES,
   );
   const retainedLogs = logsFit ? marked : [marker];
   const retainedContexts = logsFit ? markedContexts : [null];
   return {
     logs: retainedLogs,
+    ...(markedMetadata?.some(Boolean)
+      ? { logMetadata: logsFit ? markedMetadata : [null] }
+      : {}),
+    ...(markedIds
+      ? { logIds: logsFit ? markedIds : markedIds.slice(0, 1) }
+      : {}),
     ...(retainedContexts?.some(Boolean)
       ? { logContexts: retainedContexts }
       : {}),
@@ -313,18 +352,34 @@ function appendTerminalDiagnosticsMarker(
 function boundSettledTerminalTransportDiagnostics(
   result: SettledRunnerTerminalTransportResult,
 ): SettledRunnerTerminalTransportResult {
-  const logProjection = retainTerminalLogTailWithRuntimeDiagnostics(
-    result.logs,
-  );
   if (
     result.logContexts !== undefined &&
     result.logContexts.length !== result.logs.length
   ) {
     throw new TypeError('Terminal log contexts must align with result logs.');
   }
+  if (
+    result.logMetadata !== undefined &&
+    result.logMetadata.length !== result.logs.length
+  )
+    throw new TypeError('Terminal log metadata must align with logs.');
+  const logProjection = retainTerminalLogTailWithRuntimeDiagnostics(
+    result.logs,
+    result.logContexts,
+    result.logMetadata,
+    result.logIds,
+  );
   const logContexts = result.logContexts?.length
     ? logProjection.indexes.map((index) => result.logContexts![index] ?? null)
     : undefined;
+  const logMetadata = result.logMetadata?.length
+    ? logProjection.indexes.map((index) => result.logMetadata![index] ?? null)
+    : undefined;
+  if (result.logIds && result.logIds.length !== result.logs.length)
+    throw new TypeError('Terminal log identities must align with result logs.');
+  const logIds = result.logIds
+    ? logProjection.indexes.map((index) => result.logIds![index]!)
+    : undefined;
   const statsProjection = retainRecordWithinJsonByteLimit(
     result.stats,
     TERMINAL_TRANSPORT_STATS_MAX_BYTES,
@@ -368,15 +423,21 @@ function boundSettledTerminalTransportDiagnostics(
             logProjection.values,
             truncatedFields,
             logContexts,
+            logIds,
+            logMetadata,
           )
         : {
             logs: logProjection.values,
+            ...(logIds ? { logIds } : {}),
             ...(logContexts?.some(Boolean) ? { logContexts } : {}),
+            ...(logMetadata?.some(Boolean) ? { logMetadata } : {}),
           };
     return {
       ...result,
       logs: boundedLogs.logs,
       logContexts: boundedLogs.logContexts,
+      logMetadata: boundedLogs.logMetadata,
+      logIds: boundedLogs.logIds,
       stats: statsProjection.value,
       steps: stepsProjection.values,
       ...(result.outputWarnings
@@ -408,16 +469,22 @@ function boundSettledTerminalTransportDiagnostics(
           logProjection.values,
           truncatedFields,
           logContexts,
+          logIds,
+          logMetadata,
         )
       : {
           logs: logProjection.values,
+          ...(logIds ? { logIds } : {}),
           ...(logContexts?.some(Boolean) ? { logContexts } : {}),
+          ...(logMetadata?.some(Boolean) ? { logMetadata } : {}),
         };
   return {
     ...result,
     error: error.value,
     logs: boundedLogs.logs,
     logContexts: boundedLogs.logContexts,
+    logMetadata: boundedLogs.logMetadata,
+    logIds: boundedLogs.logIds,
     stats: statsProjection.value,
     steps: stepsProjection.values,
     ...(result.errors ? { errors: errorsProjection.values } : {}),

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

@@ -90,7 +90,7 @@ const DAYTONA_PUBLIC_STATUS_TRANSIENT_RETRY_PATTERN =
 const DAYTONA_RUNNER_STARTUP_TRANSPORT_RETRY_PATTERN =
   /\bDaytonaRunnerInitializationError:\s*RUNTIME_SANDBOX_START_FAILED:.*\bScheduler diagnosis:\s*runner_heartbeat_not_observed\..*"schedulerReadinessObserved":false.*"commandFound":true.*"exitCode":null.*"sessionFound":true.*"exitCodeFile":null.*"runnerStartup":\{"phase":"heartbeat_transport","outcome":"network_error","errorCode":"(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT)"/i;
 const DAYTONA_INFRASTRUCTURE_RETRY_PATTERN =
-  /\b(?:Request failed with status code (?:408|429|500|502|503|504)|ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed|socket hang up|Daytona sandbox create failed across|Daytona sandbox create did not complete|Daytona readiness baseline)\b/i;
+  /\b(?:Request failed with status code (?:408|429|500|502|503|504)|ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed|socket hang up|The socket connection was closed unexpectedly|Daytona sandbox create failed across|Daytona sandbox create did not complete|Daytona readiness baseline)\b/i;
 
 type DaytonaExecution = { exitCode: number | null; result: string };
 export type DaytonaLookupFailure = {

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

@@ -86,6 +86,8 @@ export type PlaySchedulerSubmitInput = RetainedPipelineCarrier & {
    * Omitted for legacy launches whose Play Run row was persisted synchronously.
    */
   requiresRunCreatedProjection?: boolean;
+  /** Admission-owned producer pin. Absent keeps launch-pinned legacy logging. */
+  runtimeLogIdentity?: 'origin';
   /** Optional inline artifact for the Node scheduler. */
   runtimeArtifact?: unknown;
   artifactHash: string;

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

@@ -0,0 +1,145 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+  PLAY_ADMISSION_MAX_ACQUIRE_QUEUE_WAIT_MS,
+  PLAY_ADMISSION_MAX_ACTIVE_LIFECYCLES,
+  PLAY_ADMISSION_MAX_PARALLELISM,
+} from '../admission-transport-policy';
+import {
+  RUNTIME_SCHEDULER_CONTROL_PLANE_MAX_CLIENTS,
+  RUNTIME_SCHEDULER_SERVERLESS_IDLE_TIMEOUT_MS,
+  resolveWorkflowRuntimePostgresUrl,
+  type RuntimeSchedulerPoolOptions,
+} from './postgres-pool';
+
+// All queues in one worker share this single process pool. Scheduler queries
+// are short and batched; execution concurrency belongs to Daytona/Fly slots,
+// not to a growing set of database clients. Keeping this at two makes a
+// horizontally scaled fleet predictable against the shared PgBouncer budget.
+export const ABSURD_RUNTIME_POOL_MAX_CLIENTS =
+  RUNTIME_SCHEDULER_CONTROL_PLANE_MAX_CLIENTS;
+
+/**
+ * Vercel Fluid invocations share a process and its scheduler pool. A single
+ * client serializes unrelated launches, reads, and critical lease lookups;
+ * one held connection can make every other request hit its acquire timeout.
+ * Use the shared two-client control-plane budget so another request can make
+ * progress while keeping each instance's PgBouncer footprint bounded.
+ */
+export const ABSURD_SERVERLESS_POOL_MAX_CLIENTS =
+  RUNTIME_SCHEDULER_CONTROL_PLANE_MAX_CLIENTS;
+
+/**
+ * A Vercel isolate may survive long after a webhook has returned. Keep its
+ * scheduler clients only long enough to reuse them for an immediate follow-up,
+ * then return idle PgBouncer clients before the source's delayed Workpool
+ * recovery is due. The worker fleet keeps the ordinary 30-second idle lifetime.
+ */
+export const ABSURD_SERVERLESS_POOL_IDLE_TIMEOUT_MS =
+  RUNTIME_SCHEDULER_SERVERLESS_IDLE_TIMEOUT_MS;
+
+// Ordinary Vercel requests share the bounded control-plane pool above. The
+// private batch adapter is different: Workpool elects one global up-to-1,024-
+// source collection before entering this context, so one batch request may use
+// its larger bounded scheduler capacity without multiplying it per source.
+// Other Workpool adapters can still overlap during rollout.
+type ServerlessAdmissionPoolContext = {
+  maxClients: number;
+  maxAcquireQueueDepth: number;
+  maxAcquireQueueWaitMs: number;
+};
+
+const serverlessAdmissionPoolContext =
+  new AsyncLocalStorage<ServerlessAdmissionPoolContext>();
+
+export async function withServerlessAdmissionPoolMaxClients<T>(input: {
+  maxClients: number;
+  maxAcquireQueueDepth?: number;
+  maxAcquireQueueWaitMs?: number;
+  fn: () => Promise<T>;
+}): Promise<T> {
+  if (
+    !Number.isInteger(input.maxClients) ||
+    input.maxClients < 1 ||
+    input.maxClients > PLAY_ADMISSION_MAX_PARALLELISM
+  ) {
+    throw new Error(
+      'Serverless admission pool capacity is outside the supported range.',
+    );
+  }
+  const maxAcquireQueueDepth =
+    input.maxAcquireQueueDepth ?? PLAY_ADMISSION_MAX_ACTIVE_LIFECYCLES;
+  const maxAcquireQueueWaitMs =
+    input.maxAcquireQueueWaitMs ?? PLAY_ADMISSION_MAX_ACQUIRE_QUEUE_WAIT_MS;
+  if (
+    !Number.isSafeInteger(maxAcquireQueueDepth) ||
+    maxAcquireQueueDepth < 1 ||
+    maxAcquireQueueDepth > PLAY_ADMISSION_MAX_ACTIVE_LIFECYCLES
+  ) {
+    throw new Error(
+      'Serverless admission acquire queue capacity is outside the supported range.',
+    );
+  }
+  if (
+    !Number.isSafeInteger(maxAcquireQueueWaitMs) ||
+    maxAcquireQueueWaitMs < 5_000 ||
+    maxAcquireQueueWaitMs > PLAY_ADMISSION_MAX_ACQUIRE_QUEUE_WAIT_MS
+  ) {
+    throw new Error(
+      'Serverless admission acquire queue wait is outside the supported range.',
+    );
+  }
+  return await serverlessAdmissionPoolContext.run(
+    {
+      maxClients: input.maxClients,
+      maxAcquireQueueDepth,
+      maxAcquireQueueWaitMs,
+    },
+    input.fn,
+  );
+}
+
+/**
+ * The private batch adapter owns this request-local scheduler pool. Reserve
+ * one client for executor-token and other critical control-plane traffic; the
+ * rest may submit the independently idempotent batch sources in parallel.
+ */
+export function serverlessAdmissionSubmitMaxActive(): number | null {
+  const context = serverlessAdmissionPoolContext.getStore();
+  return context === undefined ? null : Math.max(1, context.maxClients - 1);
+}
+
+/**
+ * Resolve the runtime scheduler Postgres pool options for the absurd control
+ * plane. Loud failure over silent fallback: the absurd worker and scheduler
+ * only run under Node where `WORKFLOW_RUNTIME_POSTGRES` is configured.
+ */
+export function resolveAbsurdPoolOptions(
+  explicitUrl?: string | null,
+): RuntimeSchedulerPoolOptions {
+  const url = explicitUrl?.trim() || resolveWorkflowRuntimePostgresUrl();
+  if (!url) {
+    throw new Error(
+      'absurd scheduler backend requires WORKFLOW_RUNTIME_POSTGRES (runtime ' +
+        'scheduler Postgres URL). Refusing to fall back to local execution.',
+    );
+  }
+  const serverless = process.env.VERCEL?.trim();
+  const context = serverlessAdmissionPoolContext.getStore();
+  return {
+    url,
+    applicationName: 'deepline-absurd-runtime',
+    maxClients:
+      serverless || context !== undefined
+        ? (context?.maxClients ?? ABSURD_SERVERLESS_POOL_MAX_CLIENTS)
+        : ABSURD_RUNTIME_POOL_MAX_CLIENTS,
+    ...(serverless || context !== undefined
+      ? { idleTimeoutMs: ABSURD_SERVERLESS_POOL_IDLE_TIMEOUT_MS }
+      : {}),
+    ...(context
+      ? {
+          maxAcquireQueueDepth: context.maxAcquireQueueDepth,
+          maxAcquireQueueWaitMs: context.maxAcquireQueueWaitMs,
+        }
+      : {}),
+  };
+}

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

@@ -3040,8 +3040,14 @@ async function executeAssignedAbsurdAttempt(input: {
       });
     }
 
-    // A failed run's settled counts must reach the ledger BEFORE its terminal
-    // makes the steps immutable, so they ride the terminal outbox row.
+    // Terminal step errors and failed-map settled counts ride the existing
+    // terminal outbox row. They no longer need a progress write immediately
+    // ahead of the terminal in the same ordered run stream.
+    const observedTerminalProgressEvents =
+      progressReporter.collectTerminalFailureProgressEvents?.() ?? [];
+    if (observedTerminalProgressEvents.length > 0) {
+      progressReporter.markTerminalFailureProgressPersisted?.();
+    }
     const failedTerminalProgressEvents =
       runnerResult.status === 'failed'
         ? await collectFailedTerminalSettledProgressEvents({
@@ -3059,8 +3065,14 @@ async function executeAssignedAbsurdAttempt(input: {
           ...options,
           terminalLogOutbox: input.fromDetachedRunner ? 'ctx_log_tail' : 'omit',
           sandboxCrashDiagnostic,
-          ...(failedTerminalProgressEvents.length > 0
-            ? { failedTerminalProgressEvents }
+          ...(observedTerminalProgressEvents.length > 0 ||
+          failedTerminalProgressEvents.length > 0
+            ? {
+                terminalProgressEvents: [
+                  ...observedTerminalProgressEvents,
+                  ...failedTerminalProgressEvents,
+                ],
+              }
             : {}),
         },
       ),
@@ -4463,7 +4475,6 @@ function createAbsurdWorkerTerminalProjectionAdapter(input: {
         );
       });
   };
-  let projectionStartedAtMs: number | undefined;
   return createPlayRunAttemptWorkerTerminalProjection({
     async observeFenceLost() {
       // A lost fence means this attempt is dead, which a cancelled run is the
@@ -4479,7 +4490,6 @@ function createAbsurdWorkerTerminalProjectionAdapter(input: {
       });
     },
     async reconcileTerminalTruth() {
-      projectionStartedAtMs ??= Date.now();
       // ADR 0016 rule 3: detached Daytona runs may provide no live events, so
       // fold stored docflow/runtime-sheet facts into progress after truth wins.
       await reconcileTerminalTruthIntoReporter({
@@ -4564,9 +4574,7 @@ function createAbsurdWorkerTerminalProjectionAdapter(input: {
         runId: input.runId,
         options: input.options,
         trigger: 'committed_terminal',
-        ...(projectionStartedAtMs === undefined
-          ? {}
-          : { projectionStartedAtMs }),
+        projectionStartedAtMs: Date.now(),
       });
     },
   });