@alexeiled/pi-model-router 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.6.1 — 2026-09-21
+
+- Add compact human-readable route provenance to the Pi footer, widget and `/router status`: `🧭 Jev ✓` means Jev selected the route, `🧭 Jev ↪ base` means Jev ran but the local baseline was used, and no marker means Jev was not involved.
+- Track closed route-guidance outcomes across Jev, classifier, bypass and baseline paths, including reusable tool continuations and explicit generation fallbacks without persisting remote text or credentials.
+- Keep the normal footer uncluttered for turns without external route guidance; retain latency only as a short widget/status diagnostic.
+- Add regression coverage for UI rendering, persistence compatibility, advisor fallback, continuation inheritance and privacy boundaries.
+
 ## 0.6.0 — 2026-09-21
 
 - Add the optional `micro` tier with `off` thinking by default; all four tiers are configured model/effort choices, not security permissions. Existing three-tier and partial profiles remain supported.

package/README.md

@@ -244,6 +244,13 @@ request text, raw response or remote explanations. Older saved explanations are
 discarded as non-rendered `legacy` metadata; Pi's own conversation transcript is
 separate from router state.
 
+**Footer and widget:** The footer stays in its normal route-only form when Jev is
+not involved. When Jev selects the route it adds `· 🧭 Jev ✓`; when Jev is used
+but its advice is rejected, it adds `· 🧭 Jev ↪ base`. `base` means the local
+deterministic baseline; the selected tier and model remain visible in the route
+text. `/router widget on` and `/router status` show the same marker and a short
+latency value. No marker means no external route guidance was used.
+
 For chezmoi, use a **private template**, for example
 `private_model-router.json.tmpl` under your agent-directory source path. Render
 only the `apiKey` value using a reference such as
@@ -268,11 +275,11 @@ keeps Jev disabled.
 | `/router thinking <tier> <level>` | Override thinking level for a specific tier (e.g. `/router thinking low off`). |
 | `/router disable`           | Disable the router and switch back to the last non-router model.                |
 | `/router widget <on\|off>`  | Toggle the persistent state widget (supports `toggle`).                         |
-| `/router debug <on\|off>`   | Toggle turn-by-turn routing notifications (supports `toggle`, `clear`, `show`). |
+| `/router debug <on\|off>`   | Toggle router debug state; use `show` or `clear` for local decision history. |
 | `/router reload`            | Hot-reload the configuration JSON.                                              |
 | `/router help`              | Show usage help for all subcommands.                                            |
 
 ## Documentation
 
 - [Architecture Guide](docs/ARCHITECTURE.md): Deep dive into the routing logic and modular design.
-- [Sample Configuration](model-router.example.json): Diverse profile examples (`cheap`, `deep`, `balanced`).
+- [Sample Configuration](model-router.example.json): Profile examples (`auto`, `cheap`, `deep`, `anthropic`).

package/extensions/commands.ts

@@ -24,6 +24,7 @@ import type {
   RoutingDecision,
 } from './types';
 import {
+  formatAdvisorDetail,
   formatDecision,
   formatDecisionSource,
   formatModelRef,
@@ -183,6 +184,7 @@ export const registerCommands = (
       `Debug history: ${state.debugHistory.length} decisions`,
     ];
     if (state.lastDecision) {
+      const advisorDetail = formatAdvisorDetail(state.lastDecision);
       lines.push(
         `Last routed tier: ${state.lastDecision.tier}`,
         `Last phase: ${state.lastDecision.phase}`,
@@ -190,6 +192,7 @@ export const registerCommands = (
         ...(formatDecisionSource(state.lastDecision)
           ? [`Reason: ${formatDecisionSource(state.lastDecision)}`]
           : []),
+        ...(advisorDetail ? [advisorDetail] : []),
       );
     }
     if (state.lastConfigWarnings && state.lastConfigWarnings.length > 0) {

package/extensions/provider.ts

@@ -39,6 +39,7 @@ import {
   selectBaselineRoute,
 } from './routing';
 import type {
+  AdvisorOutcome,
   RouterConfig,
   RouterPinByProfile,
   RouterThinkingByProfile,
@@ -279,7 +280,7 @@ export const registerRouterProvider = (
   // Streams can complete out of order. Keep a small turn-keyed history rather
   // than letting the latest stream replace another stream's continuation.
   const continuations = new Map<string, ContinuationRecord>();
-  const advisedTurns = new Map<string, true>();
+  const advisedTurns = new Map<string, AdvisorOutcome>();
   const rememberContinuation = (record: ContinuationRecord) => {
     continuations.delete(record.turn);
     continuations.set(record.turn, record);
@@ -289,9 +290,9 @@ export const registerRouterProvider = (
       continuations.delete(oldest);
     }
   };
-  const rememberAdvisedTurn = (turn: string) => {
+  const rememberAdvisedTurn = (turn: string, outcome: AdvisorOutcome) => {
     advisedTurns.delete(turn);
-    advisedTurns.set(turn, true);
+    advisedTurns.set(turn, outcome);
     while (advisedTurns.size > 16) {
       const oldest = advisedTurns.keys().next().value;
       if (oldest === undefined) break;
@@ -391,6 +392,14 @@ export const registerRouterProvider = (
           ]);
           const toolContinuation =
             context.messages.at(-1)?.role === 'toolResult';
+          const jev = state.currentConfig.jev;
+          const useJev = Boolean(
+            jev?.enabled &&
+              profile.jev?.enabled &&
+              jev.apiKey.trim().length > 0,
+          );
+          const advisorConfigured =
+            useJev || Boolean(state.currentConfig.classifierModel);
           const continuationRecord =
             toolContinuation && turn ? continuations.get(turn) : undefined;
           const continuationDecision = continuationRecord?.decision;
@@ -459,6 +468,11 @@ export const registerRouterProvider = (
               baseline.reasonCode,
             );
             decision.isBudgetForced = baseline.isBudgetForced;
+            decision.advisor = advisorConfigured ? 'bypassed' : 'none';
+            if (!toolContinuation && turn) {
+              const previousAdvisor = advisedTurns.get(turn);
+              if (previousAdvisor) decision.advisor = previousAdvisor;
+            }
           }
 
           // Tool results never invoke advisors, even when their prior route cannot be reused.
@@ -469,99 +483,110 @@ export const registerRouterProvider = (
             user &&
             turn &&
             !advisedTurns.has(turn) &&
-            (state.currentConfig.classifierModel ||
-              (state.currentConfig.jev?.enabled && profile.jev?.enabled))
+            advisorConfigured
           ) {
-            rememberAdvisedTurn(turn);
             const started = performance.now();
-            const jev = state.currentConfig.jev;
-            const useJev =
-              jev?.enabled &&
-              profile.jev?.enabled &&
-              jev.apiKey.trim().length > 0;
             const routingDeadline = started + (useJev ? 1500 : 10_000);
             const candidates = primaryRoutePairs(profile, pairs).map(
               createJevCandidate,
             );
             // A single primary bypasses advice, not a baseline's eligible fallback.
-            if (candidates.length > 1) {
-              if (useJev && jev) {
-                const advice = await runJev(
-                  {
-                    ...jev,
-                    timeoutMs: Math.min(750, jev.timeoutMs),
-                  },
-                  {
-                    taskSummary: getBoundedRecentContext(
-                      context,
-                      jev.maxStateChars,
-                    ),
-                    candidates,
-                    profile: profile.jev,
-                    routingDeadline,
-                    signal: options?.signal,
-                  },
-                ).catch(() => undefined);
-                options?.signal?.throwIfAborted();
-                // Re-read registry capabilities after the network boundary.
-                pairs = available();
-                const candidate = candidates.find(
-                  (entry) => entry.id === advice?.candidateId,
-                );
-                if (
-                  candidate &&
-                  performance.now() < routingDeadline &&
-                  pairs.some(
-                    (pair) =>
-                      pair.model === candidate.model &&
-                      pair.tier === candidate.tier &&
-                      pair.thinking === candidate.thinking,
-                  )
-                ) {
-                  decision = decisionForPair(model.id, candidate, 'jev');
-                } else {
-                  const baseline = selectBaselineRoute(
-                    model.id,
-                    profile,
-                    pairs,
-                  );
-                  decision = decisionForPair(
-                    model.id,
-                    baseline.pair,
-                    baseline.reasonCode,
-                  );
-                  decision.errorClass = 'advisor-unavailable';
-                }
-              } else if (state.currentConfig.classifierModel) {
-                const classifier = state.currentConfig.classifierModel;
-                const result = await runClassifier(
-                  classifier.model,
-                  registry,
-                  context,
-                  undefined,
-                  classifier.thinking,
-                  options?.signal,
+            if (candidates.length <= 1) {
+              decision.advisor = 'bypassed';
+              rememberAdvisedTurn(turn, 'bypassed');
+            } else if (useJev && jev) {
+              decision.advisor = 'jev';
+              rememberAdvisedTurn(turn, 'jev');
+              const advice = await runJev(
+                {
+                  ...jev,
+                  timeoutMs: Math.min(750, jev.timeoutMs),
+                },
+                {
+                  taskSummary: getBoundedRecentContext(
+                    context,
+                    jev.maxStateChars,
+                  ),
+                  candidates,
+                  profile: profile.jev,
                   routingDeadline,
-                ).catch(() => undefined);
-                options?.signal?.throwIfAborted();
-                pairs = available();
+                  signal: options?.signal,
+                },
+              ).catch(() => undefined);
+              options?.signal?.throwIfAborted();
+              // Re-read registry capabilities after the network boundary.
+              pairs = available();
+              const candidate = candidates.find(
+                (entry) => entry.id === advice?.candidateId,
+              );
+              if (
+                candidate &&
+                performance.now() < routingDeadline &&
+                pairs.some(
+                  (pair) =>
+                    pair.model === candidate.model &&
+                    pair.tier === candidate.tier &&
+                    pair.thinking === candidate.thinking,
+                )
+              ) {
+                decision = {
+                  ...decisionForPair(model.id, candidate, 'jev'),
+                  advisor: 'jev',
+                };
+              } else {
                 const baseline = selectBaselineRoute(model.id, profile, pairs);
                 decision = decisionForPair(
                   model.id,
                   baseline.pair,
                   baseline.reasonCode,
                 );
-                if (result && performance.now() < routingDeadline) {
-                  const pair = pairs.find(
-                    (entry) => entry.tier === result.tier,
-                  );
-                  if (pair) {
-                    decision = {
-                      ...decisionForPair(model.id, pair, 'classifier'),
-                      isClassifier: true,
-                    };
-                  } else decision.errorClass = 'advisor-unavailable';
-                } else decision.errorClass = 'advisor-unavailable';
+                decision.advisor = 'jev-fallback';
+                rememberAdvisedTurn(turn, 'jev-fallback');
+                decision.errorClass = 'advisor-unavailable';
+              }
+              decision.routingLatencyMs = Math.max(
+                0,
+                performance.now() - started,
+              );
+              if (performance.now() >= routingDeadline)
+                decision.errorClass = 'deadline';
+            } else if (state.currentConfig.classifierModel) {
+              const classifier = state.currentConfig.classifierModel;
+              const result = await runClassifier(
+                classifier.model,
+                registry,
+                context,
+                undefined,
+                classifier.thinking,
+                options?.signal,
+                routingDeadline,
+              ).catch(() => undefined);
+              options?.signal?.throwIfAborted();
+              pairs = available();
+              const baseline = selectBaselineRoute(model.id, profile, pairs);
+              decision = decisionForPair(
+                model.id,
+                baseline.pair,
+                baseline.reasonCode,
+              );
+              if (result && performance.now() < routingDeadline) {
+                const pair = pairs.find((entry) => entry.tier === result.tier);
+                if (pair) {
+                  decision = {
+                    ...decisionForPair(model.id, pair, 'classifier'),
+                    isClassifier: true,
+                    advisor: 'classifier',
+                  };
+                  rememberAdvisedTurn(turn, 'classifier');
+                } else {
+                  decision.advisor = 'classifier-fallback';
+                  rememberAdvisedTurn(turn, 'classifier-fallback');
+                  decision.errorClass = 'advisor-unavailable';
+                }
+              } else {
+                decision.advisor = 'classifier-fallback';
+                rememberAdvisedTurn(turn, 'classifier-fallback');
+                decision.errorClass = 'advisor-unavailable';
               }
               decision.routingLatencyMs = Math.max(
                 0,
@@ -603,7 +628,10 @@ export const registerRouterProvider = (
               throw new Error(
                 'No compatible route for Google tool continuation.',
               );
-            decision = decisionForPair(model.id, priorPair, 'continuation');
+            decision = {
+              ...decisionForPair(model.id, priorPair, 'continuation'),
+              advisor: decision.advisor,
+            };
           }
 
           state.lastDecision = decision;

package/extensions/state.ts

@@ -14,7 +14,7 @@ import type {
   RouterPinByProfile,
   RoutingDecision,
 } from './types';
-import { isRoutingReasonCode } from './types';
+import { isAdvisorOutcome, isRoutingReasonCode } from './types';
 
 const LAST_PROFILE_STATE_FILE = 'model-router-state.json';
 
@@ -57,6 +57,7 @@ const isDecision = (value: unknown): value is RoutingDecision =>
   (value.reasonCode === undefined
     ? typeof value.reasoning === 'string'
     : isPersistedReasonCode(value.reasonCode)) &&
+  (value.advisor === undefined || isAdvisorOutcome(value.advisor)) &&
   ['isClassifier', 'isFallback', 'isBudgetForced'].every(
     (key) => value[key] === undefined || typeof value[key] === 'boolean',
   );
@@ -164,6 +165,7 @@ export const snapshotDecision = (
     decision.errorClass === 'deadline'
       ? decision.errorClass
       : undefined,
+  advisor: isAdvisorOutcome(decision.advisor) ? decision.advisor : undefined,
   thinking: decision.thinking,
   timestamp: decision.timestamp,
   isClassifier: decision.isClassifier,

package/extensions/types.ts

@@ -131,6 +131,17 @@ export const isRoutingReasonCode = (
 ): value is RoutingReasonCode =>
   ROUTING_REASON_CODES.some((code) => code === value);
 export type RoutingErrorClass = 'advisor-unavailable' | 'deadline';
+export const ADVISOR_OUTCOMES = [
+  'none',
+  'bypassed',
+  'jev',
+  'jev-fallback',
+  'classifier',
+  'classifier-fallback',
+] as const;
+export type AdvisorOutcome = (typeof ADVISOR_OUTCOMES)[number];
+export const isAdvisorOutcome = (value: unknown): value is AdvisorOutcome =>
+  ADVISOR_OUTCOMES.some((outcome) => outcome === value);
 
 export interface RoutingDecision {
   profile: string;
@@ -142,6 +153,7 @@ export interface RoutingDecision {
   reasonCode: RoutingReasonCode;
   routingLatencyMs?: number | undefined;
   errorClass?: RoutingErrorClass | undefined;
+  advisor?: AdvisorOutcome | undefined;
   thinking: ThinkingLevel;
   timestamp: number;
   isClassifier?: boolean | undefined;

package/extensions/ui.ts

@@ -5,7 +5,7 @@ import type {
   RouterThinkingByProfile,
   RoutingDecision,
 } from './types';
-import { isRoutingReasonCode } from './types';
+import { isAdvisorOutcome, isRoutingReasonCode } from './types';
 
 const getDecisionFlags = (decision: RoutingDecision): string[] => {
   const flags: string[] = [];
@@ -19,9 +19,53 @@ export const formatDecisionSource = (decision: RoutingDecision): string =>
     ? decision.reasonCode
     : '';
 
+export const formatAdvisorLabel = (
+  decision: RoutingDecision,
+): string | undefined => {
+  if (!isAdvisorOutcome(decision.advisor)) return undefined;
+  switch (decision.advisor) {
+    case 'none':
+    case 'bypassed':
+      return undefined;
+    case 'jev':
+      return '🧭 Jev ✓';
+    case 'jev-fallback':
+      return '🧭 Jev ↪ base';
+    case 'classifier':
+      return '🧠 Classifier ✓';
+    case 'classifier-fallback':
+      return '🧠 Classifier ↪ base';
+    default:
+      return undefined;
+  }
+};
+
+export const formatAdvisorDetail = (
+  decision: RoutingDecision,
+): string | undefined => {
+  const label = formatAdvisorLabel(decision);
+  if (!label) return undefined;
+  const latency = Number.isFinite(decision.routingLatencyMs)
+    ? ` · ${Math.round(decision.routingLatencyMs ?? 0)}ms`
+    : '';
+  return `${label}${latency}`;
+};
+
+export const formatAdvisorFooter = (decision: RoutingDecision): string => {
+  if (
+    !decision.advisor ||
+    decision.advisor === 'none' ||
+    decision.advisor === 'bypassed'
+  )
+    return '';
+  const label = formatAdvisorLabel(decision);
+  return label ? ` · ${label}` : '';
+};
+
 export const formatDecision = (decision: RoutingDecision): string => {
   const source = formatDecisionSource(decision);
-  return `${decision.profile}: ${decision.tier} -> ${decision.targetProvider}/${decision.targetModelId} [${decision.thinking}]${source ? ` (${source})` : ''}`;
+  const advisor = formatAdvisorLabel(decision);
+  return `${decision.profile}: ${decision.tier} -> ${decision.targetProvider}/${decision.targetModelId} [${decision.thinking}]${source ? ` (${source})` : ''}${advisor ? ` [${advisor}]` : ''}`;
 };
 
 export const formatPinSummary = (
@@ -79,7 +123,7 @@ export const updateStatus = (
 
     let statusText: string;
     if (lastDecision && matchesProfile && matchesPin) {
-      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`;
+      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})${formatAdvisorFooter(lastDecision)}`;
     } else {
       statusText = `router:${activeRouterProfile}${pinLabel} -> waiting`;
     }
@@ -103,18 +147,13 @@ export const updateStatus = (
   if (lastDecision && lastDecision.profile === statusProfile) {
     const flags = getDecisionFlags(lastDecision);
     const flagsStr = flags.length > 0 ? ` [${flags.join(',')}]` : '';
+    const advisorDetail = formatAdvisorDetail(lastDecision);
 
     widgetLines.push(
       `Route: ${lastDecision.tier}${flagsStr} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`,
       `Phase: ${lastDecision.phase}`,
       `Source: ${formatDecisionSource(lastDecision) || 'unknown'}`,
-      ...(Number.isFinite(lastDecision.routingLatencyMs)
-        ? [`Routing: ${Math.round(lastDecision.routingLatencyMs ?? 0)}ms`]
-        : []),
-      ...(lastDecision.errorClass === 'deadline' ||
-      lastDecision.errorClass === 'advisor-unavailable'
-        ? [`Routing error: ${lastDecision.errorClass}`]
-        : []),
+      ...(advisorDetail ? [advisorDetail] : []),
     );
   } else if (!routerEnabled && lastNonRouterModel) {
     widgetLines.push(`Fallback: ${lastNonRouterModel}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-model-router",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "files": [
     "extensions",