@fiale-plus/pi-rogue 0.2.1 → 0.2.3

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-core/src/context-broker.ts

@@ -72,6 +72,8 @@ export interface ContextBrokerStatus {
   coldBytes: number;
   maxRecords: number;
   maxBytes: number;
+  globalMaxRecords: number;
+  globalMaxBytes: number;
 }
 
 export interface ContextBrokerOptions {
@@ -89,6 +91,8 @@ export interface ContextBrokerOptions {
   hotMaxBytes?: number;
   warmMaxBytes?: number;
   coldMaxBytes?: number;
+  hotToWarmMs?: number;
+  warmToColdMs?: number;
   summaryBytes?: number;
   briefBytes?: number;
 }

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

@@ -8,6 +8,7 @@ This package contains the executable in-memory bounded broker implementation:
 - 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.
+- Aging cools unpinned artifacts from hot to warm and from warm to cold; compaction remains cleanup/removal, not a separate cooling trigger.
 - 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.
@@ -22,20 +23,36 @@ 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.
 - `/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.
+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. Exact-handle misses and text/filter misses use distinct messages, and `/context status` reports exact/text miss counters.
 
-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.
+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. Durable mode applies default global retention caps when env caps are not set: 2,048 records and 256 MiB across sessions.
 
-- `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.
+- `PI_CONTEXT_BROKER_HOT_TO_WARM_MS` controls unpinned artifact cooling from hot to warm. The default is 2 hours.
+- `PI_CONTEXT_BROKER_WARM_TO_COLD_MS` controls unpinned artifact cooling from warm/hot to cold. The default is 12 hours.
 
-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.
+
+## Tier lifecycle policy
+
+- Publish-time classification remains deterministic: explicit `tier`, `hot`/`warm`/`cold` tags, error tags, completed/archive tags, and artifact kind choose the base tier.
+- Cooling only retiers unpinned artifacts for prompt visibility and cap pressure; it does not delete payloads.
+- Pinned artifacts stay hot and are retained through compaction cleanup.
+- Cold artifacts remain retrievable by exact handle/search, but are excluded from the default prompt brief unless explicitly queried.
+- `/compact` / `session_compact` cleanup purges unpinned artifacts for the session; cooling is age-based and separate from compaction cleanup.
+
+## Payload display policy
+
+- Hostile/binary payloads are unsafe or control-heavy. They are stored/exportable but omitted from prompt lookup output with `/context export` guidance.
+- Opaque payloads are printable but low-value/high-token, such as large base64-like blobs, hex dumps, minified single-line output, or compressed-looking text. They are also stored/exportable but omitted from prompt lookup output with `/context export` guidance.
+- Normal code, logs, and test output remain visible subject to normal byte clipping.
 
 
 ## Session behavior and limits
@@ -45,9 +62,11 @@ 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:
   - `PI_CONTEXT_BROKER_GLOBAL_MAX_RECORDS`
   - `PI_CONTEXT_BROKER_GLOBAL_MAX_BYTES`
+- Durable mode defaults to global caps of 2,048 records and 256 MiB when those env vars are unset; in-memory mode remains per-session capped unless global caps are explicitly provided.
 - 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/src/extension.test.ts

@@ -287,6 +287,57 @@ lookupBytes: 80, searchBytes: 50,
     expect(commandMessage).not.toContain("\u0000");
   });
 
+  it("omits opaque printable payloads from lookup output and suggests export", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 1 });
+    const { ctx, notifications } = createCtx();
+    const payload = "A".repeat(6000);
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "call-opaque",
+      toolName: "bash",
+      input: { command: "printf opaque" },
+      content: [{ type: "text", text: payload }],
+      isError: false,
+    }, ctx);
+
+    const lookupCompletion = commands.get("context").getArgumentCompletions("lookup ")?.[0];
+    const lookupHandle = lookupCompletion?.value.replace(/^lookup /, "");
+
+    await commands.get("context").handler(`lookup ${lookupHandle}`, ctx);
+    const commandMessage = notifications.at(-1)?.message ?? "";
+    expect(commandMessage).toContain("payload omitted from prompt because it appears opaque/high-token");
+    expect(commandMessage).toContain("/context export");
+    expect(commandMessage).not.toContain(payload.slice(0, 200));
+  });
+
+  it("does not classify normal multiline code as opaque", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { lookupBytes: 8000, rewriteThresholdBytes: 1 });
+    const { ctx, notifications } = createCtx();
+    const payload = Array.from({ length: 240 }, (_, index) => `export function fn${index}() { return ${index}; }`).join("\n");
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "call-code",
+      toolName: "read",
+      input: { path: "src/generated.ts" },
+      content: [{ type: "text", text: payload }],
+      isError: false,
+    }, ctx);
+
+    const lookupCompletion = commands.get("context").getArgumentCompletions("lookup ")?.[0];
+    const lookupHandle = lookupCompletion?.value.replace(/^lookup /, "");
+
+    await commands.get("context").handler(`lookup ${lookupHandle}`, ctx);
+    const commandMessage = notifications.at(-1)?.message ?? "";
+    expect(commandMessage).toContain("export function fn0");
+    expect(commandMessage).not.toContain("payload omitted from prompt because it appears opaque/high-token");
+  });
+
   it("text search lookup returns a smaller byte-clipped excerpt", async () => {
     const { pi, handlers, commands } = createPiMock();
     registerContextBrokerBeta(pi, {
@@ -360,6 +411,27 @@ lookupBytes: 500,
     expect(result.content[0].text).toContain("exact evidence payload");
   });
 
+  it("distinguishes exact-handle and text lookup misses", async () => {
+    const { pi, handlers, commands, tools } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 1 });
+    const { ctx, notifications } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    const toolExactMiss = await tools.get("context_lookup").execute("lookup-missing-handle", { handle: "ctx://missing/handle" }, undefined, undefined, ctx);
+    const toolTextMiss = await tools.get("context_lookup").execute("lookup-missing-text", { text: "definitely absent" }, undefined, undefined, ctx);
+    await commands.get("context").handler("lookup ctx://missing/handle", ctx);
+    await commands.get("context").handler("lookup definitely absent", ctx);
+    await commands.get("context").handler("status", ctx);
+
+    expect(toolExactMiss.content[0].text).toContain("exact handle");
+    expect(toolTextMiss.content[0].text).toContain("text/filter query");
+    expect(notifications.at(-4)?.message).toContain("exact handle");
+    expect(notifications.at(-3)?.message).toContain("text/filter query");
+    const telemetry = notifications.at(-1)?.message ?? "";
+    expect(telemetry).toContain("exactMisses=1");
+    expect(telemetry).toContain("textMisses=1");
+  });
+
   it("reports routing telemetry in /context status", async () => {
     const { pi, handlers, commands, tools } = createPiMock();
     registerContextBrokerBeta(pi, { rewriteThresholdBytes: 1, lookupBytes: 500, searchBytes: 500 });
@@ -382,7 +454,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);
@@ -390,17 +462,52 @@ lookupBytes: 500,
     expect(handle).toBeTruthy();
     expect(toolResult.content[0].text).toContain("telemetry_payload_");
     expect(result).toBeDefined();
+    const statusMessage = notifications.at(-2)?.message ?? "";
+    expect(statusMessage).toContain("globalCaps=records:unbounded bytes:unbounded");
     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("exact=");
+    expect(telemetry).toContain("textMisses=");
     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 +532,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);
 
@@ -702,6 +812,7 @@ maxRecords: 1,
       const secondHandle = second.commands.get("context").getArgumentCompletions("lookup ")?.[0].value.replace(/^lookup /, "");
       await second.commands.get("context").handler(`lookup ${handle}`, secondRun.ctx);
       await second.commands.get("context").handler("brief", secondRun.ctx);
+      await second.commands.get("context").handler("status", secondRun.ctx);
 
       const third = createPiMock();
       const thirdRun = createCtx();
@@ -710,9 +821,10 @@ maxRecords: 1,
       await third.commands.get("context").handler(`lookup ${secondHandle}`, thirdRun.ctx);
       await third.commands.get("context").handler("brief", thirdRun.ctx);
 
-      expect(secondRun.notifications.at(-2)?.message).toContain("durable payload");
-      expect(secondRun.notifications.at(-1)?.message).toContain("tier=hot");
-      expect(secondRun.notifications.at(-1)?.message).toContain("pinned");
+      expect(secondRun.notifications.at(-4)?.message).toContain("durable payload");
+      expect(secondRun.notifications.at(-3)?.message).toContain("tier=hot");
+      expect(secondRun.notifications.at(-3)?.message).toContain("pinned");
+      expect(secondRun.notifications.at(-2)?.message).toContain("globalCaps=records:2048 bytes:268435456");
       expect(thirdRun.notifications.at(-2)?.message).toContain("durable payload");
       expect(thirdRun.notifications.at(-1)?.message).toContain("tier=hot");
       expect(thirdRun.notifications.at(-1)?.message).toContain("pinned");

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

@@ -20,6 +20,8 @@ export interface ContextBrokerBetaOptions {
   lookupBytes?: number;
   searchBytes?: number;
   rewriteThresholdBytes?: number;
+  hotToWarmMs?: number;
+  warmToColdMs?: number;
   durable?: boolean;
   storeDir?: string;
 }
@@ -32,6 +34,10 @@ const DEFAULT_LOOKUP_BYTES = 12_000;
 const DEFAULT_SEARCH_BYTES = 2_000;
 const DEFAULT_REWRITE_THRESHOLD_BYTES = 8 * 1024;
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_HOT_TO_WARM_MS = 2 * 60 * 60 * 1000;
+const DEFAULT_WARM_TO_COLD_MS = 12 * 60 * 60 * 1000;
+const DEFAULT_DURABLE_GLOBAL_MAX_RECORDS = 2_048;
+const DEFAULT_DURABLE_GLOBAL_MAX_BYTES = 256 * 1024 * 1024;
 const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
 
 function envFlag(name: string): boolean {
@@ -89,6 +95,28 @@ function isHostilePayload(payload: string): boolean {
   return hasHostileText(payload);
 }
 
+function isOpaquePayload(payload: string): boolean {
+  return hasOpaqueText(payload);
+}
+
+function hasOpaqueText(text: string): boolean {
+  const value = String(text ?? "");
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes < 4096) return false;
+
+  const compacted = value.replace(/\s+/g, "");
+  if (compacted.length >= 4096 && /^[A-Za-z0-9+/=_-]+$/.test(compacted) && compacted.length / Math.max(1, value.length) > 0.85) return true;
+  if (/\b(?:[A-Fa-f0-9]{2}){2048,}\b/.test(value)) return true;
+
+  const lines = value.split(/\r?\n/);
+  const longestLine = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  const whitespace = (value.match(/\s/g) ?? []).length;
+  const whitespaceRatio = whitespace / Math.max(1, value.length);
+  if (longestLine >= 4096 && whitespaceRatio < 0.03) return true;
+  if (longestLine >= 2048 && whitespaceRatio < 0.02 && /[{};:,]/.test(value)) return true;
+  return false;
+}
+
 function hasHostileText(text: string): boolean {
   let suspicious = 0;
   let scanned = 0;
@@ -117,12 +145,24 @@ function hasHostileValue(value: unknown): boolean {
   return false;
 }
 
+function hasOpaqueValue(value: unknown): boolean {
+  if (typeof value === "string") return hasOpaqueText(value);
+  if (Array.isArray(value)) return value.some(hasOpaqueValue);
+  if (value && typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some((entry) => hasOpaqueValue(entry));
+  }
+  return false;
+}
+
 function renderLookupOutput(item: ContextArtifact, payloadLimit: number): string {
   const isBinary = item.tags.includes("hostile") || item.tags.includes("binary");
-  const payloadLines = isBinary
+  const isOpaque = item.tags.includes("opaque");
+  const payloadLines = isBinary || isOpaque
     ? [
       "payload:",
-      "[payload intentionally omitted from prompt for safety; use /context export",
+      isOpaque && !isBinary
+        ? "[payload omitted from prompt because it appears opaque/high-token; use /context export"
+        : "[payload intentionally omitted from prompt for safety; use /context export",
       sanitizeForPrompt(item.handle),
       "for full content]",
     ]
@@ -176,6 +216,26 @@ function compact(value: string, max = 120): string {
   return truncateUtf8(value.replace(/\s+/g, " ").trim(), max);
 }
 
+function capText(value: number): string {
+  return Number.isFinite(value) ? String(value) : "unbounded";
+}
+
+function lookupMissMessage(exact: boolean): string {
+  return exact
+    ? "No context artifact matched that exact handle. The artifact may be missing, expired, pruned, or from a non-durable prior session."
+    : "No context artifacts matched that text/filter query. Try an exact ctx:// handle, narrower path/tag/kind/tier filters, or a more specific search term.";
+}
+
+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);
 }
@@ -283,14 +343,16 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     options.rewriteThresholdBytes
     ?? envNonNegativeInt("PI_CONTEXT_BROKER_REWRITE_THRESHOLD_BYTES")
     ?? DEFAULT_REWRITE_THRESHOLD_BYTES;
+  const durable = options.durable ?? (envFlag("PI_CONTEXT_BROKER_DURABLE") || Boolean(options.storeDir ?? process.env.PI_CONTEXT_BROKER_STORE_DIR));
   const brokerOptions = {
     maxRecords: options.maxRecords ?? 64,
     maxBytes: options.maxBytes ?? 8 * 1024 * 1024,
-    globalMaxRecords: options.globalMaxRecords ?? envNonNegativeInt("PI_CONTEXT_BROKER_GLOBAL_MAX_RECORDS"),
-    globalMaxBytes: options.globalMaxBytes ?? envNonNegativeInt("PI_CONTEXT_BROKER_GLOBAL_MAX_BYTES"),
+    globalMaxRecords: options.globalMaxRecords ?? envNonNegativeInt("PI_CONTEXT_BROKER_GLOBAL_MAX_RECORDS") ?? (durable ? DEFAULT_DURABLE_GLOBAL_MAX_RECORDS : undefined),
+    globalMaxBytes: options.globalMaxBytes ?? envNonNegativeInt("PI_CONTEXT_BROKER_GLOBAL_MAX_BYTES") ?? (durable ? DEFAULT_DURABLE_GLOBAL_MAX_BYTES : undefined),
+    hotToWarmMs: options.hotToWarmMs ?? envNonNegativeInt("PI_CONTEXT_BROKER_HOT_TO_WARM_MS") ?? DEFAULT_HOT_TO_WARM_MS,
+    warmToColdMs: options.warmToColdMs ?? envNonNegativeInt("PI_CONTEXT_BROKER_WARM_TO_COLD_MS") ?? DEFAULT_WARM_TO_COLD_MS,
     briefBytes,
   };
-  const durable = options.durable ?? (envFlag("PI_CONTEXT_BROKER_DURABLE") || Boolean(options.storeDir ?? process.env.PI_CONTEXT_BROKER_STORE_DIR));
   const durableBackend = String(process.env.PI_CONTEXT_BROKER_BACKEND ?? "sqlite").trim().toLowerCase();
   const broker = durable
     ? durableBackend === "jsonl"
@@ -308,6 +370,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,
@@ -318,24 +383,38 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     toolLookupTextCalls: 0,
     toolLookupHits: 0,
     toolLookupMisses: 0,
+    toolLookupExactMisses: 0,
+    toolLookupTextMisses: 0,
     commandLookupCalls: 0,
     commandLookupExactCalls: 0,
     commandLookupTextCalls: 0,
     commandLookupHits: 0,
     commandLookupMisses: 0,
+    commandLookupExactMisses: 0,
+    commandLookupTextMisses: 0,
     exportCalls: 0,
     pinCalls: 0,
     statusCalls: 0,
     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}`,
-      `lookups tool(calls=${routingTelemetry.toolLookupCalls}, hits=${routingTelemetry.toolLookupHits}, misses=${routingTelemetry.toolLookupMisses})`,
-      `lookups slash(calls=${routingTelemetry.commandLookupCalls}, hits=${routingTelemetry.commandLookupHits}, misses=${routingTelemetry.commandLookupMisses})`,
+      `rewriteSavings rawBytes=${routingTelemetry.contextHookRewriteRawBytes} replacementBytes=${routingTelemetry.contextHookRewriteReplacementBytes} savedBytes=${savedBytes} savedPct=${savedPct}% contextLookupHistoryOmitted=${routingTelemetry.contextHookContextLookupHistoryOmissions}`,
+      `lookups tool(calls=${routingTelemetry.toolLookupCalls}, exact=${routingTelemetry.toolLookupExactCalls}, text=${routingTelemetry.toolLookupTextCalls}, hits=${routingTelemetry.toolLookupHits}, misses=${routingTelemetry.toolLookupMisses}, exactMisses=${routingTelemetry.toolLookupExactMisses}, textMisses=${routingTelemetry.toolLookupTextMisses})`,
+      `lookups slash(calls=${routingTelemetry.commandLookupCalls}, exact=${routingTelemetry.commandLookupExactCalls}, text=${routingTelemetry.commandLookupTextCalls}, hits=${routingTelemetry.commandLookupHits}, misses=${routingTelemetry.commandLookupMisses}, exactMisses=${routingTelemetry.commandLookupExactMisses}, textMisses=${routingTelemetry.commandLookupTextMisses})`,
       `exports=${routingTelemetry.exportCalls}`,
       `pins=${routingTelemetry.pinCalls}`,
       `pruneCalls=${routingTelemetry.pruneCalls}`,
@@ -377,6 +456,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
     const payload = toolPayload(sanitizedEvent);
     const bytes = Buffer.byteLength(payload, "utf8");
     const hostilePayload = isHostilePayload(payload) || hasHostileValue(sanitizedEvent);
+    const opaquePayload = !hostilePayload && (isOpaquePayload(payload) || hasOpaqueValue(sanitizedEvent));
     const artifact = broker.publish({
       sessionId: activeSessionId,
       kind: "tool_output",
@@ -387,6 +467,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
         event.isError ? "error" : "ok",
         event.sourceId ? "session-backfill" : "live",
         ...(hostilePayload ? ["hostile", "binary"] : []),
+        ...(opaquePayload ? ["opaque"] : []),
       ],
       command: event.toolName === "bash" && typeof sanitizedEvent.input?.command === "string" ? sanitizedEvent.input.command : undefined,
       paths: typeof sanitizedEvent.input?.path === "string" ? [sanitizedEvent.input.path] : [],
@@ -572,19 +653,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 +696,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 +706,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 +733,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 +747,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 +756,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;
@@ -719,7 +823,9 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
       });
       if (!results.length) {
         routingTelemetry.toolLookupMisses += 1;
-        return textResult("No context artifacts matched. Missing or expired handles should be reported explicitly.");
+        if (exact) routingTelemetry.toolLookupExactMisses += 1;
+        else routingTelemetry.toolLookupTextMisses += 1;
+        return textResult(lookupMissMessage(exact));
       }
       routingTelemetry.toolLookupHits += 1;
       return textResult(results.map((item) => renderLookupOutput(item, exact ? lookupBytes : searchBytes)).join("\n\n---\n\n"));
@@ -738,7 +844,7 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
         routingTelemetry.statusCalls += 1;
         const status = broker.status();
         ctx.ui.notify(
-          `Context broker: enabled, session=${activeSessionId}, records=${status.records}, bytes=${status.bytes}/${status.maxBytes}, tiers=hot:${status.hotRecords}/${status.hotBytes} warm:${status.warmRecords}/${status.warmBytes} cold:${status.coldRecords}/${status.coldBytes}, pinned=${status.pinnedRecords}/${status.pinnedBytes} bytes`,
+          `Context broker: enabled, session=${activeSessionId}, records=${status.records}/${status.maxRecords}, bytes=${status.bytes}/${status.maxBytes}, globalCaps=records:${capText(status.globalMaxRecords)} bytes:${capText(status.globalMaxBytes)}, tiers=hot:${status.hotRecords}/${status.hotBytes} warm:${status.warmRecords}/${status.warmBytes} cold:${status.coldRecords}/${status.coldBytes}, pinned=${status.pinnedRecords}/${status.pinnedBytes} bytes`,
           "info",
         );
         ctx.ui.notify(formatRoutingTelemetry(), "info");
@@ -764,8 +870,10 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
           routingTelemetry.commandLookupHits += 1;
         } else {
           routingTelemetry.commandLookupMisses += 1;
+          if (exact) routingTelemetry.commandLookupExactMisses += 1;
+          else routingTelemetry.commandLookupTextMisses += 1;
         }
-        ctx.ui.notify(results.length ? results.map((item) => renderLookupOutput(item, exact ? lookupBytes : searchBytes)).join("\n\n---\n\n") : "No context artifacts matched.", "info");
+        ctx.ui.notify(results.length ? results.map((item) => renderLookupOutput(item, exact ? lookupBytes : searchBytes)).join("\n\n---\n\n") : lookupMissMessage(exact), "info");
         return;
       }
 

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

@@ -193,6 +193,38 @@ describe("createInMemoryContextBroker", () => {
     expect(broker.lookup({ sessionId: "s", tier: "cold" }).map((artifact) => artifact.id)).toEqual([explicit.id, archive.id]);
   });
 
+  it("cools old artifacts across hot, warm, and cold tiers without deleting them", () => {
+    const broker = createInMemoryContextBroker({ briefBytes: 1200, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200 });
+    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 oldWarm = broker.publish({ sessionId: "s", kind: "tool_output", payload: "old-warm", summary: "old warm", tier: "warm", createdAt: now - 300 });
+    const freshHot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "fresh-hot", summary: "fresh hot", tier: "hot", createdAt: now - 50 });
+    const pinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "pinned", summary: "pinned hot", tier: "hot", pinned: true, createdAt: now - 300 });
+
+    broker.prune(now);
+
+    expect(broker.lookup({ handle: oldHot.handle })[0]?.tier).toBe("cold");
+    expect(broker.lookup({ handle: oldWarm.handle })[0]?.tier).toBe("cold");
+    expect(broker.lookup({ handle: freshHot.handle })[0]?.tier).toBe("hot");
+    expect(broker.lookup({ handle: pinned.handle })[0]?.tier).toBe("hot");
+    const brief = broker.renderBrief({ sessionId: "s" });
+    expect(brief).not.toContain(oldHot.handle);
+    expect(brief).not.toContain(oldWarm.handle);
+    expect(brief).toContain(freshHot.handle);
+    expect(brief).toContain(pinned.handle);
+  });
+
+  it("cools protected new artifacts before enforcing tier caps", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 0, maxRecords: 10, hotMaxRecords: 1, hotToWarmMs: 10_000, warmToColdMs: 20_000 });
+    const now = Date.now();
+    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");
+  });
+
   it("renders prompt briefs hot-first, warm-second, and excludes cold unless explicit", () => {
     const broker = createInMemoryContextBroker({ briefBytes: 900, defaultTtlMs: 0 });
     const cold = broker.publish({ sessionId: "s", kind: "tool_output", payload: "cold", summary: "cold archive", tier: "cold", createdAt: 1 });