pi-smart-router 0.1.0 → 0.2.0

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

@@ -9,7 +9,16 @@
  * Any stage failure falls back to safeCloudDefault(); never throws to host.
  */
 
-import type { ModelProfile, PriceCatalog, RoutingDecision, RoutingFeatureSidecar, RoutingRequest, Tier, CandidateScore } from '../types/index.js';
+import type {
+  ModelProfile,
+  PriceCatalog,
+  RoutingDecision,
+  RoutingFeatureSidecar,
+  RoutingRequest,
+  SaarConfig,
+  Tier,
+  CandidateScore,
+} from '../types/index.js';
 import type { LowIntensityConfig } from '../types/schemas.js';
 import type { HardwareProbeConfig, HardwareProbeResult, SystemInfo } from '../../infrastructure/hardware/hardware-probe.js';
 import type { HttpFetchPort, LocalZeroTierConfig } from '../../infrastructure/local/local-zero-tier.js';
@@ -20,8 +29,8 @@ import type { TriageResult, TriageVerdict } from '../triage/triage-engine.js';
 import { classifyTurnEnvelope } from '../triage/turn-envelope.js';
 import { safeCloudDefault } from './safe-default.js';
 import {
-  hasToolCallHistory,
   isGoogleGeminiProfile,
+  sessionHasGoogleReplayRiskForDeprioritize,
 } from '../routing/tool-history-guard.js';
 import {
   filterFleetByContextFit,
@@ -31,6 +40,7 @@ import {
   type ContextFitConfig,
 } from '../routing/context-fit.js';
 import type { SessionPinner } from '../pinning/session-pinner.js';
+import { evaluateModelSwitchBreakeven } from '../pinning/session-pinner.js';
 import { evaluateLoopEscalation } from '../pinning/loop-escalation.js';
 import type { LoopEscalationConfig } from '../pinning/loop-escalation.js';
 import { selectLowestCostModel } from '../pinning/sub-route-policy.js';
@@ -158,6 +168,8 @@ export interface PipelineOptions {
   /** Preloaded P(success) weights for tests; lazy-loads artifact when omitted (SP-105). */
   readonly pSuccessWeights?: PSuccessWeights;
   readonly pSuccessWeightsPath?: string;
+  /** SAAR pin policy (SP-123). Must match sessionPinner.saarConfig when enabled. */
+  readonly saarConfig?: SaarConfig;
 }
 
 // ─── Orchestrator ────────────────────────────────────────────────────────────
@@ -191,6 +203,8 @@ export class RouterPipeline {
   private currentContextFitViableCount = 0;
   private contextOverflowPreferredProvider: string | null = null;
   private contextOverflowTriggered = false;
+  /** Internal breakeven gate reason for SP-126 explain wiring. */
+  private currentBreakevenReason: string | null = null;
 
   constructor(fleet: readonly ModelProfile[], options?: PipelineOptions) {
     this.fleet = fleet;
@@ -236,6 +250,7 @@ export class RouterPipeline {
     this.currentContextFitViableCount = 0;
     this.contextOverflowPreferredProvider = null;
     this.contextOverflowTriggered = false;
+    this.currentBreakevenReason = null;
 
     let currentStage: NamedPipelineStage | undefined;
 
@@ -244,7 +259,7 @@ export class RouterPipeline {
         currentStage = stage;
         const result = await stage.run(request);
         if (result.decided && result.decision) {
-          this.persistPinIfNeeded(request, result.decision);
+          this.finalizeRoute(request, result.decision);
           this.emitTelemetry(request, result.decision);
           return this.attachFeatures(request, result.decision);
         }
@@ -257,11 +272,12 @@ export class RouterPipeline {
       this.logPipelineError(request, failedStage, error);
       this.emitPipelineErrorTelemetry(request, failedStage, fallback);
       this.persistPinIfNeeded(request, fallback);
+      this.recordSaarTurnIfNeeded(request);
       return this.attachFeatures(request, fallback);
     }
 
     const fallback = this.buildFallbackDecision(request, Date.now() - start);
-    this.persistPinIfNeeded(request, fallback);
+    this.finalizeRoute(request, fallback);
     this.emitTelemetry(request, fallback);
     return this.attachFeatures(request, fallback);
   }
@@ -280,7 +296,11 @@ export class RouterPipeline {
     }
 
     const messages = request.messages;
-    if (!messages || messages.length === 0 || !hasToolCallHistory(messages)) {
+    if (
+      !messages ||
+      messages.length === 0 ||
+      !sessionHasGoogleReplayRiskForDeprioritize(request)
+    ) {
       return fleet;
     }
 
@@ -719,12 +739,37 @@ export class RouterPipeline {
     }
 
     const existingPin = pinner.getPin(request.session_id);
-    const result = pinner.lookupPin(request, this.activeFleet);
+    const saarRequest = this.enrichRequestWithSaarCandidate(request);
+    const result = pinner.lookupPin(saarRequest, this.activeFleet);
 
     switch (result.action) {
       case 'use_pin': {
         const model = result.pinnedModel!;
         const pin = pinner.getPin(request.session_id);
+        const reasonCode =
+          result.saarReason === 'saar_hard_lock'
+            ? 'saar_hard_lock'
+            : result.saarReason === 'saar_tier_upgrade'
+              ? 'saar_tier_upgrade'
+              : 'session_pinned';
+        return {
+          decided: true,
+          stage: 'session_pin',
+          decision: this.withEstimatedCost(request, model, {
+            request_id: request.request_id,
+            selected_model_id: model.id,
+            tier: model.tier,
+            stage: 'session_pin',
+            reason_code: reasonCode,
+            routing_latency_ms: 0,
+            pin_reason: pin?.pin_reason ?? null,
+          }),
+        };
+      }
+
+      case 'saar_route': {
+        const model = result.saarRouteModel!;
+        const pin = pinner.getPin(request.session_id);
         return {
           decided: true,
           stage: 'session_pin',
@@ -733,7 +778,7 @@ export class RouterPipeline {
             selected_model_id: model.id,
             tier: model.tier,
             stage: 'session_pin',
-            reason_code: 'session_pinned',
+            reason_code: result.saarReason ?? 'saar_buffer_active',
             routing_latency_ms: 0,
             pin_reason: pin?.pin_reason ?? null,
           }),
@@ -793,6 +838,8 @@ export class RouterPipeline {
 
     if (decision.reason_code === 'tool_result_sub_route') return;
     if (decision.reason_code === 'session_pinned') return;
+    if (decision.reason_code === 'saar_buffer_active') return;
+    if (decision.reason_code === 'saar_hard_lock') return;
 
     // Turn envelope is a per-turn tier bias — do not overwrite an existing pin (SP-064).
     if (decision.stage === 'turn_envelope' && pinner.getPin(request.session_id)) return;
@@ -800,6 +847,78 @@ export class RouterPipeline {
     pinner.recordPin(request.session_id, decision.selected_model_id, 'initial');
   }
 
+  /** Persist pin updates and advance SAAR turn index after each routed turn (SP-123). */
+  private finalizeRoute(request: RoutingRequest, decision: RoutingDecision): void {
+    this.persistPinIfNeeded(request, decision);
+    this.recordSaarTurnIfNeeded(request);
+  }
+
+  private recordSaarTurnIfNeeded(request: RoutingRequest): void {
+    this.options.sessionPinner?.recordSaarTurn(request.session_id);
+  }
+
+  private enrichRequestWithSaarCandidate(request: RoutingRequest): RoutingRequest {
+    if (request.candidate_model_id) {
+      return request;
+    }
+
+    const turnType = request.turn_type ?? classifyTurnEnvelope(request.messages);
+    const targetTier = RouterPipeline.TURN_TIER_MAP[turnType] ?? null;
+    if (!targetTier) {
+      return request;
+    }
+
+    const tierCandidates = this.activeFleet.filter(
+      (m) => m.tier === targetTier && m.healthy !== false,
+    );
+    const model = selectLowestCostModel(tierCandidates);
+    if (!model) {
+      return request;
+    }
+
+    return { ...request, candidate_model_id: model.id };
+  }
+
+  private shouldDeferPlanningForSaar(request: RoutingRequest): boolean {
+    const saarConfig = this.options.saarConfig;
+    const pinner = this.options.sessionPinner;
+    if (!saarConfig || !pinner) {
+      return false;
+    }
+
+    const pin = pinner.getPin(request.session_id);
+    if (!pin) {
+      return false;
+    }
+
+    const saarState = pinner.getSaarState(request.session_id);
+    const turnIndex = saarState?.turn_index ?? 0;
+    return turnIndex >= saarConfig.planning_turn_buffer;
+  }
+
+  /**
+   * SP-123: SAAR planning buffer explicitly allows frontier planning turns
+   * without breakeven gating (#73 composes with buffer, not replaces it).
+   */
+  private isSaarPlanningBufferActive(request: RoutingRequest): boolean {
+    const saarConfig = this.options.saarConfig;
+    const pinner = this.options.sessionPinner;
+    if (!saarConfig || !pinner) {
+      return false;
+    }
+
+    if (!pinner.getPin(request.session_id)) {
+      return false;
+    }
+
+    const saarState = pinner.getSaarState(request.session_id);
+    if (!saarState) {
+      return false;
+    }
+
+    return saarState.turn_index < saarConfig.planning_turn_buffer;
+  }
+
   // ─── Turn envelope stage (Step 2b, <2ms budget) ─────────────────────────
 
   private static readonly TURN_TIER_MAP: Readonly<Record<string, Tier | null>> = {
@@ -818,6 +937,11 @@ export class RouterPipeline {
       return { decided: false, stage: 'turn_envelope' };
     }
 
+    // SP-123: post-buffer planning defers to session_pin SAAR hard-lock.
+    if (turnType === 'planning' && this.shouldDeferPlanningForSaar(request)) {
+      return { decided: false, stage: 'turn_envelope' };
+    }
+
     const tierCandidates = this.activeFleet.filter(
       (m) => m.tier === targetTier && m.healthy !== false,
     );
@@ -826,6 +950,34 @@ export class RouterPipeline {
       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,
+      );
+      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';
+        }
+      }
+    }
+
     return {
       decided: true,
       stage: 'turn_envelope',

package/src/domain/routing/tool-history-guard.ts

@@ -1,13 +1,17 @@
 /**
- * Gemini tool-history guard — SP-077.
+ * Gemini tool-history guard — SP-077, narrowed SP-129.
  *
- * Excludes Google/Gemini fleet entries when session history contains prior
- * tool calls, avoiding thought_signature 400s until pi preserves replay
- * signatures upstream (earendil-works/pi#6342).
+ * Excludes Google/Gemini fleet entries only when session history contains
+ * Google-origin assistant tool calls with replay state SP-128 repair cannot fix.
+ * OpenAI-only tool sessions may route to economical Gemini; repairable Google
+ * tool history relies on delegation replay repair instead of a blunt ban.
  */
 
 import type { Message as PiMessage } from '@earendil-works/pi-ai/compat';
 
+import {
+  isGoogleOriginAssistantMessage,
+} from '../delegation/delegation-context.js';
 import type { Message as RoutingMessage, ModelProfile, RoutingRequest } from '../types/index.js';
 
 export const GEMINI_TOOL_HISTORY_EXCLUDED = 'gemini_tool_history_excluded' as const;
@@ -105,23 +109,109 @@ export function hasToolCallHistory(
   return false;
 }
 
-function sessionHasToolCallHistory(
+/** Google-origin assistant toolCall blocks in pi-ai context (SP-127 detector). */
+export function hasGoogleReplayRiskFromContext(
+  messages: readonly PiMessage[],
+): boolean {
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+
+    if (!isGoogleOriginAssistantMessage(message)) {
+      continue;
+    }
+
+    for (const block of message.content) {
+      if (block.type === 'toolCall') {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Routing messages lack provider/api metadata, so Google-origin replay risk
+ * cannot be detected reliably — defer to contextMessages in resolveEffectiveFleet.
+ */
+export function hasGoogleReplayRisk(
+  messages: readonly RoutingMessage[],
+): boolean {
+  // Routing messages lack provider/api metadata; Google-origin detection uses contextMessages.
+  void messages;
+  return false;
+}
+
+/**
+ * Replay-sensitive state on Google-origin turns that SP-128 repair does not rewrite
+ * (redacted thinking, thinking signatures, text signatures).
+ */
+export function hasUnrepairableGoogleReplayStateFromContext(
+  messages: readonly PiMessage[],
+): boolean {
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+
+    if (!isGoogleOriginAssistantMessage(message)) {
+      continue;
+    }
+
+    for (const block of message.content) {
+      if (block.type === 'thinking') {
+        if (block.redacted) {
+          return true;
+        }
+        if (block.thinkingSignature && block.thinkingSignature.length > 0) {
+          return true;
+        }
+      }
+
+      if (block.type === 'text' && block.textSignature && block.textSignature.length > 0) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function hasUnrepairableGoogleReplayRiskFromContext(
+  messages: readonly PiMessage[],
+): boolean {
+  return (
+    hasGoogleReplayRiskFromContext(messages) &&
+    hasUnrepairableGoogleReplayStateFromContext(messages)
+  );
+}
+
+function sessionHasGoogleReplayRisk(
   request: RoutingRequest,
   contextMessages?: readonly PiMessage[],
 ): boolean {
   if (contextMessages !== undefined && contextMessages.length > 0) {
-    return hasToolCallHistoryFromContext(contextMessages);
+    return hasGoogleReplayRiskFromContext(contextMessages);
   }
 
-  if (request.messages !== undefined && request.messages.length > 0) {
-    return hasToolCallHistory(request.messages);
+  return hasGoogleReplayRisk(request.messages ?? []);
+}
+
+function sessionHasUnrepairableGoogleReplayRisk(
+  request: RoutingRequest,
+  contextMessages?: readonly PiMessage[],
+): boolean {
+  if (contextMessages !== undefined && contextMessages.length > 0) {
+    return hasUnrepairableGoogleReplayRiskFromContext(contextMessages);
   }
 
   return false;
 }
 
 /**
- * Apply Gemini exclusion when tool history is present.
+ * Apply Gemini exclusion when unrepairable Google replay risk is present.
  * Honors `force_model_id` by returning the unfiltered fleet.
  */
 export function resolveEffectiveFleet(
@@ -133,7 +223,7 @@ export function resolveEffectiveFleet(
     return { effectiveFleet: fleet, excluded: false };
   }
 
-  if (!sessionHasToolCallHistory(request, contextMessages)) {
+  if (!sessionHasUnrepairableGoogleReplayRisk(request, contextMessages)) {
     return { effectiveFleet: fleet, excluded: false };
   }
 
@@ -157,3 +247,11 @@ export function resolveEffectiveFleet(
     reasonCode: GEMINI_TOOL_HISTORY_EXCLUDED,
   };
 }
+
+/** Shared SP-129 detector for SP-080 fleet deprioritization. */
+export function sessionHasGoogleReplayRiskForDeprioritize(
+  request: RoutingRequest,
+  contextMessages?: readonly PiMessage[],
+): boolean {
+  return sessionHasGoogleReplayRisk(request, contextMessages);
+}

package/src/domain/types/entities.ts

@@ -54,6 +54,27 @@ export interface RoutingRequest {
   readonly estimated_input_tokens?: number;
 }
 
+// ─── SAAR (Session-Aware Agentic Routing, SP-121 / #72) ─────────────────────
+
+/** Operator knobs for SAAR pin policy (config surface; behavior in SP-122+). */
+export interface SaarConfig {
+  /** Turns 0..(buffer-1) may reach frontier without permanent pin overwrite. */
+  readonly planning_turn_buffer: number;
+  /** Weight applied to prefix-cache value when gating model switches (0–1). */
+  readonly prefix_cache_weight: number;
+  /** Idle seconds before SAAR reopens the routing decision. */
+  readonly idle_timeout_seconds: number;
+  /** Minimum routing score delta required to break a warm pin (0–1). */
+  readonly switch_threshold: number;
+}
+
+/** Per-session SAAR runtime state (types only; state machine in SP-122). */
+export interface SaarSessionState {
+  readonly turn_index: number;
+  readonly hard_lock: boolean;
+  readonly last_activity_at: string;
+}
+
 // ─── SessionPin ──────────────────────────────────────────────────────────────
 
 export interface SessionPin {
@@ -175,6 +196,26 @@ export interface LowIntensityBreakdown {
   readonly rejected_tiers: readonly RejectedTierEntry[];
 }
 
+/** Cache breakeven gate observability (SP-126, #73). */
+export interface BreakevenObservability {
+  readonly marginal_savings: number | null;
+  readonly future_cache_value: number | null;
+  readonly cache_reprime_cost: number | null;
+  /** `pass` when switch clears breakeven; `blocked` when gate denies. */
+  readonly decision: 'pass' | 'blocked' | null;
+  readonly breakeven_reason_code: string | null;
+}
+
+/** SAAR pin policy observability (SP-126, #72). */
+export interface SaarObservability {
+  readonly buffer_active: boolean;
+  readonly hard_lock: boolean;
+  readonly turn_index_in_session: number | null;
+  readonly planning_turn_buffer: number | null;
+  readonly idle_timeout_seconds: number | null;
+  readonly saar_reason_code: string | null;
+}
+
 /** Tier/cluster selection observability (SP-113, #62). */
 export interface TierSelectionObservability {
   readonly cluster_id: string | null;
@@ -224,6 +265,10 @@ export interface RoutingFeatureSidecar {
   readonly context_fit?: ContextFitObservability;
   /** Tier/cluster selection observability (SP-113, #62). */
   readonly tier_selection?: TierSelectionObservability;
+  /** Cache breakeven gate breakdown (SP-126, #73). */
+  readonly breakeven?: BreakevenObservability;
+  /** SAAR pin state summary (SP-126, #72). */
+  readonly saar?: SaarObservability;
   /** Why local_zero eligibility passed (SP-111, #59). */
   readonly local_eligible_reason: string | null;
 }
@@ -381,4 +426,13 @@ export interface RoutingTelemetry {
   readonly p_success_cheap: number | null;
   readonly local_eligible_reason: string | null;
   readonly tier_selection_reason_code: string | null;
+  readonly marginal_savings: number | null;
+  readonly future_cache_value: number | null;
+  readonly cache_reprime_cost: number | null;
+  readonly breakeven_decision: string | null;
+  readonly breakeven_reason_code: string | null;
+  readonly saar_buffer_active: boolean;
+  readonly saar_hard_lock: boolean;
+  readonly turn_index_in_session: number | null;
+  readonly saar_reason_code: string | null;
 }

package/src/domain/types/index.ts

@@ -1,4 +1,5 @@
 export type {
+  BreakevenObservability,
   CandidateScore,
   ClusterMatchTableEntry,
   ContextFitObservability,
@@ -23,6 +24,9 @@ export type {
   RoutingOutcomeRecord,
   RoutingRequest,
   RoutingTelemetry,
+  SaarConfig,
+  SaarObservability,
+  SaarSessionState,
   SessionPin,
   TierFeatureSummary,
   TierSelectionObservability,

package/src/domain/types/schemas.ts

@@ -241,6 +241,74 @@ export const RoutingClustersConfigSchema = z.object({
   config_path: z.string().min(1),
 });
 
+/** SAAR operator knobs (SP-121, #72). */
+export const SaarConfigSchema = z.object({
+  planning_turn_buffer: z.number().int().positive(),
+  prefix_cache_weight: z.number().min(0).max(1),
+  idle_timeout_seconds: z.number().int().positive(),
+  switch_threshold: z.number().min(0).max(1),
+});
+
+export type SaarConfig = z.infer<typeof SaarConfigSchema>;
+
+/** SAAR defaults per routing-roadmap.md §2 P0 (SP-121). */
+export const DEFAULT_SAAR_CONFIG: Readonly<SaarConfig> = {
+  planning_turn_buffer: 2,
+  prefix_cache_weight: 0.20,
+  idle_timeout_seconds: 300,
+  switch_threshold: 0.5,
+} as const;
+
+/** 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). */
+const ENV_PREFIX_CACHE_WEIGHT = 'SMART_ROUTER_PREFIX_CACHE_WEIGHT';
+/** Env: SMART_ROUTER_IDLE_TIMEOUT_SECONDS — SAAR idle reopen timeout seconds (default 300). */
+const ENV_IDLE_TIMEOUT_SECONDS = 'SMART_ROUTER_IDLE_TIMEOUT_SECONDS';
+/** Env: SMART_ROUTER_SWITCH_THRESHOLD — SAAR switch score gate 0–1 (default 0.5). */
+const ENV_SWITCH_THRESHOLD = 'SMART_ROUTER_SWITCH_THRESHOLD';
+
+function readPositiveIntEnv(name: string): number | undefined {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') {
+    return undefined;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function readUnitIntervalEnv(name: string): number | undefined {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') {
+    return undefined;
+  }
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) && parsed >= 0 && parsed <= 1 ? parsed : undefined;
+}
+
+/** Merge SAAR env overrides onto defaults (invalid env values are ignored). */
+export function resolveSaarConfigFromEnv(
+  base: SaarConfig = DEFAULT_SAAR_CONFIG,
+): SaarConfig {
+  return {
+    planning_turn_buffer:
+      readPositiveIntEnv(ENV_PLANNING_TURN_BUFFER) ?? base.planning_turn_buffer,
+    prefix_cache_weight:
+      readUnitIntervalEnv(ENV_PREFIX_CACHE_WEIGHT) ?? base.prefix_cache_weight,
+    idle_timeout_seconds:
+      readPositiveIntEnv(ENV_IDLE_TIMEOUT_SECONDS) ?? base.idle_timeout_seconds,
+    switch_threshold:
+      readUnitIntervalEnv(ENV_SWITCH_THRESHOLD) ?? base.switch_threshold,
+  };
+}
+
+/** Per-session SAAR runtime state (SP-121 types; logic in SP-122). */
+export const SaarSessionStateSchema = z.object({
+  turn_index: z.number().int().nonnegative(),
+  hard_lock: z.boolean(),
+  last_activity_at: z.string().datetime(),
+});
+
 /** Stable snake_case cluster id — used as reason-code suffix (`cluster_${id}`). */
 export const RoutingClusterIdSchema = z
   .string()
@@ -280,6 +348,7 @@ export const OperatorConfigSchema = z.object({
   local: LocalConfigSchema,
   hydra: HydraConfigSchema,
   low_intensity: LowIntensityConfigSchema,
+  saar: SaarConfigSchema,
   routing_clusters: RoutingClustersConfigSchema.optional(),
 });
 

package/src/infra/gemini-provider.ts

@@ -67,7 +67,8 @@ export function formatGeminiThoughtSignatureErrorMessage(errorMessage: string):
     summary,
     '',
     'Gemini rejected this request because a prior tool call is missing its thought_signature (protocol validation, not provider outage).',
-    'Workarounds: start a fresh session with /new, or route to a non-Google model until pi preserves thought signatures in replay.',
+    'pi-smart-router normally repairs replay state before Google delegation (thoughtSignature preservation + skip sentinel for missing signatures).',
+    'If this error persists, the session may contain unrepairable Google replay state — start a fresh session with /new, or route to a non-Google model.',
     `Docs: ${GEMINI_THOUGHT_SIGNATURE_DOCS}`,
     `Upstream: ${PI_THOUGHT_SIGNATURE_ISSUE}`,
   ].join('\n');

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

@@ -22,6 +22,10 @@ import {
   TELEMETRY_MAX_ENTRIES,
   TELEMETRY_WINDOW_MS,
 } from '../telemetry/telemetry-limits.js';
+import {
+  DEFAULT_BREAKEVEN_TELEMETRY_FIELDS,
+  DEFAULT_SAAR_TELEMETRY_FIELDS,
+} from '../telemetry/routing-telemetry.js';
 import {
   DATASET_MAX_ENTRIES,
   DATASET_WINDOW_MS,
@@ -827,6 +831,8 @@ function telemetryRowToEntity(row: TelemetryRow): RoutingTelemetry {
     p_success_cheap: null,
     local_eligible_reason: null,
     tier_selection_reason_code: null,
+    ...DEFAULT_BREAKEVEN_TELEMETRY_FIELDS,
+    ...DEFAULT_SAAR_TELEMETRY_FIELDS,
   };
 }