@fiale-plus/pi-rogue 0.2.3 → 0.2.4

package/node_modules/@fiale-plus/pi-rogue-router/src/completions.ts

@@ -1,34 +1,57 @@
-import { DEFAULT_ROUTER_CONFIG, loadRouterConfig } from "./config.js";
+import { DEFAULT_ROUTER_CONFIG, formatProfile, loadRouterConfig } from "./config.js";
 
 type CompletionItem = { value: string; label: string; description?: string };
 
-function item(value: string, description?: string): CompletionItem {
-  return { value, label: value, ...(description ? { description } : {}) };
+function item(value: string, description?: string, label = value.trimEnd()): CompletionItem {
+  return { value, label, ...(description ? { description } : {}) };
 }
 
 function filter(items: CompletionItem[], prefix: string): CompletionItem[] | null {
   const q = prefix.trimStart().toLowerCase();
-  const out = q ? items.filter((entry) => entry.value.toLowerCase().startsWith(q)) : items;
+  const out = q ? items.filter((entry) => entry.value.toLowerCase().startsWith(q) || entry.label.toLowerCase().startsWith(q)) : items;
   return out.length ? out : null;
 }
 
+function topLevelItems(): CompletionItem[] {
+  return [
+    item("status", "show current router state"),
+    item("help", "show command tree and safety notes"),
+    item("on", "enable router using the current explicit mode"),
+    item("off", "disable router"),
+    item("mode ", "choose observe or auto_model", "mode …"),
+    item("profile ", "choose active router profile", "profile …"),
+    item("print ", "choose router notification verbosity", "print …"),
+    item("models", "show active role → model mapping"),
+    item("profiles", "list all configured profiles"),
+    item("cycle", "cycle to the next router profile"),
+    item("configure", "create/show config and suggested next commands"),
+  ];
+}
+
 export function routerArgumentCompletions(prefix: string, ctx?: any): CompletionItem[] | null {
   const trimmed = prefix.trimStart();
   const [cmd, rest = ""] = trimmed.split(/\s+/, 2);
-  const top = [
-    item("on", "enable observe-only router summaries"),
-    item("off", "disable router summaries"),
-    item("status", "show router state and active profile"),
-    item("profile", "show or set active router profile"),
-    item("profiles", "list router profiles"),
-    item("models", "show active role to model mapping"),
-    item("configure", "write default local config if missing"),
-    item("cycle", "cycle to the next router profile"),
-  ];
-  if (!cmd || !trimmed.includes(" ")) return filter(top, trimmed);
+  if (!cmd || !trimmed.includes(" ")) return filter(topLevelItems(), trimmed);
+
   if (cmd === "profile") {
     const config = ctx ? loadRouterConfig(ctx) : DEFAULT_ROUTER_CONFIG;
-    return filter(config.profileOrder.map((name) => item(`profile ${name}`, config.profiles[name]?.worker)), `profile ${rest}`);
+    return filter(config.profileOrder.map((name) => {
+      const marker = name === config.activeProfile ? "active" : "profile";
+      return item(`profile ${name}`, `${marker}: ${formatProfile(name, config.profiles[name])}`, name);
+    }), `profile ${rest}`);
+  }
+  if (cmd === "mode") {
+    return filter([
+      item("mode observe", "recommendations only", "observe"),
+      item("mode auto_model", "apply model switches only", "auto_model"),
+    ], `mode ${rest}`);
+  }
+  if (cmd === "print") {
+    return filter([
+      item("print mismatch_only", "notify only route/model mismatches", "mismatch_only"),
+      item("print all", "notify every router decision", "all"),
+      item("print off", "suppress observe notifications", "off"),
+    ], `print ${rest}`);
   }
   return null;
 }

package/node_modules/@fiale-plus/pi-rogue-router/src/config-extension.test.ts

@@ -3,10 +3,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { routerArgumentCompletions } from "./completions.js";
-import { activeProfile, cycleRouterProfile, ensureRouterConfig, loadRouterConfig, routerConfigPath, routerEventsPath, routerSessionDir, routerStatePath, saveRouterConfig, setRouterProfile } from "./config.js";
+import { activeProfile, cycleRouterProfile, ensureRouterConfig, loadRouterConfig, routerConfigPath, routerEventsPath, routerSessionDir, routerStatePath, saveRouterConfig, setRouterMode, setRouterPrint, setRouterProfile } from "./config.js";
 import { registerRouter } from "./extension.js";
 import { decideRoute } from "./decision.js";
-import { observeRouterTurn, summarizeRouterDecision } from "./observe.js";
+import { applyModelRouting, modelsMatch, observeRouterTurn, summarizeRouterDecision } from "./observe.js";
 import type { RouterCheckpoint } from "./types.js";
 
 function ctxMock(sessionPath?: string) {
@@ -37,7 +37,10 @@ function piMock() {
   const commands = new Map<string, any>();
   const shortcuts = new Map<string, any>();
   const handlers = new Map<string, any[]>();
+  const selectedModels: any[] = [];
   const pi: any = {
+    selectedModels,
+    async setModel(model: any) { selectedModels.push(model); return true; },
     registerCommand(name: string, options: any) { commands.set(name, options); },
     registerShortcut(key: string, options: any) { shortcuts.set(key, options); },
     on(name: string, handler: any) { handlers.set(name, [...(handlers.get(name) ?? []), handler]); },
@@ -91,6 +94,7 @@ describe("router config profiles", () => {
 
     expect(config.activeProfile).toBe("all-smart");
     expect(config.profileOrder).toEqual(["all-smart", "spark-smart", "local-smart"]);
+    expect(config.mode).toBe("observe");
     expect(activeProfile(config).worker).toBe("openai-codex/gpt-5.5");
     expect(readFileSync(routerConfigPath(ctx), "utf8")).toContain("spark-smart");
   });
@@ -102,11 +106,21 @@ describe("router config profiles", () => {
     expect(spark?.activeProfile).toBe("spark-smart");
     expect(cycleRouterProfile(spark!, 1).activeProfile).toBe("local-smart");
     expect(setRouterProfile(config, "missing")).toBeNull();
+    expect(setRouterMode(config, "auto")?.mode).toBe("auto_model");
+    expect(setRouterMode(config, "auto_model")?.mode).toBe("auto_model");
+    expect(setRouterMode(config, "agent-auto")).toBeNull();
+    expect(setRouterPrint(config, "all")?.print).toBe("all");
+    expect(setRouterPrint(config, "noisy")).toBeNull();
   });
 
-  it("completes router commands and profile names", () => {
-    expect(routerArgumentCompletions("")?.map((item) => item.value)).toEqual(expect.arrayContaining(["on", "off", "status", "profile"]));
+  it("completes router commands as a nested slash-menu tree", () => {
+    const top = routerArgumentCompletions("") ?? [];
+
+    expect(top.map((item) => item.value)).toEqual(["status", "help", "on", "off", "mode ", "profile ", "print ", "models", "profiles", "cycle", "configure"]);
+    expect(top.find((item) => item.value === "mode ")?.label).toBe("mode …");
     expect(routerArgumentCompletions("profile s")?.map((item) => item.value)).toEqual(["profile spark-smart"]);
+    expect(routerArgumentCompletions("mode a")?.map((item) => item.value)).toEqual(["mode auto_model"]);
+    expect(routerArgumentCompletions("print ")?.map((item) => item.value)).toEqual(["print mismatch_only", "print all", "print off"]);
   });
 
   it("keeps config repo-global while state and live events are session-scoped", async () => {
@@ -149,6 +163,18 @@ describe("router extension", () => {
     await commands.get("router").handler("profile spark-smart", ctx);
     expect(loadRouterConfig(ctx).activeProfile).toBe("spark-smart");
 
+    await commands.get("router").handler("mode auto_model", ctx);
+    expect(loadRouterConfig(ctx).mode).toBe("auto_model");
+    await commands.get("router").handler("print all", ctx);
+    expect(loadRouterConfig(ctx).print).toBe("all");
+    await commands.get("router").handler("help", ctx);
+    expect(ctx.notifications.at(-1)?.text).toContain("router command tree:");
+    await commands.get("router").handler("off", ctx);
+    await commands.get("router").handler("on", ctx);
+    expect(ctx.notifications.at(-1)?.text).toContain("auto_model applies model switches only");
+    await commands.get("router").handler("status", ctx);
+    expect(ctx.notifications.at(-1)?.text).toContain("model routing: auto_model");
+
     await shortcuts.get("ctrl+alt+p").handler(ctx);
     expect(loadRouterConfig(ctx).activeProfile).toBe("local-smart");
   });
@@ -162,4 +188,85 @@ describe("router extension", () => {
     expect(summary.text).toContain("smart(openai-codex/gpt-5.5)");
     expect(summary.text).toContain("current=gpt-5.3-codex-spark");
   });
+
+  it("auto_model applies only model switches for explicit target mismatches", async () => {
+    const { pi } = piMock();
+    const ctx = {
+      ...ctxMock(),
+      modelRegistry: {
+        find: (provider: string, id: string) => provider === "openai-codex" && id === "gpt-5.5" ? { provider, id } : undefined,
+      },
+    };
+    const config = { ...loadRouterConfig(ctx), enabled: true, mode: "auto_model" as const, activeProfile: "spark-smart" };
+    const item = checkpoint();
+    const summary = summarizeRouterDecision(item, decideRoute(item), config);
+
+    const applied = await applyModelRouting(pi, ctx, summary);
+
+    expect(applied).toMatchObject({ applied: true, fromModel: "gpt-5.3-codex-spark", toModel: "openai-codex/gpt-5.5" });
+    expect(pi.selectedModels).toEqual([{ provider: "openai-codex", id: "gpt-5.5" }]);
+
+    const none = await applyModelRouting(pi, ctx, { ...summary, role: "none", targetModel: undefined, match: null });
+    expect(none.applied).toBe(false);
+    expect(pi.selectedModels).toHaveLength(1);
+  });
+
+  it("does not treat provider-qualified target as matched when only leaf model id matches", async () => {
+    const { pi } = piMock();
+    const ctx = {
+      ...ctxMock(),
+      modelRegistry: {
+        find: (provider: string, id: string) => provider === "openai-codex" && id === "gpt-5.5" ? { provider, id } : undefined,
+      },
+    };
+    const config = { ...loadRouterConfig(ctx), enabled: true, mode: "auto_model" as const, activeProfile: "spark-smart" };
+    const item = checkpoint({ activeModel: "gpt-5.5", provider: "custom" });
+    const summary = summarizeRouterDecision(item, decideRoute(item), config);
+    const qualifiedWithoutProvider = summarizeRouterDecision(checkpoint({ activeModel: "custom/gpt-5.5", provider: undefined }), decideRoute(item), config);
+    const leafWithoutProvider = summarizeRouterDecision(checkpoint({ activeModel: "gpt-5.5", provider: undefined }), decideRoute(item), config);
+
+    expect(summary.match).toBe(false);
+    expect(qualifiedWithoutProvider.match).toBe(false);
+    expect(leafWithoutProvider.match).toBe(false);
+    expect(modelsMatch("zai/kimi-k2.6", "openrouter/moonshotai/kimi-k2.6", "openrouter")).toBe(false);
+    expect(modelsMatch("moonshotai/kimi-k2.6", "openrouter/moonshotai/kimi-k2.6", "openrouter")).toBe(true);
+    const applied = await applyModelRouting(pi, ctx, summary);
+
+    expect(applied.applied).toBe(true);
+    expect(pi.selectedModels).toEqual([{ provider: "openai-codex", id: "gpt-5.5" }]);
+  });
+
+  it("resolves bare slash-containing model ids from the registry", async () => {
+    const { pi } = piMock();
+    const ctx = {
+      ...ctxMock(),
+      modelRegistry: {
+        getAll: () => [{ provider: "openrouter", id: "moonshotai/kimi-k2.6" }],
+        find: (provider: string, id: string) => ({ provider, id }),
+      },
+    };
+
+    const applied = await applyModelRouting(pi, ctx, { checkpointId: "c", action: "ask_micro_hint", role: "smart", currentModel: "qwen", currentProvider: "openrouter", targetModel: "moonshotai/kimi-k2.6", match: false, confidence: 0.8, reason: "test", text: "test" });
+    const skipped = await applyModelRouting(pi, ctx, { checkpointId: "c", action: "ask_micro_hint", role: "smart", currentModel: "moonshotai/kimi-k2.6", currentProvider: "openrouter", targetModel: "moonshotai/kimi-k2.6", match: false, confidence: 0.8, reason: "test", text: "test" });
+    const duplicateProviderCtx = {
+      ...ctxMock(),
+      modelRegistry: {
+        getAll: () => [{ provider: "first", id: "same-model" }, { provider: "current", id: "same-model" }],
+      },
+    };
+    const duplicateSkipped = await applyModelRouting(pi, duplicateProviderCtx, { checkpointId: "c", action: "ask_micro_hint", role: "smart", currentModel: "same-model", currentProvider: "current", targetModel: "same-model", match: true, confidence: 0.8, reason: "test", text: "test" });
+
+    const ambiguousCtx = {
+      ...ctxMock(),
+      modelRegistry: { getAll: () => [{ provider: "first", id: "ambiguous" }, { provider: "second", id: "ambiguous" }] },
+    };
+    const ambiguous = await applyModelRouting(pi, ambiguousCtx, { checkpointId: "c", action: "ask_micro_hint", role: "smart", currentModel: "other", targetModel: "ambiguous", match: false, confidence: 0.8, reason: "test", text: "test" });
+
+    expect(applied.applied).toBe(true);
+    expect(skipped.applied).toBe(false);
+    expect(duplicateSkipped.applied).toBe(false);
+    expect(ambiguous.applied).toBe(false);
+    expect(ambiguous.reason).toContain("target model not configured");
+    expect(pi.selectedModels).toEqual([{ provider: "openrouter", id: "moonshotai/kimi-k2.6" }]);
+  });
 });

package/node_modules/@fiale-plus/pi-rogue-router/src/config.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { hashText } from "./hash.js";
 
-export type RouterMode = "observe";
+export type RouterMode = "observe" | "auto_model";
 export type RouterPrintMode = "all" | "mismatch_only" | "off";
 
 export interface RouterProfile {
@@ -124,6 +124,10 @@ function readJson<T>(path: string, fallback: T): T {
   }
 }
 
+function normalizeRouterMode(value: unknown): RouterMode {
+  return value === "auto_model" || value === "auto" ? "auto_model" : "observe";
+}
+
 export function normalizeRouterConfig(raw: Partial<RouterConfig> | null | undefined): RouterConfig {
   const mergedProfiles = { ...DEFAULT_ROUTER_CONFIG.profiles, ...(raw?.profiles ?? {}) };
   const profileOrder = Array.isArray(raw?.profileOrder) && raw.profileOrder.length > 0
@@ -135,7 +139,7 @@ export function normalizeRouterConfig(raw: Partial<RouterConfig> | null | undefi
   const print = raw?.print === "all" || raw?.print === "off" || raw?.print === "mismatch_only" ? raw.print : DEFAULT_ROUTER_CONFIG.print;
   return {
     enabled: Boolean(raw?.enabled ?? DEFAULT_ROUTER_CONFIG.enabled),
-    mode: "observe",
+    mode: normalizeRouterMode(raw?.mode),
     print,
     activeProfile,
     profileOrder,
@@ -187,6 +191,17 @@ export function setRouterProfile(config: RouterConfig, name: string): RouterConf
   return { ...config, activeProfile: name, profileOrder: config.profileOrder.includes(name) ? config.profileOrder : [...config.profileOrder, name] };
 }
 
+export function setRouterMode(config: RouterConfig, mode: string): RouterConfig | null {
+  if (mode === "observe") return { ...config, mode: "observe" };
+  if (mode === "auto" || mode === "auto_model") return { ...config, mode: "auto_model" };
+  return null;
+}
+
+export function setRouterPrint(config: RouterConfig, print: string): RouterConfig | null {
+  if (print === "all" || print === "mismatch_only" || print === "off") return { ...config, print };
+  return null;
+}
+
 export function formatProfile(name: string, profile: RouterProfile): string {
   const subagents = [`explore=${profile.explore ?? profile.worker}`, `debug=${profile.debug_diagnose ?? profile.smart}`, `review=${profile.review ?? profile.reviewer}`, `verify=${profile.verify ?? profile.worker}`].join(" ");
   return `${name}: worker=${profile.worker} smart=${profile.smart} teacher=${profile.teacher} reviewer=${profile.reviewer} ${subagents}`;

package/node_modules/@fiale-plus/pi-rogue-router/src/extension.ts

@@ -8,6 +8,8 @@ import {
   routerConfigPath,
   routerEventsPath,
   saveRouterConfig,
+  setRouterMode,
+  setRouterPrint,
   setRouterProfile,
   type RouterConfig,
 } from "./config.js";
@@ -17,8 +19,8 @@ import { routerArgumentCompletions } from "./completions.js";
 function statusText(ctx: any, config: RouterConfig): string {
   const profile = activeProfile(config);
   return [
-    `router: ${config.enabled ? "observe on" : "off"}`,
-    `mode: ${config.mode}`,
+    `router: ${config.enabled ? "on" : "off"}`,
+    `model routing: ${config.mode === "auto_model" ? "auto_model (applies model switches only)" : "observe (recommendations only)"}`,
     `print: ${config.print}`,
     `profile: ${config.activeProfile}`,
     `worker: ${profile.worker}`,
@@ -35,11 +37,35 @@ function notifyProfile(ctx: any, config: RouterConfig, prefix = "router profile"
   ctx.ui.notify(`${prefix}: ${config.activeProfile}\nworker: ${profile.worker}\nsmart: ${profile.smart}\nteacher: ${profile.teacher}\nreviewer: ${profile.reviewer}`, "info");
 }
 
+function helpText(ctx: any, config: RouterConfig): string {
+  return [
+    "router command tree:",
+    "  /router status                 show current router state",
+    "  /router help                   show this help",
+    "  /router on                     enable router using current explicit mode",
+    "  /router off                    disable router",
+    "  /router mode observe           recommendations only",
+    "  /router mode auto_model        apply model switches only",
+    "  /router profile <name>         choose active profile",
+    "  /router print mismatch_only    notify only mismatches",
+    "  /router print all              notify every router decision",
+    "  /router print off              suppress observe notifications",
+    "  /router models                 show active role → model mapping",
+    "  /router profiles               list configured profiles",
+    "  /router cycle                  cycle to next profile",
+    "  /router configure              create/show config",
+    "",
+    "safety: observe is recommendations only; auto_model applies model switches only, never agent/subagent/tool routing.",
+    "",
+    statusText(ctx, config),
+  ].join("\n");
+}
+
 function setEnabled(ctx: any, enabled: boolean): void {
   const config = ensureRouterConfig(ctx);
   const next = { ...config, enabled };
   saveRouterConfig(ctx, next);
-  ctx.ui.notify(enabled ? "router observe mode enabled" : "router disabled", "info");
+  ctx.ui.notify(enabled ? `router enabled: ${next.mode === "auto_model" ? "auto_model applies model switches only" : "observe recommendations only"}` : "router disabled", "info");
 }
 
 export function registerRouter(pi: ExtensionAPI): void {
@@ -48,7 +74,7 @@ export function registerRouter(pi: ExtensionAPI): void {
   p.__piRogueRouterRegistered = true;
 
   pi.registerCommand("router", {
-    description: "Observe-only trajectory router. Usage: /router on|off|status|profile|profiles|models|configure",
+    description: "Trajectory router. Usage: /router status|help|on|off|mode|profile|print|profiles|models|configure|cycle. Default observe-only; auto_model applies model switches only.",
     getArgumentCompletions: (prefix: string, ctx?: any) => routerArgumentCompletions(prefix, ctx),
     handler: async (args, ctx) => {
       const input = String(args ?? "").trim();
@@ -65,11 +91,15 @@ export function registerRouter(pi: ExtensionAPI): void {
       }
       if (cmd === "configure" || cmd === "config") {
         const config = ensureRouterConfig(ctx);
-        ctx.ui.notify(["router config ready", "", statusText(ctx, config)].join("\n"), "info");
+        ctx.ui.notify(["router config ready", "", "next: /router mode …, /router profile …, /router print …", "", statusText(ctx, config)].join("\n"), "info");
         return;
       }
 
       const config = ensureRouterConfig(ctx);
+      if (cmd === "help") {
+        ctx.ui.notify(helpText(ctx, config), "info");
+        return;
+      }
       if (cmd === "status" || cmd === "show") {
         ctx.ui.notify(statusText(ctx, config), "info");
         return;
@@ -78,6 +108,36 @@ export function registerRouter(pi: ExtensionAPI): void {
         notifyProfile(ctx, config, "router models");
         return;
       }
+      if (cmd === "mode") {
+        const mode = rest[0];
+        if (!mode) {
+          ctx.ui.notify(statusText(ctx, config), "info");
+          return;
+        }
+        const next = setRouterMode(config, mode);
+        if (!next) {
+          ctx.ui.notify("unknown router mode: use observe or auto_model", "error");
+          return;
+        }
+        saveRouterConfig(ctx, next);
+        ctx.ui.notify(`router model routing mode set: ${next.mode === "auto_model" ? "auto_model (model switches only)" : "observe (recommendations only)"}`, "info");
+        return;
+      }
+      if (cmd === "print") {
+        const print = rest[0];
+        if (!print) {
+          ctx.ui.notify(statusText(ctx, config), "info");
+          return;
+        }
+        const next = setRouterPrint(config, print);
+        if (!next) {
+          ctx.ui.notify("unknown router print mode: use mismatch_only, all, or off", "error");
+          return;
+        }
+        saveRouterConfig(ctx, next);
+        ctx.ui.notify(`router print mode set: ${next.print}`, "info");
+        return;
+      }
       if (cmd === "profiles") {
         ctx.ui.notify(config.profileOrder.map((name) => {
           const marker = name === config.activeProfile ? "*" : " ";
@@ -108,7 +168,7 @@ export function registerRouter(pi: ExtensionAPI): void {
         return;
       }
 
-      ctx.ui.notify("Usage: /router on|off|status|profile [name]|profiles|models|configure|cycle", "error");
+      ctx.ui.notify("Usage: /router status|help|on|off|mode [observe|auto_model]|profile [name]|print [mismatch_only|all|off]|profiles|models|configure|cycle", "error");
     },
   });
 
@@ -127,7 +187,7 @@ export function registerRouter(pi: ExtensionAPI): void {
 
   pi.on("turn_end", async (_event: any, ctx: any) => {
     try {
-      await observeRouterTurn(ctx);
+      await observeRouterTurn(ctx, pi);
     } catch (error) {
       ctx.ui?.notify?.(`router observe failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
     }

package/node_modules/@fiale-plus/pi-rogue-router/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./binary-gate.js";
 export * from "./checkpoints.js";
 export * from "./completions.js";
 export * from "./config.js";
@@ -10,6 +11,9 @@ export * from "./ledger.js";
 export * from "./observe.js";
 export * from "./outcomes.js";
 export * from "./progress.js";
+export * from "./reports.js";
+export * from "./sharpening.js";
 export * from "./session-reader.js";
 export * from "./subagents.js";
+export * from "./teacher-runner.js";
 export * from "./types.js";

package/node_modules/@fiale-plus/pi-rogue-router/src/observe.ts

@@ -1,3 +1,4 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { appendRouteEvent, buildRouteEvent } from "./ledger.js";
 import { decideRoute } from "./decision.js";
 import { checkpointWithDiffStats, streamCheckpointsFromSessionPath } from "./checkpoints.js";
@@ -21,12 +22,20 @@ export interface RouterObserveSummary {
   role: keyof RouterProfile | "none" | "current";
   targetModel?: string;
   currentModel?: string;
+  currentProvider?: string;
   match: boolean | null;
   confidence: number;
   reason: string;
   text: string;
 }
 
+export interface RouterModelApplySummary {
+  applied: boolean;
+  reason: string;
+  fromModel?: string;
+  toModel?: string;
+}
+
 function squish(text: unknown, max = 140): string {
   const value = String(text ?? "").replace(/\s+/g, " ").trim();
   return value.length <= max ? value : `${value.slice(0, max - 1).trimEnd()}…`;
@@ -53,10 +62,22 @@ function modelLeaf(model: string): string {
   return model.split("/").at(-1)?.toLowerCase() ?? model.toLowerCase();
 }
 
-export function modelsMatch(current: string | undefined, target: string | undefined): boolean | null {
+export function modelsMatch(current: string | undefined, target: string | undefined, currentProvider?: string): boolean | null {
   if (!current || !target) return null;
   const c = current.toLowerCase();
   const t = target.toLowerCase();
+  const provider = currentProvider?.toLowerCase();
+  const [targetProvider, ...targetModelParts] = t.split("/");
+  if (targetModelParts.length > 0) {
+    const targetModel = targetModelParts.join("/");
+    if (provider) {
+      const currentModel = c.startsWith(`${provider}/`) ? c.slice(provider.length + 1) : c;
+      if (provider === targetProvider) return currentModel === targetModel;
+      return currentModel === t;
+    }
+    if (c.includes("/")) return c === t;
+    return false;
+  }
   return c === t || modelLeaf(c) === modelLeaf(t) || c.endsWith(`/${modelLeaf(t)}`) || t.endsWith(`/${modelLeaf(c)}`);
 }
 
@@ -70,7 +91,7 @@ export function summarizeRouterDecision(checkpoint: RouterCheckpoint, decision:
   const profile = activeProfile(config);
   const role = actionRole(decision.action);
   const targetModel = targetForRole(role, profile, checkpoint.activeModel);
-  const match = role === "none" ? null : modelsMatch(checkpoint.activeModel, targetModel);
+  const match = role === "none" ? null : modelsMatch(checkpoint.activeModel, targetModel, checkpoint.provider);
   const verdict = match === null ? "INFO" : match ? "MATCH" : "MISMATCH";
   const roleText = role === "none" ? "no-model" : role;
   const targetText = targetModel ? `${roleText}(${targetModel})` : roleText;
@@ -81,6 +102,7 @@ export function summarizeRouterDecision(checkpoint: RouterCheckpoint, decision:
     role,
     targetModel,
     currentModel: checkpoint.activeModel,
+    currentProvider: checkpoint.provider,
     match,
     confidence: decision.confidence,
     reason: decision.reason,
@@ -94,9 +116,51 @@ export async function latestCheckpointFromSession(sessionPath: string): Promise<
   return latest;
 }
 
-export async function observeRouterTurn(ctx: any): Promise<RouterObserveSummary | null> {
+function findConfiguredModel(ctx: any, target: string, currentProvider?: string): { model: any; matchedBy: "qualified" | "id" } | undefined {
+  const all = ctx?.modelRegistry?.getAll?.() ?? [];
+  const observedProvider = currentProvider?.toLowerCase();
+  const byCurrentProviderId = observedProvider ? all.find((model: any) => model.id === target && String(model.provider).toLowerCase() === observedProvider) : undefined;
+  if (byCurrentProviderId) return { model: byCurrentProviderId, matchedBy: "id" };
+  const [provider, ...modelParts] = target.split("/");
+  if (modelParts.length > 0) {
+    const found = ctx?.modelRegistry?.find?.(provider, modelParts.join("/"));
+    if (found) return { model: found, matchedBy: "qualified" };
+    const byQualified = all.find((model: any) => `${model.provider}/${model.id}` === target);
+    if (byQualified) return { model: byQualified, matchedBy: "qualified" };
+  }
+  const byId = all.filter((model: any) => model.id === target);
+  return byId.length === 1 ? { model: byId[0], matchedBy: "id" } : undefined;
+}
+
+function configuredModelMatches(current: string | undefined, currentProvider: string | undefined, resolved: { model: any; matchedBy: "qualified" | "id" }): boolean {
+  const model = resolved.model;
+  if (!current || !model?.provider || !model?.id) return false;
+  const c = current.toLowerCase();
+  const provider = String(model.provider).toLowerCase();
+  const id = String(model.id).toLowerCase();
+  const observedProvider = currentProvider?.toLowerCase();
+  if (observedProvider) {
+    const currentModel = c.startsWith(`${observedProvider}/`) ? c.slice(observedProvider.length + 1) : c;
+    return observedProvider === provider && currentModel === id;
+  }
+  return c === `${provider}/${id}` || (resolved.matchedBy === "id" && c === id);
+}
+
+export async function applyModelRouting(pi: Pick<ExtensionAPI, "setModel"> | undefined, ctx: any, summary: RouterObserveSummary): Promise<RouterModelApplySummary> {
+  if (!summary.targetModel || summary.role === "none" || summary.role === "current") return { applied: false, reason: "no model switch for route action" };
+  const resolved = findConfiguredModel(ctx, summary.targetModel, summary.currentProvider);
+  if (resolved?.matchedBy === "id" && modelsMatch(summary.currentModel, summary.targetModel, summary.currentProvider)) return { applied: false, reason: "current model already matches target", fromModel: summary.currentModel, toModel: summary.targetModel };
+  if (resolved && configuredModelMatches(summary.currentModel, summary.currentProvider, resolved)) return { applied: false, reason: "current model already matches target", fromModel: summary.currentModel, toModel: summary.targetModel };
+  if (!resolved && modelsMatch(summary.currentModel, summary.targetModel, summary.currentProvider)) return { applied: false, reason: "current model already matches target", fromModel: summary.currentModel, toModel: summary.targetModel };
+  if (!resolved) return { applied: false, reason: `target model not configured: ${summary.targetModel}`, fromModel: summary.currentModel, toModel: summary.targetModel };
+  const success = await pi?.setModel?.(resolved.model);
+  if (!success) return { applied: false, reason: `target model unavailable or missing auth: ${summary.targetModel}`, fromModel: summary.currentModel, toModel: summary.targetModel };
+  return { applied: true, reason: summary.reason, fromModel: summary.currentModel, toModel: summary.targetModel };
+}
+
+export async function observeRouterTurn(ctx: any, pi?: Pick<ExtensionAPI, "setModel">): Promise<RouterObserveSummary | null> {
   const config = loadRouterConfig(ctx);
-  if (!config.enabled || config.print === "off") return null;
+  if (!config.enabled || (config.print === "off" && config.mode === "observe")) return null;
   const sessionPath = ctx?.sessionManager?.getSessionFile?.();
   if (!sessionPath) return null;
   const checkpoint = await latestCheckpointFromSession(String(sessionPath));
@@ -120,7 +184,14 @@ export async function observeRouterTurn(ctx: any): Promise<RouterObserveSummary
     lastSummary: summary.text,
   }, String(sessionPath));
 
+  if (config.mode === "auto_model") {
+    const applied = await applyModelRouting(pi, ctx, summary);
+    if (applied.applied || summary.match === false) {
+      ctx.ui?.notify?.(`router auto-model: ${applied.applied ? "APPLIED" : "SKIPPED"} ${applied.fromModel ?? "unknown"} → ${applied.toModel ?? "none"} · ${applied.reason}`, applied.applied ? "info" : "warning");
+    }
+  }
+
   if (config.print === "mismatch_only" && summary.match !== false) return summary;
-  ctx.ui?.notify?.(summary.text, summary.match === false ? "warning" : "info");
+  if (config.print !== "off") ctx.ui?.notify?.(summary.text, summary.match === false ? "warning" : "info");
   return summary;
 }