@fiale-plus/pi-rogue 0.2.2 → 0.2.4

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

@@ -2,11 +2,15 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { decideRoute, readCheckpointJsonl, selectCheckpoint } from "./decision.js";
+import { writeBinaryGateTraining } from "./binary-gate.js";
 import { writeSessionCheckpointsJsonl } from "./checkpoints.js";
 import { appendRouteEvent, buildRouteEvent } from "./ledger.js";
 import { writeCapabilityCards, writeShadowEval, writeTeacherPromptRequests, writeTeacherReflection } from "./learning.js";
 import { writeTrainingRows } from "./dataset.js";
-import { writeInferredOutcomes } from "./outcomes.js";
+import { writeEnrichedOutcomes, writeInferredOutcomes } from "./outcomes.js";
+import { writeRouterReport } from "./reports.js";
+import { writeSharpeningHints } from "./sharpening.js";
+import { runTeacherLabeling } from "./teacher-runner.js";
 
 interface Args {
   command?: string;
@@ -19,12 +23,22 @@ interface Args {
   events?: string;
   labels?: string;
   reflection?: string;
+  artifact?: string;
+  report?: string;
+  dataset?: string;
+  evalDataset?: string;
+  markdown?: string;
+  gateReport?: string;
   teacher?: string;
   teacherOutput?: string;
   teacherPrompts?: string;
+  requests?: string;
+  decisionsOutput?: string;
   outcomes?: string;
+  cards?: string;
   includeLocalRuleLabels?: boolean;
   workspaceDiff?: boolean;
+  dryRun?: boolean;
   pretty: boolean;
 }
 
@@ -35,9 +49,14 @@ function usage(): never {
   npm run router:decide -- --checkpoint-file <checkpoints.jsonl> [--checkpoint-id <id>] [--ledger <events.jsonl>] [--pretty]
   npm run router:cards -- --events <events.jsonl> --output <model-cards.jsonl> [--outcomes <outcomes.jsonl>] [--pretty]
   npm run router:outcomes -- --checkpoint-file <checkpoints.jsonl> --events <events.jsonl> --output <outcomes.jsonl> [--pretty]
+  npm run router:outcome-enrich -- --outcomes <outcomes.jsonl> --output <enriched-outcomes.jsonl> [--checkpoint-file <checkpoints.jsonl>] [--events <events.jsonl>] [--pretty]
   npm run router:teacher-requests -- --checkpoint-file <checkpoints.jsonl> --output <requests.jsonl> [--teacher openai-codex/gpt-5.5] [--pretty]
+  npm run router:teacher-label -- --requests <requests.jsonl> --teacher-output <decisions.jsonl> --labels <labels.jsonl> [--teacher openai-codex/gpt-5.5] [--dry-run] [--pretty]
   npm run router:reflect -- --checkpoint-file <checkpoints.jsonl> --labels <labels.jsonl> --reflection <reflection.md> [--teacher local-rule] [--teacher-output <decisions.jsonl>] [--teacher-prompts <requests.jsonl>] [--pretty]
   npm run router:dataset -- --checkpoint-file <checkpoints.jsonl> --output <training.jsonl> [--events <events.jsonl>] [--outcomes <outcomes.jsonl>] [--labels <labels.jsonl>] [--include-local-rule-labels] [--pretty]
+  npm run router:gate-train -- --dataset <training.jsonl> --eval-dataset <eval.jsonl> --artifact <gate.json> --report <gate-report.json> [--pretty]
+  npm run router:report -- --output <report.json> [--markdown <report.md>] [--events <events.jsonl>] [--outcomes <outcomes.jsonl>] [--dataset <training.jsonl>] [--gate-report <gate-report.json>] [--pretty]
+  npm run router:sharpen -- --events <events.jsonl> --output <hints.json> [--outcomes <outcomes.jsonl>] [--cards <model-cards.jsonl>] [--pretty]
   npm run router:shadow -- --checkpoint-file <checkpoints.jsonl> --output <report.json> [--ledger <events.jsonl>] [--pretty]
 
 Commands:
@@ -45,9 +64,14 @@ Commands:
   decide     Emit a strict JSON route decision for a checkpoint and optionally append a route event.
   cards      Generate local observed model capability cards from route events and optional outcomes.
   outcomes   Infer conservative outcome skeletons that can be manually enriched.
+  outcome-enrich Enrich outcome records from checkpoints and route events.
   teacher-requests Generate local JSONL prompt requests for explicit teacher labeling.
+  teacher-label Run explicit teacher model labeling over request JSONL.
   reflect    Generate command-triggered soft routing labels and a reflection artifact.
   dataset    Export trainable rows for a conservative continue-vs-intervene gate.
+  gate-train Train/evaluate a local binary continue-vs-intervene gate artifact.
+  report     Summarize route events, outcomes, labels, and gate eval metrics.
+  sharpen    Generate local, provenance-backed router sharpening hints without mutating policy.
   shadow     Shadow-evaluate the current rule policy over historical checkpoints.
 `);
   process.exit(2);
@@ -104,6 +128,36 @@ function parseArgs(argv: string[]): Args {
       index++;
       continue;
     }
+    if (arg === "--artifact" && next) {
+      args.artifact = next;
+      index++;
+      continue;
+    }
+    if (arg === "--report" && next) {
+      args.report = next;
+      index++;
+      continue;
+    }
+    if (arg === "--dataset" && next) {
+      args.dataset = next;
+      index++;
+      continue;
+    }
+    if (arg === "--eval-dataset" && next) {
+      args.evalDataset = next;
+      index++;
+      continue;
+    }
+    if (arg === "--markdown" && next) {
+      args.markdown = next;
+      index++;
+      continue;
+    }
+    if (arg === "--gate-report" && next) {
+      args.gateReport = next;
+      index++;
+      continue;
+    }
     if (arg === "--teacher" && next) {
       args.teacher = next;
       index++;
@@ -119,11 +173,26 @@ function parseArgs(argv: string[]): Args {
       index++;
       continue;
     }
+    if (arg === "--requests" && next) {
+      args.requests = next;
+      index++;
+      continue;
+    }
+    if (arg === "--decisions-output" && next) {
+      args.decisionsOutput = next;
+      index++;
+      continue;
+    }
     if (arg === "--outcomes" && next) {
       args.outcomes = next;
       index++;
       continue;
     }
+    if (arg === "--cards" && next) {
+      args.cards = next;
+      index++;
+      continue;
+    }
     if (arg === "--include-local-rule-labels") {
       args.includeLocalRuleLabels = true;
       continue;
@@ -132,6 +201,10 @@ function parseArgs(argv: string[]): Args {
       args.workspaceDiff = true;
       continue;
     }
+    if (arg === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
     if (arg === "--pretty") {
       args.pretty = true;
       continue;
@@ -207,12 +280,28 @@ function outcomes(args: Args): unknown {
   return writeInferredOutcomes({ checkpointPath: args.checkpointFile, eventsPath: args.events, outputPath: args.output });
 }
 
+function outcomeEnrich(args: Args): unknown {
+  if (!args.outcomes || !args.output) usage();
+  return writeEnrichedOutcomes({ outcomesPath: args.outcomes, outputPath: args.output, checkpointPath: args.checkpointFile, eventsPath: args.events });
+}
+
 function teacherRequests(args: Args): unknown {
   if (!args.checkpointFile || !args.output) usage();
   const requests = writeTeacherPromptRequests(args.checkpointFile, args.output, args.teacher ?? "openai-codex/gpt-5.5");
   return { schema: "pi-router.teacher-requests-summary.v1", output: resolve(args.output), requests: requests.length, teacher: args.teacher ?? "openai-codex/gpt-5.5" };
 }
 
+async function teacherLabel(args: Args): Promise<unknown> {
+  if (!args.requests || !args.teacherOutput || !args.labels) usage();
+  return runTeacherLabeling({
+    requestsPath: args.requests,
+    decisionsOutputPath: args.teacherOutput,
+    labelsOutputPath: args.labels,
+    teacher: args.teacher,
+    dryRun: args.dryRun,
+  });
+}
+
 function reflect(args: Args): unknown {
   if (!args.checkpointFile || !args.labels || !args.reflection) usage();
   const result = writeTeacherReflection({
@@ -244,6 +333,21 @@ function dataset(args: Args): unknown {
   });
 }
 
+function gateTrain(args: Args): unknown {
+  if (!args.dataset || !args.evalDataset || !args.artifact || !args.report) usage();
+  return writeBinaryGateTraining({ trainingRowsPath: args.dataset, evalRowsPath: args.evalDataset, artifactPath: args.artifact, reportPath: args.report });
+}
+
+function report(args: Args): unknown {
+  if (!args.output) usage();
+  return writeRouterReport({ outputPath: args.output, markdownPath: args.markdown, eventsPath: args.events, outcomesPath: args.outcomes, trainingRowsPath: args.dataset, gateReportPath: args.gateReport });
+}
+
+function sharpen(args: Args): unknown {
+  if (!args.events || !args.output) usage();
+  return writeSharpeningHints({ eventsPath: args.events, outputPath: args.output, outcomesPath: args.outcomes, cardsPath: args.cards });
+}
+
 function shadow(args: Args): unknown {
   if (!args.checkpointFile || !args.output) usage();
   return writeShadowEval(args.checkpointFile, args.output, args.ledger);
@@ -259,15 +363,25 @@ async function main(): Promise<void> {
         ? cards(args)
         : args.command === "outcomes"
           ? outcomes(args)
-          : args.command === "teacher-requests"
+          : args.command === "outcome-enrich"
+            ? outcomeEnrich(args)
+            : args.command === "teacher-requests"
             ? teacherRequests(args)
-            : args.command === "reflect"
-              ? reflect(args)
-              : args.command === "dataset"
-                ? dataset(args)
-                : args.command === "shadow"
-                  ? shadow(args)
-                  : usage();
+            : args.command === "teacher-label"
+                ? await teacherLabel(args)
+                : args.command === "reflect"
+                  ? reflect(args)
+                  : args.command === "dataset"
+                    ? dataset(args)
+                    : args.command === "gate-train"
+                      ? gateTrain(args)
+                      : args.command === "report"
+                        ? report(args)
+                        : args.command === "sharpen"
+                          ? sharpen(args)
+                          : args.command === "shadow"
+                          ? shadow(args)
+                          : usage();
   console.log(args.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result));
 }
 

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

@@ -1,20 +1,21 @@
-import { mkdtempSync, readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 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, 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 { summarizeRouterDecision } from "./observe.js";
+import { applyModelRouting, modelsMatch, observeRouterTurn, summarizeRouterDecision } from "./observe.js";
 import type { RouterCheckpoint } from "./types.js";
 
-function ctxMock() {
+function ctxMock(sessionPath?: string) {
   const cwd = mkdtempSync(join(tmpdir(), "pi-router-ext-"));
   const notifications: Array<{ text: string; level: string }> = [];
   return {
     cwd,
     notifications,
+    sessionManager: sessionPath ? { getSessionFile: () => sessionPath } : undefined,
     ui: {
       notify(text: string, level: string) {
         notifications.push({ text, level });
@@ -23,11 +24,23 @@ function ctxMock() {
   };
 }
 
+function writeSessionFixture(dir: string, name: string): string {
+  const path = join(dir, name);
+  writeFileSync(path, [
+    JSON.stringify({ type: "session", id: name, cwd: dir }),
+    JSON.stringify({ type: "message", id: `${name}-user`, message: { role: "user", content: [{ type: "text", text: "please implement a small fix" }] } }),
+  ].join("\n") + "\n");
+  return path;
+}
+
 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]); },
@@ -81,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");
   });
@@ -92,11 +106,43 @@ 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 () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pi-router-sessions-"));
+    const firstSession = writeSessionFixture(cwd, "session-a.jsonl");
+    const secondSession = writeSessionFixture(cwd, "session-b.jsonl");
+    const firstCtx = { ...ctxMock(firstSession), cwd };
+    const secondCtx = { ...ctxMock(secondSession), cwd };
+    saveRouterConfig(firstCtx, { ...loadRouterConfig(firstCtx), enabled: true, print: "all" });
+
+    expect(routerConfigPath(firstCtx)).toBe(routerConfigPath(secondCtx));
+    expect(routerStatePath(firstCtx, firstSession)).not.toBe(routerStatePath(secondCtx, secondSession));
+    expect(routerEventsPath(firstCtx, firstSession)).not.toBe(routerEventsPath(secondCtx, secondSession));
+    expect(routerSessionDir(firstCtx, firstSession)).toContain("session-a");
+
+    await observeRouterTurn(firstCtx);
+    await observeRouterTurn(secondCtx);
+
+    expect(existsSync(routerStatePath(firstCtx, firstSession))).toBe(true);
+    expect(existsSync(routerStatePath(secondCtx, secondSession))).toBe(true);
+    expect(readFileSync(routerEventsPath(firstCtx, firstSession), "utf8").trim().split("\n")).toHaveLength(1);
+    expect(readFileSync(routerEventsPath(secondCtx, secondSession), "utf8").trim().split("\n")).toHaveLength(1);
   });
 });
 
@@ -117,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");
   });
@@ -130,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

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+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 {
@@ -83,12 +84,36 @@ export function routerConfigPath(ctx: any): string {
   return join(routerDir(ctx), "config.json");
 }
 
-export function routerStatePath(ctx: any): string {
-  return join(routerDir(ctx), "state.json");
+function sessionPathFromCtx(ctx: any): string | undefined {
+  const value = ctx?.sessionManager?.getSessionFile?.();
+  return value ? String(value) : undefined;
 }
 
-export function routerEventsPath(ctx: any): string {
-  return join(routerDir(ctx), "events.jsonl");
+function safeSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96) || "session";
+}
+
+export function routerSessionKey(sessionPath: string): string {
+  const resolved = resolve(sessionPath);
+  const name = safeSegment(basename(resolved).replace(/\.jsonl$/i, ""));
+  return `${name}-${hashText(resolved).slice(0, 8)}`;
+}
+
+export function routerSessionsDir(ctx: any): string {
+  return join(routerDir(ctx), "sessions");
+}
+
+export function routerSessionDir(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  const key = sessionPath ? routerSessionKey(sessionPath) : "no-session";
+  return join(routerSessionsDir(ctx), key);
+}
+
+export function routerStatePath(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  return join(routerSessionDir(ctx, sessionPath), "state.json");
+}
+
+export function routerEventsPath(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  return join(routerSessionDir(ctx, sessionPath), "events.jsonl");
 }
 
 function readJson<T>(path: string, fallback: T): T {
@@ -99,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
@@ -110,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,
@@ -135,12 +164,12 @@ export function ensureRouterConfig(ctx: any): RouterConfig {
   return config;
 }
 
-export function loadRouterState(ctx: any): RouterState {
-  return readJson<RouterState>(routerStatePath(ctx), {});
+export function loadRouterState(ctx: any, sessionPath?: string): RouterState {
+  return readJson<RouterState>(routerStatePath(ctx, sessionPath), {});
 }
 
-export function saveRouterState(ctx: any, state: RouterState): void {
-  const path = routerStatePath(ctx);
+export function saveRouterState(ctx: any, state: RouterState, sessionPath?: string): void {
+  const path = routerStatePath(ctx, sessionPath);
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
 }
@@ -162,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}`;