pi-mega-compact 0.7.3 → 0.7.4

package/extensions/mega-events.ts

@@ -12,9 +12,12 @@ import type {
 	ExtensionContext,
 	ContextEvent,
 	SessionBeforeCompactEvent,
+	SessionCompactEvent,
 } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { normalizeSessionId } from "../src/store.js";
+import { openStore, appendRawTranscript, writeCheckpointEpoch, type CheckpointEpoch } from "../src/store/sqlite.js";
+import { epochIdFor } from "../src/mirror/epoch.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens, estimateBlockTokens } from "../src/tokens.js";
 import {
@@ -40,6 +43,39 @@ import {
 	memoryReviewCadence,
 	type MegaConfig,
 } from "./mega-config.js";
+import type { RawTranscriptRow } from "../src/store/sqlite.js";
+import { createHash } from "node:crypto";
+
+/**
+ * Convert a pi AgentMessage to a RawTranscriptRow for the DB mirror.
+ * content_bytes is canonical JSON (sorted keys) for deterministic hashing.
+ * Returns null if the message has no usable content.
+ */
+function toRawTranscriptRow(
+	msg: AgentMessage,
+	sessionId: string,
+	epochId: string,
+): RawTranscriptRow | null {
+	// Narrow to Message union (has content + timestamp).
+	const m = msg as { role?: string; content?: unknown; timestamp?: number; toolName?: string };
+	const content = m.content;
+	if (content == null || content === "") return null;
+	// Canonical form: sort object keys for deterministic hashing.
+	const contentBytes = typeof content === "string"
+		? content
+		: JSON.stringify(content, Object.keys(content as object).sort());
+	const contentHash = createHash("sha256").update(contentBytes).digest("hex");
+	return {
+		contentHash,
+		sessionId,
+		seq: 0, // assigned by appendRawTranscript (COALESCE(MAX(seq),0)+1)
+		role: m.role ?? "unknown",
+		contentBytes,
+		toolName: m.toolName ?? null,
+		messageTimestamp: m.timestamp ?? null,
+		checkpointEpoch: epochId,
+	};
+}
 
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
@@ -271,7 +307,20 @@ export function registerEventHandlers(
 				// trim we ALWAYS nudge so the agent reliably restarts. Debounced 30s.
 				let didDurableTrim = false;
 				if (idle && overThreshold && now >= runtime.debounceUntil) {
-					if (!piCompactWouldNoop(ctx)) {
+					// COMPACT-DEDUP FIX: skip the manual durable-trim trigger when pi's
+					// NATIVE auto-compaction just fired (or is in-flight). pi emits
+					// agent_end BEFORE its own _checkCompaction (per its docstring:
+					// "Called after agent_end and before prompt submission"), so a
+					// synchronous `piCompactWouldNoop` branch check misses a native
+					// compaction that hasn't appended its entry yet — calling
+					// ctx.compact() then races with pi and throws "Already compacted"
+					// to the user. The `lastCompactAt` cooldown (updated by the
+					// session_compact listener for EVERY compaction, native or
+					// extension-supplied) closes that race window.
+					const sinceCompact = now - (runtime.rt.lastNativeCompactAt ?? 0);
+					if (sinceCompact < 10_000) {
+						runtime.diagAgentEndDurableSkipRecent++;
+					} else if (!piCompactWouldNoop(ctx)) {
 						runtime.debounceUntil = now + 2000;
 						runtime.diagAgentEndDurable++;
 						runtime.logger.info("agent-end-durable-trigger", {
@@ -280,7 +329,7 @@ export function registerEventHandlers(
 							thresholdTokens: config.thresholdTokens,
 							queued,
 						});
-						ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort
+						ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort. Race-guarded by lastCompactAt cooldown above (ctx.compact returns void → throw is surfaced by pi as compaction_end; the cooldown prevents the call entirely).
 						didDurableTrim = true;
 					}
 				}
@@ -370,6 +419,22 @@ export function registerEventHandlers(
 			estimateSessionTokens(view) ??
 			Math.round((pct / 100) * (usage?.contextWindow ?? 0));
 
+		// S27 DB-mirror: append ALL incoming messages to raw_transcript.
+		// Runs BEFORE fast-gate so every message is captured, even if we
+		// don't compact this turn. Append is idempotent (content_hash PK).
+		if (config.dbMirror) {
+			try {
+				const db = openStore(runtime.currentStateDir);
+				const epochId = epochIdFor(runtime.rt.sessionId);
+				for (const msg of messages) {
+					const raw = toRawTranscriptRow(msg, runtime.rt.sessionId, epochId);
+					if (raw) appendRawTranscript(db, raw);
+				}
+			} catch (e) {
+				runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
+			}
+		}
+
 		// FAST GATE: token-based (tier% of the window), not a static amount.
 		if (currentTokens < runtime.effectiveThreshold) {
 			runtime.diagCtxFastGate++;
@@ -401,6 +466,41 @@ export function registerEventHandlers(
 			return;
 		}
 
+		// S27 DB-mirror: write checkpoint_epoch with deterministic nonce.
+		// This makes the cache key stable across identical compactions.
+		if (config.dbMirror) {
+			try {
+				const db = openStore(runtime.currentStateDir);
+				const cpId = ran.result.checkpointId ?? `epoch-${Date.now()}`;
+				const epoch: CheckpointEpoch = {
+					epochId: epochIdFor(cpId),
+					sessionId: runtime.rt.sessionId,
+					startedSeq: 0,
+					committedSeq: ran.result.compactedFrom,
+					checkpointId: cpId,
+					cutIndex: ran.result.compactedFrom,
+					summaryMessageText: ran.result.summary,
+					createdAt: Date.now(),
+				};
+				writeCheckpointEpoch(db, epoch);
+				// S27 Task 6: Fire-and-forget dedup pipeline.
+				// Deduplicates raw_transcript rows for the compacted range.
+				try {
+					const { dedupTranscript } = await import("../src/mirror/dedup.js");
+					dedupTranscript(
+						db,
+						runtime.rt.sessionId,
+						0,
+						ran.result.compactedFrom,
+					);
+				} catch (_dedupErr) {
+					// Fire-and-forget: dedup failure is non-fatal
+				}
+			} catch (e) {
+				runtime.logger.warn("db-mirror-epoch-fail", { error: String(e) });
+			}
+		}
+
 		// LEGACY path (rollback): v0.4.28 ctx.compact() + the no-op gate. The
 		// manual compact path aborts the in-flight turn — only used behind the flag.
 		// Read live from env (in addition to the load-time config) so the flag can be
@@ -411,8 +511,13 @@ export function registerEventHandlers(
 			process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" ||
 			process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
 		if (legacy) {
-			if (piCompactWouldNoop(ctx)) return;
-			ctx.compact({ customInstructions: undefined });
+			// COMPACT-DEDUP FIX: same race guard as the agent_end path. Skip when a
+			// NATIVE compaction just fired (avoids racing pi and surfacing a spurious
+			// "Already compacted" / "Nothing to compact" toast). Uses lastNativeCompactAt
+			// (NOT lastCompactAt, which runCompact also stamps for our own checkpoint).
+			const sinceCompact = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
+			if (sinceCompact < 10_000 || piCompactWouldNoop(ctx)) return;
+			ctx.compact({ customInstructions: undefined }); // race-guarded by lastNativeCompactAt cooldown (ctx.compact returns void → not catchable; the cooldown prevents the call)
 			return;
 		}
 
@@ -551,6 +656,23 @@ export function registerEventHandlers(
 		},
 	);
 
+		// COMPACT-DEDUP FIX: track EVERY compaction (native + extension-supplied)
+		// so the agent_end durable-trim guard can skip a redundant ctx.compact()
+		// when pi just compacted. Without this, agent_end fires ctx.compact()
+		// synchronously AFTER pi's native auto-compaction appended a compaction
+		// entry but BEFORE our branch read sees it on the next tick — racing
+		// into a user-facing "Already compacted" throw. `lastCompactAt` is the
+		// race-closing signal: any compaction (manual/threshold/overflow, ours
+		// or pi's own) stamps it, and the agent_end guard skips for 10s.
+		pi.on("session_compact", async (_event: SessionCompactEvent, _ctx: ExtensionContext) => {
+			runtime.rt.lastNativeCompactAt = Date.now();
+			runtime.rt.lastCompactAt = Date.now();
+			runtime.logger.info("session-compacted", {
+				sessionId: runtime.rt.sessionId,
+				at: runtime.rt.lastCompactAt,
+			});
+		});
+
 	/**
 	 * Build a minimal fallback compaction so pi never runs its throwing compact().
 	 *

package/extensions/mega-runtime.ts

@@ -72,6 +72,7 @@ interface SessionRuntime {
 	dedupAttempts: number; // total compaction attempts (for hit-rate denominator)
 	tokensSaved: number; // this session-instance only: reset on session_start
 	lastCompactAt: number | null; // wall-clock ms of the last compaction this session
+	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".
 }
 
 /** ANSI palette for the toolbar. The pi TUI's Text component preserves ANSI
@@ -272,6 +273,7 @@ export class MegaRuntime {
 		dedupAttempts: 0,
 		tokensSaved: 0,
 		lastCompactAt: null,
+		lastNativeCompactAt: null,
 	};
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -339,6 +341,7 @@ export class MegaRuntime {
 	diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
 	diagAgentEndIdle = 0; // agent_end with activeAgents===0
 	diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
+	diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
 	// Per-skip-path counters for the team-run diagnosis.
 	diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
 	diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
@@ -845,6 +848,7 @@ export class MegaRuntime {
 			dedupAttempts: 0,
 			tokensSaved: 0,
 			lastCompactAt: null,
+			lastNativeCompactAt: null,
 		};
 		this.statusKey = undefined;
 		this.activeAgents = 0;

package/package.json

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

package/src/mirror/dedup.ts

@@ -0,0 +1,57 @@
+/**
+ * dedup.ts — S27 Task 6: Fork snapshot → compress/dedupe pipeline.
+ *
+ * After the served window is handed to pi, asynchronously:
+ * 1. Read raw_transcript rows [0..cut_index] for the epoch
+ * 2. For each row, compute content_hash (reuse digest from dedup/)
+ * 3. INSERT OR IGNORE INTO dedup_mirror (stores bytes once per unique hash)
+ * 4. Update raw_transcript.content_ref to point to dedup_mirror
+ * 5. Increment dedup_mirror.ref_count for existing hashes
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ */
+
+import type { DatabaseSync } from "node:sqlite";
+import {
+  upsertDedupMirror,
+  updateRawTranscriptRef,
+  listRawTranscriptRange,
+  getDedupRatio,
+} from "../store/sqlite.js";
+import { computeContentDigest } from "../dedup/digest.js";
+
+/**
+ * Deduplicate raw transcript rows for a session range.
+ * Fire-and-forget: errors are logged, not thrown.
+ *
+ * @returns Number of rows deduplicated, or -1 on error.
+ */
+export function dedupTranscript(
+  db: DatabaseSync,
+  sessionId: string,
+  fromSeq: number,
+  toSeq: number,
+): number {
+  try {
+    const rows = listRawTranscriptRange(db, sessionId, fromSeq, toSeq);
+    let deduped = 0;
+    for (const row of rows) {
+      const contentHash = computeContentDigest(row.contentBytes).contentHash;
+      const isNew = upsertDedupMirror(db, contentHash, row.contentBytes, row.seq);
+      updateRawTranscriptRef(db, sessionId, row.seq, contentHash);
+      if (!isNew) {
+        deduped++;
+      }
+    }
+    return deduped;
+  } catch (err) {
+    // Fire-and-forget: log but don't throw
+    console.error("[mega-compact] dedupTranscript failed:", err);
+    return -1;
+  }
+}
+
+/**
+ * Get dedup ratio for a session.
+ */
+export { getDedupRatio };

package/src/mirror/epoch.ts

@@ -0,0 +1,37 @@
+/**
+ * epoch.ts — deterministic epoch-id derivation for the S27 DB-mirror.
+ *
+ * The epoch id MUST be a pure function of the checkpoint it decorates so that
+ * replaying / refreshing the same compaction yields the SAME epoch id (idempotent
+ * appends + ON CONFLICT refresh). No Date.now / uuid / crypto — this is the
+ * only source of randomness-free epoch naming in the mirror stack.
+ *
+ * - epochIdFor(cp)  → "epoch:" + cp   (human-traceable back to its checkpoint)
+ * - epochNonceFor(cp) → FNV-1a 32-bit hash (cheap, well-distributed nonce)
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ */
+
+/**
+ * FNV-1a 32-bit nonce for a checkpoint id. Deterministic and RNG-free:
+ * h = 0x811c9dc5; for each char: h ^= codePoint; h = Math.imul(h, 0x01000193);
+ * return h >>> 0 (unsigned).
+ */
+export function epochNonceFor(checkpointId: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < checkpointId.length; i++) {
+    const cp = checkpointId.codePointAt(i);
+    if (cp === undefined) continue;
+    h ^= cp;
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/**
+ * Deterministic epoch id: "epoch:" + checkpointId. Trivially traceable back to
+ * the source checkpoint, and stable under replay (refresh-safe upserts).
+ */
+export function epochIdFor(checkpointId: string): string {
+  return "epoch:" + checkpointId;
+}

package/src/mirror/mirror.test.ts

@@ -0,0 +1,240 @@
+/**
+ * mirror.test.ts — S27 DB-mirror integration tests.
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ *
+ * NOTE: raw_transcript has PRIMARY KEY (content_hash, session_id), so
+ * duplicate content in the same session is silently dropped by INSERT OR IGNORE.
+ * Tests are designed around this constraint.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import type { DatabaseSync } from "node:sqlite";
+import { openStore, closeStore } from "../../src/store/sqlite.js";
+import {
+  writeCheckpointEpoch,
+  listCheckpointEpochs,
+  appendRawTranscript,
+  listRawTranscriptRange,
+  upsertDedupMirror,
+  getDedupRatio,
+  getDedupMirrorStats,
+  countRawTranscript,
+} from "../../src/store/sqlite.js";
+import { epochIdFor } from "../../src/mirror/epoch.js";
+import { dedupTranscript } from "../../src/mirror/dedup.js";
+import { computeContentDigest } from "../../src/dedup/digest.js";
+
+function tmp(): string {
+  return mkdtempSync(join(tmpdir(), "mirror-test-"));
+}
+
+/**
+ * Build a valid RawTranscriptRow using the canonical content hash from
+ * computeContentDigest (matches what dedupTranscript uses).
+ */
+function mkRow(
+  sessionId: string,
+  seq: number, // ignored by appendRawTranscript (auto-assigned)
+  role: "user" | "assistant",
+  content: string,
+) {
+  const { contentHash } = computeContentDigest(content);
+  return {
+    contentHash,
+    sessionId,
+    seq,
+    role,
+    contentBytes: content,
+    toolName: null as string | null,
+    messageTimestamp: Date.now() as number | null,
+    checkpointEpoch: "",
+  };
+}
+
+describe("S27 DB-mirror", () => {
+  it("epochIdFor is deterministic", () => {
+    assert.equal(epochIdFor("cp-abc-123"), epochIdFor("cp-abc-123"));
+    assert.notEqual(epochIdFor("cp-abc-123"), epochIdFor("cp-abc-456"));
+    const id = epochIdFor("cp-abc-123");
+    assert.ok(id.startsWith("epoch:"));
+    assert.ok(id.length > 6);
+  });
+
+  it("writeCheckpointEpoch + listCheckpointEpochs round-trips", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    writeCheckpointEpoch(db, {
+      epochId: "epoch-test-001",
+      sessionId: "sess-abc",
+      startedSeq: 0,
+      committedSeq: 100,
+      checkpointId: "cp-test-001",
+      cutIndex: 100,
+      summaryMessageText: "Test summary",
+      createdAt: Date.now(),
+    });
+
+    const rows = listCheckpointEpochs(db);
+    assert.ok(rows.length >= 1);
+    assert.equal(rows[0].epochId, "epoch-test-001");
+    assert.equal(rows[0].sessionId, "sess-abc");
+    assert.equal(rows[0].checkpointId, "cp-test-001");
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("appendRawTranscript + listRawTranscriptRange round-trips (unique content)", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    // Use unique content for each row to avoid PK collision
+    appendRawTranscript(db, mkRow("sess-abc", 0, "user", "first message"));
+    appendRawTranscript(db, mkRow("sess-abc", 1, "assistant", "second message"));
+    appendRawTranscript(db, mkRow("sess-abc", 2, "user", "third message"));
+
+    // seq is auto-assigned: 1, 2, 3
+    const rows = listRawTranscriptRange(db, "sess-abc", 0, 10);
+    assert.equal(rows.length, 3);
+    assert.equal(rows[0].contentBytes, "first message");
+    assert.equal(rows[0].seq, 1);
+    assert.equal(rows[1].contentBytes, "second message");
+    assert.equal(rows[1].seq, 2);
+    assert.equal(rows[2].contentBytes, "third message");
+    assert.equal(rows[2].seq, 3);
+
+    // Range filter: [2..3]
+    const rows2 = listRawTranscriptRange(db, "sess-abc", 2, 3);
+    assert.equal(rows2.length, 2);
+    assert.equal(rows2[0].contentBytes, "second message");
+    assert.equal(rows2[1].contentBytes, "third message");
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("upsertDedupMirror increments ref_count for duplicate content", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    const isNew1 = upsertDedupMirror(db, "hash-aaa", "Hello", 0);
+    assert.equal(isNew1, true);
+
+    const isNew2 = upsertDedupMirror(db, "hash-aaa", "Hello", 1);
+    assert.equal(isNew2, false);
+
+    const stats = getDedupMirrorStats(db);
+    assert.equal(stats.rowCount, 1);
+    assert.equal(stats.avgRefCount, 2);
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("dedupTranscript deduplicates cross-session content via dedup_mirror", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    // Insert same content in TWO different sessions (raw_transcript PK allows this)
+    appendRawTranscript(db, mkRow("sess-a", 0, "user", "shared hello"));
+    appendRawTranscript(db, mkRow("sess-a", 1, "assistant", "shared world"));
+    appendRawTranscript(db, mkRow("sess-a", 2, "user", "unique A"));
+    appendRawTranscript(db, mkRow("sess-b", 0, "user", "shared hello"));
+    appendRawTranscript(db, mkRow("sess-b", 1, "assistant", "shared world"));
+    appendRawTranscript(db, mkRow("sess-b", 2, "user", "unique B"));
+
+    // Dedup session A: 3 rows, all new → deduped=0
+    const dedupedA = dedupTranscript(db, "sess-a", 0, 10);
+    assert.equal(dedupedA, 0);
+
+    // Dedup session B: 3 rows, but 2 already in dedup_mirror → deduped=2
+    const dedupedB = dedupTranscript(db, "sess-b", 0, 10);
+    assert.equal(dedupedB, 2);
+
+    // dedup_mirror has 4 unique hashes: shared-hello, shared-world, unique-A, unique-B
+    const stats = getDedupMirrorStats(db);
+    assert.equal(stats.rowCount, 4);
+    assert.ok(stats.avgRefCount > 1);
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("getDedupRatio reflects dedup savings", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    // Two sessions with identical content → cross-session dedup
+    for (let i = 0; i < 3; i++) {
+      appendRawTranscript(db, mkRow("sess-x", i, "user", "same content"));
+      appendRawTranscript(db, mkRow("sess-y", i, "user", "same content"));
+    }
+    // Each session has 1 row (PK dedup within session), so 1 row each
+    // sess-x: 1 row, sess-y: 1 row
+
+    dedupTranscript(db, "sess-x", 0, 10);
+    dedupTranscript(db, "sess-y", 0, 10);
+
+    // For sess-x: totalBytes = LENGTH("same content") = 12, uniqueBytes = 12 → ratio 1.0
+    const { totalBytes, uniqueBytes, ratio } = getDedupRatio(db, "sess-x");
+    assert.ok(totalBytes > 0);
+    assert.ok(uniqueBytes > 0);
+    assert.ok(ratio >= 1.0);
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("full pipeline: append + dedup + epoch", () => {
+    const dir = tmp();
+    const db: DatabaseSync = openStore(dir);
+
+    // Insert 5 unique rows
+    const contents = ["alpha", "bravo", "charlie", "delta", "echo"];
+    for (let i = 0; i < contents.length; i++) {
+      appendRawTranscript(
+        db,
+        mkRow("sess-pipe", i, i % 2 === 0 ? "user" : "assistant", contents[i]),
+      );
+    }
+
+    const total = countRawTranscript(db);
+    assert.ok(total >= 5);
+
+    // Dedup: all 5 unique → deduped = 0
+    const deduped = dedupTranscript(db, "sess-pipe", 0, 100);
+    assert.equal(deduped, 0);
+
+    // Mirror should have 5 unique hashes
+    const stats = getDedupMirrorStats(db);
+    assert.equal(stats.rowCount, 5);
+
+    // Write checkpoint epoch
+    writeCheckpointEpoch(db, {
+      epochId: "epoch-integration",
+      sessionId: "sess-pipe",
+      startedSeq: 0,
+      committedSeq: 100,
+      checkpointId: "cp-integration",
+      cutIndex: 5,
+      summaryMessageText: "Integration test summary",
+      createdAt: Date.now(),
+    });
+
+    const epochs = listCheckpointEpochs(db);
+    assert.ok(epochs.length >= 1);
+    assert.equal(epochs[0].epochId, "epoch-integration");
+
+    const rows = listRawTranscriptRange(db, "sess-pipe", 0, 100);
+    assert.equal(rows.length, 5);
+
+    closeStore(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+});

package/src/recall.ts

@@ -84,10 +84,48 @@ export function formatRecallBlock(hits: SearchHit[]): string {
  * it records injections via `markInjected` so the next call dedupes. The
  * `store` is passed by the extension (defaults to the engine's default store).
  */
+/**
+ * Recall and inline context from the checkpoint store.
+ *
+ * S27 contract — DB-Mirror demotion:
+ *
+ * When `MEGACOMPACT_DB_MIRROR` is ON, the `raw_transcript` table is the
+ * canonical, byte-stable source of truth for message reconstruction. The
+ * `dedup_mirror` provides space-efficient storage with ref_count tracking
+ * (see src/mirror/dedup.ts). The legacy JSON checkpoint is retained as a
+ * DR snapshot only (see src/store.ts checkpoint helpers).
+ *
+ * The recall function continues to work from the VectorStore (checkpoint
+ * summaries + embeddings) for fast semantic search — this path is unaffected
+ * by the mirror flag. If full transcript reconstruction is ever needed
+ * (replay, export, debug), prefer reading from `raw_transcript + dedup_mirror`
+ * via `listRawTranscriptRange()` + `dedupTranscript()` instead of the legacy
+ * JSON checkpoint. Falls back to legacy checkpoint if mirror is empty
+ * (pre-migration sessions).
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ */
 export function recallAndInline(
   opts: RecallInjectOptions,
   store: Pick<VectorStore, "search" | "wasInjected" | "markInjected">,
 ): RecallInjectResult {
+  // ── S27 Recall Demotion ─────────────────────────────────────────────
+  //
+  // When MEGACOMPACT_DB_MIRROR is ON, the raw_transcript + dedup_mirror
+  // tables are preferred for byte-stable reconstruction. The current
+  // recall path (VectorStore search → format → inject) is unaffected —
+  // it provides fast semantic search over checkpoint summaries.
+  //
+  // If full transcript reconstruction is ever needed (replay, export,
+  // debug), call reconstructFromMirror(db, sessionId, fromSeq, toSeq)
+  // from src/mirror/dedup.ts instead of reading from the legacy JSON
+  // checkpoint. Falls back to legacy checkpoint if mirror is empty
+  // (pre-migration sessions).
+  //
+  // Invariant: raw_transcript + dedup_mirror are additive and never
+  // lose data. The legacy JSON checkpoint remains as a DR snapshot.
+  // ─────────────────────────────────────────────────────────────────────
+
   const limit = opts.limit ?? 3;
   const skip = opts.skipInjected ?? true;
   const maxTokens = opts.recallMaxTokens ?? 0; // 0 = unbounded (legacy behavior)