@fiale-plus/pi-rogue 0.2.2 → 0.2.4

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-advisor/README.md

@@ -8,6 +8,7 @@ Strategic advisor for Pi sessions with low-overhead preflight/post-review routin
 
 - SOTA-first model fallback: `gpt-5.5`/`claude-opus-4-6`/`claude-sonnet-4-6` where available.
 - Keeps command-level behavior simple and explicit.
+- Router/binary-gate policy escalates architecture/refactor/tradeoff/security/high-uncertainty and material stuck/no-progress work, while tiny edits, direct answers, docs/formatting cleanup, and other low-risk reactive tasks continue without advisor noise.
 
 ## Install
 

package/node_modules/@fiale-plus/pi-rogue-advisor/src/binary-gate-features.test.ts

@@ -16,4 +16,12 @@ describe("binary gate feature extraction", () => {
     expect(features.get("safety:production")).toBe(1);
     expect(features.get("safety:deploy")).toBe(1);
   });
+
+  it("emits stuck/no-progress cues for the binary gate", () => {
+    const features = extractBinaryGateFeatureCounts("goal loop stuck with repeated planning and no concrete progress");
+
+    expect(features.get("stuck:stuck")).toBe(1);
+    expect(features.get("stuck:repeated_planning")).toBe(1);
+    expect(features.get("stuck:no_concrete_progress")).toBe(1);
+  });
 });

package/node_modules/@fiale-plus/pi-rogue-advisor/src/binary-gate-features.ts

@@ -160,6 +160,13 @@ export function extractBinaryGateFeatureCounts(text: string): Map<string, number
     }
   }
 
+  const stuckWords = ["stuck", "looping", "spinning", "no progress", "no concrete progress", "same failure", "repeated failure", "repeated planning", "self talk", "forever thinking", "alternative action", "blocked"];
+  for (const stuckWord of stuckWords) {
+    if (lower.includes(stuckWord)) {
+      inc(counts, `stuck:${replaceSpaces(stuckWord)}`);
+    }
+  }
+
   const contextWords = ["need more context", "missing context", "clarify", "not enough info", "unspecified", "unknown", "ambiguous"];
   for (const contextWord of contextWords) {
     if (lower.includes(contextWord)) {

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

@@ -36,6 +36,32 @@ describe("advisor router heuristics", () => {
     expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
   });
 
+  it("escalates material stuck/no-progress prompts", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "the goal loop is stuck with repeated planning and no concrete progress after several turns" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.escalate).toBe(true);
+    expect(route.reason).toContain("no-progress");
+  });
+
+  it("escalates stuck evidence even when low-risk edit cues are present", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "small README edit is stuck with no concrete progress after several turns" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.reason).toContain("no-progress");
+  });
+
+  it("keeps routine docs cleanup out of advisor escalation", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "routine docs and formatting cleanup in README" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("continue");
+    expect(route.escalate).toBe(false);
+    expect(route.review).toBe("off");
+  });
+
   it("flags safety-sensitive prompts", () => {
     const input: AdvisorRouteInput = { phase: "preflight", text: "run rm -rf on prod" };
     const route = heuristicRoute(input);

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

@@ -125,6 +125,7 @@ const QUICK_EDIT_RE = /\b(quick edit|small edit|tiny edit|rename|format(?:ting)?
 const ROUTINE_CLEANUP_RE = /\b(routine docs?|docs? and formatting|formatting cleanup|generated changes|large diff|docs?\/formatting)\b/i;
 const COMPLEX_RE = /\b(architecture|architectural|refactor|design|trade[- ]?off|concurrency|security|auth|migration|performance|scale|scalability|framework|system design|schema|data model|protocol|advisor routing|advisor flow|router logic|call vs skip|skip vs call|compare|recommend|benchmark|evaluate|experiment|train|strategy|choose|make sense|worth(?: it)?|kpi|kpis|how it works|where it comes from|what would you choose|what do you think|next step|pick between|buy|usage|sustained speed|available models|running model kpis)\b/i;
 const DEBUG_RE = /\b(debug|bug|error|stack trace|traceback|fail(?:ed|ure)?|broken|investigate|why is|cannot|can't|crash|regression)\b/i;
+const STUCK_RE = /\b(stuck|looping|spinning|no[- ]?progress|no concrete progress|same failure|repeated failure|repeated planning|self[- ]?talk|forever thinking|strategy change|alternative action|blocked)\b/i;
 const CONTEXT_RE = /\b(need more context|missing context|clarify|not enough info|unspecified|unknown|ambiguous)\b/i;
 const SAFETY_RE = /\b(rm\s+-rf|sudo\b|shutdown\b|reboot\b|mkfs(?:\.[\w-]+)?\b|chmod\s+-R\b|chown\b|git\s+push\b[\s\S]*--force(?:-with-lease)?|curl\b[\s\S]*\|\s*(?:sh|bash)\b|wget\b[\s\S]*\|\s*(?:sh|bash)\b|drop\s+table\b|delete\s+database\b|credential\b|password\b|secret\b)\b/i;
 const COMPACTION_RE = /\b(compact(?:ed|ion)?|missing history|history might flip|prior constraint|resume(?:d)? after compaction)\b/i;
@@ -293,6 +294,11 @@ function hasComplexSignal(text: string): boolean {
   return COMPLEX_RE.test(text) || DEBUG_RE.test(text);
 }
 
+function hasMaterialStuckSignal(text: string): boolean {
+  if (!STUCK_RE.test(text)) return false;
+  return /\b(goal|loop|autoresearch|tool|test|command|failure|failed|turns?|again|same|repeated|concrete|progress|blocked|alternative|recovery)\b/i.test(text);
+}
+
 function hasCompactionLowRiskSignal(text: string): boolean {
   return COMPACTION_RE.test(text) && /\blow[- ]?risk\b/i.test(text);
 }
@@ -342,6 +348,9 @@ function preflightSignals(input: AdvisorRouteInput): { label: PreflightLabel; co
   if (isSafetySensitive(text)) {
     return { label: "escalate_to_advisor", confidence: 0.98, reason: "Safety-sensitive keywords detected.", safety: true };
   }
+  if (hasMaterialStuckSignal(text)) {
+    return { label: "escalate_to_advisor", confidence: 0.86, reason: "Material stuck/no-progress signal detected.", safety: false };
+  }
   if (hasRoutineCleanupSignal(text) || (hasQuickEditSignal(text) && !hasComplexSignal(text))) {
     return { label: "continue", confidence: 0.9, reason: "Small-edit or routine-cleanup signal detected.", safety: false };
   }
@@ -424,7 +433,7 @@ export function buildRouterPrompt(input: AdvisorRouteInput): string {
     input.failed !== undefined ? `Failed: ${String(input.failed)}` : "",
     phase === "preflight"
       ? [
-        "Guidance: continue for tiny edits and direct answers; escalate_to_advisor for architecture, design, tradeoffs, security, or high uncertainty; need_more_context when underspecified; low_confidence when mixed signals.",
+        "Guidance: continue for tiny edits, direct answers, docs/formatting cleanup, and other low-risk reactive tasks; escalate_to_advisor for architecture, refactors, design, tradeoffs, security, irreversible actions, high uncertainty, or material stuck/no-progress evidence; need_more_context when underspecified; low_confidence when mixed signals. If advisor guidance conflicts with local evidence, the working model must reconcile explicitly rather than blindly follow it.",
       ].join(" ")
       : [
         "Guidance: on_track for clearly complete work; course_correct for partial work that needs changes; not_done when incomplete or failing; abstain when there is not enough signal.",

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.
@@ -29,14 +30,30 @@ When active, the bundle registers:
 - `/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 `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 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
 
@@ -51,4 +68,5 @@ For more aggressive prompt reduction, set `PI_CONTEXT_BROKER_REWRITE_THRESHOLD_B
 - 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 });
@@ -390,6 +462,8 @@ 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=");
@@ -398,6 +472,8 @@ lookupBytes: 500,
     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=");
@@ -736,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();
@@ -744,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,16 @@ 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");
 }
@@ -293,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"
@@ -331,11 +383,15 @@ 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,
@@ -357,8 +413,8 @@ export async function registerContextBrokerBeta(pi: ExtensionAPI, options: Conte
       `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})`,
+      `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}`,
@@ -400,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",
@@ -410,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] : [],
@@ -765,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"));
@@ -784,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");
@@ -810,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 });

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))