pi-smart-router 0.19.4 → 0.21.0

package/.pi/extensions/smart-router/command-formatters.ts

@@ -312,9 +312,16 @@ export function formatStatsMessage(
     return 'No routing stats yet (empty telemetry window).';
   }
 
+  const costBasisLabel =
+    snapshot.cost_basis === 'actual'
+      ? 'actual'
+      : snapshot.cost_basis === 'mixed'
+        ? `mixed (${snapshot.actual_usage_count}/${snapshot.entry_count} actual)`
+        : 'estimated';
+
   const lines = [
     `Entries: ${snapshot.entry_count}`,
-    `Cost: total ${formatUsd(snapshot.total_cost_usd)} | mean ${formatMean(snapshot.mean_cost_usd, '')}`,
+    `Cost (${costBasisLabel}): total ${formatUsd(snapshot.total_cost_usd)} | mean ${formatMean(snapshot.mean_cost_usd, '')}`,
     `Latency: total ${snapshot.total_latency_ms.toFixed(0)}ms | mean ${formatMean(snapshot.mean_latency_ms, 'ms')}`,
     `Planning delegate share: ${formatShare(snapshot.planning_delegate_share)} (direct ${formatShare(snapshot.direct_share)})`,
     `Local vs cloud (when known): local ${formatShare(snapshot.local_share)} | cloud ${formatShare(snapshot.cloud_share)}`,
@@ -324,10 +331,19 @@ export function formatStatsMessage(
     `  other: ${snapshot.role_cost.other.count} | ${formatUsd(snapshot.role_cost.other.total_cost_usd)}`,
   ];
 
+  if (snapshot.actual_usage_count > 0) {
+    lines.push(
+      `Actual usage: ${snapshot.actual_usage_count}/${snapshot.entry_count} entries with host-reported tokens` +
+        (snapshot.actual_total_tokens !== null
+          ? ` | ${snapshot.actual_total_tokens} actual tokens`
+          : ''),
+    );
+  }
+
   if (snapshot.frontier_savings_usd !== undefined) {
     lines.push(
-      `Vs always-frontier savings (est.): ${formatUsd(snapshot.frontier_savings_usd)}`,
-      '  formula: sum max(0, tokens/1e6 * frontier_cost_per_1m - estimated_cost_usd); omitted when prices missing',
+      `Vs always-frontier savings: ${formatUsd(snapshot.frontier_savings_usd)} (${snapshot.cost_basis === 'estimated' ? 'est.' : 'actuals preferred, est. when missing'})`,
+      '  formula: sum max(0, tokens/1e6 * frontier_cost_per_1m - cost); tokens/cost prefer actuals; omitted when prices missing',
     );
   } else {
     lines.push('Vs always-frontier savings: (omitted — frontier prices unavailable)');

package/.pi/extensions/smart-router/delegate-stream.ts

@@ -10,6 +10,12 @@ import {
 } from '@earendil-works/pi-ai/compat';
 
 import { parseAssistantMessageError } from '../../../src/infrastructure/delegation/provider-error.js';
+import { extractUsageActuals } from '../../../src/infrastructure/telemetry/routing-telemetry.js';
+import {
+  resolveAdaptiveReasoning,
+  type AdaptiveReasoningResult,
+  type AdaptiveReasoningSignal,
+} from '../../../src/domain/delegation/adaptive-reasoning.js';
 import {
   buildDelegationContext,
   forwardDelegatedEvent,
@@ -89,6 +95,7 @@ export async function collectDelegatedStream(
   deps: StreamDelegationDeps,
   options: SimpleStreamOptions | undefined,
   headroomContext?: DelegationHeadroomContext,
+  reasoning?: AdaptiveReasoningResult,
 ): Promise<DelegatedStreamResult> {
   throwIfAborted(options);
 
@@ -97,6 +104,7 @@ export async function collectDelegatedStream(
     targetModel,
     options,
     headroomContext,
+    reasoning,
   );
   const delegateStream = resolveDelegateStream(targetModel, deps);
   const inner = delegateStream(targetModel, context, delegationOptions);
@@ -156,6 +164,7 @@ export async function pipeDelegatedStream(
   options: SimpleStreamOptions | undefined,
   headroomContext: DelegationHeadroomContext | undefined,
   pipe: PipeDelegatedStreamOptions,
+  reasoning?: AdaptiveReasoningResult,
 ): Promise<PipedDelegatedStreamResult> {
   throwIfAborted(options);
 
@@ -164,6 +173,7 @@ export async function pipeDelegatedStream(
     targetModel,
     options,
     headroomContext,
+    reasoning,
   );
   const delegateStream = resolveDelegateStream(targetModel, deps);
   const inner = delegateStream(targetModel, context, delegationOptions);
@@ -257,11 +267,29 @@ function recordDelegateOutcome(
   deps: StreamDelegationDeps,
   sessionId: string | undefined,
   result: DelegatedStreamResult,
+  requestId?: string,
 ): void {
   if (!result.finalMessage) {
     return;
   }
 
+  // SP-241 / #164: capture post-turn usage actuals (success and
+  // failed-with-usage terminals). Fail open — extraction/hook errors and
+  // missing usage must never fail the route.
+  if (requestId !== undefined) {
+    try {
+      const actuals = extractUsageActuals(result.finalMessage.usage);
+      if (actuals) {
+        deps.onDelegationUsage?.(requestId, actuals);
+      }
+    } catch (error) {
+      console.warn(
+        '[smart-router] usage actuals capture failed (fail open)',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
   if (result.failed) {
     const parsed = parseAssistantMessageError(result.finalMessage);
     deps.router.dispatch.recordOutcome(targetModel.id, parsed);
@@ -282,6 +310,11 @@ function recordDelegateOutcome(
 /**
  * Delegate with outcome recording. When `pipe` is provided, live-forwards to outer
  * (holding the terminal event). Otherwise collects into a buffer (planning / probes).
+ *
+ * SP-245 (#166): when `reasoningSignal` is provided, the adaptive reasoning
+ * policy resolves the effective thinking level from turn signals and merges it
+ * into the delegated stream options (never lowering an explicit operator
+ * /thinking; fail open on non-reasoning models).
  */
 export async function delegateWithOutcome(
   targetModel: Model<Api>,
@@ -291,12 +324,54 @@ export async function delegateWithOutcome(
   sessionId: string | undefined,
   headroomContext?: DelegationHeadroomContext,
   pipe?: PipeDelegatedStreamOptions,
+  /** Routing request id for post-turn usage actuals capture (SP-241, #164). */
+  requestId?: string,
+  /** Turn/routing signals for adaptive reasoning (SP-245, #166). */
+  reasoningSignal?: AdaptiveReasoningSignal,
 ): Promise<PipedDelegatedStreamResult | DelegatedStreamResult> {
+  const reasoning = reasoningSignal
+    ? resolveAdaptiveReasoning(
+        targetModel,
+        reasoningSignal,
+        options?.reasoning,
+        // SP-246 (#166): operator enable/disable + floor/ceiling knobs.
+        deps.adaptiveReasoningConfig
+          ? {
+              enabled: deps.adaptiveReasoningConfig.enabled,
+              ...(deps.adaptiveReasoningConfig.min_level !== undefined
+                ? { floor: deps.adaptiveReasoningConfig.min_level }
+                : {}),
+              ...(deps.adaptiveReasoningConfig.max_level !== undefined
+                ? { ceiling: deps.adaptiveReasoningConfig.max_level }
+                : {}),
+            }
+          : undefined,
+      )
+    : undefined;
+
+  // SP-246 (#166): reasoning telemetry (requested / applied / reason code).
+  // Fail open — telemetry must never fail the route.
+  if (reasoningSignal && reasoning && requestId !== undefined) {
+    try {
+      deps.onDelegationReasoning?.(requestId, {
+        reasoning_level_requested: options?.reasoning ?? null,
+        reasoning_level_applied: reasoning.reasoning ?? null,
+        reasoning_reason_code: reasoning.reasonCode,
+      });
+    } catch (error) {
+      console.warn(
+        '[smart-router] reasoning telemetry callback failed (fail open)',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
   const delegationContext = buildDelegationContext(
     context,
     targetModel,
     deps,
     sessionId,
+    reasoning,
   );
 
   const result = pipe
@@ -307,6 +382,7 @@ export async function delegateWithOutcome(
         options,
         headroomContext,
         pipe,
+        reasoning,
       )
     : await collectDelegatedStream(
         targetModel,
@@ -314,9 +390,10 @@ export async function delegateWithOutcome(
         deps,
         options,
         headroomContext,
+        reasoning,
       );
 
-  recordDelegateOutcome(targetModel, deps, sessionId, result);
+  recordDelegateOutcome(targetModel, deps, sessionId, result, requestId);
 
   return result;
 }

package/.pi/extensions/smart-router/delegation-runtime.ts

@@ -13,6 +13,10 @@ import {
 } from '@earendil-works/pi-ai/compat';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 
+import {
+  applyConcisenessHint,
+  type AdaptiveReasoningResult,
+} from '../../../src/domain/delegation/adaptive-reasoning.js';
 import {
   isGoogleDelegationTarget,
   normalizeDelegationContext,
@@ -87,6 +91,7 @@ export async function resolveDelegationOptions(
   targetModel: Model<Api>,
   callerOptions?: SimpleStreamOptions,
   headroomContext?: DelegationHeadroomContext,
+  reasoning?: AdaptiveReasoningResult,
 ): Promise<SimpleStreamOptions> {
   const auth = await modelRegistry.getApiKeyAndHeaders(targetModel);
   if (!auth.ok) {
@@ -124,6 +129,14 @@ export async function resolveDelegationOptions(
     ...(auth.headers !== undefined ? { headers: auth.headers } : {}),
     ...(mergedEnv !== undefined ? { env: mergedEnv } : {}),
     ...(maxTokens !== undefined ? { maxTokens } : {}),
+    // SP-245 (#166): adaptive reasoning policy merge — applied after the
+    // caller pick so the policy-effective level wins, while every other
+    // DELEGATION_CALLER_OPTION_KEYS entry (incl. thinkingBudgets) passes
+    // through untouched. Explicit operator /thinking floors are already
+    // resolved inside the policy result.
+    ...(reasoning?.reasoning !== undefined
+      ? { reasoning: reasoning.reasoning }
+      : {}),
   };
 }
 
@@ -146,6 +159,7 @@ export function buildDelegationContext(
   targetModel: Model<Api>,
   deps: StreamDelegationDeps,
   sessionId: string | undefined,
+  reasoning?: AdaptiveReasoningResult,
 ): Context {
   const sessionExecution = sessionId
     ? deps.executionLedger.getLastExecution(sessionId)
@@ -155,11 +169,13 @@ export function buildDelegationContext(
     sessionExecution,
   });
 
-  if (isGoogleDelegationTarget(targetModel)) {
-    return repairGeminiReplayContext(normalized, targetModel, sessionExecution);
-  }
+  const repaired = isGoogleDelegationTarget(targetModel)
+    ? repairGeminiReplayContext(normalized, targetModel, sessionExecution)
+    : normalized;
 
-  return normalized;
+  // SP-245 (#166): light conciseness nudge only when the policy resolved a
+  // low/minimal effective level on a high-verbosity (GLM-class) profile.
+  return applyConcisenessHint(repaired, reasoning);
 }
 
 export function createErrorMessage(

package/.pi/extensions/smart-router/extension-setup.ts

@@ -120,6 +120,9 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
       executionLedger,
       lifecycleHookState,
       planningDelegateConfig: operatorConfig.planning_delegate,
+      ...(operatorConfig.adaptive_reasoning !== undefined
+        ? { adaptiveReasoningConfig: operatorConfig.adaptive_reasoning }
+        : {}),
       datasetRecorder,
       outcomeRecorder,
       sessionPinner,
@@ -138,6 +141,32 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
         }
         runtime.syncRegisteredLimits?.(limits);
       },
+      onDelegationUsage(requestId, actuals) {
+        // SP-241 / #164: persist post-turn usage actuals onto the routing
+        // telemetry row. Fail open — a telemetry write must never fail the
+        // route, and stores without update support simply skip actuals.
+        try {
+          runtime.store.updateTelemetryUsageActuals?.(requestId, actuals);
+        } catch (error) {
+          console.warn(
+            '[smart-router] failed to persist usage actuals (fail open)',
+            error instanceof Error ? error.message : String(error),
+          );
+        }
+      },
+      onDelegationReasoning(requestId, fields) {
+        // SP-246 / #166: persist the adaptive reasoning decision (requested /
+        // applied level + reason code) onto the routing telemetry row. Fail
+        // open — telemetry must never fail the route.
+        try {
+          runtime.store.updateTelemetryReasoning?.(requestId, fields);
+        } catch (error) {
+          console.warn(
+            '[smart-router] failed to persist reasoning telemetry (fail open)',
+            error instanceof Error ? error.message : String(error),
+          );
+        }
+      },
     },
   };
 

package/.pi/extensions/smart-router/planning-delegate.ts

@@ -27,6 +27,7 @@ import type {
   PlanningDelegateObservability,
   RoutingDecision,
 } from '../../../src/domain/types/index.js';
+import { resolveAdaptiveReasoning } from '../../../src/domain/delegation/adaptive-reasoning.js';
 import { DEFAULT_PLANNING_DELEGATE_CONFIG } from '../../../src/domain/types/schemas.js';
 import {
   createPlanningDelegateObservability,
@@ -190,11 +191,33 @@ export async function defaultSpawnPlanningDelegate(
   deps: StreamDelegationDeps,
 ): Promise<PlanningDelegateSpawnResult> {
   try {
+    // SP-245 (#166): planning sub-calls keep higher reasoning — the adaptive
+    // policy resolves at least `medium` for planning turns (explicit operator
+    // /thinking floors still win inside the policy). SP-246: honor the
+    // operator enable/disable + floor/ceiling knobs.
+    const reasoning = resolveAdaptiveReasoning(
+      frontierModel,
+      { turnType: 'planning' },
+      options?.reasoning,
+      deps.adaptiveReasoningConfig
+        ? {
+            enabled: deps.adaptiveReasoningConfig.enabled,
+            ...(deps.adaptiveReasoningConfig.min_level !== undefined
+              ? { floor: deps.adaptiveReasoningConfig.min_level }
+              : {}),
+            ...(deps.adaptiveReasoningConfig.max_level !== undefined
+              ? { ceiling: deps.adaptiveReasoningConfig.max_level }
+              : {}),
+          }
+        : undefined,
+    );
     const result = await collectDelegatedStream(
       frontierModel,
       compressedContext,
       deps,
       options,
+      undefined,
+      reasoning,
     );
     if (result.failed || !result.finalMessage) {
       return {

package/.pi/extensions/smart-router/route-and-delegate.ts

@@ -9,6 +9,7 @@ import type {
 
 import { safeCloudDefault } from '../../../src/domain/pipeline/safe-default.js';
 import { computeOutputHeadroom } from '../../../src/domain/delegation/output-headroom.js';
+import { resolvePeakPricingAdjustment } from '../../../src/domain/pricing/peak-pricing.js';
 import {
   CONTEXT_OVERFLOW_NO_FIT,
   resolveContextOverflowFallback,
@@ -84,6 +85,14 @@ function logRoutingDecision(
     return;
   }
 
+  // SP-244 / #165: surface peak vs off-peak pricing rationale for the selected
+  // model (Z.ai GLM Coding Plan / DeepSeek API windows; multiplier 1 + window
+  // 'none' for non-target providers — fail open).
+  const peakPricing = resolvePeakPricingAdjustment({
+    id: delegate?.modelId ?? decision.selected_model_id,
+    ...(delegate?.provider !== undefined ? { provider: delegate.provider } : {}),
+  });
+
   console.warn(
     '[smart-router] routing decision',
     JSON.stringify({
@@ -93,6 +102,12 @@ function logRoutingDecision(
       stage: decision.stage,
       reason_code: decision.reason_code,
       routing_latency_ms: decision.routing_latency_ms,
+      pricing_window: peakPricing.window,
+      peak_pricing: {
+        window: peakPricing.window,
+        cost_multiplier: peakPricing.cost_multiplier,
+        adapter_id: peakPricing.adapter_id,
+      },
       features: decision.features ?? null,
       delegate,
     }),
@@ -521,6 +536,15 @@ export async function routeAndDelegate(
           ...(failoverNotice !== undefined ? { failoverNotice } : {}),
           contextWindow: targetModel.contextWindow,
         },
+        decision.request_id,
+        // SP-245 (#166): adaptive reasoning policy — effective thinking level
+        // from this turn's envelope + routing decision (recomputed per
+        // failover iteration so escalation targets re-evaluate).
+        {
+          turnType: request.turn_type,
+          decision,
+          ...(targetProfile !== undefined ? { profile: targetProfile } : {}),
+        },
       );
 
       if (!isPipedResult(result)) {
@@ -761,6 +785,7 @@ export async function routeAndDelegate(
           ...(failoverNotice !== undefined ? { failoverNotice } : {}),
           contextWindow: fallbackModel.contextWindow,
         },
+        decision.request_id,
       );
       if (isPipedResult(fallbackResult)) {
         commitPipedTerminal(fallbackResult);

package/.pi/extensions/smart-router/session-lifecycle.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 
+import { evictInMemorySessionState } from '../../../src/api/session-eviction.js';
 import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import {
   bindSharedModelRegistry,
@@ -15,6 +16,15 @@ export const FLEET_MODE_ENTRY_TYPE = 'smart-router-fleet-mode' as const;
 const SMART_ROUTER_PROVIDER = 'smart-router' as const;
 const SMART_ROUTER_AUTO_ID = 'auto' as const;
 
+/**
+ * Orphan-session TTL fallback (SP-248, #145). `session_shutdown` is the primary
+ * teardown signal; if pi ever shuts a session down without delivering it
+ * (extension reload races, missed events), the session's in-memory routing
+ * state is evicted once it has been idle for ORPHAN_SESSION_TTL_MS. The sweep
+ * runs on `session_start` and fails open — eviction must never break startup.
+ */
+export const ORPHAN_SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
 export function isSmartRouterActive(model: { provider: string; id: string }): boolean {
   return model.provider === SMART_ROUTER_PROVIDER && model.id === SMART_ROUTER_AUTO_ID;
 }
@@ -97,6 +107,39 @@ export function setupSessionHooks(
 ): void {
   let activeModel: { provider: string; id: string } | undefined;
 
+  // Last-seen stamp per session for the orphan-TTL fallback (SP-248).
+  const lastSeenBySession = new Map<string, number>();
+
+  /** Evict all in-memory routing state for one session via the SP-247 helper. */
+  function evictSessionState(sessionId: string | undefined): void {
+    // Fail open: a missing/empty session id must never break teardown.
+    if (sessionId === undefined || sessionId === '') {
+      return;
+    }
+    evictInMemorySessionState(sessionId, {
+      executionLedger: runtime.executionLedger,
+      lifecycleHookState: runtime.lifecycleHookState,
+      sessionRouting: runtime.sessionRouting,
+    });
+    lastSeenBySession.delete(sessionId);
+  }
+
+  /** Drop sessions idle longer than ORPHAN_SESSION_TTL_MS (never throws). */
+  function sweepOrphanedSessions(now: number): void {
+    try {
+      for (const [sessionId, lastSeen] of lastSeenBySession) {
+        if (now - lastSeen > ORPHAN_SESSION_TTL_MS) {
+          evictSessionState(sessionId);
+        }
+      }
+    } catch (error) {
+      console.warn(
+        '[smart-router] orphan session sweep failed (fail open)',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
   pi.on('session_start', async (_event, ctx) => {
     activeModel = ctx.model;
     bindSharedModelRegistry(runtime, ctx.modelRegistry);
@@ -128,6 +171,10 @@ export function setupSessionHooks(
     datasetNotify.fn = runtime.notifyDatasetEnabled;
 
     const sessionId = ctx.sessionManager.getSessionId();
+    const now = Date.now();
+    lastSeenBySession.set(sessionId, now);
+    sweepOrphanedSessions(now);
+
     await sessionPinner.restoreSessionPin(sessionId);
 
     if (ctx.model !== undefined && isSmartRouterActive(ctx.model)) {
@@ -158,5 +205,17 @@ export function setupSessionHooks(
     delete runtime.streamDeps.ensureFleetFresh;
     datasetNotify.fn = undefined;
     ctx.ui.setStatus('smart-router-lmu', undefined);
+
+    // SP-248 (#145): drop per-session routing state so long-running pi
+    // processes do not retain ledger/lifecycle/routing maps forever.
+    // Fail open — teardown cleanup must never crash the host agent.
+    try {
+      evictSessionState(ctx.sessionManager.getSessionId());
+    } catch (error) {
+      console.warn(
+        '[smart-router] session teardown eviction failed (fail open)',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
   });
 }

package/.pi/extensions/smart-router/stream-delegation.ts

@@ -8,6 +8,7 @@ import {
 } from '@earendil-works/pi-ai/compat';
 
 import type { RoutingDecision, RoutingFeatureSidecar } from '../../../src/domain/types/index.js';
+import { resolvePeakPricingAdjustment } from '../../../src/domain/pricing/peak-pricing.js';
 import { createErrorMessage } from './delegation-runtime.js';
 import { routeAndDelegate } from './route-and-delegate.js';
 import type { StreamDelegationDeps } from './types.js';
@@ -24,6 +25,14 @@ export function logRoutingDecision(
     return;
   }
 
+  // SP-244 / #165: surface peak vs off-peak pricing rationale for the selected
+  // model (Z.ai GLM Coding Plan / DeepSeek API windows; multiplier 1 + window
+  // 'none' for non-target providers — fail open).
+  const peakPricing = resolvePeakPricingAdjustment({
+    id: delegate?.modelId ?? decision.selected_model_id,
+    ...(delegate?.provider !== undefined ? { provider: delegate.provider } : {}),
+  });
+
   console.warn(
     '[smart-router] routing decision',
     JSON.stringify({
@@ -33,6 +42,12 @@ export function logRoutingDecision(
       stage: decision.stage,
       reason_code: decision.reason_code,
       routing_latency_ms: decision.routing_latency_ms,
+      pricing_window: peakPricing.window,
+      peak_pricing: {
+        window: peakPricing.window,
+        cost_multiplier: peakPricing.cost_multiplier,
+        adapter_id: peakPricing.adapter_id,
+      },
       features: decision.features ?? null,
       delegate,
     }),

package/.pi/extensions/smart-router/types.ts

@@ -11,10 +11,13 @@ import type { HydraMatcher } from '../../../src/domain/matching/hydra-matcher.js
 import { ExecutionLedger } from '../../../src/domain/delegation/execution-ledger.js';
 import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import type {
+  AdaptiveReasoningConfig,
   ModelProfile,
   PlanningDelegateConfig,
   PriceCatalog,
   RoutingDecision,
+  RoutingReasoningTelemetry,
+  RoutingUsageActuals,
 } from '../../../src/domain/types/index.js';
 import type { PlanningDelegateSpawnFn } from './planning-delegate.js';
 import type { StorePort } from '../../../src/domain/types/store-port.js';
@@ -68,6 +71,8 @@ export interface StreamDelegationDeps {
   spawnPlanningDelegate?: PlanningDelegateSpawnFn;
   /** Planning delegate knobs incl. global + per-call timeout bounds (SP-213, #120). */
   readonly planningDelegateConfig?: PlanningDelegateConfig;
+  /** Adaptive reasoning knobs: enable/disable + floor/ceiling (SP-246, #166). */
+  readonly adaptiveReasoningConfig?: AdaptiveReasoningConfig;
   readonly lifecycleHookState?: LifecycleHookState;
   readonly datasetRecorder?: DatasetRecorder;
   readonly outcomeRecorder?: OutcomeRecorder;
@@ -82,6 +87,18 @@ export interface StreamDelegationDeps {
     readonly contextWindow?: number;
     readonly maxTokens?: number;
   }) => void;
+  /**
+   * Fired after a delegated stream ends with host-reported usage actuals
+   * (SP-241, #164). Also fires on failed-with-usage terminals. Implementations
+   * must not throw — actuals capture never fails the route.
+   */
+  onDelegationUsage?: (requestId: string, actuals: RoutingUsageActuals) => void;
+  /**
+   * Fired after the adaptive reasoning policy resolves the effective thinking
+   * level for a delegated stream (SP-246, #166). Implementations must not
+   * throw — reasoning telemetry must never fail the route.
+   */
+  onDelegationReasoning?: (requestId: string, fields: RoutingReasoningTelemetry) => void;
 }
 
 export interface SmartRouterRuntime {