ultimate-pi 0.16.0 → 0.17.0

package/vendor/pi-model-router/extensions/provider.ts

@@ -19,15 +19,21 @@ import type {
   RouterTier,
   RouterPinByProfile,
   RouterThinkingByProfile,
+  SessionLock,
 } from './types.js';
 import { profileNames, parseCanonicalModelRef, ROUTER_TIERS } from './config.js';
 import {
   phaseForTier,
   buildRoutingDecision,
   decideRouting,
+  decideSessionLock,
   runClassifier,
   extractTextFromContent,
   hasImageAttachment,
+  buildSessionLockContext,
+  sessionLockToRoutingDecision,
+  routingDecisionToSessionLock,
+  applyThinkingToDecision,
 } from './routing.js';
 
 export const createErrorMessage = (
@@ -138,6 +144,8 @@ export const registerRouterProvider = (
     readonly thinkingByProfile: RouterThinkingByProfile;
     readonly pinnedTierByProfile: RouterPinByProfile;
     accumulatedCost: number;
+    get sessionLock(): SessionLock | undefined;
+    set sessionLock(v: SessionLock | undefined);
   },
   actions: {
     persistState: () => void;
@@ -217,26 +225,111 @@ export const registerRouterProvider = (
           state.routerEnabled = true;
 
           const pinnedTier = state.pinnedTierByProfile[model.id];
+          const thinkingOverrides = state.thinkingByProfile[model.id];
           const isBudgetExceeded =
             state.currentConfig.maxSessionBudget !== undefined &&
             state.accumulatedCost >= state.currentConfig.maxSessionBudget;
 
-          let decision: RoutingDecision = decideRouting(
+          const checkModelSupportsImage = (modelRef: string) => {
+            try {
+              const { provider, modelId } = parseCanonicalModelRef(modelRef);
+              const m = state.currentModelRegistry?.find(provider, modelId);
+              return m?.input?.includes('image') ?? false;
+            } catch {
+              return false;
+            }
+          };
+
+          const pickVisionCapableLock = (
+            lockDecision: RoutingDecision,
+          ): RoutingDecision => {
+            if (!hasImageAttachment(context)) return lockDecision;
+            const candidates = [
+              lockDecision.targetLabel,
+              ...(profile[lockDecision.tier].fallbacks ?? []),
+            ];
+            if (candidates.some(checkModelSupportsImage)) return lockDecision;
+            for (const tier of ROUTER_TIERS) {
+              const refs = [profile[tier].model, ...(profile[tier].fallbacks ?? [])];
+              const visionRef = refs.find(checkModelSupportsImage);
+              if (visionRef) {
+                const { provider, modelId } = parseCanonicalModelRef(visionRef);
+                return {
+                  ...lockDecision,
+                  tier,
+                  targetLabel: visionRef,
+                  targetProvider: provider,
+                  targetModelId: modelId,
+                  reasoning: `${lockDecision.reasoning} | Vision-capable model for image input.`,
+                };
+              }
+            }
+            return lockDecision;
+          };
+
+          let lock = state.sessionLock;
+          if (!lock || lock.profile !== model.id) {
+            const lockContext = buildSessionLockContext(context);
+            let lockDecision = decideSessionLock(
+              lockContext,
+              model.id,
+              profile,
+              pinnedTier,
+              thinkingOverrides,
+              state.currentConfig.phaseBias,
+              state.currentConfig.rules,
+            );
+
+            if (
+              state.currentConfig.classifierModel &&
+              !pinnedTier &&
+              !lockDecision.isRuleMatched
+            ) {
+              const classifierResult = await runClassifier(
+                state.currentConfig.classifierModel,
+                state.currentModelRegistry,
+                lockContext,
+                undefined,
+              );
+              if (classifierResult) {
+                lockDecision = buildRoutingDecision(
+                  model.id,
+                  profile,
+                  classifierResult.tier,
+                  phaseForTier(classifierResult.tier),
+                  `Session lock classifier: ${classifierResult.reasoning}`,
+                  thinkingOverrides,
+                  true,
+                );
+              }
+            }
+
+            lockDecision = pickVisionCapableLock(lockDecision);
+            lock = routingDecisionToSessionLock(lockDecision);
+            state.sessionLock = lock;
+          }
+
+          const lockedBase = sessionLockToRoutingDecision(
+            lock,
+            profile,
+            thinkingOverrides,
+          );
+
+          let thinkingDecision: RoutingDecision = decideRouting(
             context,
             model.id,
             profile,
             state.lastDecision,
             pinnedTier,
-            state.thinkingByProfile[model.id],
+            thinkingOverrides,
             state.currentConfig.phaseBias,
             state.currentConfig.rules,
             isBudgetExceeded,
           );
 
-          // Optional Context Trigger Upgrade
           if (
             state.currentConfig.largeContextThreshold &&
-            decision.tier !== 'high' &&
+            thinkingDecision.tier !== 'high' &&
             state.lastExtensionContext
           ) {
             try {
@@ -245,28 +338,24 @@ export const registerRouterProvider = (
                 usage?.tokens &&
                 usage.tokens > state.currentConfig.largeContextThreshold
               ) {
-                decision = buildRoutingDecision(
-                  model.id,
-                  profile,
-                  'high',
-                  'planning',
-                  `Context usage (${usage.tokens}) exceeds threshold (${state.currentConfig.largeContextThreshold}). Forced high tier.`,
-                  state.thinkingByProfile[model.id],
-                  false,
-                );
-                decision.isContextTriggered = true;
+                thinkingDecision = {
+                  ...thinkingDecision,
+                  tier: 'high',
+                  phase: 'planning',
+                  reasoning: `Context usage (${usage.tokens}) exceeds threshold (${state.currentConfig.largeContextThreshold}). Forced high thinking.`,
+                  isContextTriggered: true,
+                };
               }
-            } catch (e) {
+            } catch (_e) {
               // ignore
             }
           }
 
-          // Classifier Override
           if (
             state.currentConfig.classifierModel &&
             !pinnedTier &&
-            !decision.isContextTriggered &&
-            !decision.isRuleMatched
+            !thinkingDecision.isContextTriggered &&
+            !thinkingDecision.isRuleMatched
           ) {
             const classifierResult = await runClassifier(
               state.currentConfig.classifierModel,
@@ -275,24 +364,34 @@ export const registerRouterProvider = (
               state.lastDecision?.phase,
             );
             if (classifierResult) {
-              decision = buildRoutingDecision(
+              thinkingDecision = buildRoutingDecision(
                 model.id,
                 profile,
                 classifierResult.tier,
                 phaseForTier(classifierResult.tier),
-                `Classifier: ${classifierResult.reasoning}`,
-                state.thinkingByProfile[model.id],
+                `Thinking classifier: ${classifierResult.reasoning}`,
+                thinkingOverrides,
                 true,
               );
-              if (isBudgetExceeded && decision.tier === 'high') {
-                decision.tier = 'medium';
-                decision.phase = 'implementation';
-                decision.reasoning = `Budget exceeded. Downgraded classifier decision to medium. (Original: ${decision.reasoning})`;
-                decision.isBudgetForced = true;
+              if (isBudgetExceeded && thinkingDecision.tier === 'high') {
+                thinkingDecision = {
+                  ...thinkingDecision,
+                  tier: 'medium',
+                  phase: 'implementation',
+                  reasoning: `Budget exceeded. Downgraded thinking to medium. (Original: ${thinkingDecision.reasoning})`,
+                  isBudgetForced: true,
+                };
               }
             }
           }
 
+          let decision = applyThinkingToDecision(
+            lockedBase,
+            thinkingDecision,
+            profile,
+            thinkingOverrides,
+          );
+
           const lastMessage = context.messages[context.messages.length - 1];
           const previousDecision = state.lastDecision;
           const isGoogleThinkingToolContinuation =
@@ -302,7 +401,7 @@ export const registerRouterProvider = (
             previousDecision.thinking !== 'off' &&
             decision.targetProvider === 'google' &&
             decision.thinking !== 'off' &&
-            previousDecision.targetLabel !== decision.targetLabel;
+            previousDecision.targetLabel === decision.targetLabel;
 
           if (isGoogleThinkingToolContinuation) {
             decision = {
@@ -319,56 +418,6 @@ export const registerRouterProvider = (
             };
           }
 
-          const imageAttached = hasImageAttachment(context);
-          if (imageAttached) {
-            const checkModelSupportsImage = (modelRef: string) => {
-              try {
-                const { provider, modelId } = parseCanonicalModelRef(modelRef);
-                const m = state.currentModelRegistry?.find(provider, modelId);
-                return m?.input?.includes('image') ?? false;
-              } catch {
-                return false;
-              }
-            };
-
-            const tierModels = [
-              decision.targetLabel,
-              ...(profile[decision.tier].fallbacks ?? []),
-            ];
-            if (!tierModels.some(checkModelSupportsImage)) {
-              const tiersToTry: RouterTier[] =
-                decision.tier === 'low'
-                  ? ['medium', 'high']
-                  : decision.tier === 'medium'
-                    ? ['high']
-                    : [];
-
-              let foundTier: RouterTier | undefined;
-              for (const t of tiersToTry) {
-                const tModels = [
-                  profile[t].model,
-                  ...(profile[t].fallbacks ?? []),
-                ];
-                if (tModels.some(checkModelSupportsImage)) {
-                  foundTier = t;
-                  break;
-                }
-              }
-
-              if (foundTier) {
-                decision = buildRoutingDecision(
-                  model.id,
-                  profile,
-                  foundTier,
-                  phaseForTier(foundTier),
-                  `Forced ${foundTier} tier because the originally routed ${decision.tier} tier does not support image attachments.`,
-                  state.thinkingByProfile[model.id],
-                  false,
-                );
-              }
-            }
-          }
-
           state.lastDecision = decision;
           actions.recordDebugDecision(decision);
 
@@ -376,10 +425,12 @@ export const registerRouterProvider = (
             actions.updateStatus(state.lastExtensionContext);
           }
 
+          const lockTier = lock.tier;
           let modelsToTry = [
-            decision.targetLabel,
-            ...(profile[decision.tier].fallbacks ?? []),
+            lock.modelRef,
+            ...(profile[lockTier].fallbacks ?? []),
           ];
+          const imageAttached = hasImageAttachment(context);
           if (imageAttached) {
             modelsToTry = modelsToTry.filter((modelRef) => {
               try {

package/vendor/pi-model-router/extensions/routing.ts

@@ -7,6 +7,7 @@ import type {
   RoutingDecision,
   RoutingRule,
   RouterThinkingByTier,
+  SessionLock,
 } from './types.js';
 import { parseCanonicalModelRef, isRouterTier } from './config.js';
 
@@ -38,6 +39,153 @@ export const getLastUserText = (context: Context): string => {
   return '';
 };
 
+export const getFirstUserText = (context: Context): string => {
+  for (const message of context.messages) {
+    if (message.role === 'user') {
+      return extractTextFromContent(message.content).trim();
+    }
+  }
+  return '';
+};
+
+/** Context for one-shot session model lock: system prompt + first user message only. */
+export const buildSessionLockContext = (context: Context): Context => {
+  const firstUser = context.messages.find((message) => message.role === 'user');
+  const messages = firstUser ? [firstUser] : context.messages.slice(0, 1);
+  return { ...context, messages };
+};
+
+export const sessionLockToRoutingDecision = (
+  lock: SessionLock,
+  profile: RouterProfile,
+  thinkingOverrides?: RouterThinkingByTier,
+): RoutingDecision => {
+  const routed = profile[lock.tier];
+  const { provider, modelId } = parseCanonicalModelRef(lock.modelRef);
+  const baseThinking =
+    routed.thinking ??
+    (lock.tier === 'high' ? 'high' : lock.tier === 'low' ? 'low' : 'medium');
+  const effectiveThinking = thinkingOverrides?.[lock.tier] ?? baseThinking;
+  return {
+    profile: lock.profile,
+    tier: lock.tier,
+    phase: phaseForTier(lock.tier),
+    targetProvider: provider,
+    targetModelId: modelId,
+    targetLabel: lock.modelRef,
+    reasoning: lock.reasoning,
+    thinking: effectiveThinking,
+    timestamp: Date.now(),
+  };
+};
+
+export const routingDecisionToSessionLock = (
+  decision: RoutingDecision,
+): SessionLock => ({
+  profile: decision.profile,
+  tier: decision.tier,
+  modelRef: decision.targetLabel,
+  reasoning: decision.reasoning,
+});
+
+/** Text used to score initial session complexity (system prompt + first user message). */
+export const getSessionLockAnalysisText = (context: Context): string => {
+  const lockContext = buildSessionLockContext(context);
+  const system = (context.systemPrompt ?? '').trim();
+  const firstUser = getFirstUserText(lockContext);
+  if (system && firstUser) return `${system}\n\n${firstUser}`;
+  return system || firstUser || '';
+};
+
+/**
+ * One-shot tier pick for session model lock (no prior-turn stickiness).
+ */
+export const decideSessionLock = (
+  context: Context,
+  profileName: string,
+  profile: RouterProfile,
+  pinnedTier?: RouterTier,
+  thinkingOverrides?: RouterThinkingByTier,
+  phaseBias = 0.5,
+  rules?: RoutingRule[],
+): RoutingDecision => {
+  const analysisText = getSessionLockAnalysisText(context);
+  const synthetic: Context = {
+    systemPrompt: context.systemPrompt,
+    messages: analysisText
+      ? [{ role: 'user', content: analysisText, timestamp: Date.now() }]
+      : [],
+  };
+  return decideRouting(
+    synthetic,
+    profileName,
+    profile,
+    undefined,
+    pinnedTier,
+    thinkingOverrides,
+    phaseBias,
+    rules,
+    false,
+  );
+};
+
+/** Per-turn thinking tier merged onto a session-locked model decision. */
+export const applyThinkingToDecision = (
+  locked: RoutingDecision,
+  thinkingDecision: RoutingDecision,
+  profile: RouterProfile,
+  thinkingOverrides?: RouterThinkingByTier,
+): RoutingDecision => {
+  const tier = thinkingDecision.tier;
+  const routed = profile[tier];
+  const baseThinking =
+    routed.thinking ??
+    (tier === 'high' ? 'high' : tier === 'low' ? 'low' : 'medium');
+  const effectiveThinking = thinkingOverrides?.[tier] ?? baseThinking;
+
+  return {
+    profile: locked.profile,
+    tier,
+    phase: thinkingDecision.phase,
+    targetProvider: locked.targetProvider,
+    targetModelId: locked.targetModelId,
+    targetLabel: locked.targetLabel,
+    reasoning: `${locked.reasoning} | Thinking: ${thinkingDecision.reasoning}`,
+    thinking: effectiveThinking,
+    timestamp: Date.now(),
+    isClassifier: thinkingDecision.isClassifier,
+    isRuleMatched: thinkingDecision.isRuleMatched,
+    isBudgetForced: thinkingDecision.isBudgetForced,
+    isContextTriggered: thinkingDecision.isContextTriggered,
+  };
+};
+
+/** Harness subagents: tier from system prompt + optional first user line. */
+export const resolveTierFromPrompt = (
+  systemPrompt: string,
+  userText: string,
+  profileName: string,
+  profile: RouterProfile,
+  rules?: RoutingRule[],
+  phaseBias = 0.5,
+): RouterTier => {
+  const context: Context = {
+    systemPrompt,
+    messages: userText
+      ? [{ role: 'user', content: userText, timestamp: Date.now() }]
+      : [],
+  };
+  return decideSessionLock(
+    context,
+    profileName,
+    profile,
+    undefined,
+    undefined,
+    phaseBias,
+    rules,
+  ).tier;
+};
+
 export const getRecentConversationText = (
   context: Context,
   limit = 6,

package/vendor/pi-model-router/extensions/state.ts

@@ -3,6 +3,7 @@ import type {
   RouterThinkingByProfile,
   RoutingDecision,
   RouterPersistedState,
+  SessionLock,
 } from './types.js';
 
 export const isRouterPersistedState = (
@@ -30,6 +31,7 @@ export const buildPersistedState = (
   lastDecision: RoutingDecision | undefined,
   lastNonRouterModel: string | undefined,
   accumulatedCost: number,
+  sessionLock: SessionLock | undefined,
 ): RouterPersistedState => {
   return {
     enabled: routerEnabled,
@@ -37,6 +39,7 @@ export const buildPersistedState = (
     pinTier: pinnedTierByProfile[selectedProfile],
     pinByProfile: { ...pinnedTierByProfile },
     thinkingByProfile: { ...thinkingByProfile },
+    sessionLock,
     debugEnabled,
     widgetEnabled,
     debugHistory,

package/vendor/pi-model-router/extensions/types.ts

@@ -53,12 +53,21 @@ export interface RoutingDecision {
   isRuleMatched?: boolean;
 }
 
+/** Fixed model for a router profile for the lifetime of a session (or until profile switch). */
+export interface SessionLock {
+  profile: string;
+  tier: RouterTier;
+  modelRef: string;
+  reasoning: string;
+}
+
 export interface RouterPersistedState {
   enabled: boolean;
   selectedProfile: string;
   pinTier?: RouterTier;
   pinByProfile?: RouterPinByProfile;
   thinkingByProfile?: RouterThinkingByProfile;
+  sessionLock?: SessionLock;
   debugEnabled?: boolean;
   widgetEnabled?: boolean;
   debugHistory?: RoutingDecision[];

package/vendor/pi-model-router/extensions/ui.ts

@@ -4,6 +4,7 @@ import type {
   RouterConfig,
   RouterPinByProfile,
   RouterThinkingByProfile,
+  SessionLock,
 } from './types.js';
 
 const getEffectiveThinking = (
@@ -63,6 +64,7 @@ export const updateStatus = (
   accumulatedCost: number,
   widgetEnabled: boolean,
   currentConfig: RouterConfig,
+  sessionLock: SessionLock | undefined,
 ) => {
   const activeRouterProfile = routerEnabled ? selectedProfile : undefined;
   const statusProfile = selectedProfile;
@@ -81,7 +83,13 @@ export const updateStatus = (
         activeRouterProfile,
         lastDecision,
       );
-      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${effectiveThinking})`;
+      const locked =
+        sessionLock?.profile === activeRouterProfile
+          ? sessionLock.modelRef
+          : lastDecision.targetLabel;
+      statusText = `router:${activeRouterProfile}${pinLabel} locked:${locked} thinking:${lastDecision.tier} (${effectiveThinking})`;
+    } else if (sessionLock?.profile === activeRouterProfile) {
+      statusText = `router:${activeRouterProfile}${pinLabel} locked:${sessionLock.modelRef} -> waiting`;
     } else {
       statusText = `router:${activeRouterProfile}${pinLabel} -> waiting`;
     }
@@ -104,6 +112,11 @@ export const updateStatus = (
         ? ` / $${currentConfig.maxSessionBudget.toFixed(2)}`
         : ''),
   ];
+  if (sessionLock && sessionLock.profile === statusProfile) {
+    widgetLines.push(
+      `Locked model: ${sessionLock.modelRef} (lock tier ${sessionLock.tier})`,
+    );
+  }
   if (lastDecision && lastDecision.profile === statusProfile) {
     const effectiveThinking = getEffectiveThinking(
       thinkingByProfile,
@@ -114,8 +127,9 @@ export const updateStatus = (
     const flagsStr = flags.length > 0 ? ` [${flags.join(',')}]` : '';
 
     widgetLines.push(
-      `Route: ${lastDecision.tier}${flagsStr} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${effectiveThinking})`,
+      `Thinking: ${lastDecision.tier}${flagsStr} (${effectiveThinking})`,
       `Phase: ${lastDecision.phase}`,
+      `Delegate: ${lastDecision.targetProvider}/${lastDecision.targetModelId}`,
     );
   } else if (!routerEnabled && lastNonRouterModel) {
     widgetLines.push(`Fallback: ${lastNonRouterModel}`);