@alexeiled/pi-model-router 0.6.5 → 0.7.0

package/extensions/commands.ts

@@ -7,7 +7,6 @@ import type { AutocompleteItem } from '@earendil-works/pi-tui';
 import {
   getUnsupportedTiers,
   isRouterPinValue,
-  isRouterTier,
   isThinkingLevel,
   parseCanonicalModelRef,
   profileNames,
@@ -21,7 +20,6 @@ import type {
   RouterConfig,
   RouterPinByProfile,
   RouterThinkingByProfile,
-  RouterTier,
   RoutingDecision,
 } from './types';
 import {
@@ -34,6 +32,42 @@ import {
   formatThinkingSummary,
 } from './ui';
 
+/** One verb per concern; state is shown by the verb that changes it. */
+const VERBS = [
+  { name: 'pin', desc: 'Pin the active profile to a tier, or auto' },
+  { name: 'thinking', desc: 'Override thinking for every tier, or auto' },
+  { name: 'log', desc: 'Recent decisions and Jev stats; on, off or clear' },
+  { name: 'widget', desc: 'Toggle the status widget' },
+  { name: 'off', desc: 'Leave the router and restore the previous model' },
+  { name: 'reload', desc: 'Reload model-router.json' },
+  { name: 'help', desc: 'Show usage' },
+] as const;
+
+/** Removed verbs answer with the replacement instead of acting. */
+const RETIRED_VERBS: Record<string, string> = {
+  status: '/router',
+  profile: '/router <profile>',
+  disable: '/router off',
+  fix: '/router pin <tier>',
+  debug: '/router log',
+  '?': '/router help',
+};
+
+const LOG_ACTIONS = ['on', 'off', 'clear'] as const;
+const THINKING_VALUES = ['auto', ...THINKING_LEVELS] as const;
+
+const USAGE = [
+  '/router                        status',
+  '/router <profile>              switch profile (enables the router)',
+  '/router off                    leave the router; restore the previous model',
+  '/router pin <tier|auto>        pin the active profile to high|medium|low|micro, or clear',
+  '/router thinking <level|auto>  override thinking for every tier, or clear',
+  '/router log [on|off|clear]     recent decisions and Jev stats; control collection',
+  '/router widget                 toggle the status widget',
+  '/router reload                 reload model-router.json',
+  '/router help                   this text',
+].join('\n');
+
 export const registerCommands = (
   pi: ExtensionAPI,
   state: {
@@ -66,503 +100,224 @@ export const registerCommands = (
     syncPiThinkingLevel: (level: ThinkingLevel) => void;
   },
 ) => {
-  const SUBCOMMAND_DETAILS = [
-    { name: 'status', desc: 'Show current router status' },
-    { name: 'profile', desc: 'Switch to a different router profile' },
-    { name: 'pin', desc: 'Pin routing for a profile to a specific tier' },
-    { name: 'thinking', desc: 'Override thinking level for a tier or profile' },
-    { name: 'disable', desc: 'Disable the router and restore last model' },
-    {
-      name: 'fix',
-      desc: 'Correct the last routing decision and pin that tier',
-    },
-    { name: 'widget', desc: 'Toggle the router status widget' },
-    {
-      name: 'debug',
-      desc: 'Inspect Jev stats or control router debug history',
-    },
-    { name: 'reload', desc: 'Reload the model router configuration' },
-    { name: 'help', desc: 'Show usage help for subcommands' },
-  ];
-
-  const getSubcommandCompletions = (
-    prefix: string,
-  ): AutocompleteItem[] | null => {
-    const items = SUBCOMMAND_DETAILS.filter((s) =>
-      s.name.startsWith(prefix),
-    ).map((s) => ({
-      value: s.name,
-      label: s.name,
-      description: s.desc,
-    }));
-    return items.length > 0 ? items : null;
-  };
-
-  const getPinCompletions = (args: string[]): AutocompleteItem[] | null => {
-    // pin <tier|auto>
-    if (args.length <= 1) {
-      const token = args[0] ?? '';
-      const items = ROUTER_PIN_VALUES.filter((value) =>
-        value.startsWith(token),
-      ).map((value) => ({
-        value,
-        label: value,
-        description:
-          value === 'auto'
-            ? 'Restore auto-routing (clear pin) for the active profile'
-            : `Pin active profile to ${value} tier`,
-      }));
-      return items.length > 0 ? items : null;
-    }
-    return null;
-  };
-
-  const getThinkingCompletions = (
-    args: string[],
-  ): AutocompleteItem[] | null => {
-    // thinking [tier] <level|auto>
-    const tierValues: RouterTier[] = [...ROUTER_TIERS];
-    const levelValues = ['auto', ...THINKING_LEVELS];
-
-    if (args.length <= 1) {
-      const token = args[0] ?? '';
-      return [
-        ...levelValues
-          .filter((v) => v.startsWith(token))
-          .map((v) => ({
-            value: v,
-            label: v,
-            description:
-              v === 'auto'
-                ? 'Restore default thinking level'
-                : `Set thinking level to ${v}`,
-          })),
-        ...tierValues
-          .filter((v) => v.startsWith(token))
-          .map((v) => ({
-            value: v,
-            label: v,
-            description: `Override thinking for ${v} tier`,
-          })),
-      ];
-    }
-
-    const tier = args[0];
-    if (isRouterTier(tier)) {
-      const levelPrefix = args[1] ?? '';
-      return levelValues
-        .filter((v) => v.startsWith(levelPrefix))
-        .map((v) => ({
-          value: `${tier} ${v}`,
-          label: `${tier} ${v}`,
-          description:
-            v === 'auto'
-              ? `Restore default thinking level for ${tier} tier`
-              : `Set thinking level to ${v} for ${tier} tier`,
-        }));
-    }
+  const usage = (ctx: ExtensionContext, line: string) =>
+    ctx.ui.notify(`Usage: ${line}`, 'error');
 
-    return null;
+  const activeProfile = (ctx: ExtensionContext): string | undefined => {
+    if (!state.selectedProfile)
+      ctx.ui.notify(
+        'No router profile is active. Run /router <profile> first.',
+        'error',
+      );
+    return state.selectedProfile;
   };
 
-  const handleStatus = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 0) {
-      ctx.ui.notify('Usage: /router status (no arguments)', 'error');
-      return;
-    }
-    const names = profileNames(state.currentConfig).join(', ');
-    const jev = state.currentConfig.jev;
-    const input = jev?.context ?? DEFAULT_JEV_CONTEXT;
+  const showStatus = (ctx: ExtensionContext) => {
+    const profile = state.selectedProfile;
+    const config = state.currentConfig;
+    const jev = config.jev;
+    const context = jev?.context ?? DEFAULT_JEV_CONTEXT;
+    const cost =
+      `$${state.accumulatedCost.toFixed(4)}` +
+      (config.maxSessionBudget
+        ? ` / $${config.maxSessionBudget.toFixed(2)}`
+        : '');
     const lines = [
-      'Model Router Status:',
-      `Router enabled: ${state.routerEnabled ? 'yes' : 'off'}`,
-      `Selected profile: ${state.selectedProfile ?? 'none'}`,
-      `Selected profile pin: ${state.selectedProfile ? (state.pinnedTierByProfile[state.selectedProfile] ?? 'auto') : 'none'}`,
-      `Pins by profile: ${formatPinSummary(state.pinnedTierByProfile)}`,
-      `Thinking overrides: ${formatThinkingSummary(state.thinkingByProfile)}`,
-      `Widget: ${state.widgetEnabled ? 'on' : 'off'}`,
-      `Status line: ${state.currentConfig.ui?.statusLine ?? 'compact'}`,
+      `Router: ${state.routerEnabled ? 'on' : 'off'} · profile ${profile ?? 'none'} · available: ${profileNames(config).join(', ')}`,
+      `Pin: ${formatPinSummary(state.pinnedTierByProfile)} · thinking override: ${formatThinkingSummary(state.thinkingByProfile)}`,
+      `Baseline: ${profile ? (config.profiles[profile]?.baselineTier ?? 'automatic') : 'none'} · cost: ${cost} · widget: ${state.widgetEnabled ? 'on' : 'off'} · log: ${state.debugEnabled ? 'on' : 'off'} (${state.debugHistory.length} decisions)`,
       jev
-        ? `Jev context: ${input.previousTurns} prior turns; history≈${input.maxHistoryTokens} tokens; tools=${input.toolResults}/≈${input.maxToolTokens} tokens; state≈${jev.maxStateTokens} tokens`
-        : 'Jev context: not configured',
-      `Jev: ${state.currentConfig.jev?.enabled ? 'enabled' : 'disabled'} · profile opt-in: ${state.selectedProfile && state.currentConfig.profiles[state.selectedProfile]?.jev?.enabled ? 'yes' : 'no'} · timeout: ${state.currentConfig.jev?.timeoutMs ?? 1500}ms`,
-      'Jev confidence measures classification certainty, not model success.',
-      `Session cost: $${state.accumulatedCost.toFixed(4)}` +
-        (state.currentConfig.maxSessionBudget
-          ? ` / $${state.currentConfig.maxSessionBudget.toFixed(2)}`
-          : ''),
-      `Available profiles: ${names}`,
-      `Last non-router model: ${formatModelRef(state.lastNonRouterModel)}`,
-      `Debug: ${state.debugEnabled ? 'on' : 'off'}`,
-      `Debug history: ${state.debugHistory.length} decisions`,
-      `Baseline preference: ${state.selectedProfile ? (state.currentConfig.profiles[state.selectedProfile]?.baselineTier ?? 'automatic') : 'none'} (eligibility and budget still apply)`,
+        ? `Jev: ${jev.enabled ? 'enabled' : 'disabled'} · profile opt-in: ${profile && config.profiles[profile]?.jev?.enabled ? 'yes' : 'no'} · budget ${jev.timeoutMs}ms · context ${context.previousTurns} turns / ≈${context.maxHistoryTokens} history / ${context.toolResults} ≈${context.maxToolTokens} tool / ≈${jev.maxStateTokens} state tokens`
+        : 'Jev: not configured',
+      `Previous model: ${formatModelRef(state.lastNonRouterModel)}`,
       ...formatJevStats(state.debugHistory),
     ];
-    if (state.lastDecision) {
-      const advisorDetail = formatAdvisorDetail(state.lastDecision);
+    const last = state.lastDecision;
+    if (last) {
+      const source = formatDecisionSource(last);
+      const advisor = formatAdvisorDetail(last);
       lines.push(
-        `Last routed tier: ${state.lastDecision.tier}`,
-        `Last phase: ${state.lastDecision.phase}`,
-        `Last model: ${state.lastDecision.targetProvider}/${state.lastDecision.targetModelId} (${state.lastDecision.thinking})`,
-        ...(formatDecisionSource(state.lastDecision)
-          ? [`Reason: ${formatDecisionSource(state.lastDecision)}`]
-          : []),
-        ...(advisorDetail ? [advisorDetail] : []),
+        `Last: ${last.tier} → ${last.targetProvider}/${last.targetModelId} (${last.thinking})${source ? ` · ${source}` : ''}`,
+        ...(advisor ? [advisor] : []),
       );
     }
-    if (state.lastConfigWarnings && state.lastConfigWarnings.length > 0) {
+    if (state.lastConfigWarnings.length > 0)
       lines.push(
         '',
-        '⚠️ Configuration Warnings:',
-        ...state.lastConfigWarnings.map((w) => `  - ${w}`),
+        '⚠️ Configuration warnings:',
+        ...state.lastConfigWarnings.map((warning) => `  - ${warning}`),
       );
-    }
     ctx.ui.notify(lines.join('\n'), 'info');
     actions.updateStatus(ctx);
   };
 
-  const handleProfile = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 1) {
-      ctx.ui.notify('Usage: /router profile [name]', 'error');
-      return;
-    }
-    const profileName = args[0];
-    if (!profileName) {
-      ctx.ui.notify(
-        `Current profile: ${state.selectedProfile}. Available: ${profileNames(state.currentConfig).join(', ')}`,
-        'info',
-      );
-      return;
-    }
-    const success = await actions.switchToRouterProfile(profileName, ctx);
-    if (success) {
-      ctx.ui.notify(
-        `Switched to router profile: ${state.selectedProfile}`,
-        'info',
-      );
-    }
+  const handleProfile = async (name: string, ctx: ExtensionContext) => {
+    if (await actions.switchToRouterProfile(name, ctx))
+      ctx.ui.notify(`Router profile: ${state.selectedProfile}`, 'info');
   };
 
-  const handlePin = async (args: string[], ctx: ExtensionContext) => {
-    const currentProfile = state.selectedProfile;
-    if (!currentProfile) {
+  const handleOff = async (ctx: ExtensionContext) => {
+    if (!state.lastNonRouterModel) {
       ctx.ui.notify(
-        'No router profile is active. Select a router model first.',
-        'error',
+        'No previous non-router model recorded. Use /model to pick one.',
+        'warning',
       );
       return;
     }
-    if (args.length === 0) {
+    const { provider, modelId } = parseCanonicalModelRef(
+      state.lastNonRouterModel,
+    );
+    const target = ctx.modelRegistry.find(provider, modelId);
+    if (!target) {
       ctx.ui.notify(
-        [
-          `Profile: ${currentProfile}`,
-          `Pinned tier: ${state.pinnedTierByProfile[currentProfile] ?? 'auto'}`,
-          `Usage: /router pin <high|medium|low|micro|auto>`,
-        ].join('\n'),
-        'info',
+        `Previous model is unavailable: ${state.lastNonRouterModel}`,
+        'error',
       );
-      actions.updateStatus(ctx);
       return;
     }
-
-    if (args.length > 1) {
-      ctx.ui.notify('Usage: /router pin <high|medium|low|micro|auto>', 'error');
+    if (!(await pi.setModel(target))) {
+      ctx.ui.notify(`Failed to switch to ${state.lastNonRouterModel}`, 'error');
       return;
     }
+    state.routerEnabled = false;
+    actions.persistState();
+    actions.updateStatus(ctx);
+    ctx.ui.notify(`Router off. Restored ${state.lastNonRouterModel}`, 'info');
+  };
 
-    const pinValue = args[0];
-
-    if (!isRouterPinValue(pinValue)) {
+  const handlePin = (args: string[], ctx: ExtensionContext) => {
+    const profile = activeProfile(ctx);
+    if (!profile) return;
+    const value = args[0]?.toLowerCase();
+    if (args.length === 0) {
       ctx.ui.notify(
-        `Invalid router pin: ${pinValue}. Use one of: ${ROUTER_PIN_VALUES.join(', ')}`,
-        'error',
+        `Pin: ${state.pinnedTierByProfile[profile] ?? 'auto'} (profile ${profile})`,
+        'info',
       );
       return;
     }
-
-    const nextTier: RouterTier | undefined =
-      pinValue === 'auto' ? undefined : pinValue;
-    if (nextTier) {
-      state.pinnedTierByProfile[currentProfile] = nextTier;
-    } else {
-      delete state.pinnedTierByProfile[currentProfile];
+    if (args.length > 1 || !isRouterPinValue(value)) {
+      usage(ctx, `/router pin <${ROUTER_PIN_VALUES.join('|')}>`);
+      return;
     }
+    if (value === 'auto') delete state.pinnedTierByProfile[profile];
+    else state.pinnedTierByProfile[profile] = value;
     actions.persistState();
     actions.updateStatus(ctx);
     ctx.ui.notify(
-      nextTier
-        ? `Router pinned to ${nextTier}`
-        : `Router pin cleared; baseline routing restored`,
+      value === 'auto'
+        ? 'Router pin cleared; baseline routing restored'
+        : `Router pinned to ${value}`,
       'info',
     );
   };
 
-  const handleThinking = async (args: string[], ctx: ExtensionContext) => {
-    const currentProfile = state.selectedProfile;
-    if (!currentProfile) {
-      ctx.ui.notify(
-        'No router profile is active. Select a router model first.',
-        'error',
-      );
-      return;
-    }
+  const handleThinking = (args: string[], ctx: ExtensionContext) => {
+    const profile = activeProfile(ctx);
+    if (!profile) return;
+    const value = args[0]?.toLowerCase();
     if (args.length === 0) {
       ctx.ui.notify(
-        [
-          `Profile: ${currentProfile}`,
-          `Thinking overrides: ${JSON.stringify(state.thinkingByProfile[currentProfile] ?? {})}`,
-          'Usage: /router thinking <level|auto>           (applies to all tiers)',
-          '   or: /router thinking <tier> <level|auto>    (applies to one tier)',
-          'Note: not all tier models may support every thinking level.',
-        ].join('\n'),
+        `Thinking override: ${formatThinkingSummary(state.thinkingByProfile)}`,
         'info',
       );
       return;
     }
-
-    if (args.length > 2) {
-      ctx.ui.notify('Too many arguments for /router thinking.', 'error');
-      return;
-    }
-
-    let tier: RouterTier | 'all' | undefined;
-    let levelValue = '';
-
-    const levelValues = ['auto', ...THINKING_LEVELS];
-
-    if (args.length === 1) {
-      const level = args[0];
-      if (!level) return;
-      levelValue = level;
-      tier = 'all';
-    } else if (args.length === 2) {
-      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, low, or micro.`,
-          'error',
-        );
-        return;
-      }
-    }
-
-    if (tier !== 'all' && !tier) {
-      ctx.ui.notify(
-        `Invalid tier: ${tier}. Use high, medium, low, or micro.`,
-        'error',
-      );
-      return;
-    }
-    if (!levelValues.includes(levelValue)) {
-      ctx.ui.notify(
-        `Invalid thinking level: ${levelValue}. Use auto or: ${THINKING_LEVELS.join(', ')}`,
-        'error',
-      );
+    if (
+      args.length > 1 ||
+      !value ||
+      !THINKING_VALUES.some((level) => level === value)
+    ) {
+      usage(ctx, `/router thinking <${THINKING_VALUES.join('|')}>`);
       return;
     }
-
-    const nextLevel =
-      levelValue === 'auto'
-        ? undefined
-        : isThinkingLevel(levelValue)
-          ? levelValue
-          : undefined;
-    const overrides = { ...state.thinkingByProfile[currentProfile] };
-    const tiers = tier === 'all' ? ROUTER_TIERS : [tier];
-    for (const targetTier of tiers) {
-      if (nextLevel) overrides[targetTier] = nextLevel;
-      else delete overrides[targetTier];
-    }
-    const activeProfile = state.currentConfig.profiles[currentProfile];
+    const level = isThinkingLevel(value) ? value : undefined;
+    const config = state.currentConfig.profiles[profile];
     if (
-      nextLevel &&
-      activeProfile &&
+      level &&
+      config &&
       preservesRouteCoverage(
-        activeProfile,
+        config,
         (provider, id) => ctx.modelRegistry.find(provider, id),
-        overrides,
+        Object.fromEntries(ROUTER_TIERS.map((tier) => [tier, level])),
       ) === false
     ) {
       ctx.ui.notify(
-        `Router thinking unchanged: '${nextLevel}' leaves no eligible route.`,
+        `Router thinking unchanged: '${level}' leaves no eligible route.`,
         'warning',
       );
       return;
     }
-    state.thinkingByProfile[currentProfile] = overrides;
-    if (Object.keys(overrides).length === 0) {
-      delete state.thinkingByProfile[currentProfile];
-    }
-
-    actions.persistState();
-    actions.updateStatus(ctx);
-    if (nextLevel) {
-      actions.syncPiThinkingLevel(nextLevel);
-    } else if (state.lastDecision) {
-      actions.syncPiThinkingLevel(state.lastDecision.thinking);
-    }
-    // Only warn when the level isn't supported by some tiers; skip for 'off' and 'auto'
-    if (nextLevel && nextLevel !== 'off') {
-      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}. ` +
-            `${unsupported.join(', ')} tier${unsupported.length > 1 ? 's' : ''} may not support '${nextLevel}' and will be skipped when unsupported.`,
-          'warning',
-        );
-      }
-    }
-  };
-
-  const handleDisable = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 0) {
-      ctx.ui.notify('Usage: /router disable (no arguments)', 'error');
-      return;
-    }
-    if (!state.lastNonRouterModel) {
-      ctx.ui.notify(
-        'No previous non-router model recorded. Use /model to pick a concrete model.',
-        'warning',
-      );
-      return;
-    }
-    const { provider, modelId } = parseCanonicalModelRef(
-      state.lastNonRouterModel,
-    );
-    const targetModel = ctx.modelRegistry.find(provider, modelId);
-    if (!targetModel) {
-      ctx.ui.notify(
-        `Recorded non-router model is unavailable: ${state.lastNonRouterModel}`,
-        'error',
+    if (level)
+      state.thinkingByProfile[profile] = Object.fromEntries(
+        ROUTER_TIERS.map((tier) => [tier, level]),
       );
-      return;
-    }
-    const success = await pi.setModel(targetModel);
-    if (!success) {
-      ctx.ui.notify(`Failed to switch to ${state.lastNonRouterModel}`, 'error');
-      return;
-    }
-    state.routerEnabled = false;
+    else delete state.thinkingByProfile[profile];
     actions.persistState();
     actions.updateStatus(ctx);
+    if (level) actions.syncPiThinkingLevel(level);
+    else if (state.lastDecision)
+      actions.syncPiThinkingLevel(state.lastDecision.thinking);
+    const unsupported =
+      level && level !== 'off' && config
+        ? getUnsupportedTiers(config, level)
+        : [];
     ctx.ui.notify(
-      `Router disabled. Restored ${state.lastNonRouterModel}`,
-      'info',
+      level
+        ? `Router thinking set to ${level}${unsupported.length > 0 ? `; ${unsupported.join(', ')} may not support it and will be skipped when unsupported` : ''}`
+        : 'Router thinking override cleared',
+      unsupported.length > 0 ? 'warning' : 'info',
     );
   };
 
-  const handleFix = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length !== 1) {
-      ctx.ui.notify('Usage: /router fix <high|medium|low|micro>', 'error');
+  const handleLog = (args: string[], ctx: ExtensionContext) => {
+    const action = args[0]?.toLowerCase();
+    if (args.length > 1 || (action && !LOG_ACTIONS.some((a) => a === action))) {
+      usage(ctx, `/router log [${LOG_ACTIONS.join('|')}]`);
       return;
     }
-    const tier = args[0]?.toLowerCase();
-    if (!isRouterTier(tier)) {
-      ctx.ui.notify('Usage: /router fix <high|medium|low|micro>', 'error');
+    if (action === 'on' || action === 'off') {
+      state.debugEnabled = action === 'on';
+      actions.persistState();
+      ctx.ui.notify(`Router log ${action}`, 'info');
       return;
     }
-    if (!state.lastDecision) {
-      ctx.ui.notify('No recent routing decision to fix.', 'warning');
+    if (action === 'clear') {
+      state.debugHistory.length = 0;
+      actions.persistState();
+      ctx.ui.notify('Router log cleared', 'info');
       return;
     }
-    state.pinnedTierByProfile[state.lastDecision.profile] = tier;
-    actions.persistState();
-    actions.updateStatus(ctx);
-    ctx.ui.notify(
-      `Router decision corrected. ${state.lastDecision.profile} is now pinned to ${tier}.`,
-      'info',
+    const header = state.debugEnabled
+      ? 'Log: on'
+      : 'Log: off; /router log on collects new decisions';
+    const history = state.debugHistory.map(
+      (decision) =>
+        `[${new Date(decision.timestamp).toLocaleTimeString()}] ${formatDecision(decision)}`,
     );
-  };
-
-  const handleWidget = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 1) {
-      ctx.ui.notify('Usage: /router widget <on|off|toggle>', 'error');
-      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;
-    actions.persistState();
-    actions.updateStatus(ctx);
     ctx.ui.notify(
-      `Router widget ${state.widgetEnabled ? 'enabled' : 'disabled'}.`,
+      [
+        header,
+        ...formatJevStats(state.debugHistory),
+        ...(history.length > 0
+          ? ['Recent decisions:', ...history]
+          : ['No recent routing decisions.']),
+      ].join('\n'),
       'info',
     );
   };
 
-  const handleDebug = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 1) {
-      ctx.ui.notify('Usage: /router debug <on|off|show|stats|clear>', 'error');
-      return;
-    }
-    const cmd = args[0]?.toLowerCase();
-    if (
-      cmd &&
-      !['on', 'off', 'toggle', 'clear', 'show', 'stats'].includes(cmd)
-    ) {
-      ctx.ui.notify(
-        'Usage: /router debug <on|off|toggle|show|stats|clear>',
-        'error',
-      );
-      return;
-    }
-    if (cmd === 'on') state.debugEnabled = true;
-    else if (cmd === 'off') state.debugEnabled = false;
-    else if (cmd === 'clear') state.debugHistory.length = 0;
-    else if (cmd === 'stats') {
-      ctx.ui.notify(
-        [
-          state.debugEnabled
-            ? 'Debug collection: on'
-            : 'Debug collection: off; use /router debug on to collect new decisions.',
-          ...formatJevStats(state.debugHistory),
-        ].join('\n'),
-        'info',
-      );
-      return;
-    } else if (cmd === 'show') {
-      if (state.debugHistory.length === 0) {
-        ctx.ui.notify('No recent routing decisions.', 'info');
-      } else {
-        const history = state.debugHistory
-          .map(
-            (d) =>
-              `[${new Date(d.timestamp).toLocaleTimeString()}] ${formatDecision(d)}`,
-          )
-          .join('\n');
-        ctx.ui.notify(
-          `${formatJevStats(state.debugHistory).join('\n')}\nRecent Routing Decisions:\n${history}`,
-          'info',
-        );
-      }
-      return;
-    } else {
-      state.debugEnabled = !state.debugEnabled;
-    }
+  const handleWidget = (ctx: ExtensionContext) => {
+    state.widgetEnabled = !state.widgetEnabled;
     actions.persistState();
+    actions.updateStatus(ctx);
     ctx.ui.notify(
-      `Router debug ${state.debugEnabled ? 'enabled' : 'disabled'}.`,
+      `Router widget ${state.widgetEnabled ? 'on' : 'off'}`,
       'info',
     );
   };
 
-  const handleReload = async (args: string[], ctx: ExtensionContext) => {
-    if (args.length > 0) {
-      ctx.ui.notify('Usage: /router reload (no arguments)', 'error');
-      return;
-    }
+  const handleReload = async (ctx: ExtensionContext) => {
     actions.reloadConfig(ctx, { preserveDebug: true });
     await actions.ensureValidActiveRouterProfile(ctx);
     ctx.ui.notify(
@@ -571,186 +326,133 @@ export const registerCommands = (
     );
   };
 
+  const items = (
+    values: readonly string[],
+    token: string,
+    describe: (value: string) => string,
+    prefix = '',
+  ): AutocompleteItem[] | null => {
+    const matches = values
+      .filter((value) => value.startsWith(token))
+      .map((value) => ({
+        value: `${prefix}${value}`,
+        label: value,
+        description: describe(value),
+      }));
+    return matches.length > 0 ? matches : null;
+  };
+
   pi.registerCommand('router', {
-    description: 'Model router control center',
+    description: 'Model router: profile, pin, thinking, log',
     getArgumentCompletions: (prefix) => {
-      const trimmedLeft = prefix.trimStart();
-      const hasTrailingSpace = /\s$/.test(prefix);
-      const parts = trimmedLeft.length > 0 ? trimmedLeft.split(/\s+/) : [];
-
-      if (parts.length === 0) {
-        return getSubcommandCompletions('');
-      }
-
-      if (parts.length === 1 && !hasTrailingSpace) {
-        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('');
+      const text = prefix.trimStart();
+      const parts = text.length > 0 ? text.split(/\s+/) : [];
+      const trailing = /\s$/.test(prefix);
+      if (parts.length === 0 || (parts.length === 1 && !trailing)) {
+        const token = parts[0] ?? '';
+        const profiles = items(
+          profileNames(state.currentConfig),
+          token,
+          (name) => `Switch to profile ${name}`,
+        );
+        const verbs = items(
+          VERBS.map((verb) => verb.name),
+          token,
+          (name) => VERBS.find((verb) => verb.name === name)?.desc ?? name,
+        );
+        const all = [...(profiles ?? []), ...(verbs ?? [])];
+        return all.length > 0 ? all : null;
       }
-
-      switch (subcommand) {
-        case 'profile': {
-          const profilePrefix = subArgs[0] ?? '';
-          const items = profileNames(state.currentConfig)
-            .filter((name) => name.startsWith(profilePrefix))
-            .map((name) => ({
-              value: `profile ${name}`,
-              label: `router/${name}`,
-              description: `Switch to router profile "${name}"`,
-            }));
-          return items.length > 0 ? items : null;
-        }
-        case 'pin': {
-          const completions = getPinCompletions(subArgs);
-          return (
-            completions?.map((c) => ({
-              ...c,
-              value: `pin ${c.value}`,
-              description: c.description ?? `Pin routing to ${c.label}`,
-            })) ?? null
+      const [verb, ...rest] = parts;
+      const token = trailing && rest.length === 0 ? '' : (rest[0] ?? '');
+      if (rest.length > 1) return null;
+      switch (verb) {
+        case 'pin':
+          return items(
+            ROUTER_PIN_VALUES,
+            token,
+            (value) =>
+              value === 'auto'
+                ? 'Clear the pin for the active profile'
+                : `Pin the active profile to ${value}`,
+            'pin ',
           );
-        }
-        case 'thinking': {
-          const completions = getThinkingCompletions(subArgs);
-          return (
-            completions?.map((c) => ({
-              ...c,
-              value: `thinking ${c.value}`,
-              description: c.description ?? `Set thinking level to ${c.label}`,
-            })) ?? null
+        case 'thinking':
+          return items(
+            THINKING_VALUES,
+            token,
+            (value) =>
+              value === 'auto'
+                ? 'Clear the thinking override'
+                : `Set thinking to ${value} for every tier`,
+            'thinking ',
           );
-        }
-        case 'fix': {
-          const fixPrefix = subArgs[0] ?? '';
-          const items = ROUTER_TIERS.filter((t) =>
-            t.startsWith(fixPrefix.toLowerCase()),
-          ).map((t) => ({
-            value: `fix ${t}`,
-            label: t,
-            description: `Correct decision and pin to ${t} tier`,
-          }));
-          return items.length > 0 ? items : null;
-        }
-        case 'widget': {
-          const widgetPrefix = subArgs[0] ?? '';
-          const items = ['on', 'off', 'toggle']
-            .filter((v) => v.startsWith(widgetPrefix))
-            .map((v) => ({
-              value: `widget ${v}`,
-              label: v,
-              description: `Set widget to ${v}`,
-            }));
-          return items.length > 0 ? items : null;
-        }
-        case 'debug': {
-          const debugPrefix = subArgs[0] ?? '';
-          const items = ['on', 'off', 'toggle', 'clear', 'show', 'stats']
-            .filter((v) => v.startsWith(debugPrefix))
-            .map((v) => ({
-              value: `debug ${v}`,
-              label: v,
-              description: `Router debug: ${v}`,
-            }));
-          return items.length > 0 ? items : null;
-        }
+        case 'log':
+          return items(
+            LOG_ACTIONS,
+            token,
+            (value) =>
+              ({
+                on: 'Collect decisions',
+                off: 'Stop collecting decisions',
+                clear: 'Forget collected decisions',
+              })[value] ?? value,
+            'log ',
+          );
+        default:
+          return null;
       }
-
-      return null;
     },
     handler: async (args, ctx) => {
-      const parts = args?.trim().split(/\s+/) ?? [];
-      const subcommand = parts[0];
-      const subArgs = parts.slice(1);
-      if (!subcommand) {
-        await handleStatus(subArgs, ctx);
+      const parts = args?.trim().split(/\s+/).filter(Boolean) ?? [];
+      const [verb, ...rest] = parts;
+      if (!verb) {
+        showStatus(ctx);
         return;
       }
-
-      switch (subcommand) {
-        case 'profile':
-          await handleProfile(subArgs, ctx);
-          break;
+      const noArgs = (line: string) => {
+        if (rest.length > 0) {
+          usage(ctx, line);
+          return false;
+        }
+        return true;
+      };
+      switch (verb) {
         case 'pin':
-          await handlePin(subArgs, ctx);
-          break;
+          handlePin(rest, ctx);
+          return;
         case 'thinking':
-          await handleThinking(subArgs, ctx);
-          break;
-        case 'disable':
-          await handleDisable(subArgs, ctx);
-          break;
-        case 'fix':
-          await handleFix(subArgs, ctx);
-          break;
+          handleThinking(rest, ctx);
+          return;
+        case 'log':
+          handleLog(rest, ctx);
+          return;
         case 'widget':
-          await handleWidget(subArgs, ctx);
-          break;
-        case 'debug':
-          await handleDebug(subArgs, ctx);
-          break;
+          if (noArgs('/router widget')) handleWidget(ctx);
+          return;
+        case 'off':
+          if (noArgs('/router off')) await handleOff(ctx);
+          return;
         case 'reload':
-          await handleReload(subArgs, ctx);
-          break;
-        case 'status':
-          await handleStatus(subArgs, ctx);
-          break;
+          if (noArgs('/router reload')) await handleReload(ctx);
+          return;
         case 'help':
-        case '?':
-          if (subArgs.length > 0) {
-            ctx.ui.notify('Usage: /router help (no arguments)', 'error');
-            return;
-          }
-          ctx.ui.notify(
-            [
-              'Router Subcommands:',
-              '  status                      Show current status, profile, pin, cost, and last decision.',
-              '  profile [name]              Switch to a profile (enables router if off). Lists available if no name.',
-              '  pin <tier|auto>             Force a tier (high|medium|low|micro) or set to auto.',
-              '  thinking [tier] <level>     Override thinking level (off|minimal|...|max|auto). Not all tier models may support every level.',
-              '  disable                     Disable the router and restore the last used non-router model.',
-              '  fix <tier>                  Correct the last routing decision and pin that tier for the current profile.',
-              '  widget <on|off|toggle>      Control the persistent status widget visibility.',
-              '  debug <on|off|show|stats|clear>   Control decision history; stats summarize unique Jev requests.',
-              '  reload                      Hot-reload the configuration JSON from .pi/model-router.json.',
-              '  help, ?                     Show this help message.',
-            ].join('\n'),
-            'info',
-          );
-          break;
+          if (noArgs('/router help')) ctx.ui.notify(USAGE, 'info');
+          return;
         default:
-          if (subcommand) {
-            // Check if subcommand is actually a profile name (backwards compatible-ish with /router-on)
-            if (state.currentConfig.profiles[subcommand]) {
-              if (subArgs.length > 0) {
-                ctx.ui.notify(
-                  `Usage: /router ${subcommand} (no extra arguments allowed)`,
-                  'error',
-                );
-                return;
-              }
-              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`,
-                'error',
-              );
-            }
-          } else {
-            await handleStatus(subArgs, ctx);
-          }
           break;
       }
+      if (Object.hasOwn(state.currentConfig.profiles, verb)) {
+        if (noArgs(`/router ${verb}`)) await handleProfile(verb, ctx);
+        return;
+      }
+      const replacement = RETIRED_VERBS[verb];
+      ctx.ui.notify(
+        replacement
+          ? `/router ${verb} was removed; use ${replacement}`
+          : `Unknown router command: ${verb}. Try /router help`,
+        'error',
+      );
     },
   });
 };