@fiale-plus/pi-rogue 0.2.0

package/node_modules/@fiale-plus/pi-rogue-advisor/src/state-versioning.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { registerAdvisor } from "./extension.js";
+
+const testHome = vi.hoisted(() => `/tmp/pi-rogue-advisor-state-versioning-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  return { ...actual, homedir: () => testHome };
+});
+
+vi.mock("@earendil-works/pi-ai", async () => {
+  const actual = await vi.importActual<typeof import("@earendil-works/pi-ai")>("@earendil-works/pi-ai");
+  return { ...actual, completeSimple: vi.fn() };
+});
+
+type Handler = (event: any, ctx: any) => any;
+type HandlerMap = Record<string, Handler[]>;
+type CommandMap = Record<string, { handler: (args: string, ctx: any) => any }>;
+
+function makeHandlers() {
+  const handlers: HandlerMap = {};
+  const commands: CommandMap = {};
+  const sendMessage = vi.fn();
+  const pi = {
+    on: (event: string, handler: Handler) => { handlers[event] ??= []; handlers[event].push(handler); },
+    registerMessageRenderer: () => undefined,
+    registerCommand: (name: string, command: { handler: (args: string, ctx: any) => any }) => { commands[name] = command; },
+    registerTool: vi.fn(),
+    sendMessage,
+    sendUserMessage: () => undefined,
+    ui: { setStatus: () => undefined, notify: () => undefined },
+  };
+  return { handlers, commands, pi: pi as any, sendMessage };
+}
+
+const ADVISOR_STATE_DIR = join(homedir(), ".pi", "agent", "pi-rogue", "advisor");
+const ADVISOR_STATE_PATH = join(ADVISOR_STATE_DIR, "state.json");
+const ADVISOR_CONFIG_PATH = join(ADVISOR_STATE_DIR, "config.json");
+
+function readAdvisorState(): any {
+  return JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
+}
+
+function mkCtx() {
+  return {
+    sessionManager: {
+      getSessionFile: () => join(homedir(), ".pi", "agent", "pi-rogue", "advisor", "session.jsonl"),
+    },
+    isIdle: () => true,
+    modelRegistry: {
+      find: (provider: string, model: string) => {
+        if (provider === "openai-codex") return { id: `${provider}/${model}`, provider, input: ["text"] };
+        return null;
+      },
+      getAvailable: () => [{ id: "provider/text-light", provider: "provider", input: ["text"] }],
+      getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
+    },
+    ui: { setStatus: () => undefined, notify: () => undefined },
+  } as any;
+}
+
+describe("state versioning and recovery", () => {
+  let priorState: string | null = null;
+  let priorConfig: string | null = null;
+
+  beforeEach(() => {
+    priorState = existsSync(ADVISOR_STATE_PATH) ? readFileSync(ADVISOR_STATE_PATH, "utf8") : null;
+    priorConfig = existsSync(ADVISOR_CONFIG_PATH) ? readFileSync(ADVISOR_CONFIG_PATH, "utf8") : null;
+
+    const setup = makeHandlers();
+    const { handlers, commands, pi } = setup;
+    handlers; commands;
+
+    mkdirSync(dirname(ADVISOR_STATE_PATH), { recursive: true });
+    writeFileSync(ADVISOR_CONFIG_PATH, JSON.stringify({ mode: "auto", review: "light", checkins: "off", checkinIntervalMinutes: 30 }, null, 2), "utf8");
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify({
+      turns: 0,
+      lastTask: "",
+      notes: [],
+      files: [],
+      errors: [],
+      advisorCalls: 0,
+      cacheHits: 0,
+      followUp: "",
+      router: {},
+      checkin: { queued: false },
+      reviewControl: { status: "idle", pending: false, consumed: true, running: false },
+    }, null, 2), "utf8");
+
+    registerAdvisor(pi);
+  });
+
+  afterEach(() => {
+    if (priorState === null) {
+      writeFileSync(ADVISOR_STATE_PATH, "{}", "utf8");
+    } else {
+      writeFileSync(ADVISOR_STATE_PATH, priorState, "utf8");
+    }
+    if (priorConfig === null) {
+      writeFileSync(ADVISOR_CONFIG_PATH, "{}", "utf8");
+    } else {
+      writeFileSync(ADVISOR_CONFIG_PATH, priorConfig, "utf8");
+    }
+  });
+
+  it("loads state with version field and preserves existing data", () => {
+    // Write a state without _v to simulate old state
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify({
+      turns: 0,
+      lastTask: "",
+      notes: [],
+      files: [],
+      errors: [],
+      advisorCalls: 0,
+      cacheHits: 0,
+      followUp: "",
+      router: {},
+      checkin: { queued: false },
+      reviewControl: { status: "idle", pending: false, consumed: true, running: false },
+    }, null, 2), "utf8");
+
+    // Load state directly (simulates what loadState does)
+    const raw = JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
+    expect(raw._v).toBeUndefined(); // Old state has no _v
+
+    // After loadState + saveState cycle, _v should be present
+    const setup = makeHandlers();
+    const { handlers: h, pi } = setup;
+    registerAdvisor(pi);
+    const ctx = mkCtx();
+    void h.session_start?.[0]?.({}, ctx);
+
+    const state = JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
+    // The session_start handler calls loadState() which adds _v, then saveState() writes it
+    expect(state._v).toBe(1);
+    expect(state.turns).toBe(0);
+    expect(state.lastTask).toBe("");
+  });
+
+  it("recovers corrupted state gracefully", () => {
+    // Write corrupted state
+    writeFileSync(ADVISOR_STATE_PATH, "{ corrupted json", "utf8");
+    const handlers = makeHandlers();
+    const { handlers: h, pi } = handlers;
+    registerAdvisor(pi);
+    // Loading state should not throw
+    const ctx = mkCtx();
+    void h.session_start?.[0]?.({}, ctx);
+    // State should be recovered to default
+    const recovered = readAdvisorState();
+    expect(recovered._v).toBe(1);
+    expect(recovered.turns).toBe(0);
+  });
+
+  it("migrates old state without _v field to current version", () => {
+    // Write state without _v field
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify({
+      turns: 5,
+      lastTask: "old task",
+      notes: [],
+      files: [],
+      errors: [],
+      advisorCalls: 3,
+      cacheHits: 1,
+      followUp: "",
+      router: {},
+      checkin: { queued: false },
+      reviewControl: { status: "idle", pending: false, consumed: true, running: false },
+    }, null, 2), "utf8");
+
+    const handlers = makeHandlers();
+    const { handlers: h, pi } = handlers;
+    registerAdvisor(pi);
+    const ctx = mkCtx();
+    void h.session_start?.[0]?.({}, ctx);
+
+    const migrated = readAdvisorState();
+    expect(migrated._v).toBe(1);
+    expect(migrated.turns).toBe(5);
+    expect(migrated.lastTask).toBe("old task");
+    expect(migrated.advisorCalls).toBe(3);
+  });
+
+  it("handles missing state file by creating default", () => {
+    writeFileSync(ADVISOR_STATE_PATH, "{}", "utf8");
+    const handlers = makeHandlers();
+    const { handlers: h, pi } = handlers;
+    registerAdvisor(pi);
+    const ctx = mkCtx();
+    void h.session_start?.[0]?.({}, ctx);
+
+    const loaded = readAdvisorState();
+    expect(loaded._v).toBe(1);
+    expect(loaded.turns).toBe(0);
+    expect(loaded.reviewControl.status).toBe("idle");
+  });
+
+  it("preserves reviewControl state across loads", () => {
+    const state = readAdvisorState();
+    state.reviewControl = {
+      status: "needed",
+      pending: true,
+      consumed: false,
+      running: false,
+      lastDecision: "review",
+      lastMaterialSignature: "test-sig",
+      lastReason: "test reason",
+      lastTrigger: "turn-1",
+      lastAppliedAt: new Date().toISOString(),
+    };
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+
+    const handlers = makeHandlers();
+    const { handlers: h, pi } = handlers;
+    registerAdvisor(pi);
+    const ctx = mkCtx();
+    void h.session_start?.[0]?.({}, ctx);
+
+    const recovered = readAdvisorState();
+    expect(recovered.reviewControl.status).toBe("needed");
+    expect(recovered.reviewControl.pending).toBe(true);
+    expect(recovered.reviewControl.lastDecision).toBe("review");
+  });
+});

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

@@ -0,0 +1,53 @@
+# Pi-Rogue Context Broker
+
+Beta context broker runtime for Pi-Rogue.
+
+This package contains the executable in-memory bounded broker implementation:
+
+- `createInMemoryContextBroker()` stores artifacts behind stable `ctx://...` handles.
+- Lookups support handle, session, kind, tag, path, command prefix, branch, tier, and text filters.
+- Omitted summaries become metadata-only placeholders, keeping raw payloads out of prompt briefs by default.
+- Artifacts are classified as hot/warm/cold on publish; prompt briefs render hot first, warm second, and exclude cold unless explicitly queried.
+- Pruning enforces per-session record/byte caps, optional global (cross-session) record/byte caps, tier-specific caps, TTL expiry on reads, and pinned-artifact retention.
+
+It is registered by default in the bundle, with an explicit env kill switch.
+
+## Mainline extension
+
+The bundle registers a `context_lookup` LLM tool plus `/context` commands by default. To disable the runtime for rollback:
+
+```bash
+PI_CONTEXT_BROKER_ENABLED=false pi
+```
+
+When active, the bundle registers:
+
+- `/context status` — enabled state, record/byte counts, pinned counts, and routing telemetry.
+- `/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.
+- `/context export <handle>` — write full payload to a temp file without dumping it into prompt.
+- `/context prune` — run TTL/cap pruning immediately.
+
+The command includes autocomplete for subcommands and known artifact handles. Exact handle lookup returns clipped payload text; text search returns a smaller clipped excerpt, and truncation is marked explicitly.
+
+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.
+
+For quieter sessions, set `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES` to a higher value to only rewrite larger outputs.
+
+
+## Session behavior and limits
+
+- On session start/reload, the runtime backfills the current Pi session branch from `toolResult` and prompt-visible `bashExecution` entries.
+- Backfill is idempotent by session entry id, skips malformed entries instead of failing the session, and honors Pi's `excludeFromContext` bash entries.
+- 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.
+- 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:
+  - `PI_CONTEXT_BROKER_GLOBAL_MAX_RECORDS`
+  - `PI_CONTEXT_BROKER_GLOBAL_MAX_BYTES`
+- Rollback is immediate: set `PI_CONTEXT_BROKER_ENABLED=false` and `/reload` or restart Pi. Disable durable writes by unsetting `PI_CONTEXT_BROKER_DURABLE` and `PI_CONTEXT_BROKER_STORE_DIR`.

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

@@ -0,0 +1,31 @@
+{
+  "name": "@fiale-plus/pi-rogue-context-broker",
+  "version": "0.1.0",
+  "description": "Context broker runtime for Pi-Rogue with bounded handle-first prompt payload storage.",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package"
+  ],
+  "scripts": {
+    "check": "tsc -p ../../tsconfig.json --noEmit",
+    "test": "cd ../.. && vitest run packages/context-broker/src/*.test.ts"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./extension": "./src/extension.ts",
+    "./file": "./src/file.ts",
+    "./sqlite": "./src/sqlite.ts"
+  },
+  "dependencies": {
+    "@fiale-plus/pi-core": "^0.1.0",
+    "typebox": "^1.1.24"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "package.json"
+  ]
+}