@fiale-plus/pi-rogue 0.2.0 → 0.2.2

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");
+  });
+});

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

@@ -0,0 +1,138 @@
+import { readFileSync } from "node:fs";
+import { hashText } from "./hash.js";
+import type { AdviceShape, ContextPolicy, RouteAction, RouteDecision, RouterCheckpoint } from "./types.js";
+
+export const ROUTER_POLICY_VERSION = "pi-router.rule-policy.v0";
+export const ROUTER_DECISION_SCHEMA = "pi-router.decision.v1" as const;
+
+export interface DecideOptions {
+  policyVersion?: string;
+}
+
+interface RuleResult {
+  action: RouteAction;
+  adviceShape: AdviceShape;
+  contextPolicy: ContextPolicy;
+  confidence: number;
+  reason: string;
+}
+
+function clampConfidence(value: number): number {
+  return Math.max(0, Math.min(1, Number(value.toFixed(3))));
+}
+
+function hasLargeDiff(checkpoint: RouterCheckpoint): boolean {
+  return checkpoint.features.diffLines >= 400;
+}
+
+function isContextPressure(checkpoint: RouterCheckpoint): boolean {
+  const tokens = checkpoint.features.contextTokensApprox;
+  return typeof tokens === "number" && tokens >= 100_000;
+}
+
+function ruleFor(checkpoint: RouterCheckpoint): RuleResult {
+  const { features, phase } = checkpoint;
+
+  if (features.loopScore >= 0.9) {
+    return {
+      action: "stop_and_ask_user",
+      adviceShape: "none",
+      contextPolicy: "minimal",
+      confidence: clampConfidence(0.82 + features.loopScore * 0.12),
+      reason: "high loop score; stop before compounding repeated failures",
+    };
+  }
+
+  if (isContextPressure(checkpoint)) {
+    return {
+      action: "summarize_context",
+      adviceShape: "none",
+      contextPolicy: "session_summary",
+      confidence: 0.78,
+      reason: "context token pressure is high; summarize before continuing or escalating",
+    };
+  }
+
+  if (phase === "review" && hasLargeDiff(checkpoint)) {
+    return {
+      action: "escalate_diff_review",
+      adviceShape: "diff_review",
+      contextPolicy: "diff_only",
+      confidence: 0.76,
+      reason: "review phase with large diff; request focused diff review",
+    };
+  }
+
+  if (phase === "debug" && features.sameErrorRepeatedCount >= 2) {
+    return {
+      action: "escalate_debug_diagnosis",
+      adviceShape: "debug_diagnosis",
+      contextPolicy: "focused_error_and_diff",
+      confidence: clampConfidence(0.72 + Math.min(features.sameErrorRepeatedCount, 4) * 0.05),
+      reason: "same error repeated in debug phase; ask stronger/different model for diagnosis",
+    };
+  }
+
+  if (features.noVerifierUsed) {
+    return {
+      action: "run_verifier",
+      adviceShape: "none",
+      contextPolicy: "minimal",
+      confidence: 0.74,
+      reason: "multiple tool steps without verifier; run tests/checks before more edits",
+    };
+  }
+
+  if (features.loopScore >= 0.65) {
+    return {
+      action: "ask_micro_hint",
+      adviceShape: "micro_hint",
+      contextPolicy: "recent_events",
+      confidence: clampConfidence(0.62 + features.loopScore * 0.18),
+      reason: "moderate loop signal; request a cheap micro-hint while staying local-first",
+    };
+  }
+
+  return {
+    action: checkpoint.activeModel ? "continue_current" : "continue_local",
+    adviceShape: "none",
+    contextPolicy: "none",
+    confidence: clampConfidence(0.66 + features.progressScore * 0.18),
+    reason: "progress signals are acceptable; continue with the current/local worker",
+  };
+}
+
+export function decideRoute(checkpoint: RouterCheckpoint, options: DecideOptions = {}): RouteDecision {
+  const result = ruleFor(checkpoint);
+  return {
+    schema: ROUTER_DECISION_SCHEMA,
+    checkpointId: checkpoint.checkpointId,
+    action: result.action,
+    adviceShape: result.adviceShape,
+    contextPolicy: result.contextPolicy,
+    confidence: result.confidence,
+    reason: result.reason,
+    policyVersion: options.policyVersion ?? ROUTER_POLICY_VERSION,
+  };
+}
+
+export function readCheckpointJsonl(path: string): RouterCheckpoint[] {
+  return readFileSync(path, "utf8")
+    .split("\n")
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line) as RouterCheckpoint);
+}
+
+export function selectCheckpoint(checkpoints: RouterCheckpoint[], checkpointId?: string): RouterCheckpoint {
+  const checkpoint = checkpointId
+    ? checkpoints.find((candidate) => candidate.checkpointId === checkpointId)
+    : checkpoints.at(-1);
+  if (!checkpoint) {
+    throw new Error(checkpointId ? `checkpoint not found: ${checkpointId}` : "checkpoint file contains no checkpoints");
+  }
+  return checkpoint;
+}
+
+export function decisionId(decision: RouteDecision, checkpoint: RouterCheckpoint): string {
+  return hashText(decision.policyVersion, decision.checkpointId, decision.action, checkpoint.rawSessionRef.contentHash);
+}

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

@@ -0,0 +1,139 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  activeProfile,
+  cycleRouterProfile,
+  ensureRouterConfig,
+  formatProfile,
+  loadRouterConfig,
+  routerConfigPath,
+  routerEventsPath,
+  saveRouterConfig,
+  setRouterProfile,
+  type RouterConfig,
+} from "./config.js";
+import { observeRouterTurn } from "./observe.js";
+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}`,
+    `print: ${config.print}`,
+    `profile: ${config.activeProfile}`,
+    `worker: ${profile.worker}`,
+    `smart: ${profile.smart}`,
+    `teacher: ${profile.teacher}`,
+    `reviewer: ${profile.reviewer}`,
+    `config: ${routerConfigPath(ctx)}`,
+    `ledger: ${routerEventsPath(ctx)}`,
+  ].join("\n");
+}
+
+function notifyProfile(ctx: any, config: RouterConfig, prefix = "router profile"): void {
+  const profile = activeProfile(config);
+  ctx.ui.notify(`${prefix}: ${config.activeProfile}\nworker: ${profile.worker}\nsmart: ${profile.smart}\nteacher: ${profile.teacher}\nreviewer: ${profile.reviewer}`, "info");
+}
+
+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");
+}
+
+export function registerRouter(pi: ExtensionAPI): void {
+  const p = pi as any;
+  if (p.__piRogueRouterRegistered) return;
+  p.__piRogueRouterRegistered = true;
+
+  pi.registerCommand("router", {
+    description: "Observe-only trajectory router. Usage: /router on|off|status|profile|profiles|models|configure",
+    getArgumentCompletions: (prefix: string, ctx?: any) => routerArgumentCompletions(prefix, ctx),
+    handler: async (args, ctx) => {
+      const input = String(args ?? "").trim();
+      const [cmdRaw, ...rest] = input.split(/\s+/);
+      const cmd = cmdRaw || "status";
+
+      if (cmd === "on") {
+        setEnabled(ctx, true);
+        return;
+      }
+      if (cmd === "off") {
+        setEnabled(ctx, false);
+        return;
+      }
+      if (cmd === "configure" || cmd === "config") {
+        const config = ensureRouterConfig(ctx);
+        ctx.ui.notify(["router config ready", "", statusText(ctx, config)].join("\n"), "info");
+        return;
+      }
+
+      const config = ensureRouterConfig(ctx);
+      if (cmd === "status" || cmd === "show") {
+        ctx.ui.notify(statusText(ctx, config), "info");
+        return;
+      }
+      if (cmd === "models") {
+        notifyProfile(ctx, config, "router models");
+        return;
+      }
+      if (cmd === "profiles") {
+        ctx.ui.notify(config.profileOrder.map((name) => {
+          const marker = name === config.activeProfile ? "*" : " ";
+          const profile = config.profiles[name];
+          return `${marker} ${formatProfile(name, profile)}`;
+        }).join("\n"), "info");
+        return;
+      }
+      if (cmd === "profile") {
+        const name = rest[0];
+        if (!name) {
+          notifyProfile(ctx, config);
+          return;
+        }
+        const next = setRouterProfile(config, name);
+        if (!next) {
+          ctx.ui.notify(`unknown router profile: ${name}`, "error");
+          return;
+        }
+        saveRouterConfig(ctx, next);
+        notifyProfile(ctx, next, "router profile set");
+        return;
+      }
+      if (cmd === "cycle" || cmd === "next") {
+        const next = cycleRouterProfile(config, 1);
+        saveRouterConfig(ctx, next);
+        notifyProfile(ctx, next, "router profile cycled");
+        return;
+      }
+
+      ctx.ui.notify("Usage: /router on|off|status|profile [name]|profiles|models|configure|cycle", "error");
+    },
+  });
+
+  // Ctrl-P is reserved by Pi's built-in model cycle action, so the
+  // extension uses an unreserved chord and exposes `/router cycle` for
+  // command-palette/typed rotation over the same profile set.
+  pi.registerShortcut("ctrl+alt+p", {
+    description: "Cycle router profile",
+    handler: async (ctx: any) => {
+      const config = ensureRouterConfig(ctx);
+      const next = cycleRouterProfile(config, 1);
+      saveRouterConfig(ctx, next);
+      notifyProfile(ctx, next, "router profile cycled");
+    },
+  });
+
+  pi.on("turn_end", async (_event: any, ctx: any) => {
+    try {
+      await observeRouterTurn(ctx);
+    } catch (error) {
+      ctx.ui?.notify?.(`router observe failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
+    }
+  });
+}
+
+export default function routerExtension(pi: ExtensionAPI): void {
+  registerRouter(pi);
+}