deepline 0.3.288 → 0.3.290

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -320,6 +320,7 @@ export type PlayRunLedgerEvent =
       lines: string[];
       /** Search-only context aligned to `lines`; stripped before Convex. */
       lineContexts?: Array<PlayLogContext | null>;
+      lineIds?: Array<string | null>;
       /**
        * Absolute per-run sequence (1-based) of `lines[0]`. Assigned by Run
        * Log Stream ingestion in Convex only; producers never set it.
@@ -430,6 +431,7 @@ export type PlayRunLedgerStatusPatch = {
   liveLogs?: readonly string[] | null;
   /** Search-only context aligned to `liveLogs`; stripped before Convex. */
   liveLogContexts?: readonly (PlayLogContext | null)[] | null;
+  liveLogIds?: readonly (string | null)[] | null;
   /**
    * Positional cursor for `liveLogs[0]` on this producer's log channel (the
    * count of lines emitted before it). Computed by the producer-side cursor
@@ -2369,12 +2371,14 @@ function terminalEventTypeForStatus(
 export function slicePositionalLogLines(input: {
   bufferLines: readonly string[];
   bufferContexts?: readonly (PlayLogContext | null)[];
+  bufferIds?: readonly (string | null)[];
   bufferTotalCount: number;
   sentCount: number;
 }): {
   lines: string[];
   channelOffset: number;
   lineContexts?: Array<PlayLogContext | null>;
+  lineIds?: Array<string | null>;
 } | null {
   if (
     input.bufferContexts !== undefined &&
@@ -2382,6 +2386,9 @@ export function slicePositionalLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with the retained lines.');
   }
+  if (input.bufferIds && input.bufferIds.length !== input.bufferLines.length) {
+    throw new TypeError('Run log identities must align with retained lines.');
+  }
   const total = Math.max(input.bufferTotalCount, input.bufferLines.length);
   const sent = Math.max(0, input.sentCount);
   if (total <= sent) {
@@ -2398,6 +2405,7 @@ export function slicePositionalLogLines(input: {
   return {
     lines: [...lines],
     channelOffset: sendFromOffset,
+    ...(input.bufferIds ? { lineIds: input.bufferIds.slice(start) } : {}),
     ...(lineContexts?.some(Boolean) ? { lineContexts: [...lineContexts] } : {}),
   };
 }
@@ -2427,6 +2435,7 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   channelOffset?: number | null;
@@ -2448,10 +2457,14 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with their lines.');
   }
+  if (input.lineIds && input.lineIds.length !== input.lines.length) {
+    throw new TypeError('Run log identities must align with their lines.');
+  }
   const entries = input.lines
     .map((line, index) => ({
       line: positional ? line.trim() || '(blank log line)' : line.trim(),
       context: input.lineContexts?.[index] ?? null,
+      entryId: input.lineIds?.[index] ?? null,
     }))
     .filter((entry) => positional || entry.line.length > 0);
   const newLines = entries.map((entry) => entry.line);
@@ -2470,6 +2483,13 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
       source,
       occurredAt,
       lines: newLines.slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT),
+      ...(input.lineIds
+        ? {
+            lineIds: entries
+              .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+              .map((entry) => entry.entryId),
+          }
+        : {}),
       ...(entries
         .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
         .some((entry) => entry.context)
@@ -2507,6 +2527,7 @@ export function buildTerminalLogReplayEvents(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   liveLogTotalCount?: number;
@@ -2521,6 +2542,7 @@ export function buildTerminalLogReplayEvents(input: {
     runId: input.runId,
     lines: input.lines,
     lineContexts: input.lineContexts,
+    lineIds: input.lineIds,
     source: 'coordinator',
     occurredAt: input.occurredAt,
     channelOffset,
@@ -2562,6 +2584,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         runId: patch.runId,
         lines: patch.liveLogs,
         lineContexts: patch.liveLogContexts ?? undefined,
+        lineIds: patch.liveLogIds ?? undefined,
         source,
         occurredAt: checkpointAt,
         channelOffset: patch.liveLogsChannelOffset ?? null,

package/dist/bundling-sources/shared_libs/play-runtime/run-log-buffer.ts

@@ -25,6 +25,8 @@ export function boundRunLogLine(line: string): string {
  */
 export class RunLogBuffer {
   readonly lines: string[] = [];
+  readonly ids: string[] = [];
+  private readonly origin = crypto.randomUUID();
   readonly contexts: Array<PlayLogContext | null> = [];
   private bytes = 0;
   private contextBytes = 0;
@@ -56,6 +58,7 @@ export class RunLogBuffer {
         true,
       );
     }
+    this.ids.push(`${this.origin}:${this.lines.length}`);
     this.lines.push(line);
     const retainContext =
       normalizedContext !== null &&
@@ -80,3 +83,30 @@ export class RunLogBuffer {
     };
   }
 }
+
+/** Optional origin identities: old producers omit them; never infer them from text. */
+export function normalizeRunLogIds(
+  value: unknown,
+  lines: readonly unknown[],
+): Array<string | null> | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (
+    !Array.isArray(value) ||
+    value.length !== lines.length ||
+    value.some(
+      (id) =>
+        id !== null &&
+        (typeof id !== 'string' || !/^[A-Za-z0-9:_-]{1,128}$/.test(id)),
+    )
+  ) {
+    throw new TypeError(
+      'Run log identities must be bounded strings aligned with their lines.',
+    );
+  }
+  const ids = value.filter((id): id is string => id !== null);
+  if (new Set(ids).size !== ids.length)
+    throw new TypeError(
+      'Run log identities must identify distinct occurrences.',
+    );
+  return value;
+}

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

@@ -1903,6 +1903,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;
@@ -2488,7 +2496,7 @@ async function run(
             });
           }
         : undefined,
-    onLog: (line, context) => {
+    onLog: (line, context, entryId) => {
       const timestampMatch = line.match(/^\[([^\]]+)\]/);
       const timestamp = timestampMatch?.[1];
       const at =
@@ -2501,6 +2509,9 @@ async function run(
           at,
           source: 'play',
           line,
+          ...(config.context.runtimeLogIdentity === 'origin' && entryId
+            ? { entryId }
+            : {}),
           ...(context ? { context } : {}),
         },
         options,
@@ -3128,6 +3139,9 @@ async function run(
         error: runtimeLimitExceededCause(runtimeLimitSeconds),
         errors: [runtimeLimitExceededFailure(runtimeLimitSeconds)],
         logs: terminalLogsWithPhaseSummary(ctx),
+        ...(config.context.runtimeLogIdentity === 'origin'
+          ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+          : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
@@ -3372,6 +3386,9 @@ async function run(
         : {}),
       outputRowCount,
       logs,
+      ...(config.context.runtimeLogIdentity === 'origin'
+        ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+        : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
@@ -3427,6 +3444,9 @@ async function run(
         status: 'suspended',
         suspension: error.suspension,
         logs: terminalLogsWithPhaseSummary(ctx),
+        ...(config.context.runtimeLogIdentity === 'origin'
+          ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+          : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
@@ -3463,6 +3483,9 @@ async function run(
       error: formatRunnerFailure(error),
       errors: [failure],
       logs: terminalLogsWithPhaseSummary(ctx),
+      ...(config.context.runtimeLogIdentity === 'origin'
+        ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
+        : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
@@ -3483,11 +3506,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

@@ -269,12 +269,18 @@ function appendTerminalDiagnosticsMarker(
   logs: string[],
   truncatedFields: string[],
   logContexts?: Array<PlayLogContext | null>,
-): { logs: string[]; logContexts?: Array<PlayLogContext | null> } {
+  logIds?: string[],
+): {
+  logs: string[];
+  logContexts?: Array<PlayLogContext | null>;
+  logIds?: string[];
+} {
   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 markedIds = logIds ? [crypto.randomUUID(), ...logIds] : undefined;
   while (
     marked.length > 1 &&
     !fitsJsonByteLimit(marked, TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES)
@@ -289,6 +295,7 @@ function appendTerminalDiagnosticsMarker(
     const removeAt = removableIndex === -1 ? 1 : removableIndex;
     marked.splice(removeAt, 1);
     markedContexts?.splice(removeAt, 1);
+    markedIds?.splice(removeAt, 1);
   }
   const logsFit = fitsJsonByteLimit(
     marked,
@@ -298,6 +305,9 @@ function appendTerminalDiagnosticsMarker(
   const retainedContexts = logsFit ? markedContexts : [null];
   return {
     logs: retainedLogs,
+    ...(markedIds
+      ? { logIds: logsFit ? markedIds : markedIds.slice(0, 1) }
+      : {}),
     ...(retainedContexts?.some(Boolean)
       ? { logContexts: retainedContexts }
       : {}),
@@ -325,6 +335,11 @@ function boundSettledTerminalTransportDiagnostics(
   const logContexts = result.logContexts?.length
     ? logProjection.indexes.map((index) => result.logContexts![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 +383,18 @@ function boundSettledTerminalTransportDiagnostics(
             logProjection.values,
             truncatedFields,
             logContexts,
+            logIds,
           )
         : {
             logs: logProjection.values,
+            ...(logIds ? { logIds } : {}),
             ...(logContexts?.some(Boolean) ? { logContexts } : {}),
           };
     return {
       ...result,
       logs: boundedLogs.logs,
       logContexts: boundedLogs.logContexts,
+      logIds: boundedLogs.logIds,
       stats: statsProjection.value,
       steps: stepsProjection.values,
       ...(result.outputWarnings
@@ -408,9 +426,11 @@ function boundSettledTerminalTransportDiagnostics(
           logProjection.values,
           truncatedFields,
           logContexts,
+          logIds,
         )
       : {
           logs: logProjection.values,
+          ...(logIds ? { logIds } : {}),
           ...(logContexts?.some(Boolean) ? { logContexts } : {}),
         };
   return {
@@ -418,6 +438,7 @@ function boundSettledTerminalTransportDiagnostics(
     error: error.value,
     logs: boundedLogs.logs,
     logContexts: boundedLogs.logContexts,
+    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

@@ -4463,7 +4463,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 +4478,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 +4562,7 @@ function createAbsurdWorkerTerminalProjectionAdapter(input: {
         runId: input.runId,
         options: input.options,
         trigger: 'committed_terminal',
-        ...(projectionStartedAtMs === undefined
-          ? {}
-          : { projectionStartedAtMs }),
+        projectionStartedAtMs: Date.now(),
       });
     },
   });