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

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

@@ -5,6 +5,7 @@ import type {
   ContextArtifact,
   ContextArtifactInput,
   ContextArtifactKind,
+  ContextArtifactTier,
   ContextBrokerOptions,
   ContextBrokerStatus,
   ContextLookupQuery,
@@ -15,6 +16,7 @@ export type {
   ContextArtifact,
   ContextArtifactInput,
   ContextArtifactKind,
+  ContextArtifactTier,
   ContextBrokerOptions,
   ContextBrokerStatus,
   ContextLookupQuery,
@@ -25,6 +27,8 @@ const DEFAULT_MAX_BYTES = 128 * 1024 * 1024;
 const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const DEFAULT_SUMMARY_BYTES = 320;
 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 normalizeList(values: string[] | undefined): string[] {
   return [...new Set((values ?? []).map((value) => String(value || "").trim()).filter(Boolean))];
@@ -74,12 +78,25 @@ function summarizeArtifact(summary: string | undefined, kind: ContextArtifactKin
   return truncateUtf8(`[${kind} payload stored externally; ${bytes} bytes; sha256=${sha256.slice(0, 16)}]`, maxBytes);
 }
 
+function classifyBaseTier(input: ContextArtifactInput, tags: string[]): ContextArtifactTier {
+  if (input.tier) return input.tier;
+  const normalizedTags = tags.map((tag) => tag.toLowerCase());
+  if (normalizedTags.includes("hot")) return "hot";
+  if (normalizedTags.includes("warm")) return "warm";
+  if (normalizedTags.includes("cold")) return "cold";
+  if (normalizedTags.some((tag) => tag === "error" || tag === "failed" || tag === "failure")) return "hot";
+  if (normalizedTags.some((tag) => tag === "archive" || tag === "historical" || tag === "completed")) return "cold";
+  if (input.kind === "advisor_brief" || input.kind === "memory_note") return "hot";
+  return "warm";
+}
+
 function artifactMatches(artifact: ContextArtifact, query: ContextLookupQuery): boolean {
   if (query.id && artifact.id !== query.id) return false;
   if (query.handle && artifact.handle !== query.handle) return false;
   if (query.sessionId && artifact.sessionId !== query.sessionId) return false;
   if (query.kind && artifact.kind !== query.kind) return false;
   if (query.branch && artifact.branch !== query.branch) return false;
+  if (query.tier && artifact.tier !== query.tier) return false;
   if (query.tag && !artifact.tags.includes(query.tag)) return false;
   if (query.path) {
     const queryPath = query.path.replace(/\/$/, "");
@@ -98,23 +115,55 @@ function artifactMatches(artifact: ContextArtifact, query: ContextLookupQuery):
   return true;
 }
 
+function tierLine(artifact: ContextArtifact): string {
+  const pin = artifact.pinned ? " pinned" : "";
+  const path = artifact.paths.length ? ` paths=${artifact.paths.slice(0, 3).join(",")}` : "";
+  const tags = artifact.tags.length ? ` tags=${artifact.tags.slice(0, 3).join(",")}` : "";
+  return `- ${artifact.handle} tier=${artifact.tier} kind=${artifact.kind}${pin}${path}${tags} summary="${artifact.summary}"`;
+}
+
 export function createInMemoryContextBroker(options: ContextBrokerOptions = {}): BoundedContextBroker {
   const maxRecords = Math.max(1, Math.floor(options.maxRecords ?? DEFAULT_MAX_RECORDS));
   const maxBytes = Math.max(1, Math.floor(options.maxBytes ?? DEFAULT_MAX_BYTES));
   const defaultTtlMs = Math.max(0, Math.floor(options.defaultTtlMs ?? DEFAULT_TTL_MS));
+  const tierTtlMs: Record<ContextArtifactTier, number> = {
+    hot: Math.max(0, Math.floor(options.hotTtlMs ?? defaultTtlMs)),
+    warm: Math.max(0, Math.floor(options.warmTtlMs ?? defaultTtlMs)),
+    cold: Math.max(0, Math.floor(options.coldTtlMs ?? defaultTtlMs)),
+  };
+  const tierMaxRecords: Record<ContextArtifactTier, number> = {
+    hot: Math.max(1, Math.floor(options.hotMaxRecords ?? maxRecords)),
+    warm: Math.max(1, Math.floor(options.warmMaxRecords ?? maxRecords)),
+    cold: Math.max(1, Math.floor(options.coldMaxRecords ?? maxRecords)),
+  };
+  const tierMaxBytes: Record<ContextArtifactTier, number> = {
+    hot: Math.max(1, Math.floor(options.hotMaxBytes ?? maxBytes)),
+    warm: Math.max(1, Math.floor(options.warmMaxBytes ?? maxBytes)),
+    cold: Math.max(1, Math.floor(options.coldMaxBytes ?? maxBytes)),
+  };
   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 }> = [];
+  let artifacts: Array<ContextArtifact & { sequence: number; baseTier: ContextArtifactTier }> = [];
   let sequence = 0;
 
   function currentStatus(): ContextBrokerStatus {
     const bytes = artifacts.reduce((sum, artifact) => sum + artifact.bytes, 0);
     const pinned = artifacts.filter((artifact) => artifact.pinned);
+    const byTier = (tier: ContextArtifactTier) => artifacts.filter((artifact) => artifact.tier === tier);
+    const hot = byTier("hot");
+    const warm = byTier("warm");
+    const cold = byTier("cold");
     return {
       records: artifacts.length,
       bytes,
       pinnedRecords: pinned.length,
       pinnedBytes: pinned.reduce((sum, artifact) => sum + artifact.bytes, 0),
+      hotRecords: hot.length,
+      hotBytes: hot.reduce((sum, artifact) => sum + artifact.bytes, 0),
+      warmRecords: warm.length,
+      warmBytes: warm.reduce((sum, artifact) => sum + artifact.bytes, 0),
+      coldRecords: cold.length,
+      coldBytes: cold.reduce((sum, artifact) => sum + artifact.bytes, 0),
       maxRecords,
       maxBytes,
     };
@@ -126,27 +175,40 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     );
   }
 
-  function oldestRemovable(sessionId: string, protectedIds: Set<string>): { artifact: ContextArtifact & { sequence: number }; index: number } | undefined {
+  function removalCandidates(sessionId: string, protectedIds: Set<string>, tier?: ContextArtifactTier): Array<{ artifact: ContextArtifact & { sequence: number; baseTier: ContextArtifactTier }; index: number }> {
     return artifacts
       .map((artifact, index) => ({ artifact, index }))
-      .filter(({ artifact }) => artifact.sessionId === sessionId && !artifact.pinned && !protectedIds.has(artifact.id))
+      .filter(({ artifact }) => artifact.sessionId === sessionId && !artifact.pinned && !protectedIds.has(artifact.id) && (!tier || artifact.tier === tier))
       .sort((a, b) => {
+        if (!tier && TIER_REMOVAL_ORDER[a.artifact.tier] !== TIER_REMOVAL_ORDER[b.artifact.tier]) {
+          return TIER_REMOVAL_ORDER[a.artifact.tier] - TIER_REMOVAL_ORDER[b.artifact.tier];
+        }
         if (a.artifact.createdAt !== b.artifact.createdAt) return a.artifact.createdAt - b.artifact.createdAt;
         return a.artifact.sequence - b.artifact.sequence;
-      })[0];
+      });
   }
 
-  function sessionWithinCaps(sessionId: string): boolean {
-    const sessionArtifacts = artifacts.filter((artifact) => artifact.sessionId === sessionId);
-    return sessionArtifacts.length <= maxRecords && sessionArtifacts.reduce((sum, artifact) => sum + artifact.bytes, 0) <= maxBytes;
+  function withinCaps(sessionId: string, tier?: ContextArtifactTier): boolean {
+    const sessionArtifacts = artifacts.filter((artifact) => artifact.sessionId === sessionId && (!tier || artifact.tier === tier));
+    const recordsCap = tier ? tierMaxRecords[tier] : maxRecords;
+    const bytesCap = tier ? tierMaxBytes[tier] : maxBytes;
+    return sessionArtifacts.length <= recordsCap && sessionArtifacts.reduce((sum, artifact) => sum + artifact.bytes, 0) <= bytesCap;
   }
 
   function prune(now = Date.now(), protectedIds = new Set<string>()): ContextBrokerStatus {
     dropExpired(now, protectedIds);
 
     for (const sessionId of new Set(artifacts.map((artifact) => artifact.sessionId))) {
-      while (!sessionWithinCaps(sessionId)) {
-        const candidate = oldestRemovable(sessionId, protectedIds);
+      for (const tier of ["cold", "warm", "hot"] as ContextArtifactTier[]) {
+        while (!withinCaps(sessionId, tier)) {
+          const candidate = removalCandidates(sessionId, protectedIds, tier)[0];
+          if (!candidate) break;
+          artifacts.splice(candidate.index, 1);
+        }
+      }
+
+      while (!withinCaps(sessionId)) {
+        const candidate = removalCandidates(sessionId, protectedIds)[0];
         if (!candidate) break;
         artifacts.splice(candidate.index, 1);
       }
@@ -169,10 +231,13 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     const id = `ctx-${now.toString(36)}-${String(artifactSequence).padStart(4, "0")}-${sha256.slice(0, 12)}`;
     const session = safeName(input.sessionId || "session");
     const kind = input.kind;
+    const tags = normalizeList(input.tags);
+    const baseTier = classifyBaseTier(input, tags);
+    const tier: ContextArtifactTier = input.pinned ? "hot" : baseTier;
     const handle = `ctx://session/${session}/${kind}/${sha256.slice(0, 16)}/${id}`;
-    const ttlMs = input.ttlMs ?? defaultTtlMs;
+    const ttlMs = input.ttlMs ?? tierTtlMs[tier];
 
-    const artifact: ContextArtifact & { sequence: number } = {
+    const artifact: ContextArtifact & { sequence: number; baseTier: ContextArtifactTier } = {
       id,
       handle,
       sessionId: input.sessionId,
@@ -183,14 +248,16 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
       sha256,
       payload,
       summary: summarizeArtifact(input.summary, kind, bytes, sha256, summaryBytes),
-      tags: normalizeList(input.tags),
+      tags,
       paths: normalizeList(input.paths),
       command: input.command?.trim() || undefined,
       branch: input.branch?.trim() || undefined,
+      tier,
       expiresAt: ttlMs > 0 ? now + ttlMs : undefined,
       pinned: Boolean(input.pinned),
       parentIds: normalizeList(input.parentIds),
       sequence: artifactSequence,
+      baseTier,
     };
 
     artifacts = [artifact, ...artifacts];
@@ -203,7 +270,10 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     const limit = Math.max(1, Math.floor(query.limit ?? (artifacts.length || 1)));
     return artifacts
       .filter((artifact) => artifactMatches(artifact, query))
-      .sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.createdAt - a.createdAt || b.sequence - a.sequence)
+      .sort((a, b) => Number(b.pinned) - Number(a.pinned)
+        || TIER_ORDER[a.tier] - TIER_ORDER[b.tier]
+        || b.createdAt - a.createdAt
+        || b.sequence - a.sequence)
       .slice(0, limit);
   }
 
@@ -212,6 +282,7 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
     const artifact = artifacts.find((candidate) => candidate.id === idOrHandle || candidate.handle === idOrHandle) ?? null;
     if (!artifact) return null;
     artifact.pinned = pinned;
+    artifact.tier = pinned ? "hot" : artifact.baseTier;
     artifact.updatedAt = Date.now();
     prune();
     return artifacts.find((candidate) => candidate.id === artifact.id) ?? null;
@@ -219,17 +290,25 @@ export function createInMemoryContextBroker(options: ContextBrokerOptions = {}):
 
   function renderBrief(query: ContextLookupQuery & { budgetBytes?: number } = {}): string {
     const budget = Math.max(64, Math.floor(query.budgetBytes ?? defaultBriefBytes));
+    const explicitCold = query.tier === "cold" || Boolean(query.handle || query.id);
+    const baseQuery = { ...query };
+    delete (baseQuery as { budgetBytes?: number }).budgetBytes;
+    const candidates = lookup({ ...baseQuery, limit: query.limit ?? 32 })
+      .filter((artifact) => explicitCold || artifact.tier !== "cold");
+    const hot = candidates.filter((artifact) => artifact.tier === "hot");
+    const warm = candidates.filter((artifact) => artifact.tier === "warm");
+    const cold = candidates.filter((artifact) => artifact.tier === "cold");
     const lines = [
       "## Context Broker",
       `Budget: ${budget} bytes`,
-      ...lookup({ ...query, limit: query.limit ?? 8 }).map((artifact) => {
-        const pin = artifact.pinned ? " pinned" : "";
-        const path = artifact.paths.length ? ` paths=${artifact.paths.slice(0, 3).join(",")}` : "";
-        const tags = artifact.tags.length ? ` tags=${artifact.tags.slice(0, 3).join(",")}` : "";
-        return `- ${artifact.handle} kind=${artifact.kind}${pin}${path}${tags} summary="${artifact.summary}"`;
-      }),
+      hot.length ? "Hot:" : "",
+      ...hot.map(tierLine),
+      warm.length ? "Warm:" : "",
+      ...warm.map(tierLine),
+      cold.length ? "Cold:" : "",
+      ...cold.map(tierLine),
       "Lookup: use broker lookup by handle/path/tag/kind/session before replaying raw payloads.",
-    ];
+    ].filter(Boolean);
 
     return truncateUtf8(lines.join("\n"), budget);
   }

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

@@ -0,0 +1,78 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createSqliteContextBroker } from "./sqlite.js";
+
+describe("createSqliteContextBroker", () => {
+  it("persists handles, payloads, tiers, and pin state without replay reconstruction", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 0, briefBytes: 800 });
+      const warm = broker.publish({ sessionId: "s", kind: "tool_output", payload: "needle payload", summary: "warm summary", createdAt: Date.now() });
+      const cold = broker.publish({ sessionId: "s", kind: "subagent_result", payload: "archived payload", summary: "cold archive", tier: "cold", createdAt: Date.now() + 1 });
+      expect(broker.pin(cold.handle, true)?.tier).toBe("hot");
+
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 0, briefBytes: 800 });
+
+      expect(broker.lookup({ handle: warm.handle })[0]?.payload).toBe("needle payload");
+      const reloadedCold = broker.lookup({ handle: cold.handle })[0];
+      expect(reloadedCold?.pinned).toBe(true);
+      expect(reloadedCold?.tier).toBe("hot");
+      expect(broker.renderBrief({ sessionId: "s" })).toContain(cold.handle);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("uses SQLite FTS for text lookup and enforces tier caps", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const broker = createSqliteContextBroker({ path: join(dir, "artifacts.sqlite"), defaultTtlMs: 0, coldMaxRecords: 1 });
+      const firstCold = broker.publish({ sessionId: "s", kind: "tool_output", payload: "alpha archive", tier: "cold", createdAt: Date.now() });
+      const secondCold = broker.publish({ sessionId: "s", kind: "tool_output", payload: "needle beta archive", tier: "cold", createdAt: Date.now() + 1 });
+
+      expect(broker.lookup({ id: firstCold.id })).toEqual([]);
+      expect(broker.lookup({ text: "needle" })[0]?.handle).toBe(secondCold.handle);
+    } 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 {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 0, maxRecords: 1 });
+      const original = broker.publish({ sessionId: "s", kind: "tool_output", payload: "same replayed payload", parentIds: ["tool-call-1"], createdAt: Date.now() });
+
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 0, maxRecords: 1 });
+      const replayed = broker.publish({ sessionId: "s", kind: "tool_output", payload: "same replayed payload", parentIds: ["tool-call-1"], createdAt: Date.now() + 1 });
+
+      expect(replayed.handle).toBe(original.handle);
+      expect(broker.lookup({ handle: original.handle })[0]?.payload).toBe("same replayed payload");
+      expect(broker.status().records).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("republishes expired replayed sources instead of returning dead handles", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 1 });
+      const expired = broker.publish({ sessionId: "s", kind: "tool_output", payload: "expired payload", parentIds: ["tool-call-1"], createdAt: 1 });
+      expect(broker.lookup({ handle: expired.handle })).toEqual([]);
+
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 1 });
+      const replayed = broker.publish({ sessionId: "s", kind: "tool_output", payload: "fresh replayed payload", parentIds: ["tool-call-1"], createdAt: 1, ttlMs: Date.now() + 60_000 });
+
+      expect(replayed.handle).not.toBe(expired.handle);
+      expect(broker.lookup({ handle: replayed.handle })[0]?.payload).toBe("fresh replayed payload");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});