@fiale-plus/pi-rogue 0.2.1 → 0.2.3

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

@@ -0,0 +1,165 @@
+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, routerEventsPath, routerSessionDir, routerStatePath, saveRouterConfig, setRouterProfile } from "./config.js";
+import { registerRouter } from "./extension.js";
+import { decideRoute } from "./decision.js";
+import { observeRouterTurn, summarizeRouterDecision } from "./observe.js";
+import type { RouterCheckpoint } from "./types.js";
+
+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 });
+      },
+    },
+  };
+}
+
+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 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"]);
+  });
+
+  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);
+  });
+});
+
+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,193 @@
+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 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");
+}
+
+function sessionPathFromCtx(ctx: any): string | undefined {
+  const value = ctx?.sessionManager?.getSessionFile?.();
+  return value ? String(value) : undefined;
+}
+
+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 {
+  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, sessionPath?: string): RouterState {
+  return readJson<RouterState>(routerStatePath(ctx, sessionPath), {});
+}
+
+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`);
+}
+
+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}`;
+}

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

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { decideRoute, readCheckpointJsonl } from "./decision.js";
+import { readRouteEvents, type RouteEvent } from "./ledger.js";
+import { readOutcomes, type RouterOutcome } from "./outcomes.js";
+import type { RouterCheckpoint, RouteAction } from "./types.js";
+import { readTeacherLabels, type TeacherLabel } from "./learning.js";
+
+export const ROUTER_TRAINING_ROW_SCHEMA = "pi-router.training-row.v1" as const;
+
+export type BinaryGateLabel = "continue" | "intervene" | "unknown";
+
+export interface RouterTrainingRow {
+  schema: typeof ROUTER_TRAINING_ROW_SCHEMA;
+  checkpointId: string;
+  sessionId: string;
+  rawSessionRef: RouterCheckpoint["rawSessionRef"];
+  features: {
+    phase: RouterCheckpoint["phase"];
+    activeModel?: string;
+    provider?: string;
+    contextTokensApprox: number | null;
+    sameCommandRepeatedCount: number;
+    sameErrorRepeatedCount: number;
+    loopScore: number;
+    progressScore: number;
+    verifierUsed: boolean;
+    noVerifierUsed: boolean;
+    diffLines: number;
+    diffFilesChanged: number;
+    diffChurnScore: number;
+    filesTouched: number;
+  };
+  labels: {
+    routeAction: RouteAction | null;
+    binaryGate: BinaryGateLabel;
+    source: "teacher" | "human" | "outcome" | "local-rule" | "unknown";
+    confidence: number | null;
+  };
+  outcome: {
+    taskStatus: RouterOutcome["taskStatus"] | "unknown";
+    testsPassedAfter: boolean | null;
+    acceptedDiff: boolean | null;
+    userOverrodeDecision: boolean | null;
+    reworkTurns: number | null;
+  };
+  provenance: {
+    routeEventId?: string;
+    teacherLabelId?: string;
+    localRuleAction: RouteAction;
+    excludedLocalRuleAsTruth: boolean;
+  };
+}
+
+function routeToGate(action: RouteAction | null | undefined): BinaryGateLabel {
+  if (!action) return "unknown";
+  return action === "continue_current" || action === "continue_local" ? "continue" : "intervene";
+}
+
+function labelSource(label?: TeacherLabel): RouterTrainingRow["labels"]["source"] {
+  if (!label) return "unknown";
+  if (label.source === "local-rule") return "local-rule";
+  return label.teacher === "human" ? "human" : "teacher";
+}
+
+export function buildTrainingRows(options: {
+  checkpoints: RouterCheckpoint[];
+  routeEvents?: RouteEvent[];
+  outcomes?: RouterOutcome[];
+  labels?: TeacherLabel[];
+  includeLocalRuleLabels?: boolean;
+}): RouterTrainingRow[] {
+  const eventByCheckpoint = new Map((options.routeEvents ?? []).map((event) => [event.checkpointId, event]));
+  const outcomeByCheckpoint = new Map((options.outcomes ?? []).flatMap((outcome) => outcome.checkpointId && !outcome.routeEventId ? [[outcome.checkpointId, outcome] as const] : []));
+  const outcomeByRouteEvent = new Map((options.outcomes ?? []).flatMap((outcome) => outcome.routeEventId ? [[outcome.routeEventId, outcome] as const] : []));
+  const labelByCheckpoint = new Map((options.labels ?? []).map((label) => [label.checkpointId, label]));
+
+  return options.checkpoints.map((checkpoint) => {
+    const routeEvent = eventByCheckpoint.get(checkpoint.checkpointId);
+    const outcome = (routeEvent ? outcomeByRouteEvent.get(routeEvent.eventId) : undefined) ?? outcomeByCheckpoint.get(checkpoint.checkpointId);
+    const teacherLabel = labelByCheckpoint.get(checkpoint.checkpointId);
+    const canUseLabel = Boolean(teacherLabel && (options.includeLocalRuleLabels || teacherLabel.source !== "local-rule"));
+    const routeAction = canUseLabel ? teacherLabel!.suggestedAction : null;
+    const ruleAction = decideRoute(checkpoint).action;
+    return {
+      schema: ROUTER_TRAINING_ROW_SCHEMA,
+      checkpointId: checkpoint.checkpointId,
+      sessionId: checkpoint.sessionId,
+      rawSessionRef: checkpoint.rawSessionRef,
+      features: {
+        phase: checkpoint.phase,
+        activeModel: checkpoint.activeModel,
+        provider: checkpoint.provider,
+        contextTokensApprox: checkpoint.features.contextTokensApprox,
+        sameCommandRepeatedCount: checkpoint.features.sameCommandRepeatedCount,
+        sameErrorRepeatedCount: checkpoint.features.sameErrorRepeatedCount,
+        loopScore: checkpoint.features.loopScore,
+        progressScore: checkpoint.features.progressScore,
+        verifierUsed: checkpoint.features.verifierUsed,
+        noVerifierUsed: checkpoint.features.noVerifierUsed,
+        diffLines: checkpoint.features.diffLines ?? 0,
+        diffFilesChanged: checkpoint.features.diffFilesChanged ?? 0,
+        diffChurnScore: checkpoint.features.diffChurnScore ?? 0,
+        filesTouched: checkpoint.features.filesTouched,
+      },
+      labels: {
+        routeAction,
+        binaryGate: routeToGate(routeAction),
+        source: canUseLabel ? labelSource(teacherLabel) : "unknown",
+        confidence: canUseLabel ? teacherLabel!.confidence : null,
+      },
+      outcome: {
+        taskStatus: outcome?.taskStatus ?? "unknown",
+        testsPassedAfter: outcome?.testsPassedAfter ?? null,
+        acceptedDiff: outcome?.acceptedDiff ?? null,
+        userOverrodeDecision: outcome?.userOverrodeDecision ?? null,
+        reworkTurns: outcome?.reworkTurns ?? null,
+      },
+      provenance: {
+        routeEventId: routeEvent?.eventId,
+        teacherLabelId: canUseLabel ? teacherLabel!.labelId : undefined,
+        localRuleAction: ruleAction,
+        excludedLocalRuleAsTruth: Boolean(teacherLabel?.source === "local-rule" && !options.includeLocalRuleLabels),
+      },
+    } satisfies RouterTrainingRow;
+  });
+}
+
+export function writeTrainingRows(options: {
+  checkpointPath: string;
+  outputPath: string;
+  eventsPath?: string;
+  outcomesPath?: string;
+  labelsPath?: string;
+  includeLocalRuleLabels?: boolean;
+}): { schema: "pi-router.dataset-summary.v1"; output: string; rows: number; labeledRows: number } {
+  if (options.eventsPath && !existsSync(options.eventsPath)) throw new Error(`route events file not found: ${options.eventsPath}`);
+  const rows = buildTrainingRows({
+    checkpoints: readCheckpointJsonl(options.checkpointPath),
+    routeEvents: options.eventsPath ? readRouteEvents(options.eventsPath) : [],
+    outcomes: readOutcomes(options.outcomesPath),
+    labels: options.labelsPath ? readTeacherLabels(options.labelsPath) : [],
+    includeLocalRuleLabels: options.includeLocalRuleLabels,
+  });
+  const resolved = resolve(options.outputPath);
+  mkdirSync(dirname(resolved), { recursive: true });
+  writeFileSync(resolved, rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length ? "\n" : ""));
+  return {
+    schema: "pi-router.dataset-summary.v1",
+    output: resolved,
+    rows: rows.length,
+    labeledRows: rows.filter((row) => row.labels.binaryGate !== "unknown").length,
+  };
+}

package/node_modules/@fiale-plus/pi-rogue-router/src/decision-ledger.test.ts

@@ -0,0 +1,148 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { decideRoute, readCheckpointJsonl, selectCheckpoint } from "./decision.js";
+import { appendRouteEvent, buildRouteEvent, readRouteEvents } from "./ledger.js";
+import type { RouterCheckpoint } from "./types.js";
+
+type CheckpointOverrides = Partial<Omit<RouterCheckpoint, "features" | "recent">> & {
+  features?: Partial<RouterCheckpoint["features"]>;
+  recent?: Partial<RouterCheckpoint["recent"]>;
+};
+
+function checkpoint(overrides: CheckpointOverrides = {}): RouterCheckpoint {
+  const base: RouterCheckpoint = {
+    schema: "pi-router.checkpoint.v1",
+    sessionId: "session-1",
+    checkpointId: "session-1:event-10",
+    createdAt: "2026-06-12T00:00:00.000Z",
+    rawSessionRef: {
+      schema: "pi-router.raw-session-ref.v1",
+      path: "/tmp/raw-session.jsonl",
+      fromEvent: 1,
+      toEvent: 10,
+      fromByte: 100,
+      toByte: 200,
+      contentHash: "hash-only",
+    },
+    harness: "pi",
+    repoHash: "repo-hash",
+    goalHash: "goal-hash",
+    phase: "debug",
+    activeModel: "local/qwen",
+    provider: "local",
+    features: {
+      turnIndex: 10,
+      sameCommandRepeatedCount: 2,
+      sameErrorRepeatedCount: 2,
+      errorChanged: false,
+      testsImproved: null,
+      filesTouched: 1,
+      diffLines: 12,
+      diffFilesChanged: 1,
+      diffLinesAdded: 8,
+      diffLinesDeleted: 4,
+      diffChurnScore: 0,
+      toolThrashScore: 0.25,
+      goalDriftScore: 0,
+      loopScore: 0.55,
+      progressScore: 0.45,
+      verifierUsed: true,
+      noVerifierUsed: false,
+      toolCallsLast10Turns: 4,
+      contextTokensApprox: 1234,
+      gitDirty: null,
+    },
+    recent: {
+      lastUserGoalHash: "goal-hash",
+      lastCommandHash: "command-hash",
+      lastErrorHash: "error-hash",
+      touchedFileHashes: ["file-hash"],
+    },
+    sourceEvent: {
+      index: 10,
+      byteStart: 100,
+      byteEnd: 200,
+      id: "event-id",
+      timestamp: "2026-06-12T00:00:01.000Z",
+      type: "message",
+      role: "toolResult",
+    },
+  };
+  return { ...base, ...overrides, features: { ...base.features, ...overrides.features }, recent: { ...base.recent, ...overrides.recent } };
+}
+
+describe("trajectory router decision and ledger", () => {
+  it("emits strict JSON decisions from conservative local-first rules", () => {
+    const decision = decideRoute(checkpoint());
+
+    expect(decision).toEqual({
+      schema: "pi-router.decision.v1",
+      checkpointId: "session-1:event-10",
+      action: "escalate_debug_diagnosis",
+      adviceShape: "debug_diagnosis",
+      contextPolicy: "focused_error_and_diff",
+      confidence: 0.82,
+      reason: "same error repeated in debug phase; ask stronger/different model for diagnosis",
+      policyVersion: "pi-router.rule-policy.v0",
+    });
+  });
+
+  it("keeps normal progress local/current", () => {
+    const decision = decideRoute(checkpoint({
+      phase: "implementation",
+      features: {
+        sameCommandRepeatedCount: 1,
+        sameErrorRepeatedCount: 0,
+        loopScore: 0.1,
+        progressScore: 0.8,
+      },
+    }));
+
+    expect(decision.action).toBe("continue_current");
+    expect(decision.adviceShape).toBe("none");
+    expect(decision.contextPolicy).toBe("none");
+  });
+
+  it("selects the last checkpoint by default or an explicit checkpoint id", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-router-decision-"));
+    const file = join(dir, "checkpoints.jsonl");
+    const first = checkpoint({ checkpointId: "first" });
+    const second = checkpoint({ checkpointId: "second" });
+    writeFileSync(file, `${JSON.stringify(first)}\n${JSON.stringify(second)}\n`);
+
+    const checkpoints = readCheckpointJsonl(file);
+
+    expect(selectCheckpoint(checkpoints).checkpointId).toBe("second");
+    expect(selectCheckpoint(checkpoints, "first").checkpointId).toBe("first");
+    expect(() => selectCheckpoint(checkpoints, "missing")).toThrow(/checkpoint not found/);
+  });
+
+  it("appends route ledger events without raw transcript content", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-router-ledger-"));
+    const file = join(dir, "events.jsonl");
+    const sensitiveText = "npm test src/secret.test.ts failed with API_TOKEN=abc";
+    const routeCheckpoint = checkpoint();
+    const decision = decideRoute(routeCheckpoint);
+    const event = buildRouteEvent(routeCheckpoint, decision, "2026-06-12T00:00:02.000Z");
+
+    appendRouteEvent(file, event);
+    const events = readRouteEvents(file);
+    const raw = readFileSync(file, "utf8");
+
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      schema: "pi-router.route-event.v1",
+      checkpointId: routeCheckpoint.checkpointId,
+      sessionId: routeCheckpoint.sessionId,
+      decision,
+      runtime: { activeModel: "local/qwen", provider: "local", contextTokensApprox: 1234 },
+      observed: { followed: null },
+    });
+    expect(raw).not.toContain(sensitiveText);
+    expect(raw).not.toContain("npm test");
+    expect(raw).not.toContain("API_TOKEN");
+    expect(raw).toContain("hash-only");
+  });
+});