@fiale-plus/pi-rogue 0.2.1 → 0.2.2

package/README.md

@@ -8,6 +8,7 @@ It stitches together (and bundles for a true single-package install):
 - `@fiale-plus/pi-rogue-advisor` (logic; direct releases paused)
 - `@fiale-plus/pi-rogue-context-broker` (context-broker runtime; registered by default with an env kill switch)
 - `@fiale-plus/pi-rogue-orchestration` (logic; direct releases paused)
+- `@fiale-plus/pi-rogue-router` (observe-only trajectory-router lab; direct releases paused)
 
 Direct installs of the advisor/orchestration packages are paused (marked private). All users and future releases go through the bundle. See `docs/release.md` and root `AGENTS.md` / `README.md` for the release policy.
 
@@ -37,7 +38,7 @@ npm install
 
 ## Command surface
 
-- Default: `/advisor`, `/goal`, `/loop`, `/autoresearch`, `/autoresearch-lab` plus status/config/command paths (all provided via the bundle).
+- Default: `/advisor`, `/goal`, `/loop`, `/autoresearch`, `/autoresearch-lab`, `/router` plus status/config/command paths (all provided via the bundle).
 - Context broker: enabled by default; `PI_CONTEXT_BROKER_ENABLED=false` disables `/context status`, `/context brief`, `/context lookup <handle|text>`, `/context pin <handle>`, `/context export <handle>`, and `/context prune` with autocomplete.
 
 ## Status

package/node_modules/@fiale-plus/pi-rogue-context-broker/README.md

@@ -22,7 +22,7 @@ PI_CONTEXT_BROKER_ENABLED=false pi
 
 When active, the bundle registers:
 
-- `/context status` — enabled state, record/byte counts, pinned counts, and routing telemetry.
+- `/context status` — enabled state, record/byte counts, pinned counts, routing telemetry, and prompt rewrite savings bytes.
 - `/context brief` — bounded prompt-safe broker brief with handles and summaries.
 - `/context lookup <handle|text>` — exact handle rehydration or current-session text search.
 - `/context pin <handle>` — protect an artifact from normal TTL/cap pruning.
@@ -33,9 +33,9 @@ The command includes autocomplete for subcommands and known artifact handles. Ex
 
 Optional durability is available with `PI_CONTEXT_BROKER_DURABLE=true` or `PI_CONTEXT_BROKER_STORE_DIR=/path/to/store`. Durable mode now defaults to SQLite (`artifacts.sqlite`) with an FTS index for text lookup, so exact handles, tier, and pin state survive restarts without replay reconstruction. Set `PI_CONTEXT_BROKER_BACKEND=jsonl` to use the legacy JSONL/blob backend.
 
-- `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES` controls when large `toolResult` / `bashExecution` payloads are rewritten in-context. The default is `0` (rewritten), so raw tool evidence is replaced by handles by default.
+- `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES` controls when large `toolResult` / `bashExecution` payloads are rewritten in-context. The default is `8192` bytes, so small tool evidence remains inline while larger outputs are replaced by handles.
 
-For quieter sessions, set `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES` to a higher value to only rewrite larger outputs.
+For more aggressive prompt reduction, set `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES=0`. For quieter sessions, set it to a higher value to only rewrite larger outputs.
 
 
 ## Session behavior and limits
@@ -45,6 +45,7 @@ For quieter sessions, set `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES` to a highe
 - Without durable mode, restarting Pi loses broker state until the current branch is backfilled again.
 - Prompt integration injects a bounded, tier-aware broker brief and lookup guidance; the LLM also gets a `context_lookup` tool for exact handle dereferencing. Payloads that hit hostile-binary heuristics are represented in prompt as handles plus short guidance to export the full content.
 - The `context` hook rewrites prompt-visible `toolResult` and `bashExecution` payloads in the LLM-bound message copy to broker handles and summaries, reducing prompt load while preserving exact `/context lookup` rehydration.
+- Current-turn `context_lookup` results are left visible so the model can consume requested exact evidence once. Historical `context_lookup` results that already have a later assistant response are omitted from later prompt assembly to avoid recursive prompt growth.
 - Pi `excludeFromContext` bash entries are not backfilled or rewritten into broker prompts.
 - Basic secret redaction runs before broker storage and display for common token/password/API-key patterns.
 - Optional global caps can be configured via env vars:

package/node_modules/@fiale-plus/pi-rogue-context-broker/src/extension.test.ts

@@ -382,7 +382,7 @@ lookupBytes: 500,
     await commands.get("context").handler(`export ${handle}`, ctx);
     const result = await handlers.get("context")?.[0]({
       type: "context",
-      messages: [{ role: "toolResult", toolCallId: "tool-result-telemetry", toolName: "bash", content: [{ type: "text", text: "telemetry_payload_" + "y".repeat(150) }], isError: false, timestamp: 1 }],
+      messages: [{ role: "toolResult", toolCallId: "tool-result-telemetry", toolName: "bash", content: [{ type: "text", text: "telemetry_payload_" + "y".repeat(1000) }], isError: false, timestamp: 1 }],
     }, ctx);
 
     await commands.get("context").handler("status", ctx);
@@ -392,15 +392,46 @@ lookupBytes: 500,
     expect(result).toBeDefined();
     const telemetry = notifications.at(-1)?.message ?? "";
     expect(telemetry).toContain("Context broker routing telemetry:");
+    expect(telemetry).toContain("rewriteSavings rawBytes=");
+    expect(telemetry).toContain("replacementBytes=");
+    expect(telemetry).toContain("savedBytes=");
+    expect(telemetry).toMatch(/savedBytes=[1-9]\d*/);
+    expect(telemetry).toContain("contextLookupHistoryOmitted=");
     expect(telemetry).toContain("lookups tool(calls=");
     expect(telemetry).toContain("lookups slash(calls=");
     expect(telemetry).toContain("exports=");
     expect(telemetry).toContain("pins=");
   });
 
-  it("does not broker context_lookup results recursively", async () => {
+  it("keeps current context_lookup results visible before the model consumes them", async () => {
     const { pi, handlers, commands, tools } = createPiMock();
-    registerContextBrokerBeta(pi, { lookupBytes: 500, rewriteThresholdBytes: 1 });
+    registerContextBrokerBeta(pi, { lookupBytes: 1000, rewriteThresholdBytes: 1 });
+    const { ctx } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "call-current-lookup-source",
+      toolName: "bash",
+      input: { command: "printf current-lookup" },
+      content: [{ type: "text", text: "CURRENT_LOOKUP_EVIDENCE_" + "x".repeat(120) }],
+      isError: false,
+    }, ctx);
+    const handle = commands.get("context").getArgumentCompletions("lookup ")?.[0].value.replace(/^lookup /, "");
+    const lookupResult = await tools.get("context_lookup").execute("lookup-current", { handle }, undefined, undefined, ctx);
+
+    const contextResult = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [{ role: "toolResult", toolCallId: "lookup-current", toolName: "context_lookup", content: lookupResult.content, isError: false }],
+    }, ctx);
+
+    expect(contextResult).toBeUndefined();
+    expect(lookupResult.content[0].text).toContain("CURRENT_LOOKUP_EVIDENCE_");
+  });
+
+  it("does not broker historical context_lookup results recursively", async () => {
+    const { pi, handlers, commands, tools } = createPiMock();
+    registerContextBrokerBeta(pi, { lookupBytes: 500 });
     const { ctx, notifications } = createCtx();
 
     await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
@@ -425,7 +456,10 @@ lookupBytes: 500,
     }, ctx);
     const contextResult = await handlers.get("context")?.[0]({
       type: "context",
-      messages: [{ role: "toolResult", toolCallId: "lookup-call", toolName: "context_lookup", content: lookupResult.content, isError: false }],
+      messages: [
+        { role: "toolResult", toolCallId: "lookup-call", toolName: "context_lookup", content: lookupResult.content, isError: false },
+        { role: "assistant", content: [{ type: "text", text: "I consumed the lookup." }] },
+      ],
     }, ctx);
     await commands.get("context").handler("brief", ctx);
 

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

@@ -176,6 +176,16 @@ function compact(value: string, max = 120): string {
   return truncateUtf8(value.replace(/\s+/g, " ").trim(), max);
 }
 
+function utf8Bytes(text: string): number {
+  return Buffer.byteLength(text, "utf8");
+}
+
+function promptPayloadBytes(message: any): number {
+  if (message?.role === "bashExecution") return utf8Bytes(String(message.output ?? ""));
+  if (message?.role === "toolResult") return utf8Bytes(contentText(message.content));
+  return utf8Bytes(toText(message));
+}
+
 function stableHash(value: string): string {
   return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
@@ -308,6 +318,9 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     contextHookBash: 0,
     contextHookBashRewrites: 0,
     contextHookBashHostile: 0,
+    contextHookRewriteRawBytes: 0,
+    contextHookRewriteReplacementBytes: 0,
+    contextHookContextLookupHistoryOmissions: 0,
     toolResultEvents: 0,
     toolResultArtifacts: 0,
     backfillScans: 0,
@@ -329,11 +342,21 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     pruneCalls: 0,
   };
 
+  function recordContextRewrite(rawBytes: number, replacementBytes: number): void {
+    routingTelemetry.contextHookRewriteRawBytes += Math.max(0, rawBytes);
+    routingTelemetry.contextHookRewriteReplacementBytes += Math.max(0, replacementBytes);
+  }
+
   function formatRoutingTelemetry(): string {
+    const savedBytes = Math.max(0, routingTelemetry.contextHookRewriteRawBytes - routingTelemetry.contextHookRewriteReplacementBytes);
+    const savedPct = routingTelemetry.contextHookRewriteRawBytes > 0
+      ? ((savedBytes / routingTelemetry.contextHookRewriteRawBytes) * 100).toFixed(1)
+      : "0.0";
     const line = [
       `contextHook calls=${routingTelemetry.contextHookCalls}`,
       `toolResults seen=${routingTelemetry.contextHookToolResults} rewritten=${routingTelemetry.contextHookToolResultRewrites} hostile=${routingTelemetry.contextHookToolResultHostile}`,
       `bash seen=${routingTelemetry.contextHookBash} rewritten=${routingTelemetry.contextHookBashRewrites} hostile=${routingTelemetry.contextHookBashHostile}`,
+      `rewriteSavings rawBytes=${routingTelemetry.contextHookRewriteRawBytes} replacementBytes=${routingTelemetry.contextHookRewriteReplacementBytes} savedBytes=${savedBytes} savedPct=${savedPct}% contextLookupHistoryOmitted=${routingTelemetry.contextHookContextLookupHistoryOmissions}`,
       `lookups tool(calls=${routingTelemetry.toolLookupCalls}, hits=${routingTelemetry.toolLookupHits}, misses=${routingTelemetry.toolLookupMisses})`,
       `lookups slash(calls=${routingTelemetry.commandLookupCalls}, hits=${routingTelemetry.commandLookupHits}, misses=${routingTelemetry.commandLookupMisses})`,
       `exports=${routingTelemetry.exportCalls}`,
@@ -572,19 +595,35 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     activeSessionId = sessionIdFor(ctx);
     routingTelemetry.contextHookCalls += 1;
     const toolInputs = collectToolInputs(event.messages);
-    const drafts = event.messages.map((message: any): { original: any; replacement?: any; artifact?: ContextArtifact; rewrite?: (artifact: ContextArtifact) => any; safeFallback?: any } => {
+    type RewriteDraft = {
+      original: any;
+      replacement?: any;
+      rawBytes?: number;
+      artifact?: ContextArtifact;
+      rewrite?: (artifact: ContextArtifact) => any;
+      safeFallback?: any;
+    };
+    const drafts = event.messages.map((message: any, index: number): RewriteDraft => {
       if (message?.role === "toolResult") {
         routingTelemetry.contextHookToolResults += 1;
         const raw = contentText(message.content);
+        const rawBytes = utf8Bytes(raw);
         const toolInput = typeof message.toolCallId === "string" ? toolInputs.get(message.toolCallId) : undefined;
         const toolName = String(message.toolName ?? toolInput?.toolName ?? "tool");
         const hostile = hasHostileText(raw) || hasHostileValue(message.content);
         if (hostile) routingTelemetry.contextHookToolResultHostile += 1;
-        const shouldRewrite = Buffer.byteLength(raw, "utf8") > rewriteThresholdBytes || hostile;
-        if (!shouldRewrite) return { original: message };
         if (!shouldBrokerToolName(toolName)) {
-          return { original: message, replacement: { ...message, content: [{ type: "text", text: contextLookupHistoryPlaceholder() }] } };
+          const hasLaterAssistant = event.messages.slice(index + 1).some((candidate: any) => candidate?.role === "assistant");
+          if (!hasLaterAssistant) return { original: message };
+          routingTelemetry.contextHookContextLookupHistoryOmissions += 1;
+          return {
+            original: message,
+            rawBytes,
+            replacement: { ...message, content: [{ type: "text", text: contextLookupHistoryPlaceholder() }] },
+          };
         }
+        const shouldRewrite = rawBytes > rewriteThresholdBytes || hostile;
+        if (!shouldRewrite) return { original: message };
         const artifact = publishToolArtifact({
           toolName,
           input: message.input ?? toolInput?.input,
@@ -599,6 +638,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
         routingTelemetry.contextHookToolResultRewrites += 1;
         return {
           original: message,
+          rawBytes,
           artifact,
           rewrite: (live) => ({ ...message, content: [{ type: "text", text: brokerPlaceholder(live) }] }),
           safeFallback: { ...message, content: [{ type: "text", text: prunedPayloadPlaceholder(hostile) }] },
@@ -608,9 +648,10 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
       if (message?.role === "bashExecution" && message.excludeFromContext !== true) {
         routingTelemetry.contextHookBash += 1;
         const raw = String(message.output ?? "");
+        const rawBytes = utf8Bytes(raw);
         const hostile = hasHostileText(raw) || hasHostileValue(message.output);
         if (hostile) routingTelemetry.contextHookBashHostile += 1;
-        const shouldRewrite = Buffer.byteLength(raw, "utf8") > rewriteThresholdBytes || hostile;
+        const shouldRewrite = rawBytes > rewriteThresholdBytes || hostile;
         if (!shouldRewrite) return { original: message };
         const sourceId = typeof message.timestamp === "number"
           ? `bash:${message.timestamp}:${stableHash([message.command ?? "", raw, message.exitCode ?? "", message.cancelled ?? ""].join("\n"))}`
@@ -634,6 +675,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
         routingTelemetry.contextHookBashRewrites += 1;
         return {
           original: message,
+          rawBytes,
           artifact,
           rewrite: (live) => ({ ...message, output: brokerPlaceholder(live), truncated: true }),
           safeFallback: { ...message, output: prunedPayloadPlaceholder(hostile), truncated: true },
@@ -647,6 +689,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     const messages = drafts.map((draft) => {
       if (draft.replacement) {
         changed = true;
+        recordContextRewrite(draft.rawBytes ?? promptPayloadBytes(draft.original), promptPayloadBytes(draft.replacement));
         return draft.replacement;
       }
       if (!draft.artifact || !draft.rewrite) return draft.original;
@@ -655,12 +698,15 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
         for (const parentId of draft.artifact.parentIds) sourceHandles.delete(parentId);
         if (draft.safeFallback) {
           changed = true;
+          recordContextRewrite(draft.rawBytes ?? promptPayloadBytes(draft.original), promptPayloadBytes(draft.safeFallback));
           return draft.safeFallback;
         }
         return draft.original;
       }
       changed = true;
-      return draft.rewrite(live);
+      const replacement = draft.rewrite(live);
+      recordContextRewrite(draft.rawBytes ?? promptPayloadBytes(draft.original), promptPayloadBytes(replacement));
+      return replacement;
     });
 
     return changed ? { messages } : undefined;

package/node_modules/@fiale-plus/pi-rogue-router/README.md

@@ -0,0 +1,32 @@
+# Pi-Rogue Router
+
+Local-only offline trajectory router experiments for Pi-Rogue.
+
+This package intentionally does **not** change live advisor or orchestration behavior. It reads existing Pi session JSONL files, derives compact checkpoints, and computes cheap progress/loop signals without copying raw transcript content into derived artifacts.
+
+```bash
+npm run router:rebuild -- --session ~/.pi/agent/sessions/.../session.jsonl --output .pi/router/checkpoints.jsonl
+npm run router:rebuild -- --session-dir ~/.pi/agent/sessions/... --output .pi/router/checkpoints.jsonl
+npm run router:rebuild -- --session ./current-session.jsonl --workspace-diff --output .pi/router/checkpoints-with-live-diff.jsonl
+npm run router:decide -- --checkpoint-file .pi/router/checkpoints.jsonl --ledger .pi/router/events.jsonl
+npm run router:cards -- --events .pi/router/events.jsonl --output .pi/router/model-cards.jsonl
+npm run router:outcomes -- --checkpoint-file .pi/router/checkpoints.jsonl --events .pi/router/events.jsonl --output .pi/router/outcomes.jsonl
+npm run router:teacher-requests -- --checkpoint-file .pi/router/checkpoints.jsonl --output .pi/router/teacher-requests.jsonl --teacher openai-codex/gpt-5.5
+npm run router:reflect -- --checkpoint-file .pi/router/checkpoints.jsonl --labels .pi/router/labels/teacher-labels.jsonl --reflection .pi/router/reflections/session.md --teacher local-rule
+npm run router:dataset -- --checkpoint-file .pi/router/checkpoints.jsonl --events .pi/router/events.jsonl --outcomes .pi/router/outcomes.jsonl --labels .pi/router/labels/teacher-labels.jsonl --output .pi/router/training.jsonl
+npm run router:shadow -- --checkpoint-file .pi/router/checkpoints.jsonl --ledger .pi/router/events.jsonl --output .pi/router/shadow-report.json
+
+# Live observe-only extension commands:
+# /router on|off|status|profile|profiles|models|configure|cycle
+# ctrl+alt+p cycles router profiles (Ctrl-P is reserved by Pi model cycling).
+```
+
+## V1 telemetry notes
+
+Router v1 is still observe-only. It adds outcome skeletons, stronger diff/error fingerprints, teacher-label request export, binary gate dataset export, and subagent-aware telemetry schemas. It does not switch models, spawn agents, or promote policies automatically.
+
+- Diff telemetry stores counts and hashes from `git diff`, not raw patches. Offline rebuilds remain deterministic by default; use `--workspace-diff` only with one current live session/worktree snapshot.
+- Error fingerprints normalize paths, line numbers, timestamps, UUIDs, ports, and object ids before hashing.
+- `router:teacher-requests` writes local JSONL requests for an explicit teacher model; imported teacher decisions are still required before labels become training truth.
+- `router:dataset` excludes `local-rule` labels by default so a future model does not merely imitate the current rules.
+- Subagent route/ledger schemas describe parent-child evidence flow, but live autonomous spawning remains out of scope.

package/node_modules/@fiale-plus/pi-rogue-router/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@fiale-plus/pi-rogue-router",
+  "version": "0.1.0",
+  "description": "Local-only offline trajectory router experiments for Pi-Rogue.",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "check": "tsc -p ../../tsconfig.json --noEmit",
+    "test": "cd ../.. && vitest run packages/router/src/*.test.ts"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./extension": "./src/extension.ts"
+  },
+  "pi": {
+    "extensions": [
+      "./src/extension.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "package.json"
+  ]
+}

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

@@ -0,0 +1,84 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { buildCheckpoints, rebuildCheckpointsFromSession, streamCheckpointsFromSessionPath, writeCheckpointsJsonl } from "./checkpoints.js";
+import { readPiSession } from "./session-reader.js";
+
+function writeFixture(lines: Array<Record<string, unknown>>): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-router-"));
+  const path = join(dir, "2026-06-12T00-00-00Z_fixture.jsonl");
+  writeFileSync(path, lines.map((line) => JSON.stringify(line)).join("\n") + "\n");
+  return path;
+}
+
+function fixtureSession(): string {
+  return writeFixture([
+    { type: "session", version: 1, id: "session-1", timestamp: "2026-06-12T00:00:00.000Z", cwd: "/repo/example" },
+    { type: "model_change", id: "m1", timestamp: "2026-06-12T00:00:01.000Z", provider: "local", modelId: "qwen-local" },
+    { type: "message", id: "u1", timestamp: "2026-06-12T00:00:02.000Z", message: { role: "user", content: [{ type: "text", text: "please fix the failing tests" }] } },
+    { type: "message", id: "a1", timestamp: "2026-06-12T00:00:03.000Z", message: { role: "assistant", provider: "local", model: "qwen-local", usage: { inputTokens: 1234 }, content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "npm test -- --runInBand src/foo.test.ts" } }] } },
+    { type: "message", id: "t1", timestamp: "2026-06-12T00:00:04.000Z", message: { role: "toolResult", toolCallId: "call-1", toolName: "bash", isError: true, content: [{ type: "text", text: "FAIL src/foo.test.ts\nError: boom" }] } },
+    { type: "message", id: "a2", timestamp: "2026-06-12T00:00:05.000Z", message: { role: "assistant", provider: "local", model: "qwen-local", content: [{ type: "toolCall", id: "call-2", name: "bash", arguments: { command: "npm test -- --runInBand src/foo.test.ts" } }] } },
+    { type: "message", id: "t2", timestamp: "2026-06-12T00:00:06.000Z", message: { role: "toolResult", toolCallId: "call-2", toolName: "bash", isError: true, content: [{ type: "text", text: "FAIL src/foo.test.ts\nError: boom" }] } },
+  ]);
+}
+
+describe("trajectory router checkpoint rebuild", () => {
+  it("reads Pi session JSONL and extracts command/tool metadata", () => {
+    const session = readPiSession(fixtureSession());
+
+    expect(session.id).toBe("2026-06-12T00-00-00Z_fixture");
+    expect(session.cwd).toBe("/repo/example");
+    expect(session.events).toHaveLength(7);
+    expect(session.events[3].commandEvents[0]).toMatchObject({ toolName: "bash", isVerifier: true });
+    expect(session.events[4].toolResult).toMatchObject({ toolName: "bash", isError: true });
+  });
+
+  it("builds compact derived checkpoints without raw transcript content", () => {
+    const checkpoints = rebuildCheckpointsFromSession(fixtureSession());
+    const last = checkpoints.at(-1);
+
+    expect(last?.schema).toBe("pi-router.checkpoint.v1");
+    expect(last?.rawSessionRef).toMatchObject({ schema: "pi-router.raw-session-ref.v1", fromEvent: 0, toEvent: 6 });
+    expect(last?.activeModel).toBe("qwen-local");
+    expect(last?.provider).toBe("local");
+    expect(last?.phase).toBe("debug");
+    expect(last?.features.contextTokensApprox).toBe(1234);
+    expect(last?.features.sameCommandRepeatedCount).toBe(2);
+    expect(last?.features.sameErrorRepeatedCount).toBe(2);
+    expect(last?.features.verifierUsed).toBe(true);
+    expect(last?.features.loopScore).toBeGreaterThan(0);
+    expect(last?.recent.lastCommandHash).toBeTruthy();
+    expect(last?.recent.lastErrorHash).toBeTruthy();
+    expect(last?.recent.touchedFileHashes).toHaveLength(1);
+
+    const serialized = JSON.stringify(last);
+    expect(serialized).not.toContain("please fix the failing tests");
+    expect(serialized).not.toContain("npm test");
+    expect(serialized).not.toContain("Error: boom");
+    expect(serialized).not.toContain("src/foo.test.ts");
+  });
+
+  it("streams checkpoints equivalent to the sync fixture API", async () => {
+    const path = fixtureSession();
+    const sync = rebuildCheckpointsFromSession(path).map((checkpoint) => checkpoint.checkpointId);
+    const streamed: string[] = [];
+
+    for await (const checkpoint of streamCheckpointsFromSessionPath(path)) streamed.push(checkpoint.checkpointId);
+
+    expect(streamed).toEqual(sync);
+  });
+
+  it("writes checkpoints as JSONL", () => {
+    const session = readPiSession(fixtureSession());
+    const checkpoints = buildCheckpoints(session);
+    const output = join(mkdtempSync(join(tmpdir(), "pi-router-out-")), "checkpoints.jsonl");
+
+    writeCheckpointsJsonl(checkpoints, output);
+
+    const lines = readFileSync(output, "utf8").trim().split("\n");
+    expect(lines).toHaveLength(checkpoints.length);
+    expect(JSON.parse(lines.at(-1) || "{}").checkpointId).toBe(checkpoints.at(-1)?.checkpointId);
+  });
+});