@fiale-plus/pi-rogue 0.2.0 → 0.2.2

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

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { decideRoute, readCheckpointJsonl, selectCheckpoint } from "./decision.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";
+
+interface Args {
+  command?: string;
+  sessions: string[];
+  sessionDir?: string;
+  output?: string;
+  checkpointFile?: string;
+  checkpointId?: string;
+  ledger?: string;
+  events?: string;
+  labels?: string;
+  reflection?: string;
+  teacher?: string;
+  teacherOutput?: string;
+  teacherPrompts?: string;
+  outcomes?: string;
+  includeLocalRuleLabels?: boolean;
+  workspaceDiff?: boolean;
+  pretty: boolean;
+}
+
+function usage(): never {
+  console.error(`Usage:
+  npm run router:rebuild -- --session <session.jsonl> [--session <session2.jsonl>] [--output <path>] [--workspace-diff] [--pretty]
+  npm run router:rebuild -- --session-dir <dir> [--output <path>] [--workspace-diff] [--pretty]
+  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:teacher-requests -- --checkpoint-file <checkpoints.jsonl> --output <requests.jsonl> [--teacher openai-codex/gpt-5.5] [--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:shadow -- --checkpoint-file <checkpoints.jsonl> --output <report.json> [--ledger <events.jsonl>] [--pretty]
+
+Commands:
+  rebuild    Rebuild derived router checkpoints from raw Pi session JSONL files.
+  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.
+  teacher-requests Generate local JSONL prompt requests for explicit teacher labeling.
+  reflect    Generate command-triggered soft routing labels and a reflection artifact.
+  dataset    Export trainable rows for a conservative continue-vs-intervene gate.
+  shadow     Shadow-evaluate the current rule policy over historical checkpoints.
+`);
+  process.exit(2);
+}
+
+function parseArgs(argv: string[]): Args {
+  const args: Args = { command: argv[0], sessions: [], pretty: false };
+  for (let index = 1; index < argv.length; index++) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === "--help" || arg === "-h") usage();
+    if (arg === "--session" && next) {
+      args.sessions.push(next);
+      index++;
+      continue;
+    }
+    if (arg === "--session-dir" && next) {
+      args.sessionDir = next;
+      index++;
+      continue;
+    }
+    if (arg === "--output" && next) {
+      args.output = next;
+      index++;
+      continue;
+    }
+    if (arg === "--checkpoint-file" && next) {
+      args.checkpointFile = next;
+      index++;
+      continue;
+    }
+    if (arg === "--checkpoint-id" && next) {
+      args.checkpointId = next;
+      index++;
+      continue;
+    }
+    if (arg === "--ledger" && next) {
+      args.ledger = next;
+      index++;
+      continue;
+    }
+    if (arg === "--events" && next) {
+      args.events = next;
+      index++;
+      continue;
+    }
+    if (arg === "--labels" && next) {
+      args.labels = next;
+      index++;
+      continue;
+    }
+    if (arg === "--reflection" && next) {
+      args.reflection = next;
+      index++;
+      continue;
+    }
+    if (arg === "--teacher" && next) {
+      args.teacher = next;
+      index++;
+      continue;
+    }
+    if (arg === "--teacher-output" && next) {
+      args.teacherOutput = next;
+      index++;
+      continue;
+    }
+    if (arg === "--teacher-prompts" && next) {
+      args.teacherPrompts = next;
+      index++;
+      continue;
+    }
+    if (arg === "--outcomes" && next) {
+      args.outcomes = next;
+      index++;
+      continue;
+    }
+    if (arg === "--include-local-rule-labels") {
+      args.includeLocalRuleLabels = true;
+      continue;
+    }
+    if (arg === "--workspace-diff") {
+      args.workspaceDiff = true;
+      continue;
+    }
+    if (arg === "--pretty") {
+      args.pretty = true;
+      continue;
+    }
+    usage();
+  }
+  return args;
+}
+
+function defaultOutput(): string {
+  return join(process.cwd(), ".pi", "router", "checkpoints.jsonl");
+}
+
+function sessionFilesFromDir(dir: string): string[] {
+  const resolved = resolve(dir);
+  if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+    throw new Error(`--session-dir is not a directory: ${dir}`);
+  }
+  const files: string[] = [];
+  const visit = (current: string): void => {
+    for (const entry of readdirSync(current)) {
+      const path = join(current, entry);
+      const stat = statSync(path);
+      if (stat.isDirectory()) {
+        visit(path);
+        continue;
+      }
+      if (stat.isFile() && path.endsWith(".jsonl")) files.push(path);
+    }
+  };
+  visit(resolved);
+  return files.sort();
+}
+
+function resolveSessions(args: Args): string[] {
+  const sessions = [...args.sessions];
+  if (args.sessionDir) sessions.push(...sessionFilesFromDir(args.sessionDir));
+  return [...new Set(sessions.map((session) => resolve(session)))];
+}
+
+async function rebuild(args: Args): Promise<unknown> {
+  const sessions = resolveSessions(args);
+  if (sessions.length === 0) usage();
+  const output = args.output ?? defaultOutput();
+  const result = await writeSessionCheckpointsJsonl(sessions, output, { workspaceDiff: args.workspaceDiff });
+  return {
+    schema: "pi-router.rebuild-summary.v1",
+    sessions: result.sessions,
+    output: result.output,
+    checkpoints: result.checkpoints,
+    firstCheckpointId: result.firstCheckpointId,
+    lastCheckpointId: result.lastCheckpointId,
+  };
+}
+
+function decide(args: Args): unknown {
+  if (!args.checkpointFile) usage();
+  const checkpoints = readCheckpointJsonl(args.checkpointFile);
+  const checkpoint = selectCheckpoint(checkpoints, args.checkpointId);
+  const decision = decideRoute(checkpoint);
+  if (args.ledger) appendRouteEvent(args.ledger, buildRouteEvent(checkpoint, decision));
+  return decision;
+}
+
+function cards(args: Args): unknown {
+  if (!args.events || !args.output) usage();
+  const cards = writeCapabilityCards(args.events, args.output, args.outcomes);
+  return { schema: "pi-router.cards-summary.v1", output: resolve(args.output), cards: cards.length };
+}
+
+function outcomes(args: Args): unknown {
+  if (!args.checkpointFile || !args.events || !args.output) usage();
+  return writeInferredOutcomes({ checkpointPath: args.checkpointFile, eventsPath: args.events, outputPath: args.output });
+}
+
+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" };
+}
+
+function reflect(args: Args): unknown {
+  if (!args.checkpointFile || !args.labels || !args.reflection) usage();
+  const result = writeTeacherReflection({
+    checkpointPath: args.checkpointFile,
+    labelsPath: args.labels,
+    reflectionPath: args.reflection,
+    teacher: args.teacher ?? "local-rule",
+    teacherOutputPath: args.teacherOutput,
+    teacherPromptPath: args.teacherPrompts,
+  });
+  return {
+    schema: "pi-router.reflect-summary.v1",
+    labels: resolve(args.labels),
+    reflection: resolve(args.reflection),
+    labelCount: result.labels.length,
+    teacher: args.teacher ?? "local-rule",
+  };
+}
+
+function dataset(args: Args): unknown {
+  if (!args.checkpointFile || !args.output) usage();
+  return writeTrainingRows({
+    checkpointPath: args.checkpointFile,
+    outputPath: args.output,
+    eventsPath: args.events,
+    outcomesPath: args.outcomes,
+    labelsPath: args.labels,
+    includeLocalRuleLabels: args.includeLocalRuleLabels,
+  });
+}
+
+function shadow(args: Args): unknown {
+  if (!args.checkpointFile || !args.output) usage();
+  return writeShadowEval(args.checkpointFile, args.output, args.ledger);
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const result = args.command === "rebuild"
+    ? await rebuild(args)
+    : args.command === "decide"
+      ? decide(args)
+      : args.command === "cards"
+        ? cards(args)
+        : args.command === "outcomes"
+          ? outcomes(args)
+          : args.command === "teacher-requests"
+            ? teacherRequests(args)
+            : args.command === "reflect"
+              ? reflect(args)
+              : args.command === "dataset"
+                ? dataset(args)
+                : args.command === "shadow"
+                  ? shadow(args)
+                  : usage();
+  console.log(args.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result));
+}
+
+main().catch((error: unknown) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

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

@@ -0,0 +1,34 @@
+import { DEFAULT_ROUTER_CONFIG, 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 filter(items: CompletionItem[], prefix: string): CompletionItem[] | null {
+  const q = prefix.trimStart().toLowerCase();
+  const out = q ? items.filter((entry) => entry.value.toLowerCase().startsWith(q)) : items;
+  return out.length ? out : null;
+}
+
+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 === "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 null;
+}

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

@@ -0,0 +1,133 @@
+import { mkdtempSync, readFileSync } 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 { registerRouter } from "./extension.js";
+import { decideRoute } from "./decision.js";
+import { summarizeRouterDecision } from "./observe.js";
+import type { RouterCheckpoint } from "./types.js";
+
+function ctxMock() {
+  const cwd = mkdtempSync(join(tmpdir(), "pi-router-ext-"));
+  const notifications: Array<{ text: string; level: string }> = [];
+  return {
+    cwd,
+    notifications,
+    ui: {
+      notify(text: string, level: string) {
+        notifications.push({ text, level });
+      },
+    },
+  };
+}
+
+function piMock() {
+  const commands = new Map<string, any>();
+  const shortcuts = new Map<string, any>();
+  const handlers = new Map<string, any[]>();
+  const pi: any = {
+    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]); },
+  };
+  return { pi, commands, shortcuts, handlers };
+}
+
+function checkpoint(overrides: Partial<RouterCheckpoint> = {}): RouterCheckpoint {
+  const base: RouterCheckpoint = {
+    schema: "pi-router.checkpoint.v1",
+    sessionId: "session-1",
+    checkpointId: "session-1:event-1",
+    createdAt: "2026-06-12T00:00:00.000Z",
+    rawSessionRef: { schema: "pi-router.raw-session-ref.v1", path: "/tmp/session.jsonl", fromEvent: 0, toEvent: 1, fromByte: 0, toByte: 10, contentHash: "hash" },
+    harness: "pi",
+    phase: "debug",
+    activeModel: "gpt-5.3-codex-spark",
+    provider: "openai-codex",
+    features: {
+      turnIndex: 1,
+      sameCommandRepeatedCount: 2,
+      sameErrorRepeatedCount: 2,
+      errorChanged: false,
+      testsImproved: null,
+      filesTouched: 1,
+      diffLines: 0,
+      diffFilesChanged: 0,
+      diffLinesAdded: 0,
+      diffLinesDeleted: 0,
+      diffChurnScore: 0,
+      toolThrashScore: 0.2,
+      goalDriftScore: 0,
+      loopScore: 0.55,
+      progressScore: 0.45,
+      verifierUsed: true,
+      noVerifierUsed: false,
+      toolCallsLast10Turns: 4,
+      contextTokensApprox: 1000,
+      gitDirty: null,
+    },
+    recent: { touchedFileHashes: [] },
+    sourceEvent: { index: 1, byteStart: 0, byteEnd: 10, type: "message", role: "toolResult" },
+  };
+  return { ...base, ...overrides, features: { ...base.features, ...(overrides.features ?? {}) } };
+}
+
+describe("router config profiles", () => {
+  it("creates default all-smart/spark/local profiles", () => {
+    const ctx = ctxMock();
+    const config = ensureRouterConfig(ctx);
+
+    expect(config.activeProfile).toBe("all-smart");
+    expect(config.profileOrder).toEqual(["all-smart", "spark-smart", "local-smart"]);
+    expect(activeProfile(config).worker).toBe("openai-codex/gpt-5.5");
+    expect(readFileSync(routerConfigPath(ctx), "utf8")).toContain("spark-smart");
+  });
+
+  it("sets and cycles profiles", () => {
+    const config = loadRouterConfig(ctxMock());
+    const spark = setRouterProfile(config, "spark-smart");
+
+    expect(spark?.activeProfile).toBe("spark-smart");
+    expect(cycleRouterProfile(spark!, 1).activeProfile).toBe("local-smart");
+    expect(setRouterProfile(config, "missing")).toBeNull();
+  });
+
+  it("completes router commands and profile names", () => {
+    expect(routerArgumentCompletions("")?.map((item) => item.value)).toEqual(expect.arrayContaining(["on", "off", "status", "profile"]));
+    expect(routerArgumentCompletions("profile s")?.map((item) => item.value)).toEqual(["profile spark-smart"]);
+  });
+});
+
+describe("router extension", () => {
+  it("registers slash command, ctrl-alt-p profile cycling, and observe hook", async () => {
+    const { pi, commands, shortcuts, handlers } = piMock();
+    const ctx = ctxMock();
+
+    registerRouter(pi);
+
+    expect(commands.has("router")).toBe(true);
+    expect(shortcuts.has("ctrl+alt+p")).toBe(true);
+    expect(handlers.has("turn_end")).toBe(true);
+
+    await commands.get("router").handler("on", ctx);
+    expect(loadRouterConfig(ctx).enabled).toBe(true);
+
+    await commands.get("router").handler("profile spark-smart", ctx);
+    expect(loadRouterConfig(ctx).activeProfile).toBe("spark-smart");
+
+    await shortcuts.get("ctrl+alt+p").handler(ctx);
+    expect(loadRouterConfig(ctx).activeProfile).toBe("local-smart");
+  });
+
+  it("formats observe-only mismatch summaries without changing models", () => {
+    const config = { ...loadRouterConfig(ctxMock()), enabled: true, activeProfile: "spark-smart" };
+    const item = checkpoint();
+    const summary = summarizeRouterDecision(item, decideRoute(item), config);
+
+    expect(summary.text).toContain("MISMATCH");
+    expect(summary.text).toContain("smart(openai-codex/gpt-5.5)");
+    expect(summary.text).toContain("current=gpt-5.3-codex-spark");
+  });
+});

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

@@ -0,0 +1,168 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export type RouterMode = "observe";
+export type RouterPrintMode = "all" | "mismatch_only" | "off";
+
+export interface RouterProfile {
+  main?: string;
+  worker: string;
+  smart: string;
+  teacher: string;
+  reviewer: string;
+  explore?: string;
+  debug_diagnose?: string;
+  review?: string;
+  verify?: string;
+}
+
+export interface RouterConfig {
+  enabled: boolean;
+  mode: RouterMode;
+  print: RouterPrintMode;
+  activeProfile: string;
+  profileOrder: string[];
+  profiles: Record<string, RouterProfile>;
+}
+
+export interface RouterState {
+  lastObservedCheckpointId?: string;
+  lastDecisionAction?: string;
+  lastSummary?: string;
+}
+
+export const DEFAULT_ROUTER_CONFIG: RouterConfig = {
+  enabled: false,
+  mode: "observe",
+  print: "mismatch_only",
+  activeProfile: "all-smart",
+  profileOrder: ["all-smart", "spark-smart", "local-smart"],
+  profiles: {
+    "all-smart": {
+      worker: "openai-codex/gpt-5.5",
+      smart: "openai-codex/gpt-5.5",
+      teacher: "openai-codex/gpt-5.5",
+      reviewer: "openai-codex/gpt-5.5",
+      explore: "openai-codex/gpt-5.5",
+      debug_diagnose: "openai-codex/gpt-5.5",
+      review: "openai-codex/gpt-5.5",
+      verify: "openai-codex/gpt-5.5",
+    },
+    "spark-smart": {
+      worker: "openai-codex/gpt-5.3-codex-spark",
+      smart: "openai-codex/gpt-5.5",
+      teacher: "openai-codex/gpt-5.5",
+      reviewer: "openai-codex/gpt-5.5",
+      explore: "openai-codex/gpt-5.3-codex-spark",
+      debug_diagnose: "openai-codex/gpt-5.5",
+      review: "openai-codex/gpt-5.5",
+      verify: "openai-codex/gpt-5.3-codex-spark",
+    },
+    "local-smart": {
+      worker: "qwen3.6-35b-a3b-128k",
+      smart: "openai-codex/gpt-5.5",
+      teacher: "openai-codex/gpt-5.5",
+      reviewer: "openai-codex/gpt-5.5",
+      explore: "qwen3.6-35b-a3b-128k",
+      debug_diagnose: "openai-codex/gpt-5.5",
+      review: "openai-codex/gpt-5.5",
+      verify: "qwen3.6-35b-a3b-128k",
+    },
+  },
+};
+
+function cwdFromCtx(ctx: any): string {
+  return resolve(String(ctx?.cwd ?? process.cwd()));
+}
+
+export function routerDir(ctx: any): string {
+  return join(cwdFromCtx(ctx), ".pi", "router");
+}
+
+export function routerConfigPath(ctx: any): string {
+  return join(routerDir(ctx), "config.json");
+}
+
+export function routerStatePath(ctx: any): string {
+  return join(routerDir(ctx), "state.json");
+}
+
+export function routerEventsPath(ctx: any): string {
+  return join(routerDir(ctx), "events.jsonl");
+}
+
+function readJson<T>(path: string, fallback: T): T {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+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
+    ? raw.profileOrder.filter((name) => typeof name === "string" && mergedProfiles[name])
+    : DEFAULT_ROUTER_CONFIG.profileOrder;
+  const activeProfile = raw?.activeProfile && mergedProfiles[raw.activeProfile]
+    ? raw.activeProfile
+    : profileOrder[0] ?? DEFAULT_ROUTER_CONFIG.activeProfile;
+  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",
+    print,
+    activeProfile,
+    profileOrder,
+    profiles: mergedProfiles,
+  };
+}
+
+export function loadRouterConfig(ctx: any): RouterConfig {
+  return normalizeRouterConfig(readJson<Partial<RouterConfig>>(routerConfigPath(ctx), {}));
+}
+
+export function saveRouterConfig(ctx: any, config: RouterConfig): void {
+  const path = routerConfigPath(ctx);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(normalizeRouterConfig(config), null, 2)}\n`);
+}
+
+export function ensureRouterConfig(ctx: any): RouterConfig {
+  const path = routerConfigPath(ctx);
+  const config = loadRouterConfig(ctx);
+  if (!existsSync(path)) saveRouterConfig(ctx, config);
+  return config;
+}
+
+export function loadRouterState(ctx: any): RouterState {
+  return readJson<RouterState>(routerStatePath(ctx), {});
+}
+
+export function saveRouterState(ctx: any, state: RouterState): void {
+  const path = routerStatePath(ctx);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export function activeProfile(config: RouterConfig): RouterProfile {
+  return config.profiles[config.activeProfile] ?? config.profiles[config.profileOrder[0]] ?? DEFAULT_ROUTER_CONFIG.profiles[DEFAULT_ROUTER_CONFIG.activeProfile];
+}
+
+export function cycleRouterProfile(config: RouterConfig, direction: 1 | -1 = 1): RouterConfig {
+  const order = config.profileOrder.filter((name) => config.profiles[name]);
+  if (order.length === 0) return normalizeRouterConfig(config);
+  const currentIndex = Math.max(0, order.indexOf(config.activeProfile));
+  const nextIndex = (currentIndex + direction + order.length) % order.length;
+  return { ...config, activeProfile: order[nextIndex] };
+}
+
+export function setRouterProfile(config: RouterConfig, name: string): RouterConfig | null {
+  if (!config.profiles[name]) return null;
+  return { ...config, activeProfile: name, profileOrder: config.profileOrder.includes(name) ? config.profileOrder : [...config.profileOrder, name] };
+}
+
+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}`;
+}