@fiale-plus/pi-rogue 0.2.1 → 0.2.2

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

@@ -0,0 +1,150 @@
+export const ROUTER_CHECKPOINT_SCHEMA = "pi-router.checkpoint.v1" as const;
+export const RAW_SESSION_REF_SCHEMA = "pi-router.raw-session-ref.v1" as const;
+
+export type SessionRole = "user" | "assistant" | "toolResult" | "system" | "unknown";
+export type RouteAction =
+  | "continue_current"
+  | "continue_local"
+  | "summarize_context"
+  | "run_verifier"
+  | "ask_micro_hint"
+  | "escalate_plan_critique"
+  | "escalate_debug_diagnosis"
+  | "escalate_diff_review"
+  | "delegate_full_step"
+  | "spawn_subagent"
+  | "merge_subagent_result"
+  | "stop_and_ask_user";
+
+export type SubagentRole = "explore" | "debug_diagnose" | "implement" | "review" | "verify";
+export type SubagentToolPolicy = "read_only" | "test_only" | "edit_in_worktree" | "edit_main";
+export type SubagentReturnContract = "evidence_summary_v1";
+export type TaskStatus = "success" | "partial" | "failed" | "abandoned" | "unknown";
+export type TaskType = "implementation" | "debug" | "review" | "research" | "ops" | "planning" | "unknown";
+
+export type AdviceShape =
+  | "none"
+  | "micro_hint"
+  | "plan_critique"
+  | "debug_diagnosis"
+  | "diff_review"
+  | "full_delegation";
+
+export type ContextPolicy =
+  | "none"
+  | "minimal"
+  | "recent_events"
+  | "focused_error_and_diff"
+  | "diff_only"
+  | "session_summary"
+  | "full_context";
+
+export interface RawSessionRef {
+  schema: typeof RAW_SESSION_REF_SCHEMA;
+  path: string;
+  fromEvent: number;
+  toEvent: number;
+  fromByte: number;
+  toByte: number;
+  contentHash: string;
+}
+
+export interface SessionEventPointer {
+  index: number;
+  byteStart: number;
+  byteEnd: number;
+  id?: string;
+  timestamp?: string;
+  type: string;
+  role: SessionRole;
+}
+
+export interface SessionCommandEvent {
+  eventIndex: number;
+  toolCallId?: string;
+  toolName: string;
+  commandHash?: string;
+  normalizedCommandHash?: string;
+  isVerifier: boolean;
+}
+
+export interface SessionToolResultEvent {
+  eventIndex: number;
+  toolCallId?: string;
+  toolName?: string;
+  isError: boolean;
+  outputHash?: string;
+  normalizedOutputHash?: string;
+  errorHash?: string;
+  errorFingerprintHash?: string;
+  exitCode?: number;
+  failingTestHash?: string;
+}
+
+export interface DiffStats {
+  filesChanged: number;
+  linesAdded: number;
+  linesDeleted: number;
+  totalLines: number;
+  fileHashes: string[];
+  shortStatHash?: string;
+}
+
+export interface ProgressSignals {
+  sameCommandRepeatedCount: number;
+  sameErrorRepeatedCount: number;
+  errorChanged: boolean;
+  testsImproved: boolean | null;
+  filesTouched: number;
+  diffLines: number;
+  diffFilesChanged: number;
+  diffLinesAdded: number;
+  diffLinesDeleted: number;
+  diffChurnScore: number;
+  toolThrashScore: number;
+  goalDriftScore: number;
+  loopScore: number;
+  progressScore: number;
+  verifierUsed: boolean;
+  noVerifierUsed: boolean;
+  toolCallsLast10Turns: number;
+}
+
+export interface RouterCheckpoint {
+  schema: typeof ROUTER_CHECKPOINT_SCHEMA;
+  sessionId: string;
+  checkpointId: string;
+  createdAt: string;
+  rawSessionRef: RawSessionRef;
+  harness: "pi";
+  repoHash?: string;
+  goalHash?: string;
+  phase: "planning" | "implementation" | "debug" | "review" | "research" | "ops" | "unknown";
+  activeModel?: string;
+  provider?: string;
+  features: ProgressSignals & {
+    turnIndex: number;
+    contextTokensApprox: number | null;
+    gitDirty: boolean | null;
+  };
+  recent: {
+    lastUserGoalHash?: string;
+    lastCommandHash?: string;
+    lastErrorHash?: string;
+    lastErrorFingerprintHash?: string;
+    touchedFileHashes: string[];
+    diffFileHashes?: string[];
+  };
+  sourceEvent: SessionEventPointer;
+}
+
+export interface RouteDecision {
+  schema: "pi-router.decision.v1";
+  checkpointId: string;
+  action: RouteAction;
+  adviceShape: AdviceShape;
+  contextPolicy: ContextPolicy;
+  confidence: number;
+  reason: string;
+  policyVersion: string;
+}

package/node_modules/@fiale-plus/pi-rogue-router/src/v1-telemetry.test.ts

@@ -0,0 +1,293 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { rebuildCheckpointsFromSession, writeSessionCheckpointsJsonl } from "./checkpoints.js";
+import { buildTrainingRows, writeTrainingRows } from "./dataset.js";
+import { decideRoute } from "./decision.js";
+import { buildRouteEvent } from "./ledger.js";
+import { readGitDiffStats } from "./git-features.js";
+import { generateTeacherPromptRequests } from "./learning.js";
+import { buildUnknownOutcome, inferOutcomes, writeInferredOutcomes } from "./outcomes.js";
+import { buildSubagentLedgerEvent, recommendSubagentDecision } from "./subagents.js";
+import type { RouterCheckpoint } from "./types.js";
+
+function tempFile(name: string): string {
+  return join(mkdtempSync(join(tmpdir(), "pi-router-v1-")), name);
+}
+
+function writeFixture(lines: Array<Record<string, unknown>>): string {
+  const path = tempFile("session.jsonl");
+  writeFileSync(path, lines.map((line) => JSON.stringify(line)).join("\n") + "\n");
+  return path;
+}
+
+function checkpoint(overrides: Partial<Omit<RouterCheckpoint, "features" | "recent">> & { features?: Partial<RouterCheckpoint["features"]> } = {}): 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/session.jsonl", fromEvent: 1, toEvent: 10, fromByte: 100, toByte: 200, contentHash: "hash-only" },
+    harness: "pi",
+    phase: "debug",
+    activeModel: "qwen3.6-35b-a3b-128k",
+    provider: "local",
+    features: {
+      turnIndex: 10,
+      sameCommandRepeatedCount: 1,
+      sameErrorRepeatedCount: 2,
+      errorChanged: false,
+      testsImproved: null,
+      filesTouched: 1,
+      diffLines: 40,
+      diffFilesChanged: 2,
+      diffLinesAdded: 25,
+      diffLinesDeleted: 15,
+      diffChurnScore: 0.033,
+      toolThrashScore: 0.1,
+      goalDriftScore: 0,
+      loopScore: 0.52,
+      progressScore: 0.48,
+      verifierUsed: false,
+      noVerifierUsed: true,
+      toolCallsLast10Turns: 4,
+      contextTokensApprox: 1200,
+      gitDirty: null,
+    },
+    recent: { lastErrorHash: "error", lastErrorFingerprintHash: "fingerprint", touchedFileHashes: ["file"], diffFileHashes: ["diff-file"] },
+    sourceEvent: { index: 10, byteStart: 100, byteEnd: 200, type: "message", role: "toolResult" },
+  };
+  return { ...base, ...overrides, features: { ...base.features, ...(overrides.features ?? {}) } };
+}
+
+describe("router v1 outcome and feature telemetry", () => {
+  it("normalizes noisy repeated errors into stable fingerprints", () => {
+    const sessionPath = writeFixture([
+      { type: "session", id: "s", cwd: "/repo" },
+      { type: "message", message: { role: "user", content: [{ type: "text", text: "debug failing test" }] } },
+      { type: "message", message: { role: "toolResult", isError: true, content: [{ type: "text", text: "FAIL /tmp/a/foo.test.ts:10:2\nError: boom at 2026-06-12T00:00:00Z" }] } },
+      { type: "message", message: { role: "toolResult", isError: true, content: [{ type: "text", text: "FAIL /var/b/foo.test.ts:99:8\nError: boom at 2026-06-13T00:00:00Z" }] } },
+    ]);
+
+    const last = rebuildCheckpointsFromSession(sessionPath).at(-1);
+
+    expect(last?.features.sameErrorRepeatedCount).toBe(2);
+    expect(last?.features.errorChanged).toBe(false);
+    expect(last?.recent.lastErrorFingerprintHash).toBeTruthy();
+  });
+
+  it("reads staged and untracked git diff counts without raw paths", () => {
+    const repo = mkdtempSync(join(tmpdir(), "pi-router-git-"));
+    execFileSync("git", ["init", "-q"], { cwd: repo });
+    execFileSync("git", ["config", "user.email", "router@example.invalid"], { cwd: repo });
+    execFileSync("git", ["config", "user.name", "router"], { cwd: repo });
+    writeFileSync(join(repo, "tracked.txt"), "a\n");
+    execFileSync("git", ["add", "tracked.txt"], { cwd: repo });
+    execFileSync("git", ["commit", "-q", "-m", "init"], { cwd: repo });
+    writeFileSync(join(repo, "tracked.txt"), "a\nb\n");
+    execFileSync("git", ["add", "tracked.txt"], { cwd: repo });
+    writeFileSync(join(repo, "new-file.txt"), "secret-ish content\n");
+
+    const stats = readGitDiffStats(repo);
+    const excluded = readGitDiffStats(repo, { excludePaths: [join(repo, "new-file.txt")] });
+
+    expect(stats.filesChanged).toBeGreaterThanOrEqual(2);
+    expect(stats.linesAdded).toBeGreaterThanOrEqual(1);
+    expect(stats.fileHashes).toHaveLength(stats.filesChanged);
+    expect(JSON.stringify(stats)).not.toContain("tracked.txt");
+    expect(JSON.stringify(stats)).not.toContain("new-file.txt");
+    expect(excluded.filesChanged).toBe(1);
+  });
+
+  it("reads untracked files from repo root when launched in a subdirectory", () => {
+    const repo = mkdtempSync(join(tmpdir(), "pi-router-git-subdir-"));
+    execFileSync("git", ["init", "-q"], { cwd: repo });
+    execFileSync("git", ["config", "user.email", "router@example.invalid"], { cwd: repo });
+    execFileSync("git", ["config", "user.name", "router"], { cwd: repo });
+    writeFileSync(join(repo, "tracked.txt"), "a\n");
+    execFileSync("git", ["add", "tracked.txt"], { cwd: repo });
+    execFileSync("git", ["commit", "-q", "-m", "init"], { cwd: repo });
+    execFileSync("mkdir", ["-p", "nested"], { cwd: repo });
+    writeFileSync(join(repo, "root-new.txt"), "one\n");
+
+    expect(readGitDiffStats(join(repo, "nested")).filesChanged).toBe(1);
+  });
+
+  it("reads untracked diff counts in repositories without HEAD", () => {
+    const repo = mkdtempSync(join(tmpdir(), "pi-router-git-no-head-"));
+    execFileSync("git", ["init", "-q"], { cwd: repo });
+    writeFileSync(join(repo, "new-file.txt"), "one\ntwo\n");
+    execFileSync("git", ["add", "new-file.txt"], { cwd: repo });
+    writeFileSync(join(repo, "new-file.txt"), "one\ntwo\nthree\n");
+
+    const stats = readGitDiffStats(repo);
+
+    expect(stats.filesChanged).toBe(1);
+    expect(stats.linesAdded).toBe(3);
+  });
+
+  it("infers conservative outcome skeletons linked to route events", () => {
+    const item = checkpoint();
+    const event = buildRouteEvent(item, decideRoute(item), "2026-06-12T00:00:00.000Z");
+    const outcome = buildUnknownOutcome(event, item, "2026-06-12T00:00:01.000Z");
+
+    expect(outcome).toMatchObject({
+      schema: "pi-router.outcome.v1",
+      sessionId: item.sessionId,
+      checkpointId: item.checkpointId,
+      routeEventId: event.eventId,
+      taskStatus: "unknown",
+      finalFilesTouched: 2,
+      finalDiffLines: 40,
+      reworkTurns: 1,
+      evidence: { source: "inferred" },
+    });
+    expect(buildUnknownOutcome(event, checkpoint({ features: { diffFilesChanged: 0, filesTouched: 1 } }))).toMatchObject({ finalFilesTouched: 1 });
+    expect(JSON.stringify(outcome)).not.toContain("Error: boom");
+  });
+
+  it("writes inferred outcomes from checkpoint and route-event files", () => {
+    const item = checkpoint();
+    const checkpointPath = tempFile("checkpoints.jsonl");
+    const eventsPath = tempFile("events.jsonl");
+    const outputPath = tempFile("outcomes.jsonl");
+    writeFileSync(checkpointPath, `${JSON.stringify(item)}\n`);
+    writeFileSync(eventsPath, `${JSON.stringify(buildRouteEvent(item, decideRoute(item)))}\n`);
+
+    const summary = writeInferredOutcomes({ checkpointPath, eventsPath, outputPath });
+
+    expect(summary.outcomes).toBe(1);
+    expect(readFileSync(outputPath, "utf8")).toContain("pi-router.outcome.v1");
+    expect(() => writeInferredOutcomes({ checkpointPath, eventsPath: join(tmpdir(), "missing-router-events.jsonl"), outputPath: tempFile("bad.jsonl") })).toThrow(/required route events file not found/);
+  });
+
+  it("rejects workspace diff annotation for multi-session rebuilds", async () => {
+    await expect(writeSessionCheckpointsJsonl([tempFile("one.jsonl"), tempFile("two.jsonl")], tempFile("out.jsonl"), { workspaceDiff: true }))
+      .rejects.toThrow(/exactly one current session/);
+  });
+});
+
+describe("router v1 teacher requests and trainable gate dataset", () => {
+  it("generates explicit teacher prompt requests without raw transcript content", () => {
+    const item = checkpoint();
+    const requests = generateTeacherPromptRequests([item], "openai-codex/gpt-5.5");
+
+    expect(requests[0]).toMatchObject({
+      schema: "pi-router.teacher-prompt.v1",
+      teacher: "openai-codex/gpt-5.5",
+      checkpointId: item.checkpointId,
+    });
+    expect(requests[0].allowedActions).toContain("spawn_subagent");
+    expect(JSON.stringify(requests[0])).not.toContain("npm test");
+  });
+
+  it("exports binary gate rows and excludes local-rule labels as ground truth by default", () => {
+    const item = checkpoint();
+    const event = buildRouteEvent(item, decideRoute(item));
+    const outcome = inferOutcomes([event], [item])[0];
+    const localRuleLabel = {
+      schema: "pi-router.teacher-label.v1" as const,
+      labelId: "label-1",
+      generatedAt: "2026-06-12T00:00:00.000Z",
+      teacher: "local-rule",
+      checkpointId: item.checkpointId,
+      sessionId: item.sessionId,
+      rawSessionRef: item.rawSessionRef,
+      suggestedAction: "run_verifier" as const,
+      confidence: 0.8,
+      rationale: "local rule",
+      source: "local-rule" as const,
+    };
+
+    const oldCheckpoint = { ...item, features: { ...item.features, diffFilesChanged: undefined as unknown as number, diffChurnScore: undefined as unknown as number } };
+    const oldRows = buildTrainingRows({ checkpoints: [oldCheckpoint] });
+    expect(oldRows[0].features).toMatchObject({ diffFilesChanged: 0, diffChurnScore: 0 });
+
+    const rows = buildTrainingRows({ checkpoints: [item], routeEvents: [event], outcomes: [outcome], labels: [localRuleLabel] });
+
+    expect(rows[0].labels.binaryGate).toBe("unknown");
+    expect(rows[0].provenance.excludedLocalRuleAsTruth).toBe(true);
+    expect(rows[0].provenance.localRuleAction).toBe(decideRoute(item).action);
+
+    const routeOnlyOutcome = { ...outcome, checkpointId: undefined, taskStatus: "partial" as const };
+    const rowsFromRouteEventOutcome = buildTrainingRows({ checkpoints: [item], routeEvents: [event], outcomes: [routeOnlyOutcome] });
+    expect(rowsFromRouteEventOutcome[0].outcome.taskStatus).toBe("partial");
+
+    const includedRows = buildTrainingRows({ checkpoints: [item], labels: [localRuleLabel], includeLocalRuleLabels: true });
+    expect(includedRows[0].labels).toMatchObject({ binaryGate: "intervene", source: "local-rule" });
+  });
+
+  it("writes labeled dataset rows when teacher-output labels are provided", () => {
+    const item = checkpoint();
+    const checkpointPath = tempFile("checkpoints.jsonl");
+    const labelsPath = tempFile("labels.jsonl");
+    const outputPath = tempFile("training.jsonl");
+    writeFileSync(checkpointPath, `${JSON.stringify(item)}\n`);
+    writeFileSync(labelsPath, `${JSON.stringify({
+      schema: "pi-router.teacher-label.v1",
+      labelId: "label-2",
+      generatedAt: "2026-06-12T00:00:00.000Z",
+      teacher: "openai-codex/gpt-5.5",
+      checkpointId: item.checkpointId,
+      sessionId: item.sessionId,
+      rawSessionRef: item.rawSessionRef,
+      suggestedAction: "run_verifier",
+      confidence: 0.81,
+      rationale: "needs verifier",
+      source: "teacher-output",
+    })}\n`);
+
+    const summary = writeTrainingRows({ checkpointPath, labelsPath, outputPath });
+
+    expect(summary).toMatchObject({ rows: 1, labeledRows: 1 });
+    expect(readFileSync(outputPath, "utf8")).toContain("pi-router.training-row.v1");
+    expect(() => writeTrainingRows({ checkpointPath, outcomesPath: join(tmpdir(), "missing-outcomes.jsonl"), outputPath: tempFile("bad-training.jsonl") })).toThrow(/outcomes file not found/);
+    expect(() => writeTrainingRows({ checkpointPath, eventsPath: join(tmpdir(), "missing-events.jsonl"), outputPath: tempFile("bad-events-training.jsonl") })).toThrow(/route events file not found/);
+  });
+});
+
+describe("router v1 subagent-aware observation telemetry", () => {
+  it("recommends observe-only subagent decisions with evidence-summary contracts", () => {
+    const decision = recommendSubagentDecision(checkpoint(), { worker: "qwen", smart: "gpt-5.5" });
+
+    expect(decision).toMatchObject({
+      schema: "pi-router.subagent-decision.v1",
+      action: "spawn_subagent",
+      subagentRole: "debug_diagnose",
+      targetModel: "gpt-5.5",
+      toolPolicy: "read_only",
+      returnContract: "evidence_summary_v1",
+    });
+  });
+
+  it("builds parent-child subagent ledger events", () => {
+    const event = buildSubagentLedgerEvent({
+      parentSessionId: "parent",
+      childSessionId: "child",
+      parentCheckpointId: "parent:event-1",
+      subagentRole: "review",
+      model: "openai-codex/gpt-5.5",
+      toolPolicy: "read_only",
+      contextPolicy: "diff_only",
+      inputSummaryHash: "input-hash",
+      outputSummaryHash: "output-hash",
+      acceptedIntoParent: null,
+      useful: null,
+      causedRework: null,
+      returnContract: "evidence_summary_v1",
+      recordedAt: "2026-06-12T00:00:00.000Z",
+    });
+
+    expect(event).toMatchObject({
+      schema: "pi-router.subagent-ledger-event.v1",
+      parentSessionId: "parent",
+      childSessionId: "child",
+      acceptedIntoParent: null,
+      useful: null,
+      causedRework: null,
+    });
+    expect(event.eventId).toBeTruthy();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Public Pi-Rogue package for bundled advisor, orchestration, and context broker logic.",
   "type": "module",
   "license": "MIT",
@@ -37,13 +37,15 @@
     "@fiale-plus/pi-core": "^0.1.0",
     "@fiale-plus/pi-rogue-advisor": "^0.1.0",
     "@fiale-plus/pi-rogue-context-broker": "^0.1.0",
-    "@fiale-plus/pi-rogue-orchestration": "^0.1.0"
+    "@fiale-plus/pi-rogue-orchestration": "^0.1.0",
+    "@fiale-plus/pi-rogue-router": "^0.1.0"
   },
   "bundledDependencies": [
     "@fiale-plus/pi-core",
     "@fiale-plus/pi-rogue-advisor",
     "@fiale-plus/pi-rogue-context-broker",
-    "@fiale-plus/pi-rogue-orchestration"
+    "@fiale-plus/pi-rogue-orchestration",
+    "@fiale-plus/pi-rogue-router"
   ],
   "publishConfig": {
     "access": "public"

package/src/extension.test.ts

@@ -40,6 +40,7 @@ describe("bundle extension defaults", () => {
     await registerBundle(pi);
 
     expect(commands.has("context")).toBe(true);
+    expect(commands.has("router")).toBe(true);
   });
 
   it("keeps an explicit env kill switch for context broker rollout", async () => {

package/src/extension.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAdvisor } from "@fiale-plus/pi-rogue-advisor";
 import { registerOrchestration } from "@fiale-plus/pi-rogue-orchestration";
+import { registerRouter } from "@fiale-plus/pi-rogue-router/extension";
 
 const DISABLED_VALUES = new Set(["0", "false", "no", "off"]);
 
@@ -20,6 +21,7 @@ export async function registerBundle(pi: ExtensionAPI): Promise<void> {
 
   registerAdvisor(pi);
   registerOrchestration(pi);
+  registerRouter(pi);
 }
 
 export default function bundleExtension(pi: ExtensionAPI): Promise<void> {