pi-mega-compact 0.11.5 → 0.11.6

package/extensions/mega-events/perf-handler.ts

@@ -15,7 +15,10 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type MegaRuntime } from "../mega-runtime.js";
-import { recordPerfSample } from "../../src/store/sqlite.js";
+import {
+	recordPerfSample,
+	readPerfSamples,
+} from "../../src/store/sqlite.js";
 import { classifyPrefixBreak, type EventTimestamps } from "../../src/prefix-break.js";
 
 /** Structural view of an AssistantMessage usage block (no pi-ai import). */
@@ -42,6 +45,9 @@ function usageOf(
  * classifyPrefixBreak with the three candidate event timestamps from the
  * runtime and records a `prefix_break` sample.  Best-effort + non-fatal.
  *
+ * Also evaluates rolling cache health and emits a degradation event when the
+ * composite score falls below 0.6 (A3, PLAN_V2 Phase 4).
+ *
  * PREVENT-PI-004: guardrails-allow PREVENT-PI-004: local SQLite write only.
  * PREVENT-002: SQL is fully parameterized via recordPerfSample.
  */
@@ -74,11 +80,115 @@ function tryRecordPrefixBreak(
 				breakAt,
 			},
 		); // guardrails-allow PREVENT-PI-004: local SQLite write (loopback perf instrumentation)
+
+		// A3: compute rolling cache health score and emit alert on degradation.
+		tryComputeCacheHealth(stateDir, currHitPct, runtime);
 	} catch {
 		/* non-fatal: prefix-break detection never blocks the agent loop */
 	}
 }
 
+/**
+ * Compute a rolling cache health score and emit a dashboard event when it
+ * falls below the degradation threshold (0.6 / "yellow").
+ *
+ * The score is a weighted composite of:
+ *   - hitRateScore (0-1): recent cache_hit_pct sample average / 100
+ *   - stabilityScore (0-1): 1 - recent prefix_break count / maxExpectedBreaks
+ *   - churnScore (0-1): 1 - stripe re-assignment rate (derived from prefix_break classifications)
+ *
+ * Weights: hit rate 50%, prefix stability 30%, churn 20%.
+ *
+ * PREVENT-PI-004: guardrails-allow PREVENT-PI-004: local SQLite read, no network.
+ * PREVENT-001: readPerfSamples returns empty array when no data; handled.
+ * PREVENT-011: no `any` — all arrays are typed PerfSampleRow[].
+ */
+function tryComputeCacheHealth(
+	stateDir: string,
+	currHitPct: number,
+	runtime: MegaRuntime,
+): void {
+	try {
+		const now = Date.now();
+		const windowMs = 300_000; // 5-minute lookback
+		const sinceTs = now - windowMs;
+
+		// Read recent cache_hit_pct and prefix_break samples.
+		const hitSamples = readPerfSamples(stateDir, sinceTs, "cache_hit_pct");
+		const breakSamples = readPerfSamples(stateDir, sinceTs, "prefix_break");
+
+		// hitRateScore: average of recent cache hit percentages / 100.
+		let hitRateAvg = currHitPct;
+		if (hitSamples.length > 0) {
+			const sum = hitSamples.reduce((a, r) => a + r.value, 0);
+			hitRateAvg = sum / hitSamples.length;
+		}
+		const hitRateScore = Math.max(0, Math.min(1, hitRateAvg / 100));
+
+		// stabilityScore: penalize for frequent prefix breaks.
+		// Assume at most 2 breaks in 5min is tolerable.
+		const maxExpectedBreaks = 2;
+		const stabilityScore = Math.max(
+			0,
+			1 - breakSamples.length / maxExpectedBreaks,
+		);
+
+		// churnScore: if recent breaks have varied causes, penalize.
+		const causeVariety = new Set(
+			breakSamples.map((r) => {
+				const m = typeof r.meta === "string" ? (JSON.parse(r.meta) as Record<string, unknown>) : null;
+				return typeof m?.cause === "string" ? m.cause : "other";
+			}),
+		);
+		const churnPenalty = Math.min(1, causeVariety.size / 4); // 4 possible causes
+		const churnScore = 1 - churnPenalty;
+
+		// Composite: hitRate dominates.
+		const composite =
+			hitRateScore * 0.5 + stabilityScore * 0.3 + churnScore * 0.2;
+
+		// Emit degradation event when score < 0.6.
+		if (composite < 0.6) {
+			const prevScore = runtime.rt._lastCacheHealthScore ?? 1;
+			runtime.rt._lastCacheHealthScore = composite;
+
+			recordPerfSample(
+				stateDir,
+				"cache_health",
+				composite,
+				{
+					hitRateScore: Math.round(hitRateScore * 1000) / 1000,
+					stabilityScore: Math.round(stabilityScore * 1000) / 1000,
+					churnScore: Math.round(churnScore * 1000) / 1000,
+					breakCount: breakSamples.length,
+					hitSampleCount: hitSamples.length,
+					currHitPct,
+					trend: composite < prevScore ? "falling" : "stable",
+				},
+			); // guardrails-allow PREVENT-PI-004: local SQLite write (loopback dashboard event)
+
+			// Structured log line for the host to pick up.
+			const level = composite < 0.4 ? "error" : "warn";
+			// eslint-disable-next-line no-console
+			console.log(
+				JSON.stringify({
+					ts: now,
+					event: `cache_health_${level}`,
+					composite: Math.round(composite * 1000) / 1000,
+					hitRateAvg: Math.round(hitRateAvg * 10) / 10,
+					breakCount: breakSamples.length,
+					trend: composite < prevScore ? "falling" : "stable",
+				}),
+			);
+		} else {
+			// Still healthy — just update the stored score.
+			runtime.rt._lastCacheHealthScore = composite;
+		}
+	} catch {
+		/* non-fatal: cache health computation never blocks */
+	}
+}
+
 /** Register perf instrumentation handlers + start the 5s cpu/mem interval. */
 export function registerPerfHandler(
 	pi: ExtensionAPI,

package/extensions/mega-events/separated-prompt.ts

@@ -0,0 +1,329 @@
+/**
+ * extensions/mega-events/separated-prompt.ts — A1+A2 PLAN_V2 Phase 2+3
+ * Message Separation + Cache-Optimized Prompt Builder:
+ *   - buildSeparatedPrompt(): Basic 4-layer message separation (Phase 2).
+ *   - buildCacheOptimizedPrompt(): Insert Layer 2 (vector-optimized stable
+ *     context) between summary (Layer 1) and thread (Layer 3), ordered by
+ *     stripe stability DESC (Phase 3).
+ *   - detectTopicShift(): Cosine-similarity-based topic-shift detection.
+ *   - cosineSimilarity(): cosine similarity of two Float32Array embeddings.
+ *
+ * Layer order (Phase 3): 0 (system) -> 1 (summary) -> 2 (cache stripes) ->
+ * 3 (thread: user/assistant turns) -> 4 (tool results at tail).
+ *
+ * Feature-gated by MEGACOMPACT_CACHE_STRIPING (default OFF).
+ * MEGACOMPACT_MESSAGE_SEPARATION must also be ON for any layering to occur.
+ * Flag-OFF = byte-identical to pre-sprint — returns messages unchanged.
+ */
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { openStore } from "../../src/store/sqlite/utils.js";
+import { getStateDir } from "../../src/store.js";
+
+// ─── Exported types ──────────────────────────────────────────────────────────
+
+export interface SeparatedPromptOptions {
+  /** Path to the SQLite store directory. Defaults to getStateDir(). */
+  stateDir?: string;
+  /** Conversation/agent ID for stripe lookups. Defaults to 'main'. */
+  conversationId?: string;
+  /** Current turn index for embedding_cache lookups. Defaults to 0. */
+  turnIndex?: number;
+}
+
+export interface CacheStripeRow {
+  chunk_id: string;
+  stripe: number;
+  stability: number;
+  assigned_at: number;
+  epoch_id: string | null;
+}
+
+export interface EmbeddingCacheRow {
+  content_hash: string;
+  embedding: Buffer;
+  computed_at: number;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+/** Default stripe limit: top 10 most stable chunks. */
+const DEFAULT_STRIPE_LIMIT = 10;
+
+/** Topic-shift threshold: similarity below this triggers a stripe refresh. */
+const TOPIC_SHIFT_THRESHOLD = 0.7;
+
+// ─── Build separated prompt (Phase 2) ────────────────────────────────────────
+
+/**
+ * Reorganize messages into stable layers for better prompt caching.
+ *
+ * Layer order: 0 (system) -> 1 (summary) -> 3 (thread: user/assistant turns) ->
+ * 4 (tool results at tail).
+ *
+ * Feature gate: MEGACOMPACT_MESSAGE_SEPARATION env var.  When OFF (default),
+ * returns `messages` unchanged (byte-identical to pre-sprint).
+ */
+export function buildSeparatedPrompt(
+  messages: AgentMessage[],
+  _opts?: SeparatedPromptOptions,
+): AgentMessage[] {
+  const flag = process.env.MEGACOMPACT_MESSAGE_SEPARATION;
+  if (flag === "0" || flag === "false" || flag === undefined || flag === "") {
+    return messages;
+  }
+
+  // pi's AgentMessage union has no "system" role — the system prompt lives in
+  // AgentState.systemPrompt, separate from this array. The cache-relevant,
+  // low-risk transformation is moving volatile tool results/executions to the
+  // tail so the stable prefix (user/assistant/summaries/custom) stays contiguous.
+  // Discriminate by role only — never reach into `.content`/`.tool_calls`,
+  // which are variant-specific and require narrowing.
+  const main: AgentMessage[] = [];
+  const tail: AgentMessage[] = [];
+  for (const m of messages) {
+    if (m.role === "toolResult" || m.role === "bashExecution") {
+      tail.push(m);
+    } else {
+      main.push(m);
+    }
+  }
+  if (tail.length === 0) return messages; // nothing to reorder — byte-identical
+  return [...main, ...tail];
+}
+
+// ─── Cosine similarity ───────────────────────────────────────────────────────
+
+/**
+ * Compute cosine similarity between two Float32Array embeddings.
+ * Returns a value in [0, 1] where 1 = identical direction.
+ * Returns 0 if either vector is zero or inputs are mismatched.
+ */
+export function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  if (a.length !== b.length || a.length === 0) return 0;
+
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0) return 0;
+
+  return dot / denom;
+}
+
+// ─── Buffer ↔ Float32Array helpers ───────────────────────────────────────────
+
+/**
+ * Decode a Float32Array from a Buffer (little-endian float32 blob).
+ * Returns null on empty/undefined input.
+ */
+export function decodeEmbeddingBlob(buf: Buffer | undefined | null): Float32Array | null {
+  if (!buf || buf.length === 0) return null;
+  return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+}
+
+/**
+ * Encode a Float32Array into a Buffer for DB storage.
+ */
+export function encodeEmbeddingBlob(vec: Float32Array): Buffer {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+
+// ─── Topic-shift detection ───────────────────────────────────────────────────
+
+/**
+ * Detect whether the conversation topic has shifted between the current turn
+ * and the previous turn. Uses cosine similarity between topic embeddings.
+ *
+ * Returns `true` when similarity < TOPIC_SHIFT_THRESHOLD (0.7), meaning the
+ * stable cache prefix may need reordering.
+ *
+ * Returns `false` (no shift) when either embedding is missing.
+ */
+export function detectTopicShift(
+  currentEmb: Float32Array | null | undefined,
+  previousEmb: Float32Array | null | undefined,
+): boolean {
+  if (!currentEmb || !previousEmb) return false;
+  return cosineSimilarity(currentEmb, previousEmb) < TOPIC_SHIFT_THRESHOLD;
+}
+
+// ─── Load embeddings from store ──────────────────────────────────────────────
+
+/**
+ * Load the topic embedding for a given turn from the embedding_cache table.
+ * Returns null if no embedding is stored for that turn.
+ */
+export function loadTopicEmbedding(
+  stateDir: string,
+  conversationId: string,
+  turnIndex: number,
+): Float32Array | null {
+  const db = openStore(stateDir);
+  try {
+    const row = db.prepare(
+      `SELECT embedding FROM embedding_cache WHERE content_hash = ?`,
+    ).get(`topic:${conversationId}:${turnIndex}`) as { embedding: Buffer } | undefined;
+
+    if (!row) return null;
+    return decodeEmbeddingBlob(row.embedding);
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Store a topic embedding for a given turn in the embedding_cache table.
+ * Idempotent (INSERT OR REPLACE).
+ */
+export function storeTopicEmbedding(
+  stateDir: string,
+  conversationId: string,
+  turnIndex: number,
+  embedding: Float32Array,
+): void {
+  const db = openStore(stateDir);
+  try {
+    const contentHash = `topic:${conversationId}:${turnIndex}`;
+    const blob = encodeEmbeddingBlob(embedding);
+    db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache (content_hash, embedding, computed_at) VALUES (?, ?, ?)`,
+    ).run(contentHash, blob, Date.now());
+  } finally {
+    db.close();
+  }
+}
+
+// ─── Cache stripe management ─────────────────────────────────────────────────
+
+/**
+ * Refresh cache stripe assignments from the cache_stripes table for a given
+ * conversation/epoch. Returns rows ordered by stability DESC.
+ *
+ * This is called at the start of each turn (or on topic-shift) to ensure the
+ * stripe assignments reflect the latest stability scores.
+ */
+export function refreshStripeAssignments(
+  stateDir: string,
+  epochId: string,
+  limit = DEFAULT_STRIPE_LIMIT,
+): CacheStripeRow[] {
+  const db = openStore(stateDir);
+  try {
+    const rows = db.prepare(
+      `SELECT chunk_id, stripe, stability, assigned_at, epoch_id
+       FROM cache_stripes
+       WHERE epoch_id = ?
+       ORDER BY stability DESC
+       LIMIT ?`,
+    ).all(epochId, limit) as unknown as CacheStripeRow[];
+
+    return rows;
+  } finally {
+    db.close();
+  }
+}
+
+// ─── Build cache-optimized prompt (Phase 3) ──────────────────────────────────
+
+/**
+ * Build a cache-optimized prompt with 5 layers:
+ *   0 (system) -> 1 (summary) -> 2 (cache stripes) -> 3 (thread) -> 4 (tool)
+ *
+ * Feature gate: MEGACOMPACT_CACHE_STRIPING (default OFF). When OFF, delegates
+ * to buildSeparatedPrompt (byte-identical to Phase 2 behavior).
+ *
+ * When ON but MEGACOMPACT_MESSAGE_SEPARATION is OFF, also delegates to
+ * buildSeparatedPrompt (which returns messages unchanged).
+ */
+export function buildCacheOptimizedPrompt(
+  messages: AgentMessage[],
+  opts?: SeparatedPromptOptions,
+): AgentMessage[] {
+  const flag = process.env.MEGACOMPACT_CACHE_STRIPING;
+  if (flag === "0" || flag === "false" || flag === undefined || flag === "") {
+    // Flag OFF: delegate to buildSeparatedPrompt (byte-identical).
+    return buildSeparatedPrompt(messages, opts);
+  }
+
+  // Build the base 4-layer structure first.
+  const base = buildSeparatedPrompt(messages, opts);
+
+  // If base equals messages, separation is OFF — return unchanged.
+  if (base === messages) return base;
+
+  const stateDir = opts?.stateDir ?? getStateDir();
+
+  // Layer 1 = leading branch/compaction summaries (the stable summary layer).
+  // There is no "system" role in pi's AgentMessage union, so Layer 0 is empty.
+  // Count leading summaries to find where to insert the cache-stripe layer.
+  let layer1End = 0;
+  for (let i = 0; i < base.length; i++) {
+    const r = base[i].role;
+    if (r === "branchSummary" || r === "compactionSummary") {
+      layer1End = i + 1;
+    } else {
+      break;
+    }
+  }
+
+  // Lay out the result: Layer 1 (summaries) first.
+  const result: AgentMessage[] = base.slice(0, layer1End);
+
+  // Insert Layer 2: cache stripes (stable context ordered by stability DESC).
+  // Try to find the most recent epoch.
+  const db = openStore(stateDir);
+  let epochId: string | null = null;
+  try {
+    const epoch = db.prepare(
+      `SELECT epoch_id FROM checkpoint_epochs ORDER BY created_at DESC LIMIT 1`,
+    ).get() as { epoch_id: string } | undefined;
+    epochId = epoch?.epoch_id ?? null;
+  } finally {
+    db.close();
+  }
+
+  if (epochId) {
+    const stripes = refreshStripeAssignments(stateDir, epochId);
+    if (stripes.length > 0) {
+      // Build a single user message with concatenated stripe content.
+      const stripeBlocks: string[] = [];
+      for (const s of stripes) {
+        // Load chunk content from context_chunks table.
+        const db2 = openStore(stateDir);
+        try {
+          const chunk = db2.prepare(
+            `SELECT normalized_text FROM context_chunks WHERE id = ?`,
+          ).get(s.chunk_id) as { normalized_text: string } | undefined;
+          if (chunk?.normalized_text) {
+            stripeBlocks.push(chunk.normalized_text);
+          }
+        } finally {
+          db2.close();
+        }
+      }
+
+      if (stripeBlocks.length > 0) {
+        result.push({
+          role: "user",
+          content: stripeBlocks.join("\n\n---\n\n"),
+          timestamp: Date.now(),
+        } as AgentMessage);
+      }
+    }
+  }
+
+  // Append remaining layers (3: thread, 4: tool results).
+  for (let i = layer1End; i < base.length; i++) {
+    result.push(base[i]);
+  }
+
+  return result;
+}

package/extensions/mega-runtime/env-loader.ts

@@ -0,0 +1,55 @@
+/**
+ * mega-runtime/env-loader.ts — load `.mega-compact.env` from the state dir.
+ *
+ * The /mega-setup wizard and the dashboard Setup tab write a `.mega-compact.env`
+ * file with the user's chosen embedder configuration. Without a loader, that
+ * file is write-only dead weight — config is read from process.env at startup
+ * (mega-config.ts:loadConfig), so the file was never applied.
+ *
+ * This loader runs BEFORE loadConfig in the extension entry. It parses the
+ * file (KEY=VALUE lines, # comments, quoted values) and applies each key to
+ * process.env ONLY if it is not already set — so shell profile / inline env
+ * vars always win over the file (the user can override without editing it).
+ *
+ * Non-fatal: a missing or malformed file never breaks the extension.
+ *
+ * PREVENT-PI-004: reads a local file only — no network.
+ * PREVENT-001: no JSON here; line parser is null/empty-safe.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Load `.mega-compact.env` from `stateDir` into `process.env`.
+ * Keys already set in the environment win (file does not override shell).
+ */
+export function loadMegaEnv(stateDir: string): void {
+	const envPath = join(stateDir, ".mega-compact.env");
+	if (!existsSync(envPath)) return;
+	let content: string;
+	try {
+		content = readFileSync(envPath, "utf-8");
+	} catch {
+		return; // unreadable — non-fatal
+	}
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eq = trimmed.indexOf("=");
+		if (eq < 0) continue;
+		const key = trimmed.slice(0, eq).trim();
+		if (!key) continue;
+		let val = trimmed.slice(eq + 1).trim();
+		if (
+			(val.startsWith('"') && val.endsWith('"')) ||
+			(val.startsWith("'") && val.endsWith("'"))
+		) {
+			val = val.slice(1, -1);
+		}
+		// Shell / inline env vars win over the file.
+		if (process.env[key] === undefined) {
+			process.env[key] = val;
+		}
+	}
+}

package/extensions/mega-runtime/helpers.ts

@@ -42,6 +42,8 @@ export interface SessionRuntime {
 	lastInjectAt: number | null; // last tail injection this session
 	// S53A: previous cache_hit_pct for drop detection.
 	_prevCacheHitPct: number | null;
+	// A3: rolling cache health score (0-1) cached between turns for trend detection.
+	_lastCacheHealthScore: number | undefined;
 	lastNativeCompactAt: number | null; // COMPACT-DEDUP FIX: wall-clock ms of the last NATIVE pi compaction (session_compact event) — used by the agent_end/legacy race guard to skip a redundant ctx.compact() that would throw "Already compacted".
 	// S25: live dashboard counters (reset on session_start, mirrored to SQLite).
 	compactCount: number; // compactions performed this session-instance

package/extensions/mega-runtime/reset-runtime.ts

@@ -57,6 +57,7 @@ export function resetRuntimeImpl(
 		lastRecallAt: null,
 		lastInjectAt: null,
 		_prevCacheHitPct: null,
+		_lastCacheHealthScore: undefined,
 		lastNativeCompactAt: null,
 		compactCount: 0,
 		recallInjections: 0,

package/extensions/mega-runtime/runtime-snapshot.ts

@@ -267,6 +267,7 @@ export function snapshotImpl(
 			armed,
 			modelSnap,
 			providerCachePct,
+			perTurnCacheHitPct: self.rt._prevCacheHitPct ?? undefined,
 		});
 		self.widgetData = _snapResult.widgetData;
 		// S33: consume the flare after copying it into widgetData so it fires

package/extensions/mega-runtime/runtime.ts

@@ -90,6 +90,7 @@ export class MegaRuntime {
 		lastRecallAt: null,
 		lastInjectAt: null,
 		_prevCacheHitPct: null,
+		_lastCacheHealthScore: undefined,
 		lastNativeCompactAt: null,
 		compactCount: 0,
 		recallInjections: 0,

package/extensions/mega-runtime/snapshot.ts

@@ -106,6 +106,11 @@ export interface SnapshotInput {
 	} | null;
 
 	lastActivityAt: number;
+
+	/** A3: per-turn cache hit percentage (most recent turn's ratio, separate
+	 *  from providerCachePct which is the running average). Optional — when null
+	 *  the cache-hit line is omitted from the widget. */
+	perTurnCacheHitPct?: number;
 }
 
 export interface SnapshotResult {
@@ -220,6 +225,7 @@ export function computeMegaSnapshot(p: SnapshotInput): SnapshotResult {
 		cachePct,
 		megaCacheFlare: p.megaCacheFlare,
 		megaCacheFlarePct: p.megaCacheFlarePct,
+		perTurnCacheHitPct: p.perTurnCacheHitPct ?? cachePct,
 		levelUpFlare: p.levelUpFlare,
 		achievementFlare: p.achievementFlare,
 		achievementFlareTitles: p.achievementFlareTitles,

package/extensions/mega-runtime/widget-types.ts

@@ -77,4 +77,7 @@ export interface WidgetData {
 		startedAt: number;
 		durationMs: number;
 	} | null;
+	/** A3: per-turn cache hit percentage (most recent turn's hit/miss ratio,
+	 *  0–100). Separate from cachePct (running average) for trend visibility. */
+	perTurnCacheHitPct?: number;
 }

package/extensions/mega-runtime/widget.ts

@@ -131,6 +131,11 @@ export function buildWidgetLines(
 		`${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset}`,
 		`${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
 		`${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`,
+		...(wd.perTurnCacheHitPct != null
+			? [
+					`${C.gray}cache hit${C.reset} this turn ${C.green}${Math.round(wd.perTurnCacheHitPct)}%${C.reset}`,
+				]
+			: []),
 	].join(sep);
 	// Wrap to terminal width and pad each line
 	const wrapped = wrapLine(content, width - 2, panelBg); // 2-char indent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.11.5",
+  "version": "0.11.6",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",