pi-smart-router 0.3.0 → 0.4.0

package/src/domain/pipeline/router-pipeline.ts

@@ -11,6 +11,8 @@
 
 import type {
   ModelProfile,
+  PlanningDelegateConfig,
+  PlanningDelegateObservability,
   PriceCatalog,
   RoutingDecision,
   RoutingFeatureSidecar,
@@ -49,6 +51,10 @@ import {
   estimateRoutingCost,
   enrichRoutingDecisionWithContextFit,
   enrichRoutingDecisionWithTierSelection,
+  createPlanningDelegateObservability,
+  PLANNING_DELEGATE,
+  PLANNING_DELEGATE_DISABLED,
+  PLANNING_DIRECT_FRONTIER,
 } from '../../infrastructure/telemetry/routing-telemetry.js';
 import type { HydraMatcher as HydraMatcherType, MatchResult } from '../matching/hydra-matcher.js';
 import type { ClusterMatcher, ClusterMatchResult } from '../matching/cluster-matcher.js';
@@ -178,6 +184,8 @@ export interface PipelineOptions {
   readonly routingCalibrationPath?: string;
   /** SAAR pin policy (SP-123). Must match sessionPinner.saarConfig when enabled. */
   readonly saarConfig?: SaarConfig;
+  /** Planning delegate operator knobs (SP-143, #71). Defaults to operator config. */
+  readonly planningDelegateConfig?: PlanningDelegateConfig;
 }
 
 // ─── Orchestrator ────────────────────────────────────────────────────────────
@@ -217,6 +225,8 @@ export class RouterPipeline {
   private contextOverflowTriggered = false;
   /** Internal breakeven gate reason for SP-126 explain wiring. */
   private currentBreakevenReason: string | null = null;
+  /** Planning delegate observability for SP-143 explain/telemetry wiring. */
+  private currentPlanningDelegate: PlanningDelegateObservability | null = null;
 
   constructor(fleet: readonly ModelProfile[], options?: PipelineOptions) {
     this.fleet = fleet;
@@ -265,6 +275,7 @@ export class RouterPipeline {
     this.contextOverflowPreferredProvider = null;
     this.contextOverflowTriggered = false;
     this.currentBreakevenReason = null;
+    this.currentPlanningDelegate = null;
 
     let currentStage: NamedPipelineStage | undefined;
 
@@ -359,6 +370,9 @@ export class RouterPipeline {
       p_success_calibrated: this.currentPSuccessCalibrated,
       p_success_alpha: this.currentPSuccessAlpha,
       local_eligible_reason: this.currentLocalEligibleReason,
+      ...(this.currentPlanningDelegate
+        ? { planning_delegate: this.currentPlanningDelegate }
+        : {}),
     };
 
     const withBaseFeatures = { ...decision, features };
@@ -961,54 +975,155 @@ export class RouterPipeline {
     const tierCandidates = this.activeFleet.filter(
       (m) => m.tier === targetTier && m.healthy !== false,
     );
-    const model = selectLowestCostModel(tierCandidates);
-    if (!model) {
+    const targetModel = selectLowestCostModel(tierCandidates);
+    if (!targetModel) {
       return { decided: false, stage: 'turn_envelope' };
     }
 
     const pinner = this.options.sessionPinner;
     const pin = pinner?.getPin(request.session_id) ?? null;
-    if (pin) {
-      const pinnedModel = this.activeFleet.find(
-        (m) => m.id === pin.pinned_model_id && m.healthy !== false,
+    const pinnedModel =
+      pin !== null
+        ? this.activeFleet.find(
+            (m) => m.id === pin.pinned_model_id && m.healthy !== false,
+          )
+        : undefined;
+
+    // SP-143: cache-preserving planning delegate when warm economical pin would switch to frontier.
+    if (
+      turnType === 'planning' &&
+      pinnedModel &&
+      pinnedModel.tier === 'economical-cloud' &&
+      pinnedModel.id !== targetModel.id
+    ) {
+      const delegateDecision = this.tryPlanningDelegateDecision(
+        request,
+        pinnedModel,
+        targetModel,
       );
-      if (pinnedModel && pinnedModel.id !== model.id) {
-        const skipBreakeven =
-          turnType === 'planning' && this.isSaarPlanningBufferActive(request);
-        if (!skipBreakeven) {
-          const tokenEstimate =
-            request.estimated_input_tokens ?? request.prompt_text.length;
-          const breakeven = evaluateModelSwitchBreakeven(
-            pinnedModel,
-            model,
-            tokenEstimate,
-            tokenEstimate,
-            this.options.saarConfig,
-          );
-          if (!breakeven.shouldSwitch) {
-            this.currentBreakevenReason = 'breakeven_blocked';
-            return { decided: false, stage: 'turn_envelope' };
-          }
-          this.currentBreakevenReason = 'breakeven_pass';
+      if (delegateDecision) {
+        return delegateDecision;
+      }
+    }
+
+    if (pinnedModel && pinnedModel.id !== targetModel.id) {
+      const skipBreakeven =
+        turnType === 'planning' && this.isSaarPlanningBufferActive(request);
+      if (!skipBreakeven) {
+        const tokenEstimate =
+          request.estimated_input_tokens ?? request.prompt_text.length;
+        const breakeven = evaluateModelSwitchBreakeven(
+          pinnedModel,
+          targetModel,
+          tokenEstimate,
+          tokenEstimate,
+          this.options.saarConfig,
+        );
+        if (!breakeven.shouldSwitch) {
+          this.currentBreakevenReason = 'breakeven_blocked';
+          return { decided: false, stage: 'turn_envelope' };
         }
+        this.currentBreakevenReason = 'breakeven_pass';
       }
     }
 
+    const directReasonCode = `turn_${turnType}`;
+    let planningDirectFallback: string | null = null;
+
+    if (
+      turnType === 'planning' &&
+      pinnedModel &&
+      pinnedModel.tier === 'economical-cloud' &&
+      pinnedModel.id !== targetModel.id
+    ) {
+      planningDirectFallback = this.resolvePlanningDirectFallbackReason();
+    }
+
+    if (planningDirectFallback) {
+      this.setPlanningDelegateDirectFallback(targetModel.id, planningDirectFallback);
+    }
+
     return {
       decided: true,
       stage: 'turn_envelope',
-      decision: this.withEstimatedCost(request, model, {
+      decision: this.withEstimatedCost(request, targetModel, {
         request_id: request.request_id,
-        selected_model_id: model.id,
+        selected_model_id: targetModel.id,
         tier: targetTier,
         stage: 'turn_envelope',
-        reason_code: `turn_${turnType}`,
+        reason_code: planningDirectFallback
+          ? PLANNING_DIRECT_FRONTIER
+          : directReasonCode,
         routing_latency_ms: 0,
         pin_reason: null,
       }),
     };
   }
 
+  private resolvePlanningDirectFallbackReason(): string | null {
+    const config = this.resolvePlanningDelegateConfig();
+    if (!config.enabled) {
+      return PLANNING_DELEGATE_DISABLED;
+    }
+    return null;
+  }
+
+  private resolvePlanningDelegateConfig(): PlanningDelegateConfig {
+    return (
+      this.options.planningDelegateConfig ??
+      DEFAULT_OPERATOR_CONFIG.planning_delegate
+    );
+  }
+
+  /**
+   * SP-143: emit planning_delegate when enabled; otherwise record direct fallback
+   * observability and return null so breakeven-gated direct frontier can proceed.
+   */
+  private tryPlanningDelegateDecision(
+    request: RoutingRequest,
+    pinnedModel: ModelProfile,
+    frontierModel: ModelProfile,
+  ): StageResult | null {
+    const config = this.resolvePlanningDelegateConfig();
+    if (!config.enabled) {
+      return null;
+    }
+
+    this.currentPlanningDelegate = createPlanningDelegateObservability({
+      path: 'delegate',
+      primary_model_id: pinnedModel.id,
+      delegate_model_id: frontierModel.id,
+      compressed_context: config.compressed_context,
+      planning_delegate_reason_code: PLANNING_DELEGATE,
+    });
+
+    return {
+      decided: true,
+      stage: 'turn_envelope',
+      decision: this.withEstimatedCost(request, pinnedModel, {
+        request_id: request.request_id,
+        selected_model_id: pinnedModel.id,
+        tier: pinnedModel.tier,
+        stage: 'turn_envelope',
+        reason_code: PLANNING_DELEGATE,
+        routing_latency_ms: 0,
+        pin_reason: null,
+      }),
+    };
+  }
+
+  private setPlanningDelegateDirectFallback(
+    delegateModelId: string | null,
+    fallbackReason: string,
+  ): void {
+    this.currentPlanningDelegate = createPlanningDelegateObservability({
+      path: 'direct',
+      delegate_model_id: delegateModelId,
+      planning_delegate_reason_code: PLANNING_DIRECT_FRONTIER,
+      fallback_reason: fallbackReason,
+    });
+  }
+
   // ─── Low-intensity tier gate (SP-103, #58) ───────────────────────────────
 
   /**

package/src/domain/types/entities.ts

@@ -208,6 +208,48 @@ export interface BreakevenObservability {
   readonly breakeven_reason_code: string | null;
 }
 
+/** Planning delegate routing path (SP-142, #71). */
+export type PlanningDelegatePath = 'delegate' | 'direct' | 'none';
+
+/**
+ * Compressed context limits for ephemeral frontier sub-calls (SP-142).
+ * Excludes full execution history per #71; enforced by pi extension in SP-144.
+ */
+export interface CompressedContextSpec {
+  /** Max user/assistant messages retained in the delegate sub-call. */
+  readonly max_messages: number;
+  /** Max estimated tokens for delegate context window. */
+  readonly max_tokens: number;
+  /** When true, tool execution traces and verbose history are excluded. */
+  readonly exclude_execution_history: boolean;
+}
+
+/** Operator knobs for cache-preserving planning delegate (SP-142, #71). */
+export interface PlanningDelegateConfig {
+  /** Prefer ephemeral frontier sub-call over primary model switch on planning turns. */
+  readonly enabled: boolean;
+  readonly compressed_context: CompressedContextSpec;
+}
+
+/** Planning delegate observability for explain and telemetry (SP-142, #71). */
+export interface PlanningDelegateObservability {
+  /** Active routing path for this planning turn. */
+  readonly path: PlanningDelegatePath;
+  /** Primary model kept on pinned session when path is delegate. */
+  readonly primary_model_id: string | null;
+  /** Frontier model selected for delegate sub-call when path is delegate. */
+  readonly delegate_model_id: string | null;
+  /** Compressed context limits applied to delegate sub-call. */
+  readonly compressed_context: CompressedContextSpec | null;
+  /**
+   * Machine-readable path reason, e.g. `planning_delegate`, `planning_direct_frontier`,
+   * `planning_delegate_disabled`.
+   */
+  readonly planning_delegate_reason_code: string | null;
+  /** Operator-visible fallback explanation when path is not delegate. */
+  readonly fallback_reason: string | null;
+}
+
 /** SAAR pin policy observability (SP-126, #72). */
 export interface SaarObservability {
   readonly buffer_active: boolean;
@@ -275,6 +317,8 @@ export interface RoutingFeatureSidecar {
   readonly breakeven?: BreakevenObservability;
   /** SAAR pin state summary (SP-126, #72). */
   readonly saar?: SaarObservability;
+  /** Planning delegate path summary (SP-142, #71). */
+  readonly planning_delegate?: PlanningDelegateObservability;
   /** Why local_zero eligibility passed (SP-111, #59). */
   readonly local_eligible_reason: string | null;
 }
@@ -441,4 +485,12 @@ export interface RoutingTelemetry {
   readonly saar_hard_lock: boolean;
   readonly turn_index_in_session: number | null;
   readonly saar_reason_code: string | null;
+  readonly planning_delegate_path: PlanningDelegatePath | null;
+  readonly planning_delegate_primary_model_id: string | null;
+  readonly planning_delegate_model_id: string | null;
+  readonly planning_delegate_reason_code: string | null;
+  readonly planning_delegate_fallback_reason: string | null;
+  readonly planning_delegate_max_messages: number | null;
+  readonly planning_delegate_max_tokens: number | null;
+  readonly planning_delegate_exclude_execution_history: boolean | null;
 }

package/src/domain/types/index.ts

@@ -2,12 +2,16 @@ export type {
   BreakevenObservability,
   CandidateScore,
   ClusterMatchTableEntry,
+  CompressedContextSpec,
   ContextFitObservability,
   ContextFitRejectedEntry,
   LoadedRoutingCluster,
   LowIntensityBreakdown,
   Message,
   ModelCapabilities,
+  PlanningDelegateConfig,
+  PlanningDelegateObservability,
+  PlanningDelegatePath,
   ModelLimits,
   ModelPerformance,
   ModelPricing,

package/src/domain/types/schemas.ts

@@ -251,6 +251,23 @@ export const SaarConfigSchema = z.object({
 
 export type SaarConfig = z.infer<typeof SaarConfigSchema>;
 
+/** Compressed context limits for planning delegate sub-calls (SP-142, #71). */
+export const CompressedContextSpecSchema = z.object({
+  max_messages: z.number().int().positive(),
+  max_tokens: z.number().int().positive(),
+  exclude_execution_history: z.boolean(),
+});
+
+export type CompressedContextSpec = z.infer<typeof CompressedContextSpecSchema>;
+
+/** Planning delegate operator knobs (SP-142, #71). */
+export const PlanningDelegateConfigSchema = z.object({
+  enabled: z.boolean(),
+  compressed_context: CompressedContextSpecSchema,
+});
+
+export type PlanningDelegateConfig = z.infer<typeof PlanningDelegateConfigSchema>;
+
 /** SAAR defaults per routing-roadmap.md §2 P0 (SP-121). */
 export const DEFAULT_SAAR_CONFIG: Readonly<SaarConfig> = {
   planning_turn_buffer: 2,
@@ -259,6 +276,61 @@ export const DEFAULT_SAAR_CONFIG: Readonly<SaarConfig> = {
   switch_threshold: 0.5,
 } as const;
 
+/** Planning delegate defaults per routing-roadmap.md §2 P0 / #71 (SP-142). */
+export const DEFAULT_PLANNING_DELEGATE_CONFIG: Readonly<PlanningDelegateConfig> = {
+  enabled: true,
+  compressed_context: {
+    max_messages: 12,
+    max_tokens: 16_384,
+    exclude_execution_history: true,
+  },
+} as const;
+
+/** Env: SMART_ROUTER_PLANNING_DELEGATE_ENABLED — enable delegate path (default true). */
+const ENV_PLANNING_DELEGATE_ENABLED = 'SMART_ROUTER_PLANNING_DELEGATE_ENABLED';
+/** Env: SMART_ROUTER_PLANNING_DELEGATE_MAX_MESSAGES — compressed context message cap (default 12). */
+const ENV_PLANNING_DELEGATE_MAX_MESSAGES = 'SMART_ROUTER_PLANNING_DELEGATE_MAX_MESSAGES';
+/** Env: SMART_ROUTER_PLANNING_DELEGATE_MAX_TOKENS — compressed context token cap (default 16384). */
+const ENV_PLANNING_DELEGATE_MAX_TOKENS = 'SMART_ROUTER_PLANNING_DELEGATE_MAX_TOKENS';
+/** Env: SMART_ROUTER_PLANNING_DELEGATE_EXCLUDE_EXECUTION_HISTORY — exclude tool traces (default true). */
+const ENV_PLANNING_DELEGATE_EXCLUDE_EXECUTION_HISTORY =
+  'SMART_ROUTER_PLANNING_DELEGATE_EXCLUDE_EXECUTION_HISTORY';
+
+function readBooleanEnv(name: string): boolean | undefined {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') {
+    return undefined;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') {
+    return true;
+  }
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') {
+    return false;
+  }
+  return undefined;
+}
+
+/** Merge planning delegate env overrides onto defaults (invalid env values are ignored). */
+export function resolvePlanningDelegateConfigFromEnv(
+  base: PlanningDelegateConfig = DEFAULT_PLANNING_DELEGATE_CONFIG,
+): PlanningDelegateConfig {
+  return {
+    enabled: readBooleanEnv(ENV_PLANNING_DELEGATE_ENABLED) ?? base.enabled,
+    compressed_context: {
+      max_messages:
+        readPositiveIntEnv(ENV_PLANNING_DELEGATE_MAX_MESSAGES) ??
+        base.compressed_context.max_messages,
+      max_tokens:
+        readPositiveIntEnv(ENV_PLANNING_DELEGATE_MAX_TOKENS) ??
+        base.compressed_context.max_tokens,
+      exclude_execution_history:
+        readBooleanEnv(ENV_PLANNING_DELEGATE_EXCLUDE_EXECUTION_HISTORY) ??
+        base.compressed_context.exclude_execution_history,
+    },
+  };
+}
+
 /** Env: SMART_ROUTER_PLANNING_TURN_BUFFER — SAAR planning buffer turns (default 2). */
 const ENV_PLANNING_TURN_BUFFER = 'SMART_ROUTER_PLANNING_TURN_BUFFER';
 /** Env: SMART_ROUTER_PREFIX_CACHE_WEIGHT — SAAR prefix cache weight 0–1 (default 0.20). */
@@ -349,6 +421,7 @@ export const OperatorConfigSchema = z.object({
   hydra: HydraConfigSchema,
   low_intensity: LowIntensityConfigSchema,
   saar: SaarConfigSchema,
+  planning_delegate: PlanningDelegateConfigSchema,
   routing_clusters: RoutingClustersConfigSchema.optional(),
 });
 

package/src/infrastructure/persistence/sqlite-store.ts

@@ -24,6 +24,7 @@ import {
 } from '../telemetry/telemetry-limits.js';
 import {
   DEFAULT_BREAKEVEN_TELEMETRY_FIELDS,
+  DEFAULT_PLANNING_DELEGATE_TELEMETRY_FIELDS,
   DEFAULT_SAAR_TELEMETRY_FIELDS,
 } from '../telemetry/routing-telemetry.js';
 import {
@@ -833,6 +834,7 @@ function telemetryRowToEntity(row: TelemetryRow): RoutingTelemetry {
     tier_selection_reason_code: null,
     ...DEFAULT_BREAKEVEN_TELEMETRY_FIELDS,
     ...DEFAULT_SAAR_TELEMETRY_FIELDS,
+    ...DEFAULT_PLANNING_DELEGATE_TELEMETRY_FIELDS,
   };
 }
 

package/src/infrastructure/telemetry/routing-telemetry.ts

@@ -26,6 +26,8 @@ import type {
   ContextFitRejectedEntry,
   LowIntensityBreakdown,
   ModelProfile,
+  PlanningDelegateObservability,
+  PlanningDelegatePath,
   PriceCatalog,
   RejectedTierEntry,
   RoutingDecision,
@@ -59,6 +61,11 @@ export const BREAKEVEN_PASS = 'breakeven_pass' as const;
 export const SAAR_BUFFER_ACTIVE = 'saar_buffer_active' as const;
 export const SAAR_HARD_LOCK = 'saar_hard_lock' as const;
 
+export const PLANNING_DELEGATE = 'planning_delegate' as const;
+export const PLANNING_DIRECT_FRONTIER = 'planning_direct_frontier' as const;
+export const PLANNING_DELEGATE_DISABLED = 'planning_delegate_disabled' as const;
+export const PLANNING_DELEGATE_UNAVAILABLE = 'planning_delegate_unavailable' as const;
+
 const TURN_ENVELOPE_TIER_MAP: Readonly<Record<string, Tier | null>> = {
   planning: 'frontier-cloud',
   tool_result: 'economical-cloud',
@@ -538,6 +545,51 @@ function resolveSaarReasonCode(decision: RoutingDecision): string | null {
   return null;
 }
 
+/** Build planning delegate observability from routing decision features (SP-142). */
+export function buildPlanningDelegateObservability(
+  decision: RoutingDecision,
+): PlanningDelegateObservability | null {
+  return decision.features?.planning_delegate ?? null;
+}
+
+/** Construct planning delegate observability for pipeline and tests (SP-142). */
+export function createPlanningDelegateObservability(input: {
+  path: PlanningDelegatePath;
+  primary_model_id?: string | null;
+  delegate_model_id?: string | null;
+  compressed_context?: PlanningDelegateObservability['compressed_context'];
+  planning_delegate_reason_code: string;
+  fallback_reason?: string | null;
+}): PlanningDelegateObservability {
+  return {
+    path: input.path,
+    primary_model_id: input.primary_model_id ?? null,
+    delegate_model_id: input.delegate_model_id ?? null,
+    compressed_context: input.compressed_context ?? null,
+    planning_delegate_reason_code: input.planning_delegate_reason_code,
+    fallback_reason: input.fallback_reason ?? null,
+  };
+}
+
+/** Attach planning delegate observability to routing decision features (SP-142). */
+export function enrichRoutingDecisionWithPlanningDelegate(
+  decision: RoutingDecision,
+  planningDelegate?: PlanningDelegateObservability | null,
+): RoutingDecision {
+  const observability = planningDelegate ?? buildPlanningDelegateObservability(decision);
+  if (!observability) {
+    return decision;
+  }
+
+  return {
+    ...decision,
+    features: {
+      ...(decision.features ?? emptyFeatureSidecar()),
+      planning_delegate: observability,
+    },
+  };
+}
+
 /** Build privacy-safe SAAR pin state for explain and telemetry (SP-126). */
 export function buildSaarObservability(
   input: PinEconomicsObservabilityInput,
@@ -658,6 +710,53 @@ export const DEFAULT_BREAKEVEN_TELEMETRY_FIELDS = defaultBreakevenTelemetry();
 /** Default SAAR telemetry scalars for tests and legacy store reads. */
 export const DEFAULT_SAAR_TELEMETRY_FIELDS = defaultSaarTelemetry();
 
+function defaultPlanningDelegateTelemetry(): Pick<
+  RoutingTelemetry,
+  | 'planning_delegate_path'
+  | 'planning_delegate_primary_model_id'
+  | 'planning_delegate_model_id'
+  | 'planning_delegate_reason_code'
+  | 'planning_delegate_fallback_reason'
+  | 'planning_delegate_max_messages'
+  | 'planning_delegate_max_tokens'
+  | 'planning_delegate_exclude_execution_history'
+> {
+  return {
+    planning_delegate_path: null,
+    planning_delegate_primary_model_id: null,
+    planning_delegate_model_id: null,
+    planning_delegate_reason_code: null,
+    planning_delegate_fallback_reason: null,
+    planning_delegate_max_messages: null,
+    planning_delegate_max_tokens: null,
+    planning_delegate_exclude_execution_history: null,
+  };
+}
+
+/** Default planning delegate telemetry scalars for tests and legacy store reads. */
+export const DEFAULT_PLANNING_DELEGATE_TELEMETRY_FIELDS = defaultPlanningDelegateTelemetry();
+
+function planningDelegateTelemetryFromDecision(
+  decision: RoutingDecision,
+): ReturnType<typeof defaultPlanningDelegateTelemetry> {
+  const observability = buildPlanningDelegateObservability(decision);
+  if (!observability) {
+    return defaultPlanningDelegateTelemetry();
+  }
+
+  return {
+    planning_delegate_path: observability.path === 'none' ? null : observability.path,
+    planning_delegate_primary_model_id: observability.primary_model_id,
+    planning_delegate_model_id: observability.delegate_model_id,
+    planning_delegate_reason_code: observability.planning_delegate_reason_code,
+    planning_delegate_fallback_reason: observability.fallback_reason,
+    planning_delegate_max_messages: observability.compressed_context?.max_messages ?? null,
+    planning_delegate_max_tokens: observability.compressed_context?.max_tokens ?? null,
+    planning_delegate_exclude_execution_history:
+      observability.compressed_context?.exclude_execution_history ?? null,
+  };
+}
+
 function pinEconomicsTelemetryFromInput(
   input: PinEconomicsObservabilityInput,
 ): ReturnType<typeof defaultBreakevenTelemetry> &
@@ -786,7 +885,9 @@ export async function enrichRoutingDecisionForExplain(
 
   return enrichRoutingDecisionWithPinEconomics(
     request,
-    enrichRoutingDecisionWithTierSelection(withContextFit, clusterMatchTable),
+    enrichRoutingDecisionWithPlanningDelegate(
+      enrichRoutingDecisionWithTierSelection(withContextFit, clusterMatchTable),
+    ),
     pinEconomicsOptionsFromExplain(options),
   );
 }
@@ -847,12 +948,14 @@ export function buildRoutingDecisionLogPayload(
 ): Record<string, unknown> {
   const enriched = enrichRoutingDecisionWithPinEconomics(
     request,
-    enrichRoutingDecisionWithTierSelection(
-      enrichRoutingDecisionWithContextFit(
-        request,
-        decision,
-        fleet,
-        contextFitConfig,
+    enrichRoutingDecisionWithPlanningDelegate(
+      enrichRoutingDecisionWithTierSelection(
+        enrichRoutingDecisionWithContextFit(
+          request,
+          decision,
+          fleet,
+          contextFitConfig,
+        ),
       ),
     ),
     {
@@ -869,6 +972,7 @@ export function buildRoutingDecisionLogPayload(
   const tierSelection = enriched.features?.tier_selection;
   const breakeven = enriched.features?.breakeven;
   const saar = enriched.features?.saar;
+  const planningDelegate = enriched.features?.planning_delegate;
 
   return {
     request_id: enriched.request_id,
@@ -908,6 +1012,16 @@ export function buildRoutingDecisionLogPayload(
           saar_reason_code: saar.saar_reason_code,
         }
       : null,
+    planning_delegate_summary: planningDelegate
+      ? {
+          path: planningDelegate.path,
+          primary_model_id: planningDelegate.primary_model_id,
+          delegate_model_id: planningDelegate.delegate_model_id,
+          compressed_context: planningDelegate.compressed_context,
+          planning_delegate_reason_code: planningDelegate.planning_delegate_reason_code,
+          fallback_reason: planningDelegate.fallback_reason,
+        }
+      : null,
     delegate,
   };
 }
@@ -1093,6 +1207,7 @@ export class RoutingTelemetryEmitter {
         : {}),
       ...(this.saarConfig !== undefined ? { saarConfig: this.saarConfig } : {}),
     });
+    const planningDelegateFields = planningDelegateTelemetryFromDecision(decision);
 
     const record: RoutingTelemetry = {
       timestamp: this.clock(),
@@ -1128,6 +1243,7 @@ export class RoutingTelemetryEmitter {
       saar_hard_lock: pinEconomicsFields.saar_hard_lock,
       turn_index_in_session: pinEconomicsFields.turn_index_in_session,
       saar_reason_code: pinEconomicsFields.saar_reason_code,
+      ...planningDelegateFields,
     };
 
     this.entries.push(record);