@fiale-plus/pi-rogue 0.2.1 → 0.2.3

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

@@ -32,6 +32,10 @@ const DEFAULT_BRIEF_BYTES = 2_000;
 const TIER_ORDER: Record<ContextArtifactTier, number> = { hot: 0, warm: 1, cold: 2 };
 const TIER_REMOVAL_ORDER: Record<ContextArtifactTier, number> = { cold: 0, warm: 1, hot: 2 };
 
+function optionMs(value: number | undefined): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : Number.POSITIVE_INFINITY;
+}
+
 function normalizeList(values: string[] | undefined): string[] {
   return [...new Set((values ?? []).map((value) => String(value || "").trim()).filter(Boolean))];
 }
@@ -149,11 +153,32 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     warm: Math.max(1, Math.floor(options.warmMaxBytes ?? maxBytes)),
     cold: Math.max(1, Math.floor(options.coldMaxBytes ?? maxBytes)),
   };
+  const hotToWarmMs = optionMs(options.hotToWarmMs);
+  const warmToColdMs = optionMs(options.warmToColdMs);
   const summaryBytes = Math.max(16, Math.floor(options.summaryBytes ?? DEFAULT_SUMMARY_BYTES));
   const defaultBriefBytes = Math.max(64, Math.floor(options.briefBytes ?? DEFAULT_BRIEF_BYTES));
   let artifacts: Array<ContextArtifact & { sequence: number; baseTier: ContextArtifactTier }> = [];
   let sequence = 0;
 
+  function cooledTier(artifact: ContextArtifact & { baseTier: ContextArtifactTier }, now = Date.now()): ContextArtifactTier {
+    if (artifact.pinned) return "hot";
+    if (artifact.baseTier === "cold") return "cold";
+    const age = Math.max(0, now - artifact.createdAt);
+    if (age >= warmToColdMs) return "cold";
+    if (artifact.baseTier === "hot" && age >= hotToWarmMs) return "warm";
+    return artifact.baseTier;
+  }
+
+  function applyCooling(now = Date.now(), _protectedIds = new Set<string>()): void {
+    for (const artifact of artifacts) {
+      const nextTier = cooledTier(artifact, now);
+      if (artifact.tier !== nextTier) {
+        artifact.tier = nextTier;
+        artifact.updatedAt = now;
+      }
+    }
+  }
+
   function currentStatus(): ContextBrokerStatus {
     const bytes = artifacts.reduce((sum, artifact) => sum + artifact.bytes, 0);
     const pinned = artifacts.filter((artifact) => artifact.pinned);
@@ -174,6 +199,8 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
       coldBytes: cold.reduce((sum, artifact) => sum + artifact.bytes, 0),
       maxRecords,
       maxBytes,
+      globalMaxRecords,
+      globalMaxBytes,
     };
   }
 
@@ -225,6 +252,7 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
 
   function prune(now = Date.now(), protectedIds = new Set<string>()): ContextBrokerStatus {
     dropExpired(now, protectedIds);
+    applyCooling(now, protectedIds);
 
     for (const sessionId of new Set(artifacts.map((artifact) => artifact.sessionId))) {
       for (const tier of ["cold", "warm", "hot"] as ContextArtifactTier[]) {
@@ -253,11 +281,13 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
 
   function status(): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     return currentStatus();
   }
 
   function purge(options: ContextPurgeOptions = {}): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     const keepPinned = options.keepPinned ?? true;
     artifacts = artifacts.filter((artifact) => {
       if (options.sessionId && artifact.sessionId !== options.sessionId) return true;
@@ -305,12 +335,13 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     };
 
     artifacts = [artifact, ...artifacts];
-    prune(now, new Set([artifact.id]));
+    prune(Date.now(), new Set([artifact.id]));
     return artifact;
   }
 
   function lookup(query: ContextLookupQuery = {}): ContextArtifact[] {
     dropExpired();
+    applyCooling();
     const limit = Math.max(1, Math.floor(query.limit ?? (artifacts.length || 1)));
     return artifacts
       .filter((artifact) => artifactMatches(artifact, query))

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

@@ -40,6 +40,43 @@ describe("createSqliteContextBroker", () => {
     }
   });
 
+  it("persists age-based tier cooling without deleting artifacts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+      const now = Date.now();
+      const oldHot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "old hot", summary: "old hot", tier: "hot", createdAt: now - 300 });
+      const pinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "pinned", summary: "pinned", tier: "hot", pinned: true, createdAt: now - 300 });
+
+      broker.prune(now);
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+
+      expect(broker.lookup({ handle: oldHot.handle })[0]?.tier).toBe("cold");
+      expect(broker.lookup({ handle: pinned.handle })[0]?.tier).toBe("hot");
+      expect(broker.renderBrief({ sessionId: "s" })).not.toContain(oldHot.handle);
+      expect(broker.renderBrief({ sessionId: "s" })).toContain(pinned.handle);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("cools protected new artifacts before enforcing durable tier caps", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const now = Date.now();
+      const broker = createSqliteContextBroker({ path: join(dir, "artifacts.sqlite"), defaultTtlMs: 0, maxRecords: 10, hotMaxRecords: 1, hotToWarmMs: 10_000, warmToColdMs: 20_000 });
+      const fresh = broker.publish({ sessionId: "s", kind: "tool_output", payload: "fresh", summary: "fresh", tier: "hot", createdAt: now - 1_000 });
+      const aged = broker.publish({ sessionId: "s", kind: "tool_output", payload: "aged", summary: "aged", tier: "hot", createdAt: now - 30_000 });
+
+      expect(aged.tier).toBe("cold");
+      expect(broker.lookup({ handle: fresh.handle })[0]?.tier).toBe("hot");
+      expect(broker.lookup({ handle: aged.handle })[0]?.tier).toBe("cold");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("dedupes replayed source artifacts so durable handles survive caps", () => {
     const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
     try {

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

@@ -29,6 +29,10 @@ const DEFAULT_BRIEF_BYTES = 2_000;
 const TIER_ORDER: Record<ContextArtifactTier, number> = { hot: 0, warm: 1, cold: 2 };
 const TIER_REMOVAL_ORDER: Record<ContextArtifactTier, number> = { cold: 0, warm: 1, hot: 2 };
 
+function optionMs(value: number | undefined): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : Number.POSITIVE_INFINITY;
+}
+
 function defaultStoreDir(): string {
   return join(homedir(), ".pi", "agent", "fiale-plus", "context-broker");
 }
@@ -226,6 +230,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     warm: Math.max(1, Math.floor(options.warmMaxBytes ?? maxBytes)),
     cold: Math.max(1, Math.floor(options.coldMaxBytes ?? maxBytes)),
   };
+  const hotToWarmMs = optionMs(options.hotToWarmMs);
+  const warmToColdMs = optionMs(options.warmToColdMs);
   const summaryBytes = Math.max(16, Math.floor(options.summaryBytes ?? DEFAULT_SUMMARY_BYTES));
   const defaultBriefBytes = Math.max(64, Math.floor(options.briefBytes ?? DEFAULT_BRIEF_BYTES));
 
@@ -241,6 +247,31 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     db.prepare("DELETE FROM artifacts WHERE id = ?").run(id);
   }
 
+  function cooledTier(artifact: ContextArtifact & { baseTier: ContextArtifactTier }, now = Date.now()): ContextArtifactTier {
+    if (artifact.pinned) return "hot";
+    if (artifact.baseTier === "cold") return "cold";
+    const age = Math.max(0, now - artifact.createdAt);
+    if (age >= warmToColdMs) return "cold";
+    if (artifact.baseTier === "hot" && age >= hotToWarmMs) return "warm";
+    return artifact.baseTier;
+  }
+
+  function applyCooling(now = Date.now(), _protectedIds = new Set<string>()): void {
+    const rows = db.prepare("SELECT id, createdAt, tier, baseTier, pinned FROM artifacts WHERE pinned = 0").all();
+    const update = db.prepare("UPDATE artifacts SET tier = ?, updatedAt = ? WHERE id = ?");
+    for (const row of rows) {
+      const artifact = {
+        id: String(row.id),
+        createdAt: Number(row.createdAt),
+        tier: String(row.tier) as ContextArtifactTier,
+        baseTier: String(row.baseTier ?? row.tier) as ContextArtifactTier,
+        pinned: Boolean(row.pinned),
+      };
+      const nextTier = cooledTier(artifact as ContextArtifact & { baseTier: ContextArtifactTier }, now);
+      if (artifact.tier !== nextTier) update.run(nextTier, now, artifact.id);
+    }
+  }
+
   function currentStatus(): ContextBrokerStatus {
     const row = db.prepare(`
       SELECT
@@ -269,6 +300,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       coldBytes: Number(row.coldBytes ?? 0),
       maxRecords,
       maxBytes,
+      globalMaxRecords,
+      globalMaxBytes,
     };
   }
 
@@ -329,6 +362,7 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function prune(now = Date.now(), protectedIds = new Set<string>()): ContextBrokerStatus {
     dropExpired(now, protectedIds);
+    applyCooling(now, protectedIds);
     const sessions = db.prepare("SELECT DISTINCT sessionId FROM artifacts").all().map((row) => String(row.sessionId));
     for (const sessionId of sessions) {
       for (const tier of ["cold", "warm", "hot"] as ContextArtifactTier[]) {
@@ -356,11 +390,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function status(): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     return currentStatus();
   }
 
   function purge(options: ContextPurgeOptions = {}): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     const keepPinned = options.keepPinned ?? true;
     const clauses: string[] = [];
     const params: Array<string | number> = [];
@@ -468,12 +504,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       throw error;
     }
 
-    prune(now, new Set([artifact.id]));
-    return artifact;
+    prune(Date.now(), new Set([artifact.id]));
+    return lookup({ id: artifact.id })[0] ?? artifact;
   }
 
   function lookup(query: ContextLookupQuery = {}): ContextArtifact[] {
     dropExpired();
+    applyCooling();
     const storedCount = Number(db.prepare("SELECT COUNT(*) AS count FROM artifacts").get()?.count ?? 1) || 1;
     const limit = Math.max(1, Math.floor(query.limit ?? storedCount));
     const clauses: string[] = [];

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

@@ -0,0 +1,34 @@
+# 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.
+
+Live config is repo-global at `.pi/router/config.json`, while mutable live state and route ledgers are isolated per Pi session under `.pi/router/sessions/<session-key>/state.json` and `events.jsonl`.
+
+- 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);
+  });
+});