deepline 0.1.227 → 0.1.229

package/dist/bundling-sources/shared_libs/play-runtime/coordinator-headers.ts

@@ -29,16 +29,9 @@ export const WORKER_CALLBACK_URL_OVERRIDE_HEADER =
 export const RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER =
   'x-deepline-runtime-scheduler-schema';
 /**
- * Child-launch defense-in-depth: an Absurd worker sets this to its own
- * `currentAbsurdReleaseId()` when it launches a `ctx.runPlay` child via
- * `/api/v2/plays/run`. The run route pins the child to this release lane over
- * the resolver's schema-derived default, so a child always finishes on the
- * release that launched its parent. Honored ONLY for internal `internalRunPlay`
- * child launches (executor-token authed, lineage-validated), plus internally
- * authenticated root `profile=absurd` launches used by deploy canaries to pin
- * an exact candidate release before activation. Public API keys cannot use
- * this override. Absent =>
- * inherit-when-absent back-compat: the resolver default applies unchanged.
+ * Internal top-level `profile=absurd` launches, including deploy canaries, use
+ * this header to pin an exact candidate release before activation. Public API
+ * keys cannot use it. When absent, the resolver chooses the registered lane.
  */
 export const ABSURD_RELEASE_OVERRIDE_HEADER = 'x-deepline-absurd-release';
 /**

package/dist/bundling-sources/shared_libs/play-runtime/ctx-contract.ts

@@ -214,7 +214,7 @@ export type PlayStep =
   | {
       type: 'play_call';
       playId: string;
-      execution?: 'inline' | 'child-workflow';
+      execution?: 'inline';
       results?: PlayStepRowResult[];
       nestedSteps: PlayStep[];
       description?: string;
@@ -253,7 +253,7 @@ export type PlayDatasetSubstep =
   | {
       type: 'play_call';
       playId: string;
-      execution?: 'inline' | 'child-workflow';
+      execution?: 'inline';
       results?: PlayStepRowResult[];
       nestedSteps: PlayStep[];
       description?: string;

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

@@ -307,7 +307,17 @@ export type CustomerDbQueryHandler = (
 
 export interface PlayCallOptions {
   description?: string;
-  execution?: PlayCallExecution;
+  /**
+   * `child-workflow` is accepted only so the checker/runtime can emit the
+   * canonical CTX_RUN_PLAY_INLINE_ONLY migration diagnostic. It never starts a
+   * child workflow.
+   */
+  execution?: PlayCallExecution | 'child-workflow';
+  /**
+   * Parsed so source preflight and an untyped runtime call can return the
+   * canonical CTX_RUN_PLAY_INLINE_ONLY migration error. It is never honored.
+   */
+  timeoutMs?: number;
 }
 
 export interface StepOptions {
@@ -331,38 +341,6 @@ export interface ResolvedPlayExecution {
   contractSnapshot?: PlayRunContractSnapshot | null;
 }
 
-export interface PlayExecutionGovernanceLimits {
-  maxPlayCallDepth: number;
-  maxPlayCallCount: number;
-  maxToolCallCount: number;
-  maxWaterfallStepExecutions: number | null;
-  maxRetryCount: number;
-  maxDescendants: number;
-  maxChildPlayCallsPerParent: number;
-  maxConcurrentPlayCalls: number;
-  maxConcurrentToolCalls: number;
-}
-
-export interface PlayExecutionGovernanceState {
-  rootPlayId: string;
-  rootRunId: string;
-  currentPlayId: string;
-  currentRunId: string;
-  ancestryPlayIds: string[];
-  ancestryRunIds: string[];
-  callDepth: number;
-  playCallCount: number;
-  toolCallCount: number;
-  waterfallStepExecutions: number;
-  retryCount: number;
-  descendantCount: number;
-  parentChildCalls: Record<string, number>;
-  inFlightPlayCalls: number;
-  inFlightPlayCallsByPlayId?: Record<string, number>;
-  inFlightToolCalls: number;
-  limits: PlayExecutionGovernanceLimits;
-}
-
 export interface BatchRequest {
   provider: string;
   toolName: string;
@@ -763,11 +741,7 @@ export interface ContextOptions {
   skipRuntimeStepReceipt?: (
     input: SkipRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
-  /**
-   * Lineage governance snapshot to resume a child play run from. Produced by the
-   * parent's Play Execution Governor `forkChild(...)` so budgets/depth/cycle
-   * guards accumulate across the nested-play tree. Only set on child contexts.
-   */
+  /** Inline composition scope used for recursion and shared-resource governance. */
   governance?: GovernanceSnapshot;
   /** Internal in-process child view sharing the root run's resource governor. */
   executionGovernor?: PlayExecutionGovernor;
@@ -821,15 +795,6 @@ export interface PlayCheckpoint {
         output?: unknown;
         completedAt?: number;
       }
-    | {
-        kind: 'child_play';
-        childRunId: string;
-        childPlayName: string;
-        status: 'completed' | 'failed' | 'cancelled';
-        output?: unknown;
-        error?: string;
-        completedAt?: number;
-      }
   >;
   /** Per-map execution frames keyed by invocation id. */
   mapFrames?: Record<string, MapExecutionFrame>;

package/dist/bundling-sources/shared_libs/play-runtime/governor/block-reserving-budget-state-backend.ts

@@ -9,8 +9,6 @@ const RESERVATION_BLOCKS: Record<string, number> = {
   toolCall: 256,
   retry: 16,
   waterfallStep: 256,
-  playCall: 16,
-  descendant: 16,
 };
 
 export type BudgetStateChargePort = (input: {

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

@@ -8,9 +8,9 @@
  * "may I, and how many at once" policy. See ADR 0007 + CONTEXT.md.
  *
  * Surface (small, by design):
- *   - acquireRowSlot / acquireChildSubmitSlot / acquireToolSlot → blocking leases
+ *   - acquireRowSlot / acquireToolSlot                         → blocking leases
  *   - chargeBudget                                            → throws on breach
- *   - forkChild                                               → child lineage snapshot
+ *   - forkInlineChild                                         → inline recursion scope
  *   - resolveRowConcurrency / reportProviderBackpressure / snapshot
  */
 import {
@@ -35,14 +35,9 @@ export interface WorkLease {
   release(): void;
 }
 
-export type BudgetKind =
-  | 'playCall'
-  | 'toolCall'
-  | 'retry'
-  | 'descendant'
-  | 'waterfallStep';
+export type BudgetKind = 'toolCall' | 'retry' | 'waterfallStep';
 
-/** Counters that accumulate down the dispatch lineage; thread via the snapshot. */
+/** Runtime identity and counters shared by inline composition. */
 export interface GovernanceSnapshot {
   rootRunId: string;
   currentRunId: string;
@@ -50,18 +45,14 @@ export interface GovernanceSnapshot {
   ancestryPlayIds: string[];
   ancestryRunIds: string[];
   callDepth: number;
-  playCallCount: number;
   toolCallCount: number;
   retryCount: number;
-  descendantCount: number;
   waterfallStepExecutions: number;
-  /** Direct child plays launched, keyed by parent play id. */
-  parentChildCalls: Record<string, number>;
 }
 
 export class GovernorBudgetError extends Error {
   constructor(
-    readonly budget: BudgetKind | 'playDepth' | 'childPerParent',
+    readonly budget: BudgetKind | 'playDepth',
     readonly observed: number,
     readonly limit: number,
   ) {
@@ -104,8 +95,6 @@ export interface PlayExecutionGovernor {
 
   /** Block until a map-row slot is free. */
   acquireRowSlot(opts?: { signal?: AbortSignal }): Promise<WorkLease>;
-  /** Block until a child-play submit slot is free. Released after submit, not terminal. */
-  acquireChildSubmitSlot(opts?: { signal?: AbortSignal }): Promise<WorkLease>;
   /**
    * Block until a global tool-concurrency slot AND the per-(org,provider) pacer
    * permit are free, then charge the tool-call budget and return a lease. Order:
@@ -129,28 +118,8 @@ export interface PlayExecutionGovernor {
   chargeBudget(kind: BudgetKind, amount?: number): Promise<void>;
 
   /**
-   * Reserve depth + per-parent + descendant budget for a child play and return
-   * the snapshot to thread into the child run so budgets accumulate across the
-   * lineage (and across isolates on `esm_workers`). Throws on breach.
-   *
-   * Unlike {@link acquireToolSlot} (which charges last so an aborted acquire
-   * never consumes budget), child-lineage counters are charged here at fork
-   * time, BEFORE the caller acquires a child-submit slot. A slot acquire that then
-   * fails (e.g. abort) does NOT refund these counters. This is intentional and
-   * safe given the 100k child caps: the charge reserves lineage-global capacity
-   * for a launch the caller has committed to, and forkChild must return the
-   * threaded snapshot synchronously, so the charge cannot be deferred behind the
-   * async slot acquire.
-   */
-  forkChild(input: {
-    childPlayName: string;
-    childRunId: string;
-  }): Promise<GovernanceSnapshot>;
-
-  /**
-   * Fork an in-process child view. The child gets its own lineage while sharing
-   * the parent's row/tool/child semaphores, adaptive admission, and global
-   * budget counters.
+   * Fork an inline child view. The child gets its own recursion lineage while
+   * sharing the parent's row/tool semaphores, adaptive admission, and budgets.
    */
   forkInlineChild(input: {
     childPlayName: string;
@@ -254,12 +223,9 @@ export function createDefaultGovernanceSnapshot(scope: {
     ancestryPlayIds: scope.rootPlayId ? [scope.rootPlayId] : [],
     ancestryRunIds: [scope.rootRunId],
     callDepth: scope.rootPlayId ? 1 : 0,
-    playCallCount: 0,
     toolCallCount: 0,
     retryCount: 0,
-    descendantCount: 0,
     waterfallStepExecutions: 0,
-    parentChildCalls: {},
   };
 }
 
@@ -271,7 +237,6 @@ export function createPlayExecutionGovernor(
     input.resume ?? createDefaultGovernanceSnapshot(input.scope);
 
   const rowSlots = new Semaphore(policy.concurrency.rowMax);
-  const childPlaySlots = new Semaphore(policy.concurrency.childPlay);
   const toolSlots = new Semaphore(policy.concurrency.toolCalls);
   const adaptiveAdmission =
     input.adaptiveAdmission ??
@@ -320,14 +285,10 @@ export function createPlayExecutionGovernor(
 
   const budgetLimit = (kind: BudgetKind): number => {
     switch (kind) {
-      case 'playCall':
-        return policy.budgets.maxPlayCallCount;
       case 'toolCall':
         return policy.budgets.maxToolCallCount;
       case 'retry':
         return policy.budgets.maxRetryCount;
-      case 'descendant':
-        return policy.budgets.maxDescendants;
       case 'waterfallStep':
         return policy.budgets.maxWaterfallStepExecutions;
     }
@@ -359,32 +320,22 @@ export function createPlayExecutionGovernor(
 
   async function chargeBudget(kind: BudgetKind, amount = 1): Promise<void> {
     const current =
-      kind === 'playCall'
-        ? state.playCallCount
-        : kind === 'toolCall'
-          ? state.toolCallCount
-          : kind === 'retry'
-            ? state.retryCount
-            : kind === 'descendant'
-              ? state.descendantCount
-              : state.waterfallStepExecutions;
+      kind === 'toolCall'
+        ? state.toolCallCount
+        : kind === 'retry'
+          ? state.retryCount
+          : state.waterfallStepExecutions;
     if (current + amount > budgetLimit(kind)) {
       throw new GovernorBudgetError(kind, current + amount, budgetLimit(kind));
     }
     await reserveBudgets([{ kind, amount }]);
     switch (kind) {
-      case 'playCall':
-        state.playCallCount += amount;
-        return;
       case 'toolCall':
         state.toolCallCount += amount;
         return;
       case 'retry':
         state.retryCount += amount;
         return;
-      case 'descendant':
-        state.descendantCount += amount;
-        return;
       case 'waterfallStep':
         state.waterfallStepExecutions += amount;
         return;
@@ -396,8 +347,6 @@ export function createPlayExecutionGovernor(
     policy,
 
     acquireRowSlot: (opts) => rowSlots.acquire(opts?.signal),
-    acquireChildSubmitSlot: (opts) => childPlaySlots.acquire(opts?.signal),
-
     async acquireToolSlot(toolId, opts) {
       // 1. global tool-concurrency slot.
       const slot = await toolSlots.acquire(opts?.signal);
@@ -450,93 +399,6 @@ export function createPlayExecutionGovernor(
 
     chargeBudget,
 
-    async forkChild(childInput) {
-      if (state.ancestryPlayIds.includes(childInput.childPlayName)) {
-        const chain = [...state.ancestryPlayIds, childInput.childPlayName].join(
-          ' -> ',
-        );
-        throw new Error(`Recursive play graph detected: ${chain}`);
-      }
-      const nextDepth = state.callDepth + 1;
-      if (nextDepth > policy.budgets.maxPlayCallDepth)
-        throw new GovernorBudgetError(
-          'playDepth',
-          nextDepth,
-          policy.budgets.maxPlayCallDepth,
-        );
-      const parentKey = state.currentPlayId;
-      const nextParent = (state.parentChildCalls[parentKey] ?? 0) + 1;
-      if (nextParent > policy.budgets.maxChildPlayCallsPerParent)
-        throw new GovernorBudgetError(
-          'childPerParent',
-          nextParent,
-          policy.budgets.maxChildPlayCallsPerParent,
-        );
-      if (state.playCallCount + 1 > policy.budgets.maxPlayCallCount)
-        throw new GovernorBudgetError(
-          'playCall',
-          state.playCallCount + 1,
-          policy.budgets.maxPlayCallCount,
-        );
-      if (state.descendantCount + 1 > policy.budgets.maxDescendants)
-        throw new GovernorBudgetError(
-          'descendant',
-          state.descendantCount + 1,
-          policy.budgets.maxDescendants,
-        );
-      // Charge the run-wide play/descendant budgets on the parent. Charged at
-      // fork time (not after the caller's child-play slot acquire) and never
-      // refunded if that acquire fails — see the forkChild interface doc.
-      try {
-        await budgetState.charge({
-          rootRunId: state.rootRunId,
-          charges: [
-            {
-              key: 'playCall',
-              amount: 1,
-              limit: policy.budgets.maxPlayCallCount,
-            },
-            {
-              key: 'descendant',
-              amount: 1,
-              limit: policy.budgets.maxDescendants,
-            },
-            {
-              key: `childPerParent:${state.currentRunId}`,
-              amount: 1,
-              limit: policy.budgets.maxChildPlayCallsPerParent,
-            },
-          ],
-        });
-      } catch (error) {
-        if (error instanceof BudgetStateLimitError) {
-          const budget = error.key.startsWith('childPerParent:')
-            ? 'childPerParent'
-            : (error.key as BudgetKind);
-          throw new GovernorBudgetError(budget, error.observed, error.limit);
-        }
-        throw error;
-      }
-      state.playCallCount += 1;
-      state.descendantCount += 1;
-      state.parentChildCalls[parentKey] = nextParent;
-      // Child seeds from the parent's accumulated counters → lineage-global budget.
-      return {
-        rootRunId: state.rootRunId,
-        currentRunId: childInput.childRunId,
-        currentPlayId: childInput.childPlayName,
-        ancestryPlayIds: [...state.ancestryPlayIds, childInput.childPlayName],
-        ancestryRunIds: [...state.ancestryRunIds, childInput.childRunId],
-        callDepth: nextDepth,
-        playCallCount: state.playCallCount,
-        toolCallCount: state.toolCallCount,
-        retryCount: state.retryCount,
-        descendantCount: state.descendantCount,
-        waterfallStepExecutions: state.waterfallStepExecutions,
-        parentChildCalls: {},
-      };
-    },
-
     async forkInlineChild(childInput) {
       return createInlineChildGovernor(
         governor,
@@ -587,7 +449,6 @@ export function createPlayExecutionGovernor(
       ...state,
       ancestryPlayIds: [...state.ancestryPlayIds],
       ancestryRunIds: [...state.ancestryRunIds],
-      parentChildCalls: { ...state.parentChildCalls },
     }),
   };
   return governor;
@@ -621,7 +482,6 @@ function deriveInlineChildSnapshot(
     ancestryPlayIds: [...parent.ancestryPlayIds, input.childPlayName],
     ancestryRunIds: [...parent.ancestryRunIds, input.childRunId],
     callDepth: nextDepth,
-    parentChildCalls: {},
   };
 }
 
@@ -636,14 +496,12 @@ function createInlineChildGovernor(
     ancestryPlayIds: [...initial.ancestryPlayIds],
     ancestryRunIds: [...initial.ancestryRunIds],
     callDepth: initial.callDepth,
-    parentChildCalls: { ...initial.parentChildCalls },
   };
 
   const child: PlayExecutionGovernor = {
     adapter: root.adapter,
     policy: root.policy,
     acquireRowSlot: (opts) => root.acquireRowSlot(opts),
-    acquireChildSubmitSlot: (opts) => root.acquireChildSubmitSlot(opts),
     acquireToolSlot: (toolId, opts) => root.acquireToolSlot(toolId, opts),
     suggestedParallelism: (toolId, fallback) =>
       root.suggestedParallelism(toolId, fallback),
@@ -653,51 +511,6 @@ function createInlineChildGovernor(
       root.reportProviderBackpressure(input),
     observeProviderSuccess: (input) => root.observeProviderSuccess(input),
     observeToolSuccess: (input) => root.observeToolSuccess(input),
-    async forkChild(input) {
-      if (lineage.ancestryPlayIds.includes(input.childPlayName)) {
-        throw new Error(
-          `Recursive play graph detected: ${[
-            ...lineage.ancestryPlayIds,
-            input.childPlayName,
-          ].join(' -> ')}`,
-        );
-      }
-      const nextDepth = lineage.callDepth + 1;
-      if (nextDepth > child.policy.budgets.maxPlayCallDepth) {
-        throw new GovernorBudgetError(
-          'playDepth',
-          nextDepth,
-          child.policy.budgets.maxPlayCallDepth,
-        );
-      }
-      const nextParent =
-        (lineage.parentChildCalls[lineage.currentPlayId] ?? 0) + 1;
-      if (nextParent > child.policy.budgets.maxChildPlayCallsPerParent) {
-        throw new GovernorBudgetError(
-          'childPerParent',
-          nextParent,
-          child.policy.budgets.maxChildPlayCallsPerParent,
-        );
-      }
-      await root.chargeBudget('playCall');
-      await root.chargeBudget('descendant');
-      lineage.parentChildCalls[lineage.currentPlayId] = nextParent;
-      const counters = root.snapshot();
-      return {
-        rootRunId: lineage.rootRunId,
-        currentRunId: input.childRunId,
-        currentPlayId: input.childPlayName,
-        ancestryPlayIds: [...lineage.ancestryPlayIds, input.childPlayName],
-        ancestryRunIds: [...lineage.ancestryRunIds, input.childRunId],
-        callDepth: nextDepth,
-        playCallCount: counters.playCallCount,
-        toolCallCount: counters.toolCallCount,
-        retryCount: counters.retryCount,
-        descendantCount: counters.descendantCount,
-        waterfallStepExecutions: counters.waterfallStepExecutions,
-        parentChildCalls: {},
-      };
-    },
     async forkInlineChild(input) {
       return createInlineChildGovernor(
         child,
@@ -711,7 +524,6 @@ function createInlineChildGovernor(
         ...lineage,
         ancestryPlayIds: [...lineage.ancestryPlayIds],
         ancestryRunIds: [...lineage.ancestryRunIds],
-        parentChildCalls: { ...lineage.parentChildCalls },
       };
     },
   };

package/dist/bundling-sources/shared_libs/play-runtime/governor/policy.ts

@@ -28,26 +28,18 @@ export interface ExecutionConcurrencyPolicy {
   readonly rowDefault: number;
   /** Hard ceiling for an explicit map `concurrency` value; larger is clamped. */
   readonly rowMax: number;
-  /** Concurrently in-flight child plays (`ctx.runPlay`). Excess launches block. */
-  readonly childPlay: number;
   /** Global backstop on concurrently in-flight tool calls across all providers. */
   readonly toolCalls: number;
 }
 
 /**
  * Per-run budgets — total attempts allowed before a run is treated as runaway.
- * Accumulated down the dispatch lineage (a child seeds from the parent), so the
- * budget is global across the nested-play tree, not per-worker.
+ * Applied inside one run. Inline `ctx.runPlay` composition has a separate
+ * recursion-depth guard; it never creates a second scheduled run.
  */
 export interface ExecutionBudgetPolicy {
   /** Max nesting depth of `ctx.runPlay` chains. Deeper is almost certainly a cycle. */
   readonly maxPlayCallDepth: number;
-  /** Max total `ctx.runPlay` calls along a lineage. */
-  readonly maxPlayCallCount: number;
-  /** Max direct child plays one play may launch. */
-  readonly maxChildPlayCallsPerParent: number;
-  /** Max nested-play descendants created during a run. */
-  readonly maxDescendants: number;
   /** Max total tool calls in a run. */
   readonly maxToolCallCount: number;
   /** Max total retries across all steps/tools. */
@@ -99,10 +91,6 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
     // matches the default: throughput grows through provider pacing/batching,
     // while row payload size can only reduce admission through the byte budget.
     rowMax: 1_000,
-    // Concurrent child-play launches. Generous; each child is a real launch, so
-    // this is the one value most likely to need a documented esm_workers
-    // override if isolate pressure shows up in E2E.
-    childPlay: 32,
     // Global all-provider backstop. Per-provider pacing is the real limit; this
     // just stops a single run from opening an absurd number of sockets at once.
     toolCalls: 256,
@@ -111,9 +99,6 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
     // Runaway guards, not workload limits. A 5,000-row map calling several tools
     // per row is normal and must fit comfortably under these.
     maxPlayCallDepth: 8,
-    maxPlayCallCount: 100_000,
-    maxChildPlayCallsPerParent: 100_000,
-    maxDescendants: 100_000,
     maxToolCallCount: 5_000_000,
     maxRetryCount: 100_000,
     maxWaterfallStepExecutions: 5_000_000,

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -1,12 +1,6 @@
-export type PlayRunLiveStatus =
-  | 'queued'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'cancelled'
-  | 'terminated'
-  | 'timed_out'
-  | 'unknown';
+import type { PlayRunLifecycleStatus } from './run-lifecycle-policy';
+
+export type PlayRunLiveStatus = PlayRunLifecycleStatus;
 
 export type PlayVisualNodeStatus =
   | 'idle'

package/dist/bundling-sources/shared_libs/play-runtime/play-call-execution.ts

@@ -1 +1,6 @@
-export type PlayCallExecution = 'inline' | 'child-workflow';
+/**
+ * ctx.runPlay is inline function composition. The static analyser still
+ * recognizes the historical `child-workflow` spelling so preflight can return
+ * CTX_RUN_PLAY_INLINE_ONLY, but it is no longer a supported runtime option.
+ */
+export type PlayCallExecution = 'inline';

package/dist/bundling-sources/shared_libs/play-runtime/play-latency-trace.ts

@@ -129,6 +129,34 @@ export const PLAY_LATENCY_SUMMARY_COLUMNS: PlayLatencyPhaseDefinition[] = [
     description:
       'Start route Runtime Sheet Data Plane readiness check; active tenants use the cached or record fast path, new tenants may provision here.',
   },
+  {
+    header: 'ready_plane',
+    phase: 'server.runtime_data_plane_ensure_plane',
+    source: 'server',
+    description:
+      'Runtime Sheet readiness control-plane record lookup or first-workspace provisioning.',
+  },
+  {
+    header: 'ready_markers',
+    phase: 'server.runtime_data_plane_read_markers',
+    source: 'server',
+    description:
+      'Single pooled tenant-Postgres read of the storage-contract fingerprint and runtime migration version.',
+  },
+  {
+    header: 'ready_repair',
+    phase: 'server.runtime_data_plane_repair_contract',
+    source: 'server',
+    description:
+      'Exceptional stale storage-contract repair; absent from the healthy path.',
+  },
+  {
+    header: 'ready_migrate',
+    phase: 'server.runtime_data_plane_migrate',
+    source: 'server',
+    description:
+      'Exceptional stale Runtime Sheet migration; absent from the healthy path.',
+  },
   {
     header: 'route_wait',
     phase: 'server.start_route_wait_completion',