pi-mega-compact 0.11.4 → 0.11.6

package/extensions/mega-commands.ts

@@ -16,6 +16,11 @@ import { type MegaRuntime, C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
 import { vectorStats, vectorRepoStats, vectorDataInvariant } from "../src/vectorStore.js";
 import type { MegaConfig } from "./mega-config.js";
+import { spawnSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: local subprocess detection only (no network)
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createRequire } from "node:module";
 
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime: MegaRuntime, sid: string, ref: string) {
@@ -79,7 +84,7 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
       runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossRepo ? " (cross-repo)" : ""}`);
       ctx.ui.notify(
         `[mega-compact] recall staged ${r.toInject.length} checkpoint(s) for "${query}"${crossRepo ? " (cross-repo)" : ""}:\n${list}\n` +
-          `(injected at the next turn via system prompt)`,
+          `(injected at the tail of the next turn's context)`,
       );
      } catch (e) {
        ctx.ui.notify(`[mega-compact] /mega-recall failed: ${String(e)}`);
@@ -275,6 +280,211 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
     },
   });
 
+  pi.registerCommand("mega-setup", {
+    description:
+      "Local embedding setup wizard — detect available embedders and configure mega-compact.",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+     try {
+      const log = (msg: string) => ctx.ui.notify(msg);
+
+      // --- 1. Current config ---
+      const embeddingUrl = process.env["MEGACOMPACT_EMBEDDING_URL"];
+      const minilm = process.env["MEGACOMPACT_MINILM"];
+
+      let currentEmbedder = "TrigramEmbedder (heuristic, default)";
+      if (embeddingUrl) currentEmbedder = `httpEmbedder → ${embeddingUrl}`;
+      else if (minilm) currentEmbedder = "MiniLM (experimental)";
+
+      // --- 2. Detection ---
+      let ollamaDetected = false;
+      let ollamaModels: string[] = [];
+      let ollamaRunning = false;
+      let llamaDetected = false;
+      let onnxDetected = false;
+
+      try {
+        const ollamaVer = spawnSync("ollama", ["--version"], {
+          timeout: 5000,
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "pipe"],
+        }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+        if (ollamaVer.status === 0) {
+          ollamaDetected = true;
+          try {
+            const listResult = spawnSync("ollama", ["list"], {
+              timeout: 5000,
+              encoding: "utf-8",
+              stdio: ["ignore", "pipe", "pipe"],
+            }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+            if (listResult.status === 0) {
+              ollamaRunning = true;
+              const lines = listResult.stdout?.split("\n") ?? [];
+              for (const line of lines) {
+                const name = line.split(/\s+/)[0];
+                if (name && name !== "NAME") ollamaModels.push(name);
+              }
+            }
+          } catch {
+            // ollama list fails if server not running — that's fine
+          }
+        }
+      } catch {
+        // ollama not found
+      }
+
+      try {
+        const whichLlama = spawnSync("which", ["llama-server"], {
+          timeout: 3000,
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "pipe"],
+        }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+        llamaDetected = whichLlama.status === 0;
+      } catch {
+        // not found
+      }
+
+      try {
+        const req = createRequire(import.meta.url);
+        try {
+          req.resolve("onnxruntime-node");
+          onnxDetected = true;
+        } catch {
+          // not in node_modules
+        }
+      } catch {
+        // require error
+      }
+
+      // --- 3. Build choices ---
+      interface Choice {
+        label: string;
+        value: string;
+      }
+      const choices: Choice[] = [];
+
+      if (ollamaDetected && ollamaRunning) {
+        const model = ollamaModels.find(
+          (m) =>
+            m.includes("nomic-embed") ||
+            m.includes("embed") ||
+            m.includes("mxbai"),
+        );
+        const suggestedModel = model ?? "nomic-embed-text";
+        choices.push({
+          label: `Use Ollama (${suggestedModel}) at localhost:11434`,
+          value: `ollama:${suggestedModel}`,
+        });
+      } else if (ollamaDetected && !ollamaRunning) {
+        choices.push({
+          label: "Ollama detected but server is not running — start it first",
+          value: "ollama:offline",
+        });
+      }
+
+      if (llamaDetected) {
+        choices.push({
+          label: "Use llama.cpp server at localhost:8080",
+          value: "llama:default",
+        });
+      }
+
+      if (onnxDetected) {
+        choices.push({
+          label: "Use ONNX Runtime (experimental, requires config)",
+          value: "onnx:default",
+        });
+      }
+
+      choices.push({
+        label: "Keep TrigramEmbedder (default, no setup)",
+        value: "trigram",
+      });
+
+      // --- 4. Prompt user ---
+      log(`Current embedder: ${currentEmbedder}`);
+      let selected = "trigram";
+      if (choices.length > 1) {
+        try {
+          const labels = choices.map((c) => c.label);
+          const picked = await ctx.ui.select("Select an embedder to configure:", labels);
+          if (picked === undefined) {
+            log("Setup cancelled by user.");
+            return;
+          }
+          const match = choices.find((c) => c.label === picked);
+          selected = match?.value ?? "trigram";
+        } catch {
+          log("Setup cancelled by user.");
+          return;
+        }
+      } else {
+        log("No local embedders detected. Keeping TrigramEmbedder default.");
+      }
+
+      // --- 5. Apply selection ---
+      if (selected.startsWith("ollama:")) {
+        const model = selected.split(":")[1];
+        const url = `http://localhost:11434/api/embeddings`; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+        const lines = [
+          `# Mega-Compact Embedder Configuration — Ollama`,
+          `# Generated by /megasetup at ${new Date().toISOString()}`,
+          `export MEGACOMPACT_EMBEDDING_URL="${url}"`,
+          `# Optional: uncomment to set cache size (default 1000)`,
+          `# export MEGACOMPACT_EMBED_CACHE=1000`,
+        ];
+        const envContent = lines.join("\n") + "\n";
+
+        // Write .mega-compact.env to state dir
+        const stateDir = process.env["MEGACOMPACT_STATE_DIR"] ?? path.join(os.homedir(), ".pi", "mega-compact");
+        try {
+          mkdirSync(stateDir, { recursive: true });
+          writeFileSync(path.join(stateDir, ".mega-compact.env"), envContent, "utf-8");
+        } catch {
+          // non-fatal
+        }
+
+        log(
+          `Configured for Ollama (${model}).\n\nAdd to your shell profile (~/.bashrc, ~/.zshrc, or ~/.config/fish/config.fish):\n\n  source "${path.join(
+            stateDir,
+            ".mega-compact.env",
+          )}"\n\nOr export manually:\n\n  export MEGACOMPACT_EMBEDDING_URL="${url}"\n\nThen restart pi to activate the http embedder.`,
+        );
+      } else if (selected.startsWith("llama:")) {
+        const url = "http://localhost:8080/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+        const lines = [
+          `# Mega-Compact Embedder Configuration — llama.cpp`,
+          `# Generated by /megasetup at ${new Date().toISOString()}`,
+          `export MEGACOMPACT_EMBEDDING_URL="${url}"`,
+        ];
+        const envContent = lines.join("\n") + "\n";
+
+        const stateDir = process.env["MEGACOMPACT_STATE_DIR"] ?? path.join(os.homedir(), ".pi", "mega-compact");
+        try {
+          mkdirSync(stateDir, { recursive: true });
+          writeFileSync(path.join(stateDir, ".mega-compact.env"), envContent, "utf-8");
+        } catch {
+          // non-fatal
+        }
+
+        log(
+          `Configured for llama.cpp server.\n\nAdd to your shell profile:\n\n  source "${path.join(
+            stateDir,
+            ".mega-compact.env",
+          )}"\n\nOr export manually:\n\n  export MEGACOMPACT_EMBEDDING_URL="${url}"\n\nThen restart pi to activate the http embedder.`,
+        );
+      } else if (selected.startsWith("onnx:")) {
+        log(
+          "ONNX Runtime configuration is experimental.\n\nSet MEGACOMPACT_EMBEDDING_URL to your local ONNX server URL, or see docs for manual setup.\nKeeping TrigramEmbedder for now.",
+        );
+      } else {
+        log("Keeping TrigramEmbedder (default). No configuration needed.");
+      }
+     } catch (e) {
+       ctx.ui.notify(`[mega-compact] /mega-setup failed: ${String(e)}`);
+     }
+    },
+  });
+
   // NOTE: /mega-tier was removed in S24. The tier the user sees is now the LIVE
   // pressure band (low/medium/high/ultra/mega), which climbs automatically as
   // context fills — there is no manual tier to set. See docs/specs/s24-unified-pressure.md.

package/extensions/mega-compact.ts

@@ -30,6 +30,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { closeVectorIndex } from "../src/store/vectorIndex.js";
 import { closeMemoryIndex } from "../src/store/memoryIndex.js";
 import { loadConfig } from "./mega-config.js";
+import { loadMegaEnv } from "./mega-runtime/env-loader.js";
 import { MegaRuntime } from "./mega-runtime.js";
 import { registerEventHandlers } from "./mega-events.js";
 import { registerCommands } from "./mega-commands.js";
@@ -41,6 +42,10 @@ import { registerMetricsCommands } from "./mega-metrics-cmds.js";
 import { registerTopicsCommands } from "./mega-topics-cmds.js";
 
 export default function (pi: ExtensionAPI) {
+	// Load .mega-compact.env (written by /mega-setup + dashboard Setup tab) BEFORE
+	// config resolution so the wizard's choices take effect. Shell env wins over
+	// the file (see env-loader.ts). Non-fatal: missing/malformed file is a no-op.
+	loadMegaEnv(loadConfig().stateDir);
 	const config = loadConfig();
 	// S38.9: preflight env validation — check for obviously invalid values at startup.
 	// Non-fatal: log warnings and fall back to defaults.

package/extensions/mega-config.ts

@@ -111,6 +111,10 @@ export interface MegaConfig {
 	 *  advisory is sent to the user (distinct from the poisoned /clear advise).
 	 *  Default 3. `0` disables the advisory entirely. */
 	providerOutageAdviseThreshold: number;
+	/** R13: when true (default), poisoned-context and provider-outage advisories
+	 *  are dashboard-only (events tab + log) — no user-visible message injection.
+	 *  When false, the legacy sendUserMessage path runs (byte-identical pre-R13). */
+	advisoryChannel: boolean;
 	/** S29: override the auto-compact fire point for tiered configs, as a
 	 *  fraction of the context window (e.g. 0.85). null = inherit the tier's
 	 *  tierPct (default; preserves existing fire points). The context-handler
@@ -160,9 +164,25 @@ export interface MegaConfig {
 	 *  a hit whose summary is ≥ dedupSim similar to a live message — "dedupe on
 	 *  inline/read" so we never re-inject context already resident. */
 	windowDedupe: boolean;
+	/** S53: Recall Tail Injection — inject staged recall block as a user message at
+	 *  the tail of the view when auto is OFF AND no trim action is needed. Default ON
+	 *  (true). When false, restores the pre-sprint systemPrompt prepend behavior. */
+	recallTailInject: boolean;
+	/** A1 PLAN_V2 Phase 2: Message Separation — isolate user/assistant turns
+	 *  from volatile tool results so the prompt-cache prefix stays stable.
+	 *  Default OFF (flag-OFF = byte-identical pre-sprint). */
+	messageSeparation: boolean;
 	debug: boolean;
 	/** Master reconciliation: TUI shutdown widget (MEGACOMPACT_TUI_WIDGET=0 to disable). */
 	tuiWidget: boolean;
+	/** S57 B1: Query reformulation via embedding-neighbor keyword expansion. */
+	ragQueryReformulation: boolean;
+	/** S57 B2: Tiered recall router (L0 cache -> L1 FTS5 -> L2). */
+	ragTieredRouter: boolean;
+	/** S57 B3: Recall quality metrics (precision/recall scoring + logging). */
+	ragRecallMetrics: boolean;
+	/** S57 B4: Memory graph traversal (dashboard-oriented). */
+	ragMemoryGraph: boolean;
 }
 
 function envFlag(name: string, fallback: number): number {
@@ -306,6 +326,7 @@ export function loadConfig(): MegaConfig {
 			"MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD",
 			3,
 		),
+		advisoryChannel: envBool("MEGACOMPACT_ADVISORY_CHANNEL", true),
 		autoPctTrigger,
 		autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
 		dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
@@ -322,7 +343,13 @@ export function loadConfig(): MegaConfig {
 		memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
 		recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
 		windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
+		recallTailInject: envBool("MEGACOMPACT_RECALL_TAIL_INJECT", true),
+		messageSeparation: envBool("MEGACOMPACT_MESSAGE_SEPARATION", false),
 		tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
+		ragQueryReformulation: envBool("MEGACOMPACT_QUERY_REFORMULATION", false),
+		ragTieredRouter: envBool("MEGACOMPACT_TIERED_ROUTER", false),
+		ragRecallMetrics: envBool("MEGACOMPACT_RECALL_METRICS", false),
+		ragMemoryGraph: envBool("MEGACOMPACT_MEMORY_GRAPH", false),
 		// D.1: env-overridable recompact delta (minimum context growth % before
 		// re-compacting instead of replaying the cached live trim). Default 50.
 		recompactPctDelta: envFlag("MEGACOMPACT_RECOMPACT_PCT_DELTA", 50),

package/extensions/mega-events/agent-handlers.ts

@@ -189,7 +189,10 @@ export function registerAgentHandlers(
 							setTimeout(() => {
 								try {
 									if (runtime.rt.sessionId !== liveSid) return; // session reset
-									const since2 = now - (runtime.rt.lastNativeCompactAt ?? 0);
+									// IMPORTANT: recompute Date.now() inside the timeout.
+									// `now` above is the durable-trim handler's timestamp and can be
+									// ~500ms stale by the time this callback runs.
+									const since2 = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
 									if (
 										runtime.rt.lastNativeCompactAt !== stamp &&
 										since2 < cooldownMs
@@ -267,6 +270,16 @@ export function registerAgentHandlers(
 		runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
 		runtime.snapshot(ctx);
 
+		// S53: consume staged recall blocks ONLY if they were actually injected
+		// into a view this turn. If no context event fired (edge: turn ended
+		// before any LLM call), recallInjectedThisTurn stays false and the blocks
+		// remain staged for the next turn's first context event.
+		if (config.recallTailInject && runtime.rt.recallInjectedThisTurn) {
+			runtime.pendingRecallBlock = undefined;
+			runtime.pendingMemoryRecallBlock = undefined;
+			runtime.rt.recallInjectedThisTurn = false;
+		}
+
 		// S43 (per-turn tracking): record one turn row with the cached metrics so
 		// the turn layer is queryable + forkable. Best-effort + non-fatal: a write
 		// failure never breaks the agent loop.
@@ -571,9 +584,12 @@ export function registerAgentHandlers(
 						rawText: (errSig || '').slice(0, 500),
 						...(detail.httpStatus !== undefined ? { httpStatus: detail.httpStatus } : {}),
 					});
-					// (b) one-per-session advise message (throttled by poisonedAdviseSent)
-					if (!runtime.rt.poisonedAdviseSent) {
-						runtime.rt.poisonedAdviseSent = true;
+					// (b) throttle flag: set unconditionally so the advise fires at
+					// most once per session regardless of channel.
+					runtime.rt.poisonedAdviseSent = true;
+					// Legacy flag-OFF path: user-role advise message.
+					// Default ON (advisoryChannel=true): dashboard-only, no user message.
+					if (!config.advisoryChannel) {
 						// PREVENT-PI-003: user-role sendUserMessage only.
 						await safeSendUserMessage(
 							pi,

package/extensions/mega-events/compact-handlers.ts

@@ -69,6 +69,7 @@ async function nudgeResume(pi: ExtensionAPI, runtime: MegaRuntime): Promise<void
 		const now = Date.now();
 		if (now >= runtime.resumeNudgeUntil) {
 			runtime.resumeNudgeUntil = now + 30_000;
+			runtime.rt.extensionInitiatedTurn = true; // R13: suppress self-classification
 			await safeSendUserMessage(
 				pi,
 				"[mega-compact] continue from the compacted context above.",

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

@@ -13,10 +13,8 @@ import type {
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import {
 	openStore,
-	appendRawTranscript,
 	writeCheckpointEpoch,
 	type CheckpointEpoch,
-	type RawTranscriptRow,
 } from "../../src/store/sqlite.js";
 import { epochIdFor } from "../../src/mirror/epoch.js";
 import { autoCompactCheck } from "../../src/compact.js";
@@ -37,84 +35,9 @@ import {
 	pressureRatio,
 	type MegaConfig,
 } from "../mega-config.js";
-import { computeContentDigest } from "../../src/dedup/digest.js";
-
-/**
- * Recursively canonicalize a value for deterministic JSON serialization:
- * - Objects: keys sorted alphabetically, values recursively canonicalized
- * - Arrays: elements recursively canonicalized (array ORDER is preserved)
- * - Primitives: returned as-is
- *
- * F5 fix: shallow-sorted JSON.stringify(content, Object.keys(content).sort())
- * omitted nested keys not in the top-level keys array and only sorted one level.
- * This recursively sorts every object at every depth so semantically-equal
- * differently-ordered content hashes identically.
- */
-function canonicalize(value: unknown): unknown {
-	if (value === null || value === undefined) return value;
-	if (typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(canonicalize);
-	// Plain object: sort keys, recursively canonicalize values.
-	const sorted = Object.keys(value as Record<string, unknown>).sort();
-	const out: Record<string, unknown> = {};
-	for (const k of sorted) {
-		out[k] = canonicalize((value as Record<string, unknown>)[k]);
-	}
-	return out;
-}
-
-/**
- * Convert a pi AgentMessage to a RawTranscriptRow for the DB mirror.
- * content_bytes is canonical JSON (sorted keys, recursive) for deterministic
- * storage; contentHash is the canonical digest (normalize + hash) that matches
- * what dedupTranscript computes so the two pipelines use the same linkage key.
- *
- * F4 fix: the hash key MUST match on both sides of the append/dedup split.
- * Using computeContentDigest here (normalize → hash) ensures content_ref set
- * by dedupTranscript always resolves to an existing dedup_mirror row even for
- * whitespace/case-variant content. F5 fix: recursive canonicalize replaces the
- * broken shallow-sorted JSON.stringify replacer.
- */
-function toRawTranscriptRow(
-	msg: AgentMessage,
-	sessionId: string,
-	epochId: string,
-	currentTurn?: number,
-): 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 bytes: string content → normalize for consistent byte content;
-	// object content → recursive canonicalize then JSON (no replacer).
-	const contentBytes =
-		typeof content === "string"
-			? content // F5: strings are primitives; their byte content is fixed
-			: JSON.stringify(canonicalize(content));
-	// F4 fix: use the same digest as dedupTranscript so contentHash is consistent
-	// on both sides of the append/dedup split. computeContentDigest normalizes
-	// (strip ANSI, NFC, case-fold, collapse whitespace) then hashes → the same
-	// key is stored in raw_transcript.content_hash AND used as the dedup link.
-	const { contentHash } = computeContentDigest(contentBytes);
-	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,
-		// S50: label the row with the turn that produced it (per-turn dedup /
-		// compression-by-turn metrics). Null when the writer omits it (back-compat).
-		turnIndex: currentTurn ?? null,
-	};
-}
+import { appendMirrorMessages } from "./mirror-append.js";
+import { stagedForTail, withRecallTail } from "./recall-tail.js";
+import { buildSeparatedPrompt } from "./separated-prompt.js";
 
 /** Register the context event handler (live-trim auto-trigger). */
 export function registerContextHandler(
@@ -140,6 +63,23 @@ export function registerContextHandler(
 		const usage = ctx.getContextUsage();
 		const pct = usage?.percent;
 		const messages = event.messages;
+		// S53: helper to inject the staged recall/memory block as a user-role
+		// tail message at any view-return point. Returns undefined when nothing
+		// is staged (or the flag is OFF) so the caller falls through to its
+		// normal return. The F3 mirror append (above the gates) runs on the
+		// REAL transcript before any view is built, so the injected tail never
+		// reaches raw_transcript (PREVENT-PI: append-only, view-only).
+		const tailResult = (msgs?: readonly AgentMessage[]) => {
+			const base = msgs ?? messages;
+			if (!stagedForTail(runtime, config) && !config.messageSeparation) return undefined;
+			let result: AgentMessage[] = stagedForTail(runtime, config)
+				? withRecallTail(base, runtime, config)
+				: (base as AgentMessage[]);
+			if (config.messageSeparation) {
+				result = buildSeparatedPrompt(result);
+			}
+			return { messages: result };
+		};
 		// Always track context for the dashboard/widget, even when auto is off.
 		// (v0.8 regression: !config.auto gate sat above this, leaving ctx stats
 		// null -> widget '?% / ?/?' when auto disabled. Track first, THEN gate.)
@@ -162,30 +102,35 @@ export function registerContextHandler(
 		runtime.lastCtxPercent = pct ?? null;
 		runtime.lastCtxWindow = usage?.contextWindow ?? 0;
 		runtime.snapshot(ctx);
-		if (!config.auto) return;
+		if (!config.auto) {
+			const tailed = tailResult();
+			if (tailed) return tailed;
+			return;
+		}
 
 		const view = viewForFallback ?? runtime.engineView(messages);
 
-		// 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,
+		// S27 DB-mirror: append 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).
+			// F3: high-water mark (mirror-append.ts) skips already-processed
+			// messages on subsequent events. On fork/rewind (shorter list or
+			// boundary hash mismatch) the mark is dropped, falling back to a
+			// full reprocess.
+			if (config.dbMirror) {
+				try {
+					const db = openStore(runtime.currentStateDir);
+					appendMirrorMessages(
+						db,
+						messages,
 						runtime.rt.sessionId,
-						epochId,
+						epochIdFor(runtime.rt.sessionId),
 						runtime.currentTurn,
 					);
-					if (raw) appendRawTranscript(db, raw);
+				} catch (e) {
+					runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
 				}
-			} catch (e) {
-				runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
 			}
-		}
 
 		// S29 FAST GATE: drive the auto-trigger off the context % (the number the
 		// menu bar shows), NOT the token count — the model under-reports tokens,
@@ -205,18 +150,18 @@ export function registerContextHandler(
 			// custom tier OR tiered-but-pct-unavailable → token gate (S27 fallback).
 			if (currentTokens < runtime.effectiveThreshold) {
 				runtime.diagCtxFastGate++;
-				return;
+				return tailResult() ?? undefined;
 			}
 			const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
 			if (!check.shouldCompact) {
 				runtime.diagCtxNoCompact++;
-				return;
+				return tailResult() ?? undefined;
 			}
 			gatePassed = true;
 		}
 		if (!gatePassed) {
 			runtime.diagCtxFastGate++;
-			return;
+			return tailResult() ?? undefined;
 		}
 
 		// D.2: Replay MUST be exempt from debounce — replay is free (no compute,
@@ -249,9 +194,8 @@ export function registerContextHandler(
 				runtime.snapshot(ctx);
 				// v0.8.7: shallow-copy the cached summary so pi's transformContext can't
 				// mutate the shared reference across replays (audit P3).
-				return {
-					messages: [{ ...runtime.trimCache.summaryAgentMsg }, ...recent],
-				};
+				const replayView = [{ ...runtime.trimCache.summaryAgentMsg }, ...recent];
+				return tailResult(replayView) ?? { messages: replayView };
 			}
 			// else: context grew enough → fall through to re-compact (cache is stale)
 		}
@@ -261,7 +205,7 @@ export function registerContextHandler(
 		const now = Date.now();
 		if (now < runtime.debounceUntil) {
 			runtime.diagCtxDebounce++;
-			return;
+			return tailResult() ?? undefined;
 		}
 		runtime.debounceUntil = now + 2000;
 
@@ -290,11 +234,10 @@ export function registerContextHandler(
 				runtime.diagLiveTrimFires++;
 				runtime.diagLiveTrimReplays++;
 				runtime.snapshot(ctx);
-				return {
-					messages: [{ ...runtime.trimCache.summaryAgentMsg }, ...recent],
-				};
+				const skipView = [{ ...runtime.trimCache.summaryAgentMsg }, ...recent];
+				return tailResult(skipView) ?? { messages: skipView };
 			}
-			return;
+			return tailResult() ?? undefined;
 		}
 
 		// S27 DB-mirror: write checkpoint_epoch with deterministic nonce.
@@ -460,7 +403,7 @@ export function registerContextHandler(
 					viewLen: view.length,
 					anchorUserMessages,
 				});
-				return; // unsafe / below anchor floor — no trim this call
+				return tailResult() ?? undefined; // unsafe / below anchor floor — no trim this call
 			}
 			const summaryMsg = liveTrimSummaryMessage({
 				compactedFrom: ran.result.compactedFrom,
@@ -515,10 +458,10 @@ export function registerContextHandler(
 				ctxPct: pct,
 				ctxTokens: usage?.tokens ?? null,
 			});
-			return { messages: [summaryAgentMsg, ...recent] };
+			return tailResult([summaryAgentMsg, ...recent]) ?? { messages: [summaryAgentMsg, ...recent] };
 		} catch {
 			runtime.diagCtxThrown++;
-			return; // non-fatal: no trim this call; the next context event retries
+			return tailResult() ?? undefined; // non-fatal: no trim this call; the next context event retries
 		}
 	});
 }