@alexeiled/pi-model-router 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Changelog
 
-## 0.5.0 (unreleased)
+## 0.5.2 — 2026-09-20
+
+- Fix context trimming so preserved system instructions count toward the actual token estimate.
+- Display the thinking level used by the completed route, not a pending profile override.
+- Separate classifier, context extraction and pure routing modules; share one runtime state adapter across provider and commands.
+- Validate raw configuration at the boundary and enable strict TypeScript indexing, optional-property and unused-code checks.
+- Add focused Biome async-safety, import-order, cycle and Node import rules.
+- Use Vitest worker threads for the small suite; remove arbitrary test sleeps and obvious test comments while preserving the full assertion set.
+- Align package metadata, architecture documentation and release instructions.
+
+## 0.5.1 — 2026-09-20
+
+- Delegate generation and classification through Pi's native model registry instead of duplicating auth/dispatch logic. Cover keyless and headers-only auth, native providers and credential URLs with in-memory SDK integration tests.
+- Retry only before output; preserve aborts and partial output, reject unterminated streams, and record the actual fallback model.
+- Use each attempted model's context limit and trim complete turns without discarding system messages or orphaning tool results.
+- Resolve classifier choices against partial profiles, bound classifier requests, and reject malformed/error responses.
+- Deep-copy and validate persisted state; reset snapshot deduplication across branches.
+- Validate rule keywords and malformed profiles; avoid inherited-name lookups and respect non-reasoning tier declarations.
+- Reject invalid debug/widget options, fix thinking completions, and avoid success notifications after failed switches.
+- Replace sleep-based stream tests with real event streams; share typed fixtures and keep test helpers out of npm artifacts.
+- Fail closed on npm registry lookup errors other than a missing version. Document the release and provenance verification procedure.
+
+## 0.5.0 — 2026-09-20
 
 This is the first release of the independently maintained `@alexeiled/pi-model-router` fork.
 

package/README.md

@@ -1,6 +1,13 @@
 # pi-model-router
 
-Smart per-turn model router extension for the [pi-coding-agent](https://github.com/earendil-works/pi/tree/main/packages/coding-agent) that optimizes your AI budget and usage limits without sacrificing quality by dynamically routing each turn to the optimal LLM tier. It automatically selects between high, medium, and low-tier models based on task intent, session budget, context size, and custom rules — complete with automatic fallbacks and phase awareness.
+[![CI](https://github.com/alexei-led/pi-model-router/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexei-led/pi-model-router/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40alexeiled%2Fpi-model-router?logo=npm)](https://www.npmjs.com/package/@alexeiled/pi-model-router)
+[![npm downloads](https://img.shields.io/npm/dm/%40alexeiled%2Fpi-model-router?logo=npm)](https://www.npmjs.com/package/@alexeiled/pi-model-router)
+[![Latest release](https://img.shields.io/github/v/release/alexei-led/pi-model-router?display_name=tag&sort=semver)](https://github.com/alexei-led/pi-model-router/releases)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node.js >=22.19](https://img.shields.io/badge/node-%3E%3D22.19-339933?logo=node.js&logoColor=white)](package.json)
+
+Per-turn model router for [Pi](https://github.com/earendil-works/pi/tree/main/packages/coding-agent). Selects high, medium or low-tier models using task intent, a soft budget policy and custom rules, while keeping the selected `router/<profile>` model stable.
 
 > **Independent fork:** This project is an independently maintained fork of [yeliu84/pi-model-router](https://github.com/yeliu84/pi-model-router), originally created by Ye Liu. It is not an official upstream release. The original MIT license and copyright notice are preserved.
 
@@ -56,13 +63,15 @@ npm run check
 npm test
 ```
 
-`npm run check` runs Biome lint, formatting and import-order checks, then the
-TypeScript compiler. Warnings fail the check. CI and releases use the same gate.
+`npm run check` runs Biome lint, formatting, import-order and async-safety checks, then
+TypeScript 7 with strict indexing, optional-property and unused-code checks. Warnings fail
+the check. CI and releases use the same gate.
 
 - `npm run format` formats TypeScript and root JSON files.
 - `npm run lint` checks lint rules; `npm run lint:fix` applies safe lint fixes.
 - `npx biome check --write .` also fixes formatting and import order.
 - `npm run tsc` runs only the type checker.
+- `npm test` uses Vitest worker threads; this keeps the small suite fast without weakening assertions.
 
 [Biome](https://biomejs.dev/) replaces Prettier and supplies linting in one pinned
 direct tooling dependency, without ESLint or formatter plugins. Type checking stays with
@@ -82,6 +91,15 @@ Or load directly for one run:
 pi -e ./extensions/index.ts
 ```
 
+## Reliability
+
+- Both generation and classification use Pi's provider registry, including native/custom providers and credential-specific URLs.
+- Fallbacks run only before content is emitted; cancellation does not retry.
+- Classifier requests use isolated context, a 10-second cancellation deadline and a 256-token output limit. Failures retain local routing.
+- Context trimming preserves system instructions and whole active tool turns. It is a text estimate, not a guarantee that images or a large active turn fit.
+
+See [architecture](https://github.com/alexei-led/pi-model-router/blob/main/docs/ARCHITECTURE.md) and [release procedure](https://github.com/alexei-led/pi-model-router/blob/main/docs/RELEASING.md).
+
 ## Configuration
 
 Copy the example config to one of:
@@ -112,7 +130,7 @@ The extension stores the last selected profile in `~/.pi/agent/model-router-stat
 | Field                   | Description                                                                       |
 | ----------------------- | --------------------------------------------------------------------------------- |
 | `classifierModel`       | (Optional) Model used to categorize intent. Supports model aliases. If omitted, fast heuristics are used. |
-| `maxSessionBudget`      | (Optional) USD budget for the session. Forces `medium` tier once exceeded.        |
+| `maxSessionBudget`      | (Optional) Soft generation-cost threshold in USD. Downgrades high to medium, or low if medium is absent. Not a spending cap; classifier cost is excluded. |
 | `phaseBias`             | (0.0 - 1.0) Stickiness of the current phase. Higher = more stable. Default `0.5`. |
 | `rules`                 | List of custom keyword rules (e.g. `{ "matches": "deploy", "tier": "high" }`).    |
 | `models`                | (Optional) Map of model aliases to definitions with `model`, `contextWindow`, `maxTokens`. |

package/extensions/classifier.ts

@@ -0,0 +1,93 @@
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
+import type {
+  ThinkingLevel as AiThinkingLevel,
+  Context,
+} from '@earendil-works/pi-ai';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { isRouterTier, parseCanonicalModelRef } from './config';
+import { extractTextFromContent, getRecentConversationText } from './context';
+import type { RouterPhase, RouterTier } from './types';
+
+const CLASSIFIER_TIMEOUT_MS = 10_000;
+const CLASSIFIER_MAX_TOKENS = 256;
+
+export const runClassifier = async (
+  classifierModelRef: string,
+  modelRegistry: ExtensionContext['modelRegistry'],
+  context: Context,
+  currentPhase?: RouterPhase,
+  thinking?: ThinkingLevel,
+  signal?: AbortSignal,
+): Promise<{ tier: RouterTier; reasoning: string } | undefined> => {
+  if (signal?.aborted) return undefined;
+  const { provider, modelId } = parseCanonicalModelRef(classifierModelRef);
+  if (provider === 'router') return undefined;
+  const model = modelRegistry.find(provider, modelId);
+  if (!model) return undefined;
+
+  const latestMessage = context.messages.at(-1);
+  const classifierContext: Context = {
+    messages: [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: [
+              'Classify the coding task into exactly one tier: high, medium, or low.',
+              'Return exactly two lines:',
+              'Tier: <high|medium|low>',
+              'Reasoning: <short reason>',
+              `Current phase: ${currentPhase ?? 'unknown'}`,
+              `Recent conversation:\n${getRecentConversationText(context)}`,
+              `Latest request:\n${latestMessage ? extractTextFromContent(latestMessage.content) : ''}`,
+            ].join('\n'),
+          },
+        ],
+        timestamp: Date.now(),
+      },
+    ],
+  };
+  const timeout = AbortSignal.timeout(CLASSIFIER_TIMEOUT_MS);
+  const classifierSignal = signal
+    ? AbortSignal.any([signal, timeout])
+    : timeout;
+  const reasoning: AiThinkingLevel | undefined =
+    thinking && thinking !== 'off' ? thinking : undefined;
+  const stream = modelRegistry.streamSimple(model, classifierContext, {
+    signal: classifierSignal,
+    maxTokens: CLASSIFIER_MAX_TOKENS,
+    ...(reasoning ? { reasoning } : {}),
+  });
+
+  let fullText = '';
+  let completed = false;
+  for await (const event of stream) {
+    if (event.type === 'error') return undefined;
+    if (event.type === 'text_delta') fullText += event.delta;
+    if (event.type === 'done') {
+      completed = true;
+      fullText = extractTextFromContent(event.message.content);
+      break;
+    }
+  }
+  if (!completed) return undefined;
+
+  const tierLine = fullText
+    .split('\n')
+    .find((line) => line.toLowerCase().startsWith('tier:'));
+  const reasoningLine = fullText
+    .split('\n')
+    .find((line) => line.toLowerCase().startsWith('reasoning:'));
+  if (!tierLine || !reasoningLine) return undefined;
+
+  const tierValue = tierLine
+    .slice(tierLine.indexOf(':') + 1)
+    .trim()
+    .toLowerCase();
+  if (!isRouterTier(tierValue)) return undefined;
+  return {
+    tier: tierValue,
+    reasoning: reasoningLine.slice(reasoningLine.indexOf(':') + 1).trim(),
+  };
+};

package/extensions/commands.ts

@@ -6,6 +6,9 @@ import type {
 import type { AutocompleteItem } from '@earendil-works/pi-tui';
 import {
   getUnsupportedTiers,
+  isRouterPinValue,
+  isRouterTier,
+  isThinkingLevel,
   parseCanonicalModelRef,
   profileNames,
   ROUTER_PIN_VALUES,
@@ -110,7 +113,7 @@ export const registerCommands = (
     args: string[],
   ): AutocompleteItem[] | null => {
     // thinking [tier] <level|auto>
-    const tierValues = [...ROUTER_TIERS];
+    const tierValues: RouterTier[] = [...ROUTER_TIERS];
     const levelValues = ['auto', ...THINKING_LEVELS];
 
     if (args.length <= 1) {
@@ -136,12 +139,8 @@ export const registerCommands = (
       ];
     }
 
-    if (levelValues.includes(args[0])) {
-      return null;
-    }
-
-    if ((tierValues as string[]).includes(args[0])) {
-      const tier = args[0];
+    const tier = args[0];
+    if (isRouterTier(tier)) {
       const levelPrefix = args[1] ?? '';
       return levelValues
         .filter((v) => v.startsWith(levelPrefix))
@@ -252,7 +251,7 @@ export const registerCommands = (
 
     const pinValue = args[0];
 
-    if (!ROUTER_PIN_VALUES.some((value) => value === pinValue)) {
+    if (!isRouterPinValue(pinValue)) {
       ctx.ui.notify(
         `Invalid router pin: ${pinValue}. Use one of: ${ROUTER_PIN_VALUES.join(', ')}`,
         'error',
@@ -260,7 +259,8 @@ export const registerCommands = (
       return;
     }
 
-    const nextTier = pinValue === 'auto' ? undefined : (pinValue as RouterTier);
+    const nextTier: RouterTier | undefined =
+      pinValue === 'auto' ? undefined : pinValue;
     if (nextTier) {
       state.pinnedTierByProfile[currentProfile] = nextTier;
     } else {
@@ -307,16 +307,20 @@ export const registerCommands = (
     let tier: RouterTier | 'all' | undefined;
     let levelValue = '';
 
-    const tierValues = ['high', 'medium', 'low'];
     const levelValues = ['auto', ...THINKING_LEVELS];
 
     if (args.length === 1) {
-      levelValue = args[0];
+      const level = args[0];
+      if (!level) return;
+      levelValue = level;
       tier = 'all';
     } else if (args.length === 2) {
-      if (tierValues.includes(args[0]) || args[0] === 'all') {
-        tier = args[0] as RouterTier | 'all';
-        levelValue = args[1];
+      const requestedTier = args[0];
+      const requestedLevel = args[1];
+      if (!requestedTier || !requestedLevel) return;
+      if (isRouterTier(requestedTier) || requestedTier === 'all') {
+        tier = requestedTier === 'all' ? 'all' : requestedTier;
+        levelValue = requestedLevel;
       } else {
         ctx.ui.notify(
           `Invalid tier: ${args[0]}. Use high, medium, or low.`,
@@ -326,7 +330,7 @@ export const registerCommands = (
       }
     }
 
-    if (tier !== 'all' && !tierValues.includes(tier as string)) {
+    if (tier !== 'all' && !tier) {
       ctx.ui.notify(
         `Invalid tier: ${tier}. Use high, medium, or low.`,
         'error',
@@ -342,10 +346,17 @@ export const registerCommands = (
     }
 
     const nextLevel =
-      levelValue === 'auto' ? undefined : (levelValue as ThinkingLevel);
-    state.thinkingByProfile[currentProfile] ??= {};
-    const overrides = state.thinkingByProfile[currentProfile];
-    const tiers = tier === 'all' ? ROUTER_TIERS : [tier as RouterTier];
+      levelValue === 'auto'
+        ? undefined
+        : isThinkingLevel(levelValue)
+          ? levelValue
+          : undefined;
+    let overrides = state.thinkingByProfile[currentProfile];
+    if (!overrides) {
+      overrides = {};
+      state.thinkingByProfile[currentProfile] = overrides;
+    }
+    const tiers = tier === 'all' ? ROUTER_TIERS : [tier];
     for (const targetTier of tiers) {
       if (nextLevel) overrides[targetTier] = nextLevel;
       else delete overrides[targetTier];
@@ -363,10 +374,9 @@ export const registerCommands = (
     }
     // Only warn when the level isn't supported by some tiers; skip for 'off' and 'auto'
     if (nextLevel && nextLevel !== 'off') {
-      const unsupported = getUnsupportedTiers(
-        state.currentConfig.profiles[currentProfile],
-        nextLevel,
-      );
+      const activeProfile = state.currentConfig.profiles[currentProfile];
+      if (!activeProfile) return;
+      const unsupported = getUnsupportedTiers(activeProfile, nextLevel);
       if (unsupported.length > 0) {
         ctx.ui.notify(
           `Router thinking (${tier}) set to ${nextLevel}. ` +
@@ -420,7 +430,7 @@ export const registerCommands = (
       return;
     }
     const tier = args[0]?.toLowerCase();
-    if (!ROUTER_TIERS.includes(tier as RouterTier)) {
+    if (!isRouterTier(tier)) {
       ctx.ui.notify('Usage: /router fix <high|medium|low>', 'error');
       return;
     }
@@ -428,7 +438,7 @@ export const registerCommands = (
       ctx.ui.notify('No recent routing decision to fix.', 'warning');
       return;
     }
-    state.pinnedTierByProfile[state.lastDecision.profile] = tier as RouterTier;
+    state.pinnedTierByProfile[state.lastDecision.profile] = tier;
     actions.persistState();
     actions.updateStatus(ctx);
     ctx.ui.notify(
@@ -443,6 +453,10 @@ export const registerCommands = (
       return;
     }
     const cmd = args[0]?.toLowerCase();
+    if (cmd && !['on', 'off', 'toggle'].includes(cmd)) {
+      ctx.ui.notify('Usage: /router widget <on|off|toggle>', 'error');
+      return;
+    }
     if (cmd === 'on') state.widgetEnabled = true;
     else if (cmd === 'off') state.widgetEnabled = false;
     else state.widgetEnabled = !state.widgetEnabled;
@@ -460,6 +474,10 @@ export const registerCommands = (
       return;
     }
     const cmd = args[0]?.toLowerCase();
+    if (cmd && !['on', 'off', 'toggle', 'clear', 'show'].includes(cmd)) {
+      ctx.ui.notify('Usage: /router debug <on|off|toggle|show|clear>', 'error');
+      return;
+    }
     if (cmd === 'on') state.debugEnabled = true;
     else if (cmd === 'off') state.debugEnabled = false;
     else if (cmd === 'clear') state.debugHistory.length = 0;
@@ -511,10 +529,12 @@ export const registerCommands = (
       }
 
       if (parts.length === 1 && !hasTrailingSpace) {
-        return getSubcommandCompletions(parts[0]);
+        const subcommand = parts[0];
+        return subcommand ? getSubcommandCompletions(subcommand) : null;
       }
 
       const subcommand = parts[0];
+      if (!subcommand) return null;
       const subArgs = parts.slice(1);
       if (hasTrailingSpace && parts.length === 1) {
         subArgs.push('');
@@ -593,6 +613,10 @@ export const registerCommands = (
       const parts = args?.trim().split(/\s+/) ?? [];
       const subcommand = parts[0];
       const subArgs = parts.slice(1);
+      if (!subcommand) {
+        await handleStatus(subArgs, ctx);
+        return;
+      }
 
       switch (subcommand) {
         case 'profile':
@@ -656,11 +680,12 @@ export const registerCommands = (
                 );
                 return;
               }
-              await actions.switchToRouterProfile(subcommand, ctx);
-              ctx.ui.notify(
-                `Router enabled with profile: ${state.selectedProfile}`,
-                'info',
-              );
+              if (await actions.switchToRouterProfile(subcommand, ctx)) {
+                ctx.ui.notify(
+                  `Router enabled with profile: ${state.selectedProfile}`,
+                  'info',
+                );
+              }
             } else {
               ctx.ui.notify(
                 `Unknown router subcommand: ${subcommand}. Try /router help`,

package/extensions/config.ts

@@ -9,6 +9,7 @@ import type {
   ConfigLoadResult,
   ModelDefinition,
   ParsedConfigFile,
+  RawRouterConfig,
   RoutedTierConfig,
   RouterConfig,
   RouterProfile,
@@ -19,7 +20,7 @@ import type {
 export const ROUTER_TIERS = ['high', 'medium', 'low'] as const;
 
 // Pi accepts this model capability at runtime, but older peer type releases omit it.
-export const MAX_THINKING_LEVEL = 'max' as ThinkingLevel;
+export const MAX_THINKING_LEVEL: ThinkingLevel = 'max';
 
 export const THINKING_LEVELS: readonly ThinkingLevel[] = [
   'off',
@@ -31,6 +32,9 @@ export const THINKING_LEVELS: readonly ThinkingLevel[] = [
   MAX_THINKING_LEVEL,
 ];
 export const ROUTER_PIN_VALUES = ['auto', 'high', 'medium', 'low'] as const;
+export type RouterPinValue = (typeof ROUTER_PIN_VALUES)[number];
+export const isRouterPinValue = (value: unknown): value is RouterPinValue =>
+  ROUTER_PIN_VALUES.some((candidate) => candidate === value);
 
 export const DEFAULT_THINKING_LEVELS: readonly ThinkingLevel[] = [
   'high',
@@ -44,7 +48,7 @@ export const isObjectRecord = (
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
 export const isThinkingLevel = (value: unknown): value is ThinkingLevel =>
-  typeof value === 'string' && THINKING_LEVELS.includes(value as ThinkingLevel);
+  typeof value === 'string' && THINKING_LEVELS.some((level) => level === value);
 
 export const isRouterTier = (value: unknown): value is RouterTier =>
   value === 'high' || value === 'medium' || value === 'low';
@@ -55,14 +59,14 @@ export const parseConfigFile = (path: string): ParsedConfigFile => {
   }
 
   try {
-    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf-8'));
     if (!isObjectRecord(parsed)) {
       return {
         config: {},
         warnings: [`Ignored router config at ${path}: expected a JSON object.`],
       };
     }
-    return { config: parsed as Partial<RouterConfig>, warnings: [] };
+    return { config: parsed, warnings: [] };
   } catch (error) {
     return {
       config: {},
@@ -82,42 +86,50 @@ export const resolveModelRef = (
   ref: string,
   models: Record<string, ModelDefinition> | undefined,
 ): { canonicalRef: string; definition?: ModelDefinition } => {
-  const definition = models?.[ref];
+  const definition =
+    models && Object.hasOwn(models, ref) ? models[ref] : undefined;
   if (definition) {
     return { canonicalRef: definition.model, definition };
   }
   return { canonicalRef: ref };
 };
 
-const mergeTier = (
-  existing?: RoutedTierConfig,
-  next?: Partial<RoutedTierConfig>,
-): RoutedTierConfig | undefined => {
-  if (!existing && !next) return undefined;
-  if (!next) return existing;
-  if (!existing) return next as RoutedTierConfig;
-  return { ...existing, ...next };
+const mergeRawValue = (existing: unknown, next: unknown): unknown => {
+  if (next === undefined) return existing;
+  if (isObjectRecord(existing) && isObjectRecord(next)) {
+    return { ...existing, ...next };
+  }
+  return next;
 };
 
 export const mergeConfig = (
-  base: RouterConfig,
-  override: Partial<RouterConfig>,
-): RouterConfig => {
-  const mergedProfiles: Record<string, RouterProfile> = { ...base.profiles };
-  for (const [name, profile] of Object.entries(override.profiles ?? {})) {
-    const existing = mergedProfiles[name];
-    const nextProfile = profile as Partial<RouterProfile>;
+  base: RawRouterConfig,
+  override: RawRouterConfig,
+): RawRouterConfig => {
+  const baseProfiles = isObjectRecord(base.profiles) ? base.profiles : {};
+  const overrideProfiles = isObjectRecord(override.profiles)
+    ? override.profiles
+    : {};
+  const mergedProfiles: Record<string, unknown> = { ...baseProfiles };
+  for (const [name, profile] of Object.entries(overrideProfiles)) {
+    if (name === '__proto__') continue;
+    if (!isObjectRecord(profile)) {
+      mergedProfiles[name] = profile;
+      continue;
+    }
+    const existing = isObjectRecord(mergedProfiles[name])
+      ? mergedProfiles[name]
+      : {};
     mergedProfiles[name] = {
-      high: mergeTier(existing?.high, nextProfile.high),
-      medium: mergeTier(existing?.medium, nextProfile.medium),
-      low: mergeTier(existing?.low, nextProfile.low),
+      high: mergeRawValue(existing.high, profile.high),
+      medium: mergeRawValue(existing.medium, profile.medium),
+      low: mergeRawValue(existing.low, profile.low),
     };
   }
 
-  const mergedModels: Record<string, ModelDefinition> = {
-    ...(base.models ?? {}),
-    ...(override.models ?? {}),
-  };
+  const baseModels = isObjectRecord(base.models) ? base.models : {};
+  const overrideModels = isObjectRecord(override.models) ? override.models : {};
+  const mergedModels = { ...baseModels, ...overrideModels };
 
   return {
     debug: override.debug ?? base.debug,
@@ -153,13 +165,14 @@ export const parseCanonicalModelRef = (
  * Validate and normalize the models map from config.
  */
 export const normalizeModelsMap = (
-  raw: Record<string, unknown> | undefined,
+  raw: unknown,
   warnings: string[],
 ): Record<string, ModelDefinition> => {
   const result: Record<string, ModelDefinition> = {};
   if (!raw || !isObjectRecord(raw)) return result;
 
   for (const [alias, entry] of Object.entries(raw)) {
+    if (alias === '__proto__') continue;
     if (!isObjectRecord(entry)) {
       warnings.push(
         `Ignored invalid model definition "${alias}": expected an object.`,
@@ -314,8 +327,8 @@ export const normalizeTierConfig = (
   // Validate tier-level thinkingLevels array
   let tierThinkingLevels: ThinkingLevel[] | undefined;
   if (Array.isArray(value.thinkingLevels)) {
-    tierThinkingLevels = (value.thinkingLevels as unknown[]).filter(
-      (l): l is ThinkingLevel => isThinkingLevel(l),
+    tierThinkingLevels = value.thinkingLevels.filter((l): l is ThinkingLevel =>
+      isThinkingLevel(l),
     );
     if (tierThinkingLevels.length === 0) tierThinkingLevels = undefined;
   }
@@ -331,6 +344,7 @@ export const normalizeTierConfig = (
   const resolvedThinkingLevels: ThinkingLevel[] = [...baseThinkingLevels];
   if (
     !explicitThinkingLevels &&
+    effectiveReasoning !== false &&
     thinking !== 'off' &&
     !resolvedThinkingLevels.includes(thinking)
   ) {
@@ -351,35 +365,36 @@ export const normalizeTierConfig = (
   };
 };
 
-export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
+export const normalizeConfig = (raw: RawRouterConfig): ConfigLoadResult => {
   const warnings: string[] = [];
 
   // Normalize models map first so aliases are available during tier normalization
-  const normalizedModels = normalizeModelsMap(
-    raw.models as Record<string, unknown> | undefined,
-    warnings,
-  );
+  const normalizedModels = normalizeModelsMap(raw.models, warnings);
   const hasModels = Object.keys(normalizedModels).length > 0;
 
   const normalizedProfiles: Record<string, RouterProfile> = {};
 
-  for (const [name, profile] of Object.entries(raw.profiles ?? {})) {
+  for (const [name, profile] of Object.entries(
+    isObjectRecord(raw.profiles) ? raw.profiles : {},
+  )) {
+    if (name === '__proto__') continue;
+    const profileRecord = isObjectRecord(profile) ? profile : {};
     const high = normalizeTierConfig(
-      profile?.high,
+      profileRecord.high,
       name,
       'high',
       warnings,
       hasModels ? normalizedModels : undefined,
     );
     const medium = normalizeTierConfig(
-      profile?.medium,
+      profileRecord.medium,
       name,
       'medium',
       warnings,
       hasModels ? normalizedModels : undefined,
     );
     const low = normalizeTierConfig(
-      profile?.low,
+      profileRecord.low,
       name,
       'low',
       warnings,
@@ -411,7 +426,12 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
         const matches = rule.matches;
         const tier = rule.tier;
         if (
-          (typeof matches === 'string' || Array.isArray(matches)) &&
+          ((typeof matches === 'string' && matches.trim().length > 0) ||
+            (Array.isArray(matches) &&
+              matches.length > 0 &&
+              matches.every(
+                (m) => typeof m === 'string' && m.trim().length > 0,
+              ))) &&
           isRouterTier(tier)
         ) {
           rules.push({
@@ -430,7 +450,7 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
 
   // Resolve classifierModel — accepts string or { model, thinking } object
   let classifierModel: ClassifierConfig | undefined;
-  const rawClassifier = raw.classifierModel as unknown;
+  const rawClassifier = raw.classifierModel;
   if (typeof rawClassifier === 'string' && rawClassifier.trim()) {
     const resolved = resolveModelRef(
       rawClassifier.trim(),
@@ -494,7 +514,7 @@ export const loadRouterConfig = (cwd: string): ConfigLoadResult => {
   const projectPath = join(cwd, '.pi', 'model-router.json');
   const globalResult = parseConfigFile(globalPath);
   const projectResult = parseConfigFile(projectPath);
-  const baseConfig: RouterConfig = { profiles: {} };
+  const baseConfig: RawRouterConfig = { profiles: {} };
   const merged = mergeConfig(
     mergeConfig(baseConfig, globalResult.config),
     projectResult.config,
@@ -518,7 +538,7 @@ export const resolveProfileName = (
   config: RouterConfig,
   requested?: string,
 ): string | undefined => {
-  if (requested && config.profiles[requested]) {
+  if (requested && Object.hasOwn(config.profiles, requested)) {
     return requested;
   }
   return undefined;
@@ -633,9 +653,8 @@ export const clampThinkingLevel = (
 
   const reqIdx = THINKING_LEVELS.indexOf(requested);
   for (let i = reqIdx; i >= 0; i--) {
-    if (supported.includes(THINKING_LEVELS[i])) {
-      return THINKING_LEVELS[i];
-    }
+    const level = THINKING_LEVELS[i];
+    if (level && supported.includes(level)) return level;
   }
 
   return 'off';