@fiale-plus/pi-rogue-bundle 0.1.16 → 0.1.17

package/README.md

@@ -30,7 +30,8 @@ npm install
 - **Lab / internal helpers are excluded from this bundle.**
 - The beta context-broker runtime is bundled for opt-in experiments but is not registered/enabled by default.
 - Opt-in consumers can import the runtime through the bundle subpath: `@fiale-plus/pi-rogue-bundle/context-broker`.
-- Set `PI_CONTEXT_BROKER_ENABLED=true` before starting Pi to register the beta `/context` command surface.
+- Set `PI_CONTEXT_BROKER_ENABLED=true` before starting Pi to register the beta `/context` command surface and prompt-load rewriting.
+- Optional durable broker storage can be enabled with `PI_CONTEXT_BROKER_DURABLE=true` or `PI_CONTEXT_BROKER_STORE_DIR=/path/to/store`; it defaults to SQLite/FTS and supports `PI_CONTEXT_BROKER_BACKEND=jsonl` for the legacy JSONL/blob backend.
 - `@fiale-plus/pi-rogue-bundle` is the only published surface for the logic.
 - Internal helper packages (`@fiale-plus/pi-rogue-guardrails`, `@fiale-plus/pi-rogue-brain`, `@fiale-plus/pi-rogue-repo-arch`) are maintained separately in the lab section and not published.
 

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

@@ -6,6 +6,8 @@ export type ContextArtifactKind =
   | "advisor_brief"
   | "memory_note";
 
+export type ContextArtifactTier = "hot" | "warm" | "cold";
+
 export interface ContextArtifactInput {
   sessionId: string;
   kind: ContextArtifactKind;
@@ -15,6 +17,7 @@ export interface ContextArtifactInput {
   paths?: string[];
   command?: string;
   branch?: string;
+  tier?: ContextArtifactTier;
   ttlMs?: number;
   pinned?: boolean;
   parentIds?: string[];
@@ -36,6 +39,7 @@ export interface ContextArtifact {
   paths: string[];
   command?: string;
   branch?: string;
+  tier: ContextArtifactTier;
   expiresAt?: number;
   pinned: boolean;
   parentIds: string[];
@@ -50,6 +54,7 @@ export interface ContextLookupQuery {
   path?: string;
   commandPrefix?: string;
   branch?: string;
+  tier?: ContextArtifactTier;
   text?: string;
   limit?: number;
 }
@@ -59,6 +64,12 @@ export interface ContextBrokerStatus {
   bytes: number;
   pinnedRecords: number;
   pinnedBytes: number;
+  hotRecords: number;
+  hotBytes: number;
+  warmRecords: number;
+  warmBytes: number;
+  coldRecords: number;
+  coldBytes: number;
   maxRecords: number;
   maxBytes: number;
 }
@@ -67,6 +78,15 @@ export interface ContextBrokerOptions {
   maxRecords?: number;
   maxBytes?: number;
   defaultTtlMs?: number;
+  hotTtlMs?: number;
+  warmTtlMs?: number;
+  coldTtlMs?: number;
+  hotMaxRecords?: number;
+  warmMaxRecords?: number;
+  coldMaxRecords?: number;
+  hotMaxBytes?: number;
+  warmMaxBytes?: number;
+  coldMaxBytes?: number;
   summaryBytes?: number;
   briefBytes?: number;
 }

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

@@ -283,6 +283,15 @@ function brief(s: SessionState): string {
   return lines.join("\n").slice(0, 1200);
 }
 
+function contextBrokerBrief(pi: ExtensionAPI): string {
+  try {
+    const text = (pi as any).__piRogueContextBroker?.renderBrief?.();
+    return typeof text === "string" && text.includes("ctx://") ? sanitizeAdvisorText(text).slice(0, 2400) : "";
+  } catch {
+    return "";
+  }
+}
+
 const CLIPBOARD_IMAGE_PATH_RE = /(?:\/(?:private\/)?var\/folders\/[^\s"'`<>]+\/T|\/(?:tmp|var\/tmp))\/clipboard-\d{4}-\d{2}-\d{2}-[A-Za-z0-9-]+\.(?:png|jpe?g|gif|webp)\b/g;
 
 export function sanitizeAdvisorText(text: unknown): string {
@@ -881,12 +890,18 @@ async function askAdvisor(pi: ExtensionAPI, ctx: any, question: string, scope: s
   const state = loadState();
   if (!question.trim()) return { text: "Ask a question.", error: "empty" };
 
-  const ck = hash("adv", config.model ?? "auto", squish(question, 300), includeWork ? brief(state) : "");
+  const brokerBrief = includeWork ? contextBrokerBrief(pi) : "";
+  const ck = hash("adv", config.model ?? "auto", squish(question, 300), includeWork ? brief(state) : "", brokerBrief);
   const cache = loadCache();
   if (cache[ck]) { state.cacheHits++; saveState(state); return { text: cache[ck], cached: true }; }
 
   const msgs = [
-    { role: "user", content: [ `Question: ${question}`, scope ? `Scope: ${scope}` : "", includeWork && brief(state) ? `Session:\n${brief(state)}` : "" ].filter(Boolean).join("\n"), timestamp: new Date().toISOString() },
+    { role: "user", content: [
+      `Question: ${question}`,
+      scope ? `Scope: ${scope}` : "",
+      includeWork && brief(state) ? `Session:\n${brief(state)}` : "",
+      brokerBrief ? `Context broker brief:\n${brokerBrief}` : "",
+    ].filter(Boolean).join("\n"), timestamp: new Date().toISOString() },
   ] as any[];
 
   const completed = await completeWithModelFallback(ctx, config, ADVISOR_SYSTEM, msgs, { maxTokens: 600, reasoning: "medium" as ThinkingLevel });
@@ -984,7 +999,8 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
     }
 
     const b = brief(state);
-    if (!b) {
+    const brokerBrief = contextBrokerBrief(pi);
+    if (!b && !brokerBrief) {
       finalDecision = "defer";
       finalReason = "missing brief context";
       markReviewApplied(state, signature, trigger, finalDecision, finalReason, true);
@@ -993,7 +1009,7 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
       return;
     }
 
-    const rk = hash("rev", trigger, b, delta, String(meta.fileChanged), String(meta.failed), String(meta.isAgentEnd), String(reviewRoute.label), signature);
+    const rk = hash("rev", trigger, b, brokerBrief, delta, String(meta.fileChanged), String(meta.failed), String(meta.isAgentEnd), String(reviewRoute.label), signature);
     const cache = loadCache();
     if (cache[rk]) {
       finalDecision = "defer";
@@ -1011,7 +1027,8 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
         `Delta: ${delta || "(none)"}`,
         `Files: ${meta.fileChanged} Errors: ${meta.failed}`,
         `Route: ${summarizeRoute(reviewRoute)}`,
-        `Brief:\n${b}`,
+        b ? `Brief:\n${b}` : "",
+        brokerBrief ? `Context broker brief:\n${brokerBrief}` : "",
       ].join("\n"), timestamp: new Date().toISOString() },
     ] as any[];
     const completed = await completeWithModelFallback(ctx, config, REVIEW_SYSTEM, msgs, { maxTokens: 400, reasoning: "low" as ThinkingLevel });
@@ -1140,13 +1157,14 @@ export function registerAdvisor(pi: ExtensionAPI): void {
     const prompt = typeof event.prompt === "string" && event.prompt.trim() ? squish(event.prompt, 1000) : "";
     if (prompt) state.lastTask = prompt;
     const briefText = brief(state);
+    const brokerBrief = contextBrokerBrief(pi);
     const intent = prompt ? classifyIntent(prompt) : "";
     const mode = prompt ? classifyMode(prompt) : "";
     const intentTag = intent ? `Intent: ${intent}` : "";
     const modeTag = mode ? `Mode: ${mode}` : "";
     // Enrich preflight text with session context so the binary gate has more signal
-    const enrichedText = [prompt, event.systemPrompt || "", briefText ? `Brief: ${briefText}` : "", intentTag, modeTag].filter(Boolean).join(" ");
-    const routeInput: AdvisorRouteInput = { phase: "preflight", text: enrichedText || prompt || event.systemPrompt || briefText || intentTag || modeTag || "", brief: briefText };
+    const enrichedText = [prompt, event.systemPrompt || "", briefText ? `Brief: ${briefText}` : "", brokerBrief ? `Context broker: ${brokerBrief}` : "", intentTag, modeTag].filter(Boolean).join(" ");
+    const routeInput: AdvisorRouteInput = { phase: "preflight", text: enrichedText || prompt || event.systemPrompt || briefText || brokerBrief || intentTag || modeTag || "", brief: [briefText, brokerBrief].filter(Boolean).join("\n\n") };
 
     // Binary gate model — fast local classifier for continue/escalate decisions
     const gatePrediction = binaryGatePredict(routeInput.text);
@@ -1191,6 +1209,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
         note,
         controlTag,
         briefText ? `Brief (cache-aware):\n${briefText}` : "",
+        brokerBrief ? `Context broker brief (lookup-first):\n${brokerBrief}` : "",
       ].filter(Boolean).join("\n\n"),
     };
   });

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

@@ -93,6 +93,7 @@ describe("advisor two-agent convergence", () => {
   let messageRenderers: MessageRendererMap;
   let sendMessageMock: ReturnType<typeof vi.fn>;
   let completeSimpleMock: ReturnType<typeof vi.fn>;
+  let piMock: any;
   let priorState: string | null = null;
   let priorConfig: string | null = null;
   let priorCache: string | null = null;
@@ -107,6 +108,7 @@ describe("advisor two-agent convergence", () => {
     commands = setup.commands;
     messageRenderers = setup.messageRenderers;
     sendMessageMock = setup.sendMessage;
+    piMock = setup.pi;
 
     mkdirSync(dirname(ADVISOR_STATE_PATH), { recursive: true });
     writeFileSync(ADVISOR_CONFIG_PATH, JSON.stringify({ mode: "auto", review: "light", checkins: "off", checkinIntervalMinutes: 30 }, null, 2), "utf8");
@@ -377,6 +379,21 @@ describe("advisor two-agent convergence", () => {
     );
   });
 
+  it("includes broker briefs in manual advisor context when available", async () => {
+    expect(commands.advisor).toBeTruthy();
+    piMock.__piRogueContextBroker = {
+      renderBrief: () => "## Context Broker\nHot:\n- ctx://session/s/tool_output/abc/ctx-1 summary=\"npm test passed\"",
+    };
+    completeSimpleMock.mockResolvedValue({ content: [{ type: "text", text: "Use the broker handle as evidence." }] });
+
+    await commands.advisor.handler("should we use broker context", ctx);
+
+    const messages = completeSimpleMock.mock.calls.at(-1)?.[1]?.messages;
+    const promptText = JSON.stringify(messages ?? completeSimpleMock.mock.calls.at(-1));
+    expect(promptText).toContain("Context broker brief");
+    expect(promptText).toContain("ctx://session/s/tool_output/abc/ctx-1");
+  });
+
   it("does not re-run advisory review on repeated agent-end material snapshots", async () => {
     const preflight = handlers.before_agent_start;
     const agentEnd = handlers.agent_end;

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

@@ -5,9 +5,10 @@ Beta context broker runtime for Pi-Rogue.
 This package contains the executable in-memory bounded broker implementation:
 
 - `createInMemoryContextBroker()` stores artifacts behind stable `ctx://...` handles.
-- Lookups support handle, session, kind, tag, path, command prefix, branch, and text filters.
+- 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.
-- Pruning enforces per-session record/byte caps, TTL expiry on reads, and pinned-artifact retention.
+- Artifacts are classified as hot/warm/cold on publish; prompt briefs render hot first, warm second, and exclude cold unless explicitly queried.
+- Pruning enforces per-session record/byte caps, tier-specific record/byte caps, TTL expiry on reads, and pinned-artifact retention.
 
 It is intentionally disabled by default in the bundle.
 
@@ -19,7 +20,7 @@ Set `PI_CONTEXT_BROKER_ENABLED=true` before starting Pi with the bundle installe
 PI_CONTEXT_BROKER_ENABLED=true pi
 ```
 
-When enabled, the bundle registers `/context` commands:
+When enabled, the bundle registers a `context_lookup` LLM tool plus `/context` commands:
 
 - `/context status` — enabled state, record/byte counts, pinned counts.
 - `/context brief` — bounded prompt-safe broker brief with handles and summaries.
@@ -29,10 +30,15 @@ When enabled, the bundle registers `/context` commands:
 
 The command includes autocomplete for subcommands and known artifact handles. Exact handle lookup returns clipped payload text; text search returns a smaller clipped excerpt, and truncation is marked explicitly.
 
+Optional durability is available with `PI_CONTEXT_BROKER_DURABLE=true` or `PI_CONTEXT_BROKER_STORE_DIR=/path/to/store`. Durable mode now defaults to SQLite (`artifacts.sqlite`) with an FTS index for text lookup, so exact handles, tier, and pin state survive restarts without replay reconstruction. Set `PI_CONTEXT_BROKER_BACKEND=jsonl` to use the legacy JSONL/blob backend.
+
 ## Session behavior and limits
 
 - On session start/reload, the beta backfills the current Pi session branch from `toolResult` and prompt-visible `bashExecution` entries.
 - Backfill is idempotent by session entry id, skips malformed entries instead of failing the session, and honors Pi's `excludeFromContext` bash entries.
-- The current implementation remains in-memory. Restarting Pi loses broker state until the current branch is backfilled again.
-- Prompt integration injects only a bounded broker brief and lookup guidance. It does not yet rewrite existing raw tool-result messages out of Pi's transcript context; that deeper prompt-load reduction remains a follow-up.
-- Rollback is immediate: unset `PI_CONTEXT_BROKER_ENABLED` and `/reload` or restart Pi.
+- 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.
+- The `context` hook rewrites large `toolResult` and prompt-visible `bashExecution` payloads in the LLM-bound message copy to broker handles and summaries, reducing prompt load while preserving exact `/context lookup` rehydration.
+- Pi `excludeFromContext` bash entries are not backfilled or rewritten into broker prompts.
+- Basic secret redaction runs before broker storage and display for common token/password/API-key patterns.
+- Rollback is immediate: unset `PI_CONTEXT_BROKER_ENABLED` and `/reload` or restart Pi. Disable durable writes by unsetting `PI_CONTEXT_BROKER_DURABLE` and `PI_CONTEXT_BROKER_STORE_DIR`.

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

@@ -15,10 +15,13 @@
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
-    "./extension": "./src/extension.ts"
+    "./extension": "./src/extension.ts",
+    "./file": "./src/file.ts",
+    "./sqlite": "./src/sqlite.ts"
   },
   "dependencies": {
-    "@fiale-plus/pi-core": "^0.1.0"
+    "@fiale-plus/pi-core": "^0.1.0",
+    "typebox": "^1.1.24"
   },
   "files": [
     "src",

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

@@ -1,9 +1,13 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { registerContextBrokerBeta, shouldEnableContextBrokerBeta } from "./extension.js";
 
 function createPiMock() {
   const handlers = new Map<string, any[]>();
   const commands = new Map<string, any>();
+  const tools = new Map<string, any>();
   const pi: any = {
     on(name: string, handler: any) {
       handlers.set(name, [...(handlers.get(name) ?? []), handler]);
@@ -11,8 +15,11 @@ function createPiMock() {
     registerCommand(name: string, options: any) {
       commands.set(name, options);
     },
+    registerTool(tool: any) {
+      tools.set(tool.name, tool);
+    },
   };
-  return { pi, handlers, commands };
+  return { pi, handlers, commands, tools };
 }
 
 function createCtx(entries: any[] = []) {
@@ -61,12 +68,13 @@ describe("context broker beta enablement", () => {
     expect(shouldEnableContextBrokerBeta()).toBe(true);
   });
 
-  it("registers /context with command completions", () => {
-    const { pi, commands } = createPiMock();
+  it("registers /context with command completions and the context_lookup tool", () => {
+    const { pi, commands, tools } = createPiMock();
     registerContextBrokerBeta(pi);
 
     const command = commands.get("context");
     expect(command).toBeTruthy();
+    expect(tools.has("context_lookup")).toBe(true);
     expect(command.getArgumentCompletions("")?.map((item: any) => item.value.trim())).toEqual([
       "status",
       "brief",
@@ -196,6 +204,257 @@ describe("context broker beta enablement", () => {
     expect(Buffer.byteLength(payload, "utf8")).toBeLessThanOrEqual(50);
   });
 
+  it("context_lookup tool dereferences handles for exact evidence", async () => {
+    const { pi, handlers, commands, tools } = createPiMock();
+    registerContextBrokerBeta(pi, { lookupBytes: 500 });
+    const { ctx } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "call-tool-lookup",
+      toolName: "bash",
+      input: { command: "echo evidence" },
+      content: [{ type: "text", text: "exact evidence payload" }],
+      isError: false,
+    }, ctx);
+    const handle = commands.get("context").getArgumentCompletions("lookup ")?.[0].value.replace(/^lookup /, "");
+    const result = await tools.get("context_lookup").execute("lookup-call", { handle }, undefined, undefined, ctx);
+
+    expect(result.content[0].text).toContain(handle);
+    expect(result.content[0].text).toContain("exact evidence payload");
+  });
+
+  it("context_lookup refuses empty unfocused payload-dumping calls", async () => {
+    const { pi, handlers, tools } = createPiMock();
+    registerContextBrokerBeta(pi, { lookupBytes: 500 });
+    const { ctx } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "call-empty-lookup",
+      toolName: "bash",
+      input: { command: "echo hidden" },
+      content: [{ type: "text", text: "payload must not dump" }],
+      isError: false,
+    }, ctx);
+
+    const result = await tools.get("context_lookup").execute("lookup-call", {}, undefined, undefined, ctx);
+
+    expect(result.content[0].text).toContain("requires a focused filter");
+    expect(result.content[0].text).not.toContain("payload must not dump");
+  });
+
+  it("rewrites large historical tool results in context to live broker handles", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 40, lookupBytes: 500 });
+    const { ctx, notifications } = createCtx();
+    const raw = "RAW_TOOL_OUTPUT_" + "x".repeat(100);
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    const result = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [
+        { role: "assistant", content: [{ type: "toolCall", id: "call-large", name: "bash", arguments: { command: "printf raw" } }] },
+        { role: "toolResult", toolCallId: "call-large", toolName: "bash", content: [{ type: "text", text: raw }], isError: false, timestamp: 1 },
+      ],
+    }, ctx);
+
+    const text = result.messages[1].content[0].text;
+    const handle = text.match(/ctx:\/\/\S+/)?.[0];
+    expect(text).toContain("Context broker artifact: ctx://");
+    expect(text).toContain("Raw payload omitted from prompt");
+    expect(text).not.toContain(raw);
+
+    await commands.get("context").handler(`lookup ${handle}`, ctx);
+    expect(notifications.at(-1)?.message).toContain("RAW_TOOL_OUTPUT_");
+  });
+
+  it("leaves small tool results and excluded bash outputs unchanged in context", async () => {
+    const { pi, handlers } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 40 });
+    const { ctx } = createCtx();
+    const secret = "SECRET_TOKEN=" + "z".repeat(80);
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    const result = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [
+        { role: "toolResult", toolCallId: "small", toolName: "read", content: [{ type: "text", text: "small" }], isError: false, timestamp: 1 },
+        { role: "bashExecution", command: "echo secret", output: secret, exitCode: 0, cancelled: false, truncated: false, excludeFromContext: true, timestamp: 2 },
+      ],
+    }, ctx);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("does not collapse repeated bash rewrites for the same command and timestamp", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 20 });
+    const { ctx, notifications } = createCtx();
+    const firstRaw = "FIRST_RAW_" + "x".repeat(80);
+    const secondRaw = "SECOND_RAW_" + "y".repeat(80);
+    const sameTimestamp = Date.now();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    const result = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [
+        { role: "bashExecution", command: "npm test", output: firstRaw, exitCode: 0, cancelled: false, truncated: false, timestamp: sameTimestamp },
+        { role: "bashExecution", command: "npm test", output: secondRaw, exitCode: 0, cancelled: false, truncated: false, timestamp: sameTimestamp },
+      ],
+    }, ctx);
+
+    const firstHandle = result.messages[0].output.match(/ctx:\/\/\S+/)?.[0];
+    const secondHandle = result.messages[1].output.match(/ctx:\/\/\S+/)?.[0];
+    expect(firstHandle).toBeTruthy();
+    expect(secondHandle).toBeTruthy();
+    expect(firstHandle).not.toBe(secondHandle);
+
+    await commands.get("context").handler(`lookup ${secondHandle}`, ctx);
+    expect(notifications.at(-1)?.message).toContain("SECOND_RAW_");
+    expect(notifications.at(-1)?.message).not.toContain("FIRST_RAW_");
+  });
+
+  it("does not emit dead handles when one context pass exceeds retention caps", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { rewriteThresholdBytes: 1, maxRecords: 2, lookupBytes: 500 });
+    const { ctx, notifications } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    const result = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [0, 1, 2].map((index) => ({
+        role: "toolResult",
+        toolCallId: `call-${index}`,
+        toolName: "bash",
+        content: [{ type: "text", text: `RAW_${index}_` + "x".repeat(20) }],
+        isError: false,
+        timestamp: Date.now() + index,
+      })),
+    }, ctx);
+
+    const handles = result.messages
+      .map((message: any) => String(message.content?.[0]?.text ?? "").match(/ctx:\/\/\S+/)?.[0])
+      .filter(Boolean);
+    expect(handles.length).toBeLessThanOrEqual(2);
+    expect(result.messages.some((message: any) => String(message.content?.[0]?.text ?? "").includes("RAW_0_"))).toBe(true);
+
+    for (const handle of handles) {
+      await commands.get("context").handler(`lookup ${handle}`, ctx);
+      expect(notifications.at(-1)?.message).not.toContain("No context artifacts matched");
+      expect(notifications.at(-1)?.message).toContain("RAW_");
+    }
+  });
+
+  it("redacts secrets before storing and displaying payloads", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi);
+    const { ctx, notifications } = createCtx();
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "secret-call",
+      toolName: "bash",
+      input: { command: "echo token=abc123456789", password: "hunter2" },
+      content: [{ type: "text", text: "OPENAI_API_KEY=sk-abcdefghijklmnop" }],
+      details: { nested: { apiKey: "object-secret-value" } },
+      isError: false,
+    }, ctx);
+
+    const lookupCompletion = commands.get("context").getArgumentCompletions("lookup ")?.[0];
+    await commands.get("context").handler(lookupCompletion.value, ctx);
+
+    expect(notifications.at(-1)?.message).not.toContain("abc123456789");
+    expect(notifications.at(-1)?.message).not.toContain("hunter2");
+    expect(notifications.at(-1)?.message).not.toContain("object-secret-value");
+    expect(notifications.at(-1)?.message).not.toContain("sk-abcdefghijklmnop");
+    expect(notifications.at(-1)?.message).toContain("[REDACTED");
+  });
+
+  it("re-publishes stale source handles instead of restoring raw prompt payloads", async () => {
+    const { pi, handlers, commands } = createPiMock();
+    registerContextBrokerBeta(pi, { maxRecords: 1, rewriteThresholdBytes: 20 });
+    const { ctx } = createCtx();
+    const raw = "STALE_RAW_PAYLOAD_" + "x".repeat(100);
+
+    await runHandlers(handlers, "session_start", { type: "session_start" }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "stale-call",
+      toolName: "bash",
+      input: { command: "echo stale" },
+      content: [{ type: "text", text: raw }],
+      isError: false,
+      timestamp: 1,
+    }, ctx);
+    await runHandlers(handlers, "tool_result", {
+      type: "tool_result",
+      toolCallId: "newer-call",
+      toolName: "bash",
+      input: { command: "echo newer" },
+      content: [{ type: "text", text: "newer" }],
+      isError: false,
+      timestamp: 2,
+    }, ctx);
+    await commands.get("context").handler("prune", ctx);
+
+    const result = await handlers.get("context")?.[0]({
+      type: "context",
+      messages: [{ role: "toolResult", toolCallId: "stale-call", toolName: "bash", content: [{ type: "text", text: raw }], isError: false, timestamp: 1 }],
+    }, ctx);
+
+    expect(result.messages[0].content[0].text).toContain("Context broker artifact: ctx://");
+    expect(result.messages[0].content[0].text).not.toContain(raw);
+  });
+
+  it("can reload artifacts and pin state from durable blob storage", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-broker-test-"));
+    try {
+      const first = createPiMock();
+      registerContextBrokerBeta(first.pi, { durable: true, storeDir: dir });
+      const { ctx } = createCtx();
+      await runHandlers(first.handlers, "session_start", { type: "session_start" }, ctx);
+      await runHandlers(first.handlers, "tool_result", {
+        type: "tool_result",
+        toolCallId: "durable-call",
+        toolName: "bash",
+        input: { command: "echo durable" },
+        content: [{ type: "text", text: "durable payload" }],
+        isError: false,
+        timestamp: 100,
+      }, ctx);
+      const handle = first.commands.get("context").getArgumentCompletions("lookup ")?.[0].value.replace(/^lookup /, "");
+      await first.commands.get("context").handler(`pin ${handle}`, ctx);
+
+      const second = createPiMock();
+      const secondRun = createCtx();
+      registerContextBrokerBeta(second.pi, { durable: true, storeDir: dir });
+      await runHandlers(second.handlers, "session_start", { type: "session_start" }, secondRun.ctx);
+      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);
+
+      const third = createPiMock();
+      const thirdRun = createCtx();
+      registerContextBrokerBeta(third.pi, { durable: true, storeDir: dir });
+      await runHandlers(third.handlers, "session_start", { type: "session_start" }, thirdRun.ctx);
+      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(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");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("injects a bounded broker brief without raw payload text", async () => {
     const { pi, handlers } = createPiMock();
     registerContextBrokerBeta(pi, { briefBytes: 220 });