@fiale-plus/pi-rogue 0.2.0 → 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-advisor/src/extension.ts

@@ -5,7 +5,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 import { completeSimple, type ThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
-import { featureFile, readText, truncate, writeText, atomicWriteText } from "./internal.js";
+import { featureDir, featureFile, readText, truncate, writeText, atomicWriteText } from "./internal.js";
 import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
 import {
   appendRouteLog,
@@ -46,10 +46,10 @@ const DEFAULT_CONFIG: AdvisorConfig = {
 };
 
 const CONFIG_PATH = featureFile("advisor", "config.json");
-const STATE_PATH = featureFile("advisor", "state.json");
+const LEGACY_STATE_PATH = featureFile("advisor", "state.json");
 const CACHE_PATH = featureFile("advisor", "cache.json");
-const CURRENT_PATH = featureFile("advisor", "current.md");
 const HISTORY_PATH = featureFile("advisor", "history.jsonl");
+const SESSION_STATE_PROP = "__piRogueAdvisorStatePath";
 const ORCHESTRATION_DIR = join(homedir(), ".pi", "agent", "fiale-plus", "orchestration");
 
 const MAX_CACHE = 64;
@@ -169,8 +169,47 @@ function saveConfig(c: AdvisorConfig) {
   writeJson(CONFIG_PATH, c);
 }
 
-function loadState(): SessionState {
-  const raw = readJson<Partial<SessionState>>(STATE_PATH, {});
+function advisorSessionDir(ctxOrKey?: any): string {
+  const key = typeof ctxOrKey === "string" ? ctxOrKey : sessionKey(ctxOrKey);
+  return join(featureDir("advisor"), "sessions", safeSessionKey(key));
+}
+
+export function advisorSessionStatePath(ctxOrKey?: any): string {
+  return join(advisorSessionDir(ctxOrKey), "state.json");
+}
+
+function advisorCurrentPath(ctxOrKey?: any): string {
+  return join(advisorSessionDir(ctxOrKey), "current.md");
+}
+
+function safeSessionKey(key: string): string {
+  const safe = String(key || "session").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || "session";
+}
+
+function statePathFor(state: SessionState): string {
+  return String((state as any)[SESSION_STATE_PROP] || LEGACY_STATE_PATH);
+}
+
+function attachStatePath<T extends SessionState>(state: T, path: string): T {
+  Object.defineProperty(state, SESSION_STATE_PROP, {
+    value: path,
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  return state;
+}
+
+function loadState(ctxOrKey?: any): SessionState {
+  // Do not fall back to LEGACY_STATE_PATH here: that file was unscoped and is
+  // the source of issue #103 context bleed. New/resumed sessions must only load
+  // their own namespaced mutable advisor state.
+  return loadStateFromPath(advisorSessionStatePath(ctxOrKey));
+}
+
+function loadStateFromPath(path: string): SessionState {
+  const raw = readJson<Partial<SessionState>>(path, {});
   // Handle state versioning: migrate old versions to current
   const version = raw._v ?? 0;
   if (version < STATE_VERSION) {
@@ -181,7 +220,7 @@ function loadState(): SessionState {
   }
   const control = raw.reviewControl;
   const pauseUntil = Number(raw.advisorPauseUntilTurn);
-  return {
+  return attachStatePath({
     _v: STATE_VERSION,
     turns: raw.turns ?? 0,
     lastTask: raw.lastTask ?? "",
@@ -217,11 +256,11 @@ function loadState(): SessionState {
       lastAppliedAt: control?.lastAppliedAt,
     },
     advisorPauseUntilTurn: Number.isFinite(pauseUntil) ? pauseUntil : undefined,
-  };
+  }, path);
 }
 
 function saveState(s: SessionState) {
-  atomicWriteText(STATE_PATH, JSON.stringify(s, null, 2) + "\n");
+  atomicWriteText(statePathFor(s), JSON.stringify(s, null, 2) + "\n");
 }
 
 function loadCache(): Record<string, string> {
@@ -489,7 +528,7 @@ function markReviewApplied(state: SessionState, signature: string, trigger: stri
 }
 
 function persistReviewState(state: SessionState, includeReviewRoute: boolean): void {
-  const persisted = loadState();
+  const persisted = loadStateFromPath(statePathFor(state));
   persisted.reviewControl = state.reviewControl;
   persisted.followUp = state.followUp;
   persisted.followUpTask = state.followUpTask;
@@ -771,8 +810,12 @@ function mergeRouteReview(configReview: AdvisorConfig["review"], route?: ReviewP
 
 function sessionKey(ctx: any): string {
   const sessionFile = ctx?.sessionManager?.getSessionFile?.();
-  if (!sessionFile) return "session";
-  return basename(String(sessionFile)).replace(/\.[^.]+$/, "");
+  if (typeof sessionFile === "string" && sessionFile.length > 0) {
+    return safeSessionKey(basename(String(sessionFile)).replace(/\.[^.]+$/, ""));
+  }
+  const sessionId = ctx?.session?.id || process.env.PI_ROGUE_SESSION_ID;
+  if (typeof sessionId === "string" && sessionId.length > 0) return safeSessionKey(sessionId);
+  return "session";
 }
 
 type OrchestrationSnapshot = {
@@ -846,12 +889,13 @@ function checkinDescription(config: AdvisorConfig): string {
   return `checkins ${config.checkinIntervalMinutes}m`;
 }
 
-function setPiRogueStatus(ctx: any, config = loadConfig(), state = loadState()): void {
+function setPiRogueStatus(ctx: any, config = loadConfig(), state?: SessionState): void {
+  const currentState = state ?? loadState(ctx);
   const normalized = normalizeAdvisorConfig(config);
   const checkin = checkinDescription(normalized);
-  const pause = advisorPauseRemaining(state, state.turns);
+  const pause = advisorPauseRemaining(currentState, currentState.turns);
   const pauseText = pause > 0 ? ` · pause ${pause} turn${pause === 1 ? "" : "s"}` : "";
-  const last = state.checkin.lastAt ? ` · last ${new Date(state.checkin.lastAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}` : "";
+  const last = currentState.checkin.lastAt ? ` · last ${new Date(currentState.checkin.lastAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}` : "";
   ctx.ui.setStatus("pi-rogue", `☠︎ advisor ${normalized.mode}/${normalized.review} · ${checkin}${pauseText}${last}`);
 }
 
@@ -896,7 +940,7 @@ async function maybeAdvisorCheckin(pi: ExtensionAPI, ctx: any, source: string):
   if (checkinLocks.has(key)) return false;
 
   const config = loadConfig();
-  const state = loadState();
+  const state = loadState(ctx);
   const reason = shouldRunCheckin(config, state, Date.now(), Date.now());
   if (!reason) {
     if (state.checkin.queued) {
@@ -935,7 +979,7 @@ async function maybeAdvisorCheckin(pi: ExtensionAPI, ctx: any, source: string):
     );
     if (!completed) return false;
 
-    const next = loadState();
+    const next = loadState(ctx);
     next.checkin = {
       lastAt: new Date().toISOString(),
       lastTurn: next.turns,
@@ -1056,7 +1100,7 @@ export async function completeWithHigherAdvisorModel(
 
 async function askAdvisor(pi: ExtensionAPI, ctx: any, question: string, scope: string, includeWork: boolean) {
   const config = loadConfig();
-  const state = loadState();
+  const state = loadState(ctx);
   if (!question.trim()) return { text: "Ask a question.", error: "empty" };
 
   const brokerBrief = includeWork ? contextBrokerBrief(pi) : "";
@@ -1085,7 +1129,7 @@ async function askAdvisor(pi: ExtensionAPI, ctx: any, question: string, scope: s
 async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: string, meta: ReviewMaterialMeta) {
   const config = loadConfig();
   if (config.review === "off") return;
-  const state = loadState();
+  const state = loadState(ctx);
 
   const signature = reviewMaterialSignature(state, delta, meta);
   if (state.reviewControl.running) {
@@ -1252,7 +1296,7 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
     finalReason = (parsed.reason || parsed.summary || "review result").slice(0, 120);
 
     const display = formatAdvisorDisplay("advisor:llm", decision, finalReason);
-    writeText(CURRENT_PATH, `${display}\n`);
+    writeText(advisorCurrentPath(ctx), `${display}\n`);
 
     const reviewTask = parsed.activeTask || state.lastTask || "";
     const hasTaskActions = parsed.taskActions.length > 0;
@@ -1300,7 +1344,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
     const key = sessionKey(ctx);
     checkinLocks.delete(key);
-    const state = loadState();
+    const state = loadState(ctx);
     recoverReviewControl(state);
     saveState(state);
     setPiRogueStatus(ctx, loadConfig(), state);
@@ -1334,7 +1378,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   // ── Preflight (heuristics only — no LLM call, <1ms) ──────────────────
   pi.on("before_agent_start", async (event: any, ctx: any) => {
     const cfg = loadConfig();
-    const state = loadState();
+    const state = loadState(ctx);
     const hasFollowUp = Boolean(state.followUp);
     if ((isAdvisorAutoRunSuppressed(state, state.turns) && !hasFollowUp) || cfg.mode === "off" || cfg.mode === "manual") {
       return { systemPrompt: event.systemPrompt };
@@ -1391,7 +1435,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
     const note = routeNote(route);
     const control = state.reviewControl;
     const controlTag = control.status === "needed" || control.status === "running" ? `Review-control: ${control.status}${control.lastDecision ? ` (${control.lastDecision})` : ""}` : "";
-    writeText(CURRENT_PATH, `${note}\n`);
+    writeText(advisorCurrentPath(ctx), `${note}\n`);
     return {
       systemPrompt: [
         event.systemPrompt,
@@ -1409,7 +1453,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   pi.on("turn_end", async (event: any, ctx: any) => {
     const cfg = loadConfig();
     if (cfg.mode === "off") return;
-    const state = loadState();
+    const state = loadState(ctx);
     const suppressedThisTurn = isAdvisorAutoRunSuppressedForTurnContext(state, state.turns);
     const tools = (event.toolResults || []).map((t: any) => String(t?.toolName || t?.name || "tool"));
     const fileChanged = tools.some((t: string) => /^(edit|write)$/i.test(t));
@@ -1431,7 +1475,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
       });
     }
 
-    const post = loadState();
+    const post = loadState(ctx);
     if (!isAdvisorAutoRunSuppressed(post, post.turns)) {
       void maybeAdvisorCheckin(pi, ctx, "turn_end");
     }
@@ -1441,7 +1485,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   pi.on("agent_end", async (event: any, ctx: any) => {
     const cfg = loadConfig();
     if (cfg.mode === "off") return;
-    const state = loadState();
+    const state = loadState(ctx);
     const suppressed = isAdvisorAutoRunSuppressedForTurnContext(state, state.turns);
     if (cfg.review === "off" || suppressed) {
       if (!suppressed) {
@@ -1466,7 +1510,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
       materialSignals: signals,
     });
 
-    const post = loadState();
+    const post = loadState(ctx);
     if (!isAdvisorAutoRunSuppressed(post, post.turns)) {
       void maybeAdvisorCheckin(pi, ctx, "agent_end");
     }
@@ -1478,12 +1522,12 @@ export function registerAdvisor(pi: ExtensionAPI): void {
     getArgumentCompletions: (prefix: string) => piRogueArgumentCompletions(prefix),
     handler: async (args, ctx) => {
       const cfg = loadConfig();
-      const state = loadState();
+      const state = loadState(ctx);
       const arg = String(args ?? "").trim().toLowerCase();
       setPiRogueStatus(ctx, cfg, state);
 
       if (!arg || arg === "status" || arg === "help") {
-        ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim(), orchestrationSnapshotText(ctx)), "info");
+        ctx.ui.notify(piRogueCockpitText(cfg, state, readText(advisorCurrentPath(ctx)).trim(), orchestrationSnapshotText(ctx)), "info");
         return;
       }
 
@@ -1519,7 +1563,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
         return;
       }
 
-      ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim(), orchestrationSnapshotText(ctx)), "info");
+      ctx.ui.notify(piRogueCockpitText(cfg, state, readText(advisorCurrentPath(ctx)).trim(), orchestrationSnapshotText(ctx)), "info");
     },
   });
 
@@ -1531,10 +1575,10 @@ export function registerAdvisor(pi: ExtensionAPI): void {
       const a = String(args ?? "").trim().toLowerCase();
       const [cmd, ...rest] = a.split(/\s+/);
       const cfg = loadConfig();
-      const state = loadState();
+      const state = loadState(ctx);
 
       if (!a || cmd === "status") {
-        const note = readText(CURRENT_PATH).trim();
+        const note = readText(advisorCurrentPath(ctx)).trim();
         const resolved = await resolveModel(ctx, cfg);
         const route = state.router.review ?? state.router.preflight;
         const pause = advisorPauseRemaining(state, state.turns);

package/node_modules/@fiale-plus/pi-rogue-advisor/src/loop-convergence.test.ts

@@ -4,7 +4,7 @@ import { dirname } from "node:path";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { completeSimple } from "@earendil-works/pi-ai";
-import { registerAdvisor } from "./extension.js";
+import { advisorSessionStatePath, registerAdvisor } from "./extension.js";
 
 const testHome = vi.hoisted(() => `/tmp/pi-rogue-advisor-loop-convergence-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 
@@ -57,7 +57,7 @@ function makeHandlers() {
 }
 
 const ADVISOR_STATE_DIR = join(homedir(), ".pi", "agent", "pi-rogue", "advisor");
-const ADVISOR_STATE_PATH = join(ADVISOR_STATE_DIR, "state.json");
+const ADVISOR_STATE_PATH = advisorSessionStatePath("session");
 const ADVISOR_CONFIG_PATH = join(ADVISOR_STATE_DIR, "config.json");
 const ADVISOR_CACHE_PATH = join(ADVISOR_STATE_DIR, "cache.json");
 

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

@@ -2,7 +2,7 @@ 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";
+import { advisorSessionStatePath, registerAdvisor } from "./extension.js";
 
 const testHome = vi.hoisted(() => `/tmp/pi-rogue-advisor-state-versioning-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 
@@ -37,17 +37,17 @@ function makeHandlers() {
 }
 
 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");
+const ADVISOR_STATE_PATH = advisorSessionStatePath("session");
 
 function readAdvisorState(): any {
   return JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
 }
 
-function mkCtx() {
+function mkCtx(session = "session") {
   return {
     sessionManager: {
-      getSessionFile: () => join(homedir(), ".pi", "agent", "pi-rogue", "advisor", "session.jsonl"),
+      getSessionFile: () => join(homedir(), ".pi", "agent", "pi-rogue", "advisor", `${session}.jsonl`),
     },
     isIdle: () => true,
     modelRegistry: {
@@ -224,4 +224,25 @@ describe("state versioning and recovery", () => {
     expect(recovered.reviewControl.pending).toBe(true);
     expect(recovered.reviewControl.lastDecision).toBe("review");
   });
+
+  it("keeps mutable advisor state isolated by session", async () => {
+    const setup = makeHandlers();
+    const { handlers: h, pi } = setup;
+    registerAdvisor(pi);
+
+    const ctxA = mkCtx("model-training");
+    const ctxB = mkCtx("runpod");
+
+    void h.session_start?.[0]?.({}, ctxA);
+    await h.before_agent_start?.[0]?.({ prompt: "train advisor on regex logs", systemPrompt: "base" }, ctxA);
+
+    const stateA = JSON.parse(readFileSync(advisorSessionStatePath("model-training"), "utf8"));
+    expect(stateA.lastTask).toBe("train advisor on regex logs");
+
+    void h.session_start?.[0]?.({}, ctxB);
+    const stateB = JSON.parse(readFileSync(advisorSessionStatePath("runpod"), "utf8"));
+    expect(stateB.lastTask).toBe("");
+    expect(stateB.followUp).toBe("");
+    expect(stateB.reviewSignals).toEqual([]);
+  });
 });

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-orchestration/src/advisor-checkins.test.ts

@@ -62,6 +62,16 @@ describe("advisor check-in lifecycle bridge", () => {
     expect(JSON.parse(readFileSync(file, "utf8")).checkins).toBe("off");
   });
 
+  it("preserves legacy one-argument reset signature", () => {
+    const { config } = tempState();
+    writeFileSync(config, JSON.stringify({ checkins: "off" }), "utf8");
+
+    const next = resetAdvisorSessionContext(config);
+
+    expect(next.config.checkins).toBe("off");
+    expect(JSON.parse(readFileSync(config, "utf8")).checkins).toBe("off");
+  });
+
   it("resets advisor brief context and check-in timing for a new goal", () => {
     const { config, state } = tempState();
     const startedAt = Date.now();