@fiale-plus/pi-rogue 0.2.2 → 0.2.4

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/git-features.ts

@@ -16,7 +16,16 @@ function git(cwd: string, args: string[]): string {
   return execFileSync("git", args, { cwd: resolve(cwd), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
 }
 
-function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> {
+interface GitExcludes {
+  files: Set<string>;
+  prefixes: string[];
+}
+
+function isExcluded(file: string, excludes: GitExcludes): boolean {
+  return excludes.files.has(file) || excludes.prefixes.some((prefix) => file.startsWith(prefix));
+}
+
+function parseNumstat(output: string, excludes: GitExcludes = { files: new Set(), prefixes: [] }): Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> {
   let rows = 0;
   let linesAdded = 0;
   let linesDeleted = 0;
@@ -26,7 +35,7 @@ function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<Di
     if (!line.trim()) continue;
     const [added, deleted, ...fileParts] = line.split("\t");
     const file = fileParts.join("\t").trim();
-    if (file && excludeFiles.has(file)) continue;
+    if (file && isExcluded(file, excludes)) continue;
     rows++;
     if (file) fileHashes.add(hashText(file));
     const add = Number(added);
@@ -38,13 +47,13 @@ function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<Di
   return { filesChanged: fileHashes.size || rows, linesAdded, linesDeleted, totalLines: linesAdded + linesDeleted, fileHashes: [...fileHashes].sort() };
 }
 
-function untrackedFiles(cwd: string, excludeFiles = new Set<string>()): { hashes: string[]; linesAdded: number } {
+function untrackedFiles(cwd: string, excludes: GitExcludes = { files: new Set(), prefixes: [] }): { hashes: string[]; linesAdded: number } {
   try {
     let linesAdded = 0;
     const hashes: string[] = [];
     for (const raw of git(cwd, ["ls-files", "--others", "--exclude-standard"]).split("\n")) {
       const file = raw.trim();
-      if (!file || excludeFiles.has(file)) continue;
+      if (!file || isExcluded(file, excludes)) continue;
       hashes.push(hashText(file));
       try {
         const path = resolve(cwd, file);
@@ -63,39 +72,45 @@ function untrackedFiles(cwd: string, excludeFiles = new Set<string>()): { hashes
   }
 }
 
-function excludeFilesFromPaths(root: string, paths: string[] | undefined): Set<string> {
+function excludeFilesFromPaths(root: string, paths: string[] | undefined): GitExcludes {
   const files = new Set<string>();
+  const prefixes: string[] = [];
   const realRoot = realpathSync(root);
   for (const path of paths ?? []) {
     const absolute = isAbsolute(path) ? path : resolve(root, path);
     let rel = relative(root, absolute);
+    let isDirectory = false;
     try {
-      rel = relative(realRoot, realpathSync(absolute));
+      const realAbsolute = realpathSync(absolute);
+      rel = relative(realRoot, realAbsolute);
+      isDirectory = statSync(realAbsolute).isDirectory();
     } catch {
       // Output paths may not exist yet; fall back to lexical repo-relative path.
     }
-    if (rel && !rel.startsWith("..")) files.add(rel);
+    if (!rel || rel.startsWith("..")) continue;
+    if (isDirectory) prefixes.push(rel.endsWith("/") ? rel : `${rel}/`);
+    else files.add(rel);
   }
-  return files;
+  return { files, prefixes };
 }
 
 export function readGitDiffStats(cwd?: string, options: { excludePaths?: string[] } = {}): DiffStats {
   if (!cwd) return EMPTY_DIFF_STATS;
   try {
     const root = git(cwd, ["rev-parse", "--show-toplevel"]).trim() || cwd;
-    const excludeFiles = excludeFilesFromPaths(root, options.excludePaths);
-    const untracked = untrackedFiles(root, excludeFiles);
+    const excludes = excludeFilesFromPaths(root, options.excludePaths);
+    const untracked = untrackedFiles(root, excludes);
     let parsed: Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> = EMPTY_DIFF_STATS;
     let shortStat = "";
     try {
-      parsed = parseNumstat(git(root, ["diff", "--numstat", "HEAD"]), excludeFiles);
+      parsed = parseNumstat(git(root, ["diff", "--numstat", "HEAD"]), excludes);
       shortStat = git(root, ["diff", "--shortstat", "HEAD"]).trim();
     } catch {
       // Repositories without an initial commit have no HEAD; include staged files plus untracked counts.
       try {
         const cachedNumstat = git(root, ["diff", "--cached", "--numstat"]);
         const worktreeNumstat = git(root, ["diff", "--numstat"]);
-        parsed = parseNumstat(`${cachedNumstat}\n${worktreeNumstat}`, excludeFiles);
+        parsed = parseNumstat(`${cachedNumstat}\n${worktreeNumstat}`, excludes);
         shortStat = `${git(root, ["diff", "--cached", "--shortstat"]).trim()} ${git(root, ["diff", "--shortstat"]).trim()}`.trim();
       } catch {
         // Still report untracked-file counts/hashes below.

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";
@@ -6,6 +7,7 @@ import {
   loadRouterConfig,
   loadRouterState,
   routerConfigPath,
+  routerDir,
   routerEventsPath,
   routerStatePath,
   saveRouterState,
@@ -20,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()}…`;
@@ -52,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)}`);
 }
 
@@ -69,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;
@@ -80,6 +102,7 @@ export function summarizeRouterDecision(checkpoint: RouterCheckpoint, decision:
     role,
     targetModel,
     currentModel: checkpoint.activeModel,
+    currentProvider: checkpoint.provider,
     match,
     confidence: decision.confidence,
     reason: decision.reason,
@@ -93,27 +116,82 @@ 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));
   if (!checkpoint) return null;
-  const state = loadRouterState(ctx);
+  const state = loadRouterState(ctx, String(sessionPath));
   if (state.lastObservedCheckpointId === checkpoint.checkpointId) return null;
 
-  const liveCheckpoint = checkpointWithDiffStats(checkpoint, ctx?.cwd, [sessionPath, routerConfigPath(ctx), routerStatePath(ctx), routerEventsPath(ctx)]);
+  const liveCheckpoint = checkpointWithDiffStats(checkpoint, ctx?.cwd, [
+    String(sessionPath),
+    routerConfigPath(ctx),
+    routerDir(ctx),
+    routerStatePath(ctx, String(sessionPath)),
+    routerEventsPath(ctx, String(sessionPath)),
+  ]);
   const decision = decideRoute(liveCheckpoint);
   const summary = summarizeRouterDecision(liveCheckpoint, decision, config);
-  appendRouteEvent(routerEventsPath(ctx), buildRouteEvent(liveCheckpoint, decision));
+  appendRouteEvent(routerEventsPath(ctx, String(sessionPath)), buildRouteEvent(liveCheckpoint, decision));
   saveRouterState(ctx, {
     lastObservedCheckpointId: checkpoint.checkpointId,
     lastDecisionAction: decision.action,
     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;
 }

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

@@ -6,6 +6,7 @@ import { readRouteEvents, type RouteEvent } from "./ledger.js";
 import type { RouterCheckpoint, TaskStatus, TaskType } from "./types.js";
 
 export const ROUTER_OUTCOME_SCHEMA = "pi-router.outcome.v1" as const;
+export const ROUTER_OUTCOME_ENRICH_SUMMARY_SCHEMA = "pi-router.outcome-enrich-summary.v1" as const;
 
 export interface RouterOutcome {
   schema: typeof ROUTER_OUTCOME_SCHEMA;
@@ -43,9 +44,15 @@ export interface OutcomeWriteSummary {
   inferred: number;
 }
 
-function roundStatus(event: RouteEvent, checkpoint?: RouterCheckpoint): TaskStatus {
-  if (event.decision.action === "stop_and_ask_user") return "unknown";
-  if (checkpoint?.features.verifierUsed && checkpoint.features.progressScore >= 0.75) return "partial";
+export interface OutcomeEnrichSummary {
+  schema: typeof ROUTER_OUTCOME_ENRICH_SUMMARY_SCHEMA;
+  output: string;
+  inputOutcomes: number;
+  outputOutcomes: number;
+  enriched: number;
+}
+
+function roundStatus(_event: RouteEvent, _checkpoint?: RouterCheckpoint): TaskStatus {
   return "unknown";
 }
 
@@ -78,7 +85,7 @@ export function buildUnknownOutcome(event: RouteEvent, checkpoint?: RouterCheckp
     testsPassedAfter: null,
     verifierImproved: null,
     acceptedDiff: null,
-    userInterrupted: event.decision.action === "stop_and_ask_user",
+    userInterrupted: false,
     userOverrodeDecision: Boolean(event.observed.overriddenBy),
     finalFilesTouched: checkpoint ? ((checkpoint.features.diffFilesChanged ?? 0) > 0 ? (checkpoint.features.diffFilesChanged ?? 0) : checkpoint.features.filesTouched) : 0,
     finalDiffLines: checkpoint?.features.diffLines ?? 0,
@@ -107,8 +114,14 @@ export function readOutcomes(path?: string): RouterOutcome[] {
   return readFileSync(resolved, "utf8")
     .split("\n")
     .filter((line) => line.trim())
-    .flatMap((line) => {
-      try { return [JSON.parse(line) as RouterOutcome]; } catch { return []; }
+    .map((line, index) => {
+      try {
+        const outcome = JSON.parse(line) as RouterOutcome;
+        if (outcome.schema !== ROUTER_OUTCOME_SCHEMA) throw new Error("invalid schema");
+        return outcome;
+      } catch (error) {
+        throw new Error(`invalid outcome JSONL at ${path}:${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+      }
     });
 }
 
@@ -118,6 +131,94 @@ export function writeOutcomesJsonl(outcomes: RouterOutcome[], path: string): voi
   writeFileSync(resolved, outcomes.map((outcome) => JSON.stringify(outcome)).join("\n") + (outcomes.length ? "\n" : ""));
 }
 
+function routeEventForOutcome(outcome: RouterOutcome, byId: Map<string, RouteEvent>, byCheckpoint: Map<string, RouteEvent>): RouteEvent | undefined {
+  return (outcome.routeEventId ? byId.get(outcome.routeEventId) : undefined) ?? (outcome.checkpointId ? byCheckpoint.get(outcome.checkpointId) : undefined);
+}
+
+function checkpointForOutcome(outcome: RouterOutcome, event: RouteEvent | undefined, byCheckpoint: Map<string, RouterCheckpoint>): RouterCheckpoint | undefined {
+  return (outcome.checkpointId ? byCheckpoint.get(outcome.checkpointId) : undefined) ?? (event ? byCheckpoint.get(event.checkpointId) : undefined);
+}
+
+function inferredStatus(outcome: RouterOutcome, checkpoint?: RouterCheckpoint, event?: RouteEvent, testsPassed: boolean | null = outcome.testsPassedAfter): TaskStatus {
+  const stopWasFollowed = event?.decision.action === "stop_and_ask_user" && event.observed.followed === true && !event.observed.overriddenBy;
+  if (stopWasFollowed || outcome.userInterrupted) return outcome.taskStatus === "unknown" ? "abandoned" : outcome.taskStatus;
+  if (testsPassed === true && Math.max(outcome.finalDiffLines, checkpoint?.features.diffLines ?? 0, event?.metrics.diffLines ?? 0) > 0) return "success";
+  if (testsPassed === true && outcome.taskStatus === "unknown") return "partial";
+  if (testsPassed === false && outcome.taskStatus === "unknown") return "failed";
+  if (outcome.taskStatus === "partial" && testsPassed === true && Math.max(outcome.finalDiffLines, checkpoint?.features.diffLines ?? 0, event?.metrics.diffLines ?? 0) > 0) return "success";
+  return outcome.taskStatus;
+}
+
+export function enrichOutcome(outcome: RouterOutcome, options: { checkpoint?: RouterCheckpoint; event?: RouteEvent; recordedAt?: string } = {}): RouterOutcome {
+  const checkpoint = options.checkpoint;
+  const event = options.event;
+  const testsPassedAfter = outcome.testsPassedAfter;
+  const verifierImproved = outcome.verifierImproved
+    ?? (checkpoint?.features.testsImproved !== null && checkpoint?.features.testsImproved !== undefined ? checkpoint.features.testsImproved : null);
+  const taskStatus = inferredStatus(outcome, checkpoint, event, testsPassedAfter);
+  const evidenceDiffLines = checkpoint?.features.diffLines ?? event?.metrics.diffLines ?? 0;
+  const evidenceFilesTouched = checkpoint
+    ? ((checkpoint.features.diffFilesChanged ?? 0) > 0 ? checkpoint.features.diffFilesChanged : checkpoint.features.filesTouched)
+    : event?.metrics.diffFilesChanged ?? 0;
+  const evidenceErrorRepeats = checkpoint?.features.sameErrorRepeatedCount ?? event?.metrics.sameErrorRepeatedCount ?? 0;
+  const finalDiffLines = Math.max(outcome.finalDiffLines, evidenceDiffLines);
+  const finalFilesTouched = Math.max(outcome.finalFilesTouched, evidenceFilesTouched);
+  const reworkTurns = Math.max(outcome.reworkTurns, evidenceErrorRepeats > 1 ? evidenceErrorRepeats - 1 : 0);
+  const acceptedDiff = outcome.acceptedDiff
+    ?? (finalDiffLines > 0 && testsPassedAfter === true ? true : testsPassedAfter === false || taskStatus === "abandoned" ? false : null);
+  const notes = JSON.stringify({ enrichedFromCheckpoint: checkpoint?.checkpointId, routeEventId: event?.eventId, taskStatus, testsPassedAfter, verifierImproved, acceptedDiff });
+
+  return {
+    ...outcome,
+    recordedAt: options.recordedAt ?? outcome.recordedAt,
+    checkpointId: outcome.checkpointId ?? event?.checkpointId,
+    routeEventId: outcome.routeEventId ?? event?.eventId,
+    taskType: outcome.taskType === "unknown" ? taskTypeFromCheckpoint(checkpoint) : outcome.taskType,
+    taskStatus,
+    testsPassedAfter,
+    verifierImproved,
+    acceptedDiff,
+    userInterrupted: outcome.userInterrupted || Boolean(event?.decision.action === "stop_and_ask_user" && event.observed.followed === true && !event.observed.overriddenBy),
+    userOverrodeDecision: outcome.userOverrodeDecision || Boolean(event?.observed.overriddenBy),
+    finalFilesTouched,
+    finalDiffLines,
+    reworkTurns,
+    evidence: {
+      ...outcome.evidence,
+      rawSessionRef: outcome.evidence.rawSessionRef ?? checkpoint?.rawSessionRef ?? event?.rawSessionRef,
+      routeEventId: outcome.evidence.routeEventId ?? event?.eventId,
+      notesHash: outcome.evidence.notesHash ?? hashText(notes),
+    },
+  };
+}
+
+function validateOutcomeLinks(outcomes: RouterOutcome[], checkpoints: RouterCheckpoint[], events: RouteEvent[]): void {
+  const checkpointIds = new Set(checkpoints.map((checkpoint) => checkpoint.checkpointId));
+  const eventIds = new Set(events.map((event) => event.eventId));
+  const eventById = new Map(events.map((event) => [event.eventId, event]));
+  const eventCheckpointIds = new Set(events.map((event) => event.checkpointId));
+  for (const outcome of outcomes) {
+    if (events.length > 0 && outcome.routeEventId && !eventIds.has(outcome.routeEventId)) throw new Error(`outcome routeEventId not found: ${outcome.routeEventId}`);
+    if (outcome.routeEventId && outcome.checkpointId) {
+      const event = eventById.get(outcome.routeEventId);
+      if (event && event.checkpointId !== outcome.checkpointId) throw new Error(`outcome routeEventId/checkpointId mismatch: ${outcome.routeEventId}`);
+    }
+    if ((checkpoints.length > 0 || events.length > 0) && outcome.checkpointId && !checkpointIds.has(outcome.checkpointId) && !eventCheckpointIds.has(outcome.checkpointId)) throw new Error(`outcome checkpointId not found: ${outcome.checkpointId}`);
+  }
+}
+
+export function enrichOutcomes(outcomes: RouterOutcome[], checkpoints: RouterCheckpoint[] = [], events: RouteEvent[] = [], recordedAt?: string): RouterOutcome[] {
+  validateOutcomeLinks(outcomes, checkpoints, events);
+  const checkpointById = new Map(checkpoints.map((checkpoint) => [checkpoint.checkpointId, checkpoint]));
+  const eventById = new Map(events.map((event) => [event.eventId, event]));
+  const eventByCheckpoint = new Map(events.map((event) => [event.checkpointId, event]));
+  return outcomes.map((outcome) => {
+    const event = routeEventForOutcome(outcome, eventById, eventByCheckpoint);
+    const checkpoint = checkpointForOutcome(outcome, event, checkpointById);
+    return enrichOutcome(outcome, { checkpoint, event, recordedAt });
+  });
+}
+
 export function writeInferredOutcomes(options: { checkpointPath: string; eventsPath: string; outputPath: string }): OutcomeWriteSummary {
   if (!existsSync(resolve(options.eventsPath))) throw new Error(`required route events file not found: ${options.eventsPath}`);
   const checkpoints = readCheckpointJsonl(options.checkpointPath);
@@ -126,3 +227,26 @@ export function writeInferredOutcomes(options: { checkpointPath: string; eventsP
   writeOutcomesJsonl(outcomes, options.outputPath);
   return { schema: "pi-router.outcomes-summary.v1", output: resolve(options.outputPath), outcomes: outcomes.length, inferred: outcomes.length };
 }
+
+export function writeEnrichedOutcomes(options: { outcomesPath: string; outputPath: string; checkpointPath?: string; eventsPath?: string }): OutcomeEnrichSummary {
+  if (!options.checkpointPath && !options.eventsPath) throw new Error("outcome enrichment requires --checkpoint-file or --events evidence");
+  if (options.eventsPath && !existsSync(resolve(options.eventsPath))) throw new Error(`route events file not found: ${options.eventsPath}`);
+  if (options.checkpointPath && !existsSync(resolve(options.checkpointPath))) throw new Error(`checkpoint file not found: ${options.checkpointPath}`);
+  const input = readOutcomes(options.outcomesPath);
+  const checkpoints = options.checkpointPath ? readCheckpointJsonl(options.checkpointPath) : [];
+  const events = options.eventsPath ? readRouteEvents(options.eventsPath) : [];
+  if (checkpoints.length === 0 && events.length === 0) {
+    if (options.checkpointPath && !options.eventsPath) throw new Error(`checkpoint file contains no checkpoints: ${options.checkpointPath}`);
+    if (options.eventsPath && !options.checkpointPath) throw new Error(`route events file contains no events: ${options.eventsPath}`);
+    throw new Error("outcome enrichment evidence files contain no usable checkpoint or route events");
+  }
+  const enriched = enrichOutcomes(input, checkpoints, events);
+  writeOutcomesJsonl(enriched, options.outputPath);
+  return {
+    schema: ROUTER_OUTCOME_ENRICH_SUMMARY_SCHEMA,
+    output: resolve(options.outputPath),
+    inputOutcomes: input.length,
+    outputOutcomes: enriched.length,
+    enriched: enriched.filter((outcome, index) => JSON.stringify(outcome) !== JSON.stringify(input[index])).length,
+  };
+}