pi-smart-router 0.6.1 → 0.8.0

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

@@ -2,7 +2,11 @@ import {
   DEFAULT_HISTORY_LIMIT,
   MAX_HISTORY_LIMIT,
 } from '../../../src/infrastructure/telemetry/telemetry-limits.js';
-import type { RoutingDecision, RoutingTelemetry } from '../../../src/domain/types/index.js';
+import type {
+  ModelProfile,
+  RoutingDecision,
+  RoutingTelemetry,
+} from '../../../src/domain/types/index.js';
 import { SMART_ROUTER_USAGE } from './commands.js';
 import {
   DEFAULT_TELEMETRY_CONTRIB_EXPORT_LIMIT,
@@ -15,6 +19,78 @@ import {
 import { formatPricingStalenessLine } from './pricing-lifecycle.js';
 import type { FleetMode, SmartRouterCommand, SmartRouterRuntime } from './types.js';
 
+/** Opaque / virtual auto ids that hide the concrete delegated fleet model (SP-178). */
+function isBareOrSmartRouterAuto(modelId: string): boolean {
+  return modelId === 'auto' || modelId === 'smart-router/auto';
+}
+
+/**
+ * Resolve the operator-facing model id for history/status (SP-178 / #99).
+ * Prefer a concrete delegated/primary id over virtual `auto`.
+ */
+export function resolveHistoryModelId(
+  entry: Pick<
+    RoutingTelemetry,
+    | 'selected_model_id'
+    | 'planning_delegate_primary_model_id'
+    | 'planning_delegate_model_id'
+  >,
+  fleet?: readonly ModelProfile[],
+): string {
+  let modelId = entry.selected_model_id;
+
+  if (isBareOrSmartRouterAuto(modelId)) {
+    const primary = entry.planning_delegate_primary_model_id;
+    if (primary && !isBareOrSmartRouterAuto(primary)) {
+      modelId = primary;
+    } else if (
+      entry.planning_delegate_model_id &&
+      !isBareOrSmartRouterAuto(entry.planning_delegate_model_id)
+    ) {
+      modelId = entry.planning_delegate_model_id;
+    }
+  }
+
+  return qualifyModelIdForDisplay(modelId, fleet);
+}
+
+/**
+ * Qualify bare `auto` with provider when fleet is available so history never
+ * looks like the smart-router virtual model.
+ */
+export function qualifyModelIdForDisplay(
+  modelId: string,
+  fleet?: readonly ModelProfile[],
+): string {
+  if (modelId !== 'auto') {
+    return modelId;
+  }
+
+  const profile = fleet?.find((m) => m.id === 'auto');
+  if (profile) {
+    return `${profile.provider}/${profile.id}`;
+  }
+
+  // Cursor opaque auto is the common bare-`auto` fleet id; never leave it unqualified.
+  return 'cursor/auto';
+}
+
+export function resolveStatusModelId(
+  decision: RoutingDecision,
+  fleet?: readonly ModelProfile[],
+): string {
+  const primary = decision.features?.planning_delegate?.primary_model_id ?? null;
+  const delegate = decision.features?.planning_delegate?.delegate_model_id ?? null;
+  return resolveHistoryModelId(
+    {
+      selected_model_id: decision.selected_model_id,
+      planning_delegate_primary_model_id: primary,
+      planning_delegate_model_id: delegate,
+    },
+    fleet,
+  );
+}
+
 export function parseHistoryLimit(raw: string | undefined): number {
   if (raw === undefined) {
     return DEFAULT_HISTORY_LIMIT;
@@ -142,8 +218,9 @@ export function formatStatusMessage(
     return lines.join('\n');
   }
 
+  const displayModelId = resolveStatusModelId(decision, runtime.streamDeps.fleet);
   lines.push(
-    `Model: ${decision.selected_model_id}`,
+    `Model: ${displayModelId}`,
     `Stage: ${decision.stage}`,
     `Reason: ${decision.reason_code}`,
     `Latency: ${decision.routing_latency_ms}ms`,
@@ -151,16 +228,20 @@ export function formatStatusMessage(
   return lines.join('\n');
 }
 
-export function formatHistoryMessage(entries: readonly RoutingTelemetry[]): string {
+export function formatHistoryMessage(
+  entries: readonly RoutingTelemetry[],
+  options?: { fleet?: readonly ModelProfile[] },
+): string {
   if (entries.length === 0) {
     return 'No routing history yet.';
   }
 
+  const fleet = options?.fleet;
   return entries
-    .map(
-      (entry) =>
-        `${entry.timestamp} | ${entry.selected_model_id} | ${entry.stage} | ${entry.turn_type} | ${entry.routing_latency_ms}ms`,
-    )
+    .map((entry) => {
+      const modelId = resolveHistoryModelId(entry, fleet);
+      return `${entry.timestamp} | ${modelId} | ${entry.stage} | ${entry.turn_type} | ${entry.routing_latency_ms}ms`;
+    })
     .join('\n');
 }
 

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

@@ -160,7 +160,10 @@ export function registerSmartRouterCommand(
           throwIfCommandAborted(signal);
           const rows = await runtime.store.listTelemetry({ limit: parsed.limit });
           throwIfCommandAborted(signal);
-          ctx.ui.notify(formatHistoryMessage(rows), 'info');
+          ctx.ui.notify(
+            formatHistoryMessage(rows, { fleet: runtime.streamDeps.fleet }),
+            'info',
+          );
           return;
         }
 

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

@@ -4,8 +4,8 @@ import {
   type ExtensionAPI,
 } from '@earendil-works/pi-coding-agent';
 
+import { resolveOperatorConfigFromEnv } from '../../../src/config/defaults.js';
 import { ExecutionLedger } from '../../../src/domain/delegation/execution-ledger.js';
-import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import type { SessionRoutingSnapshot } from '../../../src/infrastructure/telemetry/outcome-recorder.js';
 import { createRouterFromFleet, LifecycleHookState } from '../../../src/index.js';
 
@@ -14,7 +14,11 @@ import {
   createExtensionDatasetRecorder,
   createExtensionOutcomeRecorder,
 } from './dataset-export.js';
-import { createDispatchOptions, initHydraMatcher } from './fleet-bootstrap.js';
+import {
+  createDispatchOptions,
+  createOperatorAwareSessionPinner,
+  initHydraMatcher,
+} from './fleet-bootstrap.js';
 import { setupSessionHooks } from './session-lifecycle.js';
 import { createStreamSimple } from './stream-delegation.js';
 import type { SmartRouterRuntime } from './types.js';
@@ -35,7 +39,8 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
   const modelRegistry = ModelRegistry.inMemory(authStorage);
   const hydraMatcher = await initHydraMatcher();
   const store = createExtensionStore(cwd);
-  const sessionPinner = new SessionPinner({ store });
+  const operatorConfig = resolveOperatorConfigFromEnv();
+  const sessionPinner = createOperatorAwareSessionPinner(store, operatorConfig);
   const executionLedger = new ExecutionLedger();
   const lifecycleHookState = new LifecycleHookState();
   const datasetNotify: DatasetNotify = {
@@ -62,7 +67,9 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
     sessionRouting,
     streamDeps: {
       router: createRouterFromFleet([], {
-        ...createDispatchOptions(store, sessionPinner, hydraMatcher),
+        ...createDispatchOptions(store, sessionPinner, hydraMatcher, {
+          operatorConfig,
+        }),
         lifecycleHookState,
       }),
       modelRegistry,

package/.pi/extensions/smart-router/fleet-bootstrap.ts

@@ -6,13 +6,18 @@ import {
 } from '@earendil-works/pi-coding-agent';
 
 import { mapFleetFromRegistry } from '../../../src/config/pi-model-mapper.js';
-import { DEFAULT_OPERATOR_CONFIG } from '../../../src/config/defaults.js';
+import {
+  DEFAULT_OPERATOR_CONFIG,
+  resolveOperatorConfigFromEnv,
+} from '../../../src/config/defaults.js';
 import {
   HydraMatcher,
   createOnnxEmbeddingProvider,
 } from '../../../src/domain/matching/hydra-matcher.js';
 import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import type { ModelProfile, PriceCatalog } from '../../../src/domain/types/index.js';
+import type { QuotaWindowPosition } from '../../../src/domain/types/entities.js';
+import type { OperatorConfig } from '../../../src/domain/types/schemas.js';
 import type { StorePort } from '../../../src/domain/types/store-port.js';
 import { getDefaultSystemInfo } from '../../../src/infrastructure/hardware/hardware-probe.js';
 import { DEFAULT_LOCAL_CONFIG } from '../../../src/infrastructure/local/local-zero-tier.js';
@@ -27,6 +32,16 @@ import { resolveModelScope } from './pi-model-scope.js';
 import type { FleetMode, SmartRouterRuntime } from './types.js';
 import { resolveRateLimiter } from './utils.js';
 
+/** Optional overrides for extension dispatch wiring (SP-173). */
+export interface CreateDispatchOptionsExtras {
+  /** Base operator config before env merge; defaults to DEFAULT_OPERATOR_CONFIG. */
+  readonly operatorConfig?: OperatorConfig;
+  /** Live price catalog when fleet discovery has loaded one. */
+  readonly priceCatalog?: PriceCatalog | null;
+  /** Rolling subscription quota position when available. */
+  readonly quotaWindowPosition?: QuotaWindowPosition;
+}
+
 /** Minimal settings surface used for scoped fleet discovery. */
 export interface ScopedSettingsReader {
   getEnabledModels(): string[] | null | undefined;
@@ -152,26 +167,58 @@ export function createDispatchOptions(
   store: StorePort,
   sessionPinner: SessionPinner,
   hydraMatcher?: HydraMatcher,
+  extras?: CreateDispatchOptionsExtras,
 ): GatewayDispatchOptions {
+  const operatorConfig = resolveOperatorConfigFromEnv(
+    extras?.operatorConfig ?? DEFAULT_OPERATOR_CONFIG,
+  );
   const telemetryEmitter = new RoutingTelemetryEmitter({
     onRecord: (record) => {
       store.appendTelemetry(record);
     },
+    sessionPinner,
+    saarConfig: operatorConfig.saar,
+    ...(extras?.priceCatalog !== undefined ? { priceCatalog: extras.priceCatalog } : {}),
+    ...(extras?.quotaWindowPosition !== undefined
+      ? { quotaWindowPosition: extras.quotaWindowPosition }
+      : {}),
   });
   const rateLimiter = resolveRateLimiter(store);
 
   return {
     sessionPinner,
-    hardwareConfig: DEFAULT_OPERATOR_CONFIG.local,
+    hardwareConfig: operatorConfig.local,
     systemInfoProvider: getDefaultSystemInfo,
     localConfig: DEFAULT_LOCAL_CONFIG,
-    loopEscalationConfig: DEFAULT_OPERATOR_CONFIG.loop_escalation,
+    loopEscalationConfig: operatorConfig.loop_escalation,
+    saarConfig: operatorConfig.saar,
+    planningDelegateConfig: operatorConfig.planning_delegate,
+    pinOnlyFallback: operatorConfig.pin_only_fallback,
+    ...(extras?.priceCatalog !== undefined ? { priceCatalog: extras.priceCatalog } : {}),
+    ...(extras?.quotaWindowPosition !== undefined
+      ? { quotaWindowPosition: extras.quotaWindowPosition }
+      : {}),
     ...(hydraMatcher ? { hydraMatcher } : {}),
     ...(rateLimiter ? { rateLimiter } : {}),
     telemetryEmitter,
   };
 }
 
+/**
+ * Build a SessionPinner wired with operator SAAR / pin-only settings (SP-173).
+ * No operator-config.json loader exists yet — env + optional base config only.
+ */
+export function createOperatorAwareSessionPinner(
+  store: StorePort,
+  operatorConfig: OperatorConfig = resolveOperatorConfigFromEnv(),
+): SessionPinner {
+  return new SessionPinner({
+    store,
+    saarConfig: operatorConfig.saar,
+    pinOnlyFallback: operatorConfig.pin_only_fallback,
+  });
+}
+
 export async function rebuildFleet(
   runtime: SmartRouterRuntime,
   pi: ExtensionAPI,
@@ -189,7 +236,9 @@ export async function rebuildFleet(
   runtime.priceCatalog = catalog;
   runtime.fleetScopeFingerprint = fingerprint;
   const router = createRouterFromFleet(fleet, {
-    ...createDispatchOptions(runtime.store, runtime.sessionPinner, runtime.hydraMatcher),
+    ...createDispatchOptions(runtime.store, runtime.sessionPinner, runtime.hydraMatcher, {
+      priceCatalog: catalog,
+    }),
     lifecycleHookState: runtime.lifecycleHookState,
   });
   router.register(createHooksAdapter(pi));

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

@@ -24,6 +24,7 @@ import {
 } from './dataset-export.js';
 import {
   createDispatchOptions,
+  createOperatorAwareSessionPinner,
   discoverFleet,
   formatLmuStatus,
   initHydraMatcher,
@@ -37,6 +38,8 @@ import {
   formatHistoryMessage,
   formatStatusMessage,
   parseSmartRouterArgs,
+  resolveHistoryModelId,
+  qualifyModelIdForDisplay,
 } from './command-formatters.js';
 import { formatPricingStalenessLine, refreshPricingCatalog } from './pricing-lifecycle.js';
 import {
@@ -62,6 +65,7 @@ export {
   createDispatchOptions,
   createExtensionDatasetRecorder,
   createExtensionOutcomeRecorder,
+  createOperatorAwareSessionPinner,
   createSmartRouterRuntime,
   createStreamSimple,
   deriveTurnType,
@@ -85,8 +89,10 @@ export {
   getSmartRouterArgumentCompletions,
   mapContextMessages,
   parseSmartRouterArgs,
+  qualifyModelIdForDisplay,
   refreshPricingCatalog,
   resolveDelegationOptions,
+  resolveHistoryModelId,
   logRoutingDecision,
   toDatasetExportRecord,
   capturePreRouteOutcomes,

package/README.md

@@ -197,7 +197,7 @@ Cursor models bill against your **Cursor Pro subscription quota**, not per-token
 |---------|---------|
 | `/smart-router` | Same as `status` (default when no subcommand is given) |
 | `/smart-router status` | Show fleet mode, fleet size, pricing freshness/staleness, and the last routing decision (stage, tier, selected model, latency) |
-| `/smart-router history` | Show recent routing telemetry from SQLite (default limit; optional numeric limit, e.g. `/smart-router history 20`) |
+| `/smart-router history` | Show recent routing telemetry from SQLite (default limit; optional numeric limit, e.g. `/smart-router history 20`). Displays the concrete delegated model id (never bare virtual `auto`) |
 | `/smart-router mode scoped` | Route only among pi's **enabled model patterns** (default) |
 | `/smart-router mode all` | Route among **all authenticated models** in the registry |
 | `/smart-router pricing refresh` | Manually fetch LiteLLM pricing from `LITELLM_PRICING_URL`, persist to SQLite, and rebuild the fleet with updated rates |
@@ -339,7 +339,7 @@ Cluster IDs are stable reason-code prefixes (`cluster_low_stakes_general`, `clus
 | Variable | Default | Purpose |
 |----------|---------|---------|
 | `ROUTER_STATE_DB_PATH` | `./.pi-smart-router/state.db` | Override SQLite state store location (telemetry, pricing catalog, session data) |
-| `SMART_ROUTER_LOG_ROUTING` | (unset) | Set to `1` to log each routing decision to stderr as JSON (debugging dogfood sessions) |
+| `SMART_ROUTER_LOG_ROUTING` | (unset) | Set to `1` to log each routing decision to stderr as JSON (debugging dogfood sessions). Canonical payload builder (`buildRoutingDecisionLogPayload`) includes top-level `stage`, `reason_code`, `low_intensity_score`, `tier_hint`, `local_eligible_reason`, and `cluster_id` (plus nested `cluster_summary` / `features`). The pi extension’s live stderr logger is still a slim subset — see [LOG_ROUTING field checklist](#log_routing-field-checklist) |
 | `SMART_ROUTER_DATASET` | (unset) | Set to `1` to opt in to privacy-safe routing dataset capture (metadata and feature fields only; 30-day / 10k-row retention). Prompt text, messages, and tool arguments are never stored. Required for outcome labels and P(success) training export. See [#8](https://github.com/beettlle/pi-smart-router/issues/8). |
 | `SMART_ROUTER_DATASET_FINGERPRINT` | (unset) | Set to `1` (requires `SMART_ROUTER_DATASET=1`) to store an install-local HMAC-SHA256 fingerprint of each normalized prompt for duplicate detection within this install. The install pepper lives in `.pi-smart-router/.dataset-key` (gitignored) and is never exported. **Warning:** short or common prompts are vulnerable to offline rainbow-table guessing; use only when you accept that tradeoff. See [#10](https://github.com/beettlle/pi-smart-router/issues/10). |
 | `MODELS_YAML_PATH` | `./config/models.yaml` | Fleet catalog path (library API only) |
@@ -354,6 +354,23 @@ Cluster IDs are stable reason-code prefixes (`cluster_low_stakes_general`, `clus
 | `ROUTER_SAFE_DEFAULT_TIER` | `economical-cloud` | Fallback tier on any routing failure |
 | `LITELLM_PRICING_URL` | — | LiteLLM pricing JSON source |
 
+### LOG_ROUTING field checklist
+
+When `SMART_ROUTER_LOG_ROUTING=1`, prefer the canonical payload from `buildRoutingDecisionLogPayload` (library / tests). Checklist for [#99](https://github.com/beettlle/pi-smart-router/issues/99):
+
+| Field | In payload builder? | Notes |
+|-------|---------------------|-------|
+| `stage` | Yes (top-level) | Pipeline stage that decided |
+| `reason_code` | Yes (top-level) | Machine-readable reason |
+| `low_intensity_score` | Yes (top-level + `cluster_summary`) | Null when low-intensity stage did not run |
+| `tier_hint` | Yes (top-level + `cluster_summary`) | Null when no tier hint |
+| `local_eligible_reason` | Yes (top-level + `features`) | Null when local_zero did not evaluate eligibility |
+| `cluster_id` | Yes (top-level + `cluster_summary`) | Null when no cluster match |
+
+**Gap:** the pi extension’s live stderr path (`logRoutingDecision` in `.pi/extensions/smart-router`) still emits a slim JSON object (`selected_model_id`, `stage`, `reason_code`, `features`, `delegate`) and does **not** yet call `buildRoutingDecisionLogPayload`. SQLite `/smart-router history` and the payload builder carry the full checklist; wire the extension logger in a follow-up if dogfood needs identical stderr shape.
+
+**History model id:** `/smart-router history` resolves bare/`smart-router` virtual `auto` to the concrete planning-delegate primary (or qualifies Cursor opaque `auto` as `cursor/auto`) so operators see the delegated fleet model, not the virtual router id.
+
 ### SAAR session pin and cache breakeven (v0.2.0 Continuity)
 
 v0.2.0 adds **Session-Aware Agentic Routing (SAAR)** pin knobs ([#72](https://github.com/beettlle/pi-smart-router/issues/72)) and a **cache breakeven gate** ([#73](https://github.com/beettlle/pi-smart-router/issues/73)) that blocks tier switches when `marginal_savings + future_cache_value <= cache_reprime_cost` — preventing cheap-turn savings from invalidating a warm prefix cache.
@@ -464,12 +481,40 @@ When `SMART_ROUTER_DATASET=1`, the router records privacy-safe dataset rows and
 
 Each JSONL row joins dataset features with `success_label` and `outcome_signals`. Success means no negative outcome signals were recorded for that `request_id` (for example `model_override` or `feedback_bad` mark failure). Prompt plaintext is never included.
 
-Train a baseline logistic scorer offline from the export (see `src/domain/routing/p-success-classifier.ts`):
+**Dogfood artifact (SP-175):** the repo ships a non-example `config/p-success-weights.json` trained on the synthetic fixture at `scripts/fixtures/p-success-synthetic-train.jsonl` (**provenance: synthetic/fixture**, not community contrib — 40 labeled feature-vector rows, no prompt text). With `trained_sample_count ≥ 30`, the low-intensity gate uses trained logistic scores instead of neutral `0.5`. Missing or invalid artifacts still fall back safely to neutral defaults.
+
+**Operator train / reload (no prompt text):**
+
+```bash
+# 1) Opt in + dogfood, then export privacy-safe labeled JSONL (features + labels only)
+SMART_ROUTER_DATASET=1
+# …run sessions with /model smart-router/auto and /smart-router feedback…
+/smart-router export dataset --limit 200
+
+# 2) Train standalone weights (≥30 labeled rows required)
+npm run routing:train-p-success -- --input path/to/export.jsonl --output config/p-success-weights.json
+
+# Or regenerate the checked-in dogfood weights from the synthetic fixture:
+npm run routing:train-p-success
+
+# 3) Optional: merge isotonic into an existing calibration bundle (does not rewrite hydra/centroids)
+npm run routing:train-p-success -- --input path/to/export.jsonl \
+  --calibration-output config/routing-calibration.json
+
+# Full Phase-3 bundle (also refreshes standalone p-success-weights.json when the gate is met):
+npm run routing:train-calibration -- --input path/to/aggregated.jsonl
+```
+
+Reload is file-based: replace `config/p-success-weights.json` (and optionally `config/routing-calibration.json` for isotonic) and restart the host agent — no prompt text is ever written into training artifacts.
+
+**Isotonic gap:** serve-time isotonic calibration loads from `config/routing-calibration.json` (`isotonic_calibrator`). The checked-in dogfood path ships trained **logistic** weights only; isotonic is produced when you pass `--calibration-output` or run `routing:train-calibration` with ≥30 labeled samples. Until that bundle exists, the pipeline uses raw logistic `P(success)` (identity / no-op calibrator) and still exposes `p_success_raw` vs `p_success_calibrated` / `p_success_cheap` on explain and telemetry.
+
+Library helpers (see `src/domain/routing/p-success-classifier.ts`):
 
 - `trainFromExportJsonl(exportContent)` — fit coefficients from labeled JSONL
 - `predictPSuccessCheap(features, weights)` — returns `P_success_cheap` in `[0, 1]`
 
-Copy `config/p-success-weights.json.example` to `config/p-success-weights.json` and replace coefficients after training. **Minimum sample guidance:** collect at least **30** labeled economical-tier rows before relying on non-neutral predictions; below that threshold the classifier returns neutral `P_success_cheap = 0.5`. **Online inference** is active in the low-intensity gate; without trained weights the router uses neutral defaults until you add `config/p-success-weights.json`.
+**Minimum sample guidance:** collect at least **30** labeled economical-tier rows before relying on non-neutral predictions; below that threshold the classifier returns neutral `P_success_cheap = 0.5`. **Online inference** is active in the low-intensity gate; without trained weights the router uses neutral defaults until you add `config/p-success-weights.json`.
 
 ### Community telemetry contribution (calibration)
 
@@ -539,8 +584,10 @@ Additional operator defaults:
 
 | Key | Default | Purpose |
 |-----|---------|---------|
-| `loop_escalation.threshold` | 3 | Consecutive identical failures before escalating to frontier |
+| `loop_escalation.threshold` | 3 | Consecutive identical failures before escalating to frontier. Also used as the default **zero-tier tool-call churn** threshold (SP-178 / [#99](https://github.com/beettlle/pi-smart-router/issues/99)): while pinned to `zero-tier`, unsupported/unknown tool results escalate immediately, and N `tool_result` turns escalate via the same `loop_escalation` pin path (FR-014) — not a cache-breakeven bypass |
 | `pin_only_fallback` | `false` | Emergency pin-on-first-turn mode — see [Pin-only emergency fallback](#pin-only-emergency-fallback) |
+| `local_zero.enabled` | `true` | When `false`, skip `local_zero` dispatch (fall through to later stages). Default keeps the cheap local path for true trivial traffic |
+| `local_zero.max_tool_use_requirement` | `0.25` | Ceiling (0–1) on cheap predicted tool_use for `local_zero`. Effective limit is `min(local model tool_use, this value)`. Skips agentic git/bash/edit/explore/delete/repo cues with telemetry reason `tool_use_capability_shortfall` (SP-177 / [#98](https://github.com/beettlle/pi-smart-router/issues/98)) |
 | `local.min_memory_gb_full` | 16 | Minimum RAM for full local inference |
 | `local.battery_threshold_pct` | 20 | Minimum battery to allow local inference |
 | `pricing.staleness_days` | 14 | Max age before re-fetching pricing data |
@@ -744,6 +791,7 @@ Contributors must run `npm run build` before publishing or consuming the library
 | `npm run routing:bootstrap-centroids` | Regenerate `config/routing-centroids.json` from cluster catalog |
 | `npm run routing:calibration-aggregate` | Aggregate community telemetry for calibration |
 | `npm run routing:train-calibration` | Train routing calibration artifact bundle |
+| `npm run routing:train-p-success` | Train standalone `config/p-success-weights.json` (synthetic fixture by default) |
 | `npm run routing:verify-calibration` | Verify calibration bundle against benchmark prompts |
 | `npm run routing:ingest-benchmarks` | Regenerate `config/benchmark-profiles.json` from leaderboard fixtures |
 | `npm run routing:verify-benchmark-profiles` | CI smoke: assert checked-in profiles match fixture ingest |
@@ -782,6 +830,16 @@ npm run routing:eval-replay
 
 Capability scores in `config/benchmark-profiles.json` are grounded from public leaderboard snapshots under `tests/fixtures/benchmark-leaderboards/`. Each artifact records provenance (`source_urls`, `scrape_date`, `catalog_freeze_date`) in its header.
 
+**Fleet ID aliases (SP-174):** live pi/Cursor scoped-fleet model IDs often differ from leaderboard `model_id` strings. The artifact’s optional `aliases` map sends those fleet IDs to an existing grounded row (never invents scores). `mapPiModelToProfile` sets `capability_source` to `benchmark` when a direct row or alias hits, otherwise `pattern_default`. Operators can also call `getCapabilitySource(modelId)` / `resolveBenchmarkModelId(modelId)`.
+
+**Add a new fleet ID after ingest:**
+
+1. Ensure the canonical model has fixture scores (edit `tests/fixtures/benchmark-leaderboards/*.json` if needed).
+2. Run `npm run routing:ingest-benchmarks` (and commit the regenerated `config/benchmark-profiles.json`).
+3. Add `"your-fleet-id": "canonical-model_id"` under `aliases` in `config/benchmark-profiles.json` (target must already appear in `models[].model_id`).
+4. Re-run ingest anytime — the CLI **preserves** existing `aliases` from the output file. Seed defaults live in `DEFAULT_FLEET_BENCHMARK_ALIASES` when no prior artifact exists.
+5. Confirm with `npm run routing:verify-benchmark-profiles` and a mapper unit test that `capability_source === 'benchmark'` for the fleet id.
+
 **Operator policy:**
 
 1. **PR smoke** — `.github/workflows/benchmark-profile-refresh.yml` runs on PRs that touch fixtures, ingest, or the checked-in artifact. It executes `npm run routing:verify-benchmark-profiles` so fixture edits cannot drift from `config/benchmark-profiles.json`.

package/config/benchmark-profiles.json

@@ -10,6 +10,28 @@
     "scrape_date": "2026-07-09",
     "catalog_freeze_date": "2026-07-09"
   },
+  "aliases": {
+    "claude-3-5-sonnet": "claude-sonnet-4-6",
+    "claude-3.5-sonnet": "claude-sonnet-4-6",
+    "claude-3.5-sonnet-latest": "claude-sonnet-4-6",
+    "claude-opus-4": "claude-opus-4-5",
+    "claude-opus-4-20250514": "claude-opus-4-5",
+    "claude-sonnet-4": "claude-sonnet-4-6",
+    "claude-sonnet-4-20250514": "claude-sonnet-4-6",
+    "composer-1": "gpt-5.3-codex",
+    "composer-latest": "gpt-5.3-codex",
+    "cursor/auto": "gpt-5.3-codex",
+    "cursor/composer-latest": "gpt-5.3-codex",
+    "default": "gpt-5.3-codex",
+    "gemini-2.0-flash": "gemini-2.5-flash",
+    "gemini-2.5-flash-lite": "gemini-2.5-flash",
+    "gemini-2.5-flash-preview": "gemini-2.5-flash",
+    "gemini-flash-latest": "gemini-2.5-flash",
+    "gpt-5": "gpt-5.3-codex",
+    "gpt-5-codex": "gpt-5.3-codex",
+    "gpt-5.3": "gpt-5.3-codex",
+    "gpt-5.5": "gpt-5.3-codex"
+  },
   "models": [
     {
       "model_id": "claude-3.5-haiku",

package/config/operator-config.json.example

@@ -60,5 +60,13 @@
       "exclude_execution_history": true
     }
   },
+  "local_zero": {
+    "enabled": true,
+    "max_tool_use_requirement": 0.25,
+    "_documentation": {
+      "enabled": "When false, skip local_zero entirely (fall through to triage cloud / HyDRA). Default true — does not disable local for trivial traffic.",
+      "max_tool_use_requirement": "Ceiling (0–1) on cheap predicted tool_use for local_zero dispatch. Effective limit is min(local model tool_use capability, this value). Default 0.25 keeps format/lint local while skipping agentic git/bash/edit/explore/delete/repo cues (SP-177, #98)."
+    }
+  },
   "pin_only_fallback": false
 }

package/config/p-success-weights.json

@@ -0,0 +1,36 @@
+{
+  "version": 1,
+  "min_training_samples": 30,
+  "feature_names": [
+    "prompt_length_norm",
+    "estimated_input_tokens_norm",
+    "triage_cyclomatic_score",
+    "requirement_reasoning",
+    "requirement_code_gen",
+    "requirement_tool_use",
+    "has_tool_context",
+    "compaction_flag",
+    "routing_latency_norm",
+    "economical_tier"
+  ],
+  "intercept": 4.101841550841884,
+  "coefficients": [
+    -3.9458158506645473,
+    -3.9458158506645473,
+    -4.6221357618419106,
+    -4.702014247565688,
+    -1.9442887494123497,
+    -2.945430358303044,
+    -2.8373347243581435,
+    0,
+    0.09441030879566878,
+    4.101841550841884
+  ],
+  "trained_sample_count": 40,
+  "provenance": {
+    "source": "synthetic_fixture",
+    "task": "SP-175",
+    "note": "Privacy-safe feature vectors + labels only; no prompt text.",
+    "trained_at": "2026-07-10"
+  }
+}

package/config/p-success-weights.json.example

@@ -15,5 +15,8 @@
   ],
   "intercept": 0,
   "coefficients": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  "trained_sample_count": 0
+  "trained_sample_count": 0,
+  "provenance": {
+    "note": "Untrained template. Prefer npm run routing:train-p-success (or copy from config/p-success-weights.json after training). Never commit prompt text."
+  }
 }

package/dist/config/defaults.d.ts

@@ -3,7 +3,7 @@
  * Values sourced from specs/001-build-smart-router/data-model.md § Configuration (Operator).
  */
 import { type OperatorConfig } from '../domain/types/schemas.js';
-export { DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv } from '../domain/types/schemas.js';
+export { DEFAULT_LOCAL_ZERO_CONFIG, DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv, } from '../domain/types/schemas.js';
 /** Merge operator env overrides onto defaults (SAAR and planning delegate sections). */
 export declare function resolveOperatorConfigFromEnv(base?: OperatorConfig): OperatorConfig;
 export declare const DEFAULT_OPERATOR_CONFIG: Readonly<OperatorConfig>;

package/dist/config/defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,gCAAgC,EAAE,mBAAmB,EAAE,oCAAoC,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEnK,wFAAwF;AACxF,wBAAgB,4BAA4B,CAC1C,IAAI,GAAE,cAAwC,GAC7C,cAAc,CAMhB;AAED,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,cAAc,CA+BnD,CAAC"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,mBAAmB,EACnB,oCAAoC,EACpC,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AAEpC,wFAAwF;AACxF,wBAAgB,4BAA4B,CAC1C,IAAI,GAAE,cAAwC,GAC7C,cAAc,CAMhB;AAED,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,cAAc,CAgCnD,CAAC"}

package/dist/config/defaults.js

@@ -2,9 +2,9 @@
  * Operator configuration defaults (FR-021).
  * Values sourced from specs/001-build-smart-router/data-model.md § Configuration (Operator).
  */
-import { DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv, } from '../domain/types/schemas.js';
+import { DEFAULT_LOCAL_ZERO_CONFIG, DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv, } from '../domain/types/schemas.js';
 import { DEFAULT_LOW_INTENSITY_WEIGHTS } from '../domain/routing/tier-features.js';
-export { DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv } from '../domain/types/schemas.js';
+export { DEFAULT_LOCAL_ZERO_CONFIG, DEFAULT_PLANNING_DELEGATE_CONFIG, DEFAULT_SAAR_CONFIG, resolvePlanningDelegateConfigFromEnv, resolveSaarConfigFromEnv, } from '../domain/types/schemas.js';
 /** Merge operator env overrides onto defaults (SAAR and planning delegate sections). */
 export function resolveOperatorConfigFromEnv(base = DEFAULT_OPERATOR_CONFIG) {
     return {
@@ -43,6 +43,7 @@ export const DEFAULT_OPERATOR_CONFIG = {
     },
     saar: DEFAULT_SAAR_CONFIG,
     planning_delegate: DEFAULT_PLANNING_DELEGATE_CONFIG,
+    local_zero: DEFAULT_LOCAL_ZERO_CONFIG,
     pin_only_fallback: false,
 };
 //# sourceMappingURL=defaults.js.map

package/dist/config/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gCAAgC,EAChC,mBAAmB,EACnB,oCAAoC,EACpC,wBAAwB,GAEzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAEnF,OAAO,EAAE,gCAAgC,EAAE,mBAAmB,EAAE,oCAAoC,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEnK,wFAAwF;AACxF,MAAM,UAAU,4BAA4B,CAC1C,OAAuB,uBAAuB;IAE9C,OAAO;QACL,GAAG,IAAI;QACP,IAAI,EAAE,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC;QACzC,iBAAiB,EAAE,oCAAoC,CAAC,IAAI,CAAC,iBAAiB,CAAC;KAChF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,uBAAuB,GAA6B;IAC/D,SAAS,EAAE;QACT,WAAW,EAAE,GAAG;QAChB,cAAc,EAAE,GAAG;QACnB,gBAAgB,EAAE,IAAI;KACvB;IACD,eAAe,EAAE;QACf,SAAS,EAAE,CAAC;KACb;IACD,OAAO,EAAE;QACP,cAAc,EAAE,EAAE;KACnB;IACD,KAAK,EAAE;QACL,kBAAkB,EAAE,EAAE;QACtB,4BAA4B,EAAE,CAAC;QAC/B,qBAAqB,EAAE,EAAE;KAC1B;IACD,KAAK,EAAE;QACL,mBAAmB,EAAE,0BAA0B;QAC/C,OAAO,EAAE,QAAQ;QACjB,WAAW,EAAE,oBAAoB;KAClC;IACD,aAAa,EAAE;QACb,OAAO,EAAE,6BAA6B;QACtC,cAAc,EAAE,IAAI;QACpB,aAAa,EAAE,IAAI;QACnB,eAAe,EAAE,GAAG;KACrB;IACD,IAAI,EAAE,mBAAmB;IACzB,iBAAiB,EAAE,gCAAgC;IACnD,iBAAiB,EAAE,KAAK;CAChB,CAAC"}
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,mBAAmB,EACnB,oCAAoC,EACpC,wBAAwB,GAEzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAEnF,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,mBAAmB,EACnB,oCAAoC,EACpC,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AAEpC,wFAAwF;AACxF,MAAM,UAAU,4BAA4B,CAC1C,OAAuB,uBAAuB;IAE9C,OAAO;QACL,GAAG,IAAI;QACP,IAAI,EAAE,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC;QACzC,iBAAiB,EAAE,oCAAoC,CAAC,IAAI,CAAC,iBAAiB,CAAC;KAChF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,uBAAuB,GAA6B;IAC/D,SAAS,EAAE;QACT,WAAW,EAAE,GAAG;QAChB,cAAc,EAAE,GAAG;QACnB,gBAAgB,EAAE,IAAI;KACvB;IACD,eAAe,EAAE;QACf,SAAS,EAAE,CAAC;KACb;IACD,OAAO,EAAE;QACP,cAAc,EAAE,EAAE;KACnB;IACD,KAAK,EAAE;QACL,kBAAkB,EAAE,EAAE;QACtB,4BAA4B,EAAE,CAAC;QAC/B,qBAAqB,EAAE,EAAE;KAC1B;IACD,KAAK,EAAE;QACL,mBAAmB,EAAE,0BAA0B;QAC/C,OAAO,EAAE,QAAQ;QACjB,WAAW,EAAE,oBAAoB;KAClC;IACD,aAAa,EAAE;QACb,OAAO,EAAE,6BAA6B;QACtC,cAAc,EAAE,IAAI;QACpB,aAAa,EAAE,IAAI;QACnB,eAAe,EAAE,GAAG;KACrB;IACD,IAAI,EAAE,mBAAmB;IACzB,iBAAiB,EAAE,gCAAgC;IACnD,UAAU,EAAE,yBAAyB;IACrC,iBAAiB,EAAE,KAAK;CAChB,CAAC"}

package/dist/config/pi-model-mapper.d.ts

@@ -3,19 +3,37 @@
  *
  * Maps pi `Model` objects (provider + id) to router fleet entries using
  * pattern-based lookup for known families. When `config/benchmark-profiles.json`
- * contains a row for the model id (SP-134/136 ingest output), capability
- * vectors are grounded in benchmark scores instead of regex defaults.
- * Unknown models or missing benchmark rows receive conservative pattern defaults.
+ * contains a row for the model id (SP-134/136 ingest output), or a fleet alias
+ * pointing at such a row (SP-174), capability vectors are grounded in benchmark
+ * scores instead of regex defaults. Unknown models or missing benchmark rows
+ * receive conservative pattern defaults. Mapped profiles include
+ * `capability_source` (`benchmark` | `pattern_default`) for explain/telemetry.
  */
 import type { ModelLimits, ModelProfile, Tier } from '../domain/types/entities.js';
 /** Checked-in ingest artifact from `npm run routing:ingest-benchmarks` (SP-134). */
 export declare const DEFAULT_BENCHMARK_PROFILES_PATH: string;
+/** Whether HyDRA capabilities came from the ingest artifact (or alias) vs regex defaults. */
+export type CapabilitySource = 'benchmark' | 'pattern_default';
+/** ModelProfile plus operator-visible capability provenance (SP-174). */
+export interface MappedModelProfile extends ModelProfile {
+    readonly capability_source: CapabilitySource;
+}
 /**
  * Test hook — override benchmark artifact path (null disables benchmark grounding).
  */
 export declare function setBenchmarkProfilesPathForTests(filePath: string | null): void;
 /** Test hook — clear cached benchmark artifact between cases. */
 export declare function resetBenchmarkProfilesCacheForTests(): void;
+/**
+ * Resolve a scoped-fleet model id to the canonical ingest `model_id` via aliases.
+ * Returns the input id when no alias exists.
+ */
+export declare function resolveBenchmarkModelId(modelId: string): string;
+/**
+ * Whether capabilities for this model id resolve from the benchmark artifact
+ * (direct row or fleet alias) vs pattern/family defaults.
+ */
+export declare function getCapabilitySource(modelId: string): CapabilitySource;
 /** Pi registry `Model.cost` shape — per-token USD rates. */
 export interface PiRegistryCost {
     readonly input: number;
@@ -41,10 +59,11 @@ export declare function getDefaultLimitsForTier(tier: Tier): ModelLimits;
 export declare const DEFAULT_CURSOR_QUOTA_COST_PER_1M = 3;
 /**
  * Map a pi model registry entry to a router ModelProfile.
+ * Includes `capability_source` for operators (benchmark vs pattern_default).
  */
-export declare function mapPiModelToProfile(input: PiModelInput): ModelProfile;
+export declare function mapPiModelToProfile(input: PiModelInput): MappedModelProfile;
 /**
  * Map an array of pi registry models to a router fleet catalog.
  */
-export declare function mapFleetFromRegistry(models: readonly PiModelInput[]): ModelProfile[];
+export declare function mapFleetFromRegistry(models: readonly PiModelInput[]): MappedModelProfile[];
 //# sourceMappingURL=pi-model-mapper.d.ts.map