@fiale-plus/pi-rogue 0.2.2 → 0.2.3

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

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

@@ -40,6 +40,43 @@ describe("createSqliteContextBroker", () => {
     }
   });
 
+  it("persists age-based tier cooling without deleting artifacts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+      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 pinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "pinned", summary: "pinned", tier: "hot", pinned: true, createdAt: now - 300 });
+
+      broker.prune(now);
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+
+      expect(broker.lookup({ handle: oldHot.handle })[0]?.tier).toBe("cold");
+      expect(broker.lookup({ handle: pinned.handle })[0]?.tier).toBe("hot");
+      expect(broker.renderBrief({ sessionId: "s" })).not.toContain(oldHot.handle);
+      expect(broker.renderBrief({ sessionId: "s" })).toContain(pinned.handle);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("cools protected new artifacts before enforcing durable tier caps", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const now = Date.now();
+      const broker = createSqliteContextBroker({ path: join(dir, "artifacts.sqlite"), defaultTtlMs: 0, maxRecords: 10, hotMaxRecords: 1, hotToWarmMs: 10_000, warmToColdMs: 20_000 });
+      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");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("dedupes replayed source artifacts so durable handles survive caps", () => {
     const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
     try {

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

@@ -29,6 +29,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 defaultStoreDir(): string {
   return join(homedir(), ".pi", "agent", "fiale-plus", "context-broker");
 }
@@ -226,6 +230,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     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));
 
@@ -241,6 +247,31 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     db.prepare("DELETE FROM artifacts WHERE id = ?").run(id);
   }
 
+  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 {
+    const rows = db.prepare("SELECT id, createdAt, tier, baseTier, pinned FROM artifacts WHERE pinned = 0").all();
+    const update = db.prepare("UPDATE artifacts SET tier = ?, updatedAt = ? WHERE id = ?");
+    for (const row of rows) {
+      const artifact = {
+        id: String(row.id),
+        createdAt: Number(row.createdAt),
+        tier: String(row.tier) as ContextArtifactTier,
+        baseTier: String(row.baseTier ?? row.tier) as ContextArtifactTier,
+        pinned: Boolean(row.pinned),
+      };
+      const nextTier = cooledTier(artifact as ContextArtifact & { baseTier: ContextArtifactTier }, now);
+      if (artifact.tier !== nextTier) update.run(nextTier, now, artifact.id);
+    }
+  }
+
   function currentStatus(): ContextBrokerStatus {
     const row = db.prepare(`
       SELECT
@@ -269,6 +300,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       coldBytes: Number(row.coldBytes ?? 0),
       maxRecords,
       maxBytes,
+      globalMaxRecords,
+      globalMaxBytes,
     };
   }
 
@@ -329,6 +362,7 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function prune(now = Date.now(), protectedIds = new Set<string>()): ContextBrokerStatus {
     dropExpired(now, protectedIds);
+    applyCooling(now, protectedIds);
     const sessions = db.prepare("SELECT DISTINCT sessionId FROM artifacts").all().map((row) => String(row.sessionId));
     for (const sessionId of sessions) {
       for (const tier of ["cold", "warm", "hot"] as ContextArtifactTier[]) {
@@ -356,11 +390,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function status(): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     return currentStatus();
   }
 
   function purge(options: ContextPurgeOptions = {}): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     const keepPinned = options.keepPinned ?? true;
     const clauses: string[] = [];
     const params: Array<string | number> = [];
@@ -468,12 +504,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       throw error;
     }
 
-    prune(now, new Set([artifact.id]));
-    return artifact;
+    prune(Date.now(), new Set([artifact.id]));
+    return lookup({ id: artifact.id })[0] ?? artifact;
   }
 
   function lookup(query: ContextLookupQuery = {}): ContextArtifact[] {
     dropExpired();
+    applyCooling();
     const storedCount = Number(db.prepare("SELECT COUNT(*) AS count FROM artifacts").get()?.count ?? 1) || 1;
     const limit = Math.max(1, Math.floor(query.limit ?? storedCount));
     const clauses: string[] = [];

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

@@ -25,6 +25,8 @@ npm run router:shadow -- --checkpoint-file .pi/router/checkpoints.jsonl --ledger
 
 Router v1 is still observe-only. It adds outcome skeletons, stronger diff/error fingerprints, teacher-label request export, binary gate dataset export, and subagent-aware telemetry schemas. It does not switch models, spawn agents, or promote policies automatically.
 
+Live config is repo-global at `.pi/router/config.json`, while mutable live state and route ledgers are isolated per Pi session under `.pi/router/sessions/<session-key>/state.json` and `events.jsonl`.
+
 - Diff telemetry stores counts and hashes from `git diff`, not raw patches. Offline rebuilds remain deterministic by default; use `--workspace-diff` only with one current live session/worktree snapshot.
 - Error fingerprints normalize paths, line numbers, timestamps, UUIDs, ports, and object ids before hashing.
 - `router:teacher-requests` writes local JSONL requests for an explicit teacher model; imported teacher decisions are still required before labels become training truth.

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

@@ -1,6 +1,7 @@
 import { closeSync, mkdirSync, openSync, writeSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { hashMaybe, hashText, normalizeText } from "./hash.js";
+import { routerSessionKey } from "./config.js";
 import { diffChurnScore, EMPTY_DIFF_STATS, readGitDiffStats } from "./git-features.js";
 import { touchedFileHashesFromEvent } from "./progress.js";
 import { readPiSession, sessionIdFromPath, streamPiSessionEvents, type PiSession, type RawPiSessionEvent } from "./session-reader.js";
@@ -321,7 +322,14 @@ export async function writeSessionCheckpointsJsonl(sessionPaths: string[], outpu
     ? (() => {
       const session = readPiSession(sessionPaths[0]);
       const routerDir = session.cwd ? resolve(session.cwd, ".pi", "router") : undefined;
-      const routerArtifacts = routerDir ? [resolve(routerDir, "config.json"), resolve(routerDir, "state.json"), resolve(routerDir, "events.jsonl")] : [];
+      const routerSessionDir = routerDir ? resolve(routerDir, "sessions", routerSessionKey(session.path)) : undefined;
+      const routerArtifacts = routerDir ? [
+        routerDir,
+        resolve(routerDir, "config.json"),
+        resolve(routerDir, "state.json"),
+        resolve(routerDir, "events.jsonl"),
+        ...(routerSessionDir ? [resolve(routerSessionDir, "state.json"), resolve(routerSessionDir, "events.jsonl")] : []),
+      ] : [];
       return applyWorkspaceDiffToLatest(buildCheckpoints(session), session.cwd, [session.path, resolved, ...routerArtifacts]);
     })()
     : null;

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

@@ -1,20 +1,21 @@
-import { mkdtempSync, readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { routerArgumentCompletions } from "./completions.js";
-import { activeProfile, cycleRouterProfile, ensureRouterConfig, loadRouterConfig, routerConfigPath, setRouterProfile } from "./config.js";
+import { activeProfile, cycleRouterProfile, ensureRouterConfig, loadRouterConfig, routerConfigPath, routerEventsPath, routerSessionDir, routerStatePath, saveRouterConfig, setRouterProfile } from "./config.js";
 import { registerRouter } from "./extension.js";
 import { decideRoute } from "./decision.js";
-import { summarizeRouterDecision } from "./observe.js";
+import { observeRouterTurn, summarizeRouterDecision } from "./observe.js";
 import type { RouterCheckpoint } from "./types.js";
 
-function ctxMock() {
+function ctxMock(sessionPath?: string) {
   const cwd = mkdtempSync(join(tmpdir(), "pi-router-ext-"));
   const notifications: Array<{ text: string; level: string }> = [];
   return {
     cwd,
     notifications,
+    sessionManager: sessionPath ? { getSessionFile: () => sessionPath } : undefined,
     ui: {
       notify(text: string, level: string) {
         notifications.push({ text, level });
@@ -23,6 +24,15 @@ function ctxMock() {
   };
 }
 
+function writeSessionFixture(dir: string, name: string): string {
+  const path = join(dir, name);
+  writeFileSync(path, [
+    JSON.stringify({ type: "session", id: name, cwd: dir }),
+    JSON.stringify({ type: "message", id: `${name}-user`, message: { role: "user", content: [{ type: "text", text: "please implement a small fix" }] } }),
+  ].join("\n") + "\n");
+  return path;
+}
+
 function piMock() {
   const commands = new Map<string, any>();
   const shortcuts = new Map<string, any>();
@@ -98,6 +108,28 @@ describe("router config profiles", () => {
     expect(routerArgumentCompletions("")?.map((item) => item.value)).toEqual(expect.arrayContaining(["on", "off", "status", "profile"]));
     expect(routerArgumentCompletions("profile s")?.map((item) => item.value)).toEqual(["profile spark-smart"]);
   });
+
+  it("keeps config repo-global while state and live events are session-scoped", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pi-router-sessions-"));
+    const firstSession = writeSessionFixture(cwd, "session-a.jsonl");
+    const secondSession = writeSessionFixture(cwd, "session-b.jsonl");
+    const firstCtx = { ...ctxMock(firstSession), cwd };
+    const secondCtx = { ...ctxMock(secondSession), cwd };
+    saveRouterConfig(firstCtx, { ...loadRouterConfig(firstCtx), enabled: true, print: "all" });
+
+    expect(routerConfigPath(firstCtx)).toBe(routerConfigPath(secondCtx));
+    expect(routerStatePath(firstCtx, firstSession)).not.toBe(routerStatePath(secondCtx, secondSession));
+    expect(routerEventsPath(firstCtx, firstSession)).not.toBe(routerEventsPath(secondCtx, secondSession));
+    expect(routerSessionDir(firstCtx, firstSession)).toContain("session-a");
+
+    await observeRouterTurn(firstCtx);
+    await observeRouterTurn(secondCtx);
+
+    expect(existsSync(routerStatePath(firstCtx, firstSession))).toBe(true);
+    expect(existsSync(routerStatePath(secondCtx, secondSession))).toBe(true);
+    expect(readFileSync(routerEventsPath(firstCtx, firstSession), "utf8").trim().split("\n")).toHaveLength(1);
+    expect(readFileSync(routerEventsPath(secondCtx, secondSession), "utf8").trim().split("\n")).toHaveLength(1);
+  });
 });
 
 describe("router extension", () => {

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { hashText } from "./hash.js";
 
 export type RouterMode = "observe";
 export type RouterPrintMode = "all" | "mismatch_only" | "off";
@@ -83,12 +84,36 @@ export function routerConfigPath(ctx: any): string {
   return join(routerDir(ctx), "config.json");
 }
 
-export function routerStatePath(ctx: any): string {
-  return join(routerDir(ctx), "state.json");
+function sessionPathFromCtx(ctx: any): string | undefined {
+  const value = ctx?.sessionManager?.getSessionFile?.();
+  return value ? String(value) : undefined;
 }
 
-export function routerEventsPath(ctx: any): string {
-  return join(routerDir(ctx), "events.jsonl");
+function safeSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96) || "session";
+}
+
+export function routerSessionKey(sessionPath: string): string {
+  const resolved = resolve(sessionPath);
+  const name = safeSegment(basename(resolved).replace(/\.jsonl$/i, ""));
+  return `${name}-${hashText(resolved).slice(0, 8)}`;
+}
+
+export function routerSessionsDir(ctx: any): string {
+  return join(routerDir(ctx), "sessions");
+}
+
+export function routerSessionDir(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  const key = sessionPath ? routerSessionKey(sessionPath) : "no-session";
+  return join(routerSessionsDir(ctx), key);
+}
+
+export function routerStatePath(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  return join(routerSessionDir(ctx, sessionPath), "state.json");
+}
+
+export function routerEventsPath(ctx: any, sessionPath = sessionPathFromCtx(ctx)): string {
+  return join(routerSessionDir(ctx, sessionPath), "events.jsonl");
 }
 
 function readJson<T>(path: string, fallback: T): T {
@@ -135,12 +160,12 @@ export function ensureRouterConfig(ctx: any): RouterConfig {
   return config;
 }
 
-export function loadRouterState(ctx: any): RouterState {
-  return readJson<RouterState>(routerStatePath(ctx), {});
+export function loadRouterState(ctx: any, sessionPath?: string): RouterState {
+  return readJson<RouterState>(routerStatePath(ctx, sessionPath), {});
 }
 
-export function saveRouterState(ctx: any, state: RouterState): void {
-  const path = routerStatePath(ctx);
+export function saveRouterState(ctx: any, state: RouterState, sessionPath?: string): void {
+  const path = routerStatePath(ctx, sessionPath);
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
 }

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

@@ -16,7 +16,16 @@ function git(cwd: string, args: string[]): string {
   return execFileSync("git", args, { cwd: resolve(cwd), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
 }
 
-function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> {
+interface GitExcludes {
+  files: Set<string>;
+  prefixes: string[];
+}
+
+function isExcluded(file: string, excludes: GitExcludes): boolean {
+  return excludes.files.has(file) || excludes.prefixes.some((prefix) => file.startsWith(prefix));
+}
+
+function parseNumstat(output: string, excludes: GitExcludes = { files: new Set(), prefixes: [] }): Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> {
   let rows = 0;
   let linesAdded = 0;
   let linesDeleted = 0;
@@ -26,7 +35,7 @@ function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<Di
     if (!line.trim()) continue;
     const [added, deleted, ...fileParts] = line.split("\t");
     const file = fileParts.join("\t").trim();
-    if (file && excludeFiles.has(file)) continue;
+    if (file && isExcluded(file, excludes)) continue;
     rows++;
     if (file) fileHashes.add(hashText(file));
     const add = Number(added);
@@ -38,13 +47,13 @@ function parseNumstat(output: string, excludeFiles = new Set<string>()): Pick<Di
   return { filesChanged: fileHashes.size || rows, linesAdded, linesDeleted, totalLines: linesAdded + linesDeleted, fileHashes: [...fileHashes].sort() };
 }
 
-function untrackedFiles(cwd: string, excludeFiles = new Set<string>()): { hashes: string[]; linesAdded: number } {
+function untrackedFiles(cwd: string, excludes: GitExcludes = { files: new Set(), prefixes: [] }): { hashes: string[]; linesAdded: number } {
   try {
     let linesAdded = 0;
     const hashes: string[] = [];
     for (const raw of git(cwd, ["ls-files", "--others", "--exclude-standard"]).split("\n")) {
       const file = raw.trim();
-      if (!file || excludeFiles.has(file)) continue;
+      if (!file || isExcluded(file, excludes)) continue;
       hashes.push(hashText(file));
       try {
         const path = resolve(cwd, file);
@@ -63,39 +72,45 @@ function untrackedFiles(cwd: string, excludeFiles = new Set<string>()): { hashes
   }
 }
 
-function excludeFilesFromPaths(root: string, paths: string[] | undefined): Set<string> {
+function excludeFilesFromPaths(root: string, paths: string[] | undefined): GitExcludes {
   const files = new Set<string>();
+  const prefixes: string[] = [];
   const realRoot = realpathSync(root);
   for (const path of paths ?? []) {
     const absolute = isAbsolute(path) ? path : resolve(root, path);
     let rel = relative(root, absolute);
+    let isDirectory = false;
     try {
-      rel = relative(realRoot, realpathSync(absolute));
+      const realAbsolute = realpathSync(absolute);
+      rel = relative(realRoot, realAbsolute);
+      isDirectory = statSync(realAbsolute).isDirectory();
     } catch {
       // Output paths may not exist yet; fall back to lexical repo-relative path.
     }
-    if (rel && !rel.startsWith("..")) files.add(rel);
+    if (!rel || rel.startsWith("..")) continue;
+    if (isDirectory) prefixes.push(rel.endsWith("/") ? rel : `${rel}/`);
+    else files.add(rel);
   }
-  return files;
+  return { files, prefixes };
 }
 
 export function readGitDiffStats(cwd?: string, options: { excludePaths?: string[] } = {}): DiffStats {
   if (!cwd) return EMPTY_DIFF_STATS;
   try {
     const root = git(cwd, ["rev-parse", "--show-toplevel"]).trim() || cwd;
-    const excludeFiles = excludeFilesFromPaths(root, options.excludePaths);
-    const untracked = untrackedFiles(root, excludeFiles);
+    const excludes = excludeFilesFromPaths(root, options.excludePaths);
+    const untracked = untrackedFiles(root, excludes);
     let parsed: Pick<DiffStats, "filesChanged" | "linesAdded" | "linesDeleted" | "totalLines" | "fileHashes"> = EMPTY_DIFF_STATS;
     let shortStat = "";
     try {
-      parsed = parseNumstat(git(root, ["diff", "--numstat", "HEAD"]), excludeFiles);
+      parsed = parseNumstat(git(root, ["diff", "--numstat", "HEAD"]), excludes);
       shortStat = git(root, ["diff", "--shortstat", "HEAD"]).trim();
     } catch {
       // Repositories without an initial commit have no HEAD; include staged files plus untracked counts.
       try {
         const cachedNumstat = git(root, ["diff", "--cached", "--numstat"]);
         const worktreeNumstat = git(root, ["diff", "--numstat"]);
-        parsed = parseNumstat(`${cachedNumstat}\n${worktreeNumstat}`, excludeFiles);
+        parsed = parseNumstat(`${cachedNumstat}\n${worktreeNumstat}`, excludes);
         shortStat = `${git(root, ["diff", "--cached", "--shortstat"]).trim()} ${git(root, ["diff", "--shortstat"]).trim()}`.trim();
       } catch {
         // Still report untracked-file counts/hashes below.

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

@@ -6,6 +6,7 @@ import {
   loadRouterConfig,
   loadRouterState,
   routerConfigPath,
+  routerDir,
   routerEventsPath,
   routerStatePath,
   saveRouterState,
@@ -100,18 +101,24 @@ export async function observeRouterTurn(ctx: any): Promise<RouterObserveSummary
   if (!sessionPath) return null;
   const checkpoint = await latestCheckpointFromSession(String(sessionPath));
   if (!checkpoint) return null;
-  const state = loadRouterState(ctx);
+  const state = loadRouterState(ctx, String(sessionPath));
   if (state.lastObservedCheckpointId === checkpoint.checkpointId) return null;
 
-  const liveCheckpoint = checkpointWithDiffStats(checkpoint, ctx?.cwd, [sessionPath, routerConfigPath(ctx), routerStatePath(ctx), routerEventsPath(ctx)]);
+  const liveCheckpoint = checkpointWithDiffStats(checkpoint, ctx?.cwd, [
+    String(sessionPath),
+    routerConfigPath(ctx),
+    routerDir(ctx),
+    routerStatePath(ctx, String(sessionPath)),
+    routerEventsPath(ctx, String(sessionPath)),
+  ]);
   const decision = decideRoute(liveCheckpoint);
   const summary = summarizeRouterDecision(liveCheckpoint, decision, config);
-  appendRouteEvent(routerEventsPath(ctx), buildRouteEvent(liveCheckpoint, decision));
+  appendRouteEvent(routerEventsPath(ctx, String(sessionPath)), buildRouteEvent(liveCheckpoint, decision));
   saveRouterState(ctx, {
     lastObservedCheckpointId: checkpoint.checkpointId,
     lastDecisionAction: decision.action,
     lastSummary: summary.text,
-  });
+  }, String(sessionPath));
 
   if (config.print === "mismatch_only" && summary.match !== false) return summary;
   ctx.ui?.notify?.(summary.text, summary.match === false ? "warning" : "info");

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

@@ -91,14 +91,18 @@ describe("router v1 outcome and feature telemetry", () => {
     writeFileSync(join(repo, "new-file.txt"), "secret-ish content\n");
 
     const stats = readGitDiffStats(repo);
+    execFileSync("mkdir", ["-p", ".pi/router/sessions/other"], { cwd: repo });
+    writeFileSync(join(repo, ".pi/router/sessions/other/events.jsonl"), "{}\n");
     const excluded = readGitDiffStats(repo, { excludePaths: [join(repo, "new-file.txt")] });
+    const excludedRouterDir = readGitDiffStats(repo, { excludePaths: [join(repo, ".pi/router")] });
 
     expect(stats.filesChanged).toBeGreaterThanOrEqual(2);
     expect(stats.linesAdded).toBeGreaterThanOrEqual(1);
     expect(stats.fileHashes).toHaveLength(stats.filesChanged);
     expect(JSON.stringify(stats)).not.toContain("tracked.txt");
     expect(JSON.stringify(stats)).not.toContain("new-file.txt");
-    expect(excluded.filesChanged).toBe(1);
+    expect(excluded.filesChanged).toBe(2);
+    expect(excludedRouterDir.filesChanged).toBe(2);
   });
 
   it("reads untracked files from repo root when launched in a subdirectory", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Public Pi-Rogue package for bundled advisor, orchestration, and context broker logic.",
   "type": "module",
   "license": "MIT",