@alexeiled/pi-model-router 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.2 - 2026-09-21
+
+- Increase the default Jev timeout from 750 ms to 1500 ms. User-level `jev.timeoutMs` now sets the total advisory budget without the previous hidden 750 ms cap or an arbitrary upper cap. Positive finite values within Node's timer range are accepted, including 4000 and 5000 ms. Existing explicit shorter timeouts remain valid.
+- Fix delayed Pi thinking-display events being mistaken for user changes and overriding every routing tier. Internal display updates now preserve configured per-tier effort; explicit user overrides still apply.
+- Keep privacy opt-in, confidence validation, caller cancellation, and direct baseline fallback unchanged. No additional advisory requests or retries.
+- Add regression coverage for delayed valid Jev responses, configurable deadlines, internal thinking events, and Astra/Luna candidate selection. Align configuration examples and operator documentation.
+
+## 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

@@ -95,7 +95,7 @@ pi -e ./extensions/index.ts
 
 - Generation and classification use Pi's provider registry, including native/custom providers and credential-specific URLs. Only the optional Jev advisor uses separate HTTPS transport.
 - Fallbacks run only before content is emitted; cancellation does not retry. Every target must support the requested input and exact thinking level; explicit unsupported effort is not silently reduced. Omitted thinking defaults to `off` for non-reasoning targets, including fallbacks.
-- Jev gets at most 750 ms (or its shorter configured timeout and remaining time in the 1500 ms advisory budget), with no retry. The separate classifier-only compatibility path retains its 10-second bound and 256-token output limit. Failure or uncertainty means eligible baseline; caller cancellation stops generation.
+- Jev gets a configurable total advisory budget via `jev.timeoutMs`: 1500 ms by default, with no additional routing cap or retry. The separate classifier-only compatibility path retains its 10-second bound and 256-token output limit. Failure or uncertainty means eligible baseline; caller cancellation stops generation.
 - Valid same-turn tool continuations reuse the actual prior route before either advisor. Pins, budget policy and a single eligible primary candidate also bypass advisors. Invalid continuations choose a compatible local route without advice; incompatible Google thought-signature replay fails plainly.
 - Pi owns tool execution permissions and per-request authentication. The router checks configured provider/profile identity, not which backend login is currently behind a provider. No private authentication storage is read.
 - 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.
@@ -199,7 +199,7 @@ profile opt-ins, are ignored with a warning, before merging user credentials.
     "apiKey": "<rendered by chezmoi/1Password>",
     "endpoint": "https://api.typesafe.ai/v1/systemone",
     "model": "jev-1.13.0",
-    "timeoutMs": 750,
+    "timeoutMs": 1500,
     "confidenceThreshold": 0.65,
     "maxStateChars": 12000,
     "mode": "advisory"
@@ -218,14 +218,22 @@ profile opt-ins, are ignored with a warning, before merging user credentials.
 
 The endpoint, model, timeout, confidence threshold, state limit and mode shown
 above are defaults. Only HTTPS endpoints without embedded credentials, query
-parameters or fragments are accepted. Timeout must be positive and at most
-1500 ms, confidence must be 0–1, and the context limit must be 1–12000 characters.
-Provider routing further caps Jev at 750 ms within the fixed 1500 ms advisory
-budget; increasing `timeoutMs` does not extend those caps. Values above 750 ms
-are normalized to 750 ms with a configuration warning. The separate classifier-only
+parameters or fragments are accepted. `timeoutMs` defaults to 1500 ms and must
+be a positive finite number within Node's timer range (at most 2147483647 ms).
+There is no product-level cap: 4000 or 5000 ms are valid if you prefer waiting
+longer before falling back. It sets the total Jev advisory budget, including
+request and response-body time; there is no separate 750 ms cap. Confidence must
+be 0–1, and the context limit must be 1–12000 characters. The separate classifier-only
 path keeps a 10-second bound. Neither path retries or starts generation after
 caller cancellation.
 
+If Jev frequently falls back because requests time out, try `"timeoutMs": 3000`
+in your user config. Existing explicit values such as 750 remain unchanged;
+remove the field or set it to 1500 to use the new default. Increasing the timeout
+does not lower the confidence threshold or guarantee a different route. After
+upgrading, start a new Pi session; use `/router thinking auto` to clear any
+unwanted effort override in an existing session.
+
 **External data:** Jev receives bounded, role-labelled recent user/assistant/tool
 text, prioritizing the latest user request within `maxStateChars`, plus candidate
 tier/model/thinking identifiers. Truncation is deterministic, with no keyword
@@ -244,6 +252,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 +283,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/config.ts

@@ -376,10 +376,13 @@ export const normalizeTierConfig = (
   };
 };
 
+// Node turns larger setTimeout delays into 1 ms rather than waiting longer.
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
 export const DEFAULT_JEV_CONFIG = {
   endpoint: 'https://api.typesafe.ai/v1/systemone',
   model: 'jev-1.13.0',
-  timeoutMs: 750,
+  timeoutMs: 1500,
   confidenceThreshold: 0.65,
   maxStateChars: 12000,
   mode: 'advisory',
@@ -420,7 +423,7 @@ export const normalizeJevConfig = (
     typeof value.timeoutMs !== 'number' ||
     !Number.isFinite(value.timeoutMs) ||
     value.timeoutMs <= 0 ||
-    value.timeoutMs > 1500 ||
+    value.timeoutMs > MAX_TIMER_DELAY_MS ||
     typeof value.confidenceThreshold !== 'number' ||
     !Number.isFinite(value.confidenceThreshold) ||
     value.confidenceThreshold < 0 ||
@@ -434,10 +437,6 @@ export const normalizeJevConfig = (
       (typeof value.apiKey !== 'string' || /[\r\n]/.test(value.apiKey)))
   )
     return invalid();
-  if (value.timeoutMs > 750)
-    warnings.push(
-      'Jev timeoutMs clamped to the effective 750 ms provider cap.',
-    );
   const apiKey = typeof value.apiKey === 'string' ? value.apiKey.trim() : '';
   if (value.enabled === true && !apiKey) {
     warnings.push('Jev disabled: missing user-config API key.');
@@ -447,7 +446,7 @@ export const normalizeJevConfig = (
     apiKey,
     endpoint: value.endpoint,
     model: value.model,
-    timeoutMs: Math.min(value.timeoutMs, 750),
+    timeoutMs: value.timeoutMs,
     confidenceThreshold: value.confidenceThreshold,
     maxStateChars: value.maxStateChars,
     mode: 'advisory',

package/extensions/index.ts

@@ -57,6 +57,10 @@ const routerExtension = (pi: ExtensionAPI) => {
   let isInitialized = false;
   let isInternalModelSwitch = false;
   let isInternalThinkingChange = false;
+  const pendingThinkingChanges: Array<{
+    previousLevel: ThinkingLevel;
+    level: ThinkingLevel;
+  }> = [];
   let ignoreStartupThinkingEvent = false;
 
   const runtimeState = {
@@ -142,13 +146,27 @@ const routerExtension = (pi: ExtensionAPI) => {
   };
 
   const setThinkingLevelInternally = (level: ThinkingLevel) => {
+    let previousLevel: ThinkingLevel;
+    try {
+      previousLevel = pi.getThinkingLevel();
+    } catch {
+      return; // The session runtime may already be torn down.
+    }
+    const change = { previousLevel, level };
+    pendingThinkingChanges.push(change);
     isInternalThinkingChange = true;
     try {
       pi.setThinkingLevel(level);
+      change.level = pi.getThinkingLevel();
     } catch {
       // Extension context may be stale after session teardown.
+      change.level = change.previousLevel;
     } finally {
       isInternalThinkingChange = false;
+      if (change.level === change.previousLevel) {
+        const index = pendingThinkingChanges.indexOf(change);
+        if (index >= 0) pendingThinkingChanges.splice(index, 1);
+      }
     }
   };
 
@@ -513,8 +531,21 @@ const routerExtension = (pi: ExtensionAPI) => {
 
   pi.on('thinking_level_select', (event, ctx) => {
     ensureInitializedFromContext(ctx);
+    if (isInternalThinkingChange) {
+      pendingThinkingChanges.pop();
+      return;
+    }
+    // Pi emits without awaiting extension handlers; earlier handlers can delay this echo.
+    const internalChange = pendingThinkingChanges.findIndex(
+      (change) =>
+        change.previousLevel === event.previousLevel &&
+        change.level === event.level,
+    );
+    if (internalChange >= 0) {
+      pendingThinkingChanges.splice(internalChange, 1);
+      return;
+    }
     if (!isInitialized || !routerEnabled || !selectedProfile) return;
-    if (isInternalThinkingChange) return;
     if (ignoreStartupThinkingEvent) {
       ignoreStartupThinkingEvent = false;
       return;

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,105 @@ 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 routingDeadline =
+              started + (useJev && jev ? jev.timeoutMs : 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,
+            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, {
+                taskSummary: getBoundedRecentContext(
                   context,
-                  undefined,
-                  classifier.thinking,
-                  options?.signal,
-                  routingDeadline,
-                ).catch(() => undefined);
-                options?.signal?.throwIfAborted();
-                pairs = available();
+                  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'),
+                  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 +623,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/model-router.example.json

@@ -5,7 +5,7 @@
     "apiKey": "<rendered by chezmoi/1Password in user config only>",
     "endpoint": "https://api.typesafe.ai/v1/systemone",
     "model": "jev-1.13.0",
-    "timeoutMs": 750,
+    "timeoutMs": 1500,
     "confidenceThreshold": 0.65,
     "maxStateChars": 12000,
     "mode": "advisory"

package/package.json

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