pi-mega-compact 0.20.86 → 0.20.88

package/dist/src/recall/vote.js

@@ -0,0 +1,217 @@
+/**
+ * recall/vote.ts — the 3-independent-source recall vote (3WF-3).
+ *
+ * Three INDEPENDENT, read-only sources name candidate checkpoints:
+ *   A vector  — raw semantic hits (recall/readonly.ts), cosine 0..1 scale.
+ *   B fts5    — BM25 trigram hits (hydrated to checkpointIds), FTS5 BM25 scale
+ *               (negative score = better match; ranking order is what matters).
+ *   C recency — the N freshest checkpoints by timestamp, query-INDEPENDENT.
+ *               (NOT turn_recall / TurnReader — that would just echo already-
+ *               injected content, not an independent signal.)
+ *
+ * Each source is a different score scale, so they are NOT directly comparable.
+ * We normalize each source's scores to a 0..1 scale (per-source min-max) BEFORE
+ * combining. Averaging raw cosine (0..1) with raw BM25 (arbitrary negative
+ * magnitude) or a recency rank would be meaningless — the largest-magnitude
+ * scale would always dominate. Normalization makes each source a peer voter.
+ *
+ * Overlap rule: a checkpoint named by >=2 of 3 distinct sources short-circuits
+ * as a winner. Fallback (no 2/3 majority): rank all candidates by the
+ * cross-source MEAN of their normalized scores.
+ *
+ * Non-fatal throughout. Pi-agnostic: no pi runtime imports.
+ */
+import { openStore } from "../store/sqlite/utils.js";
+import { fts5SearchScoped, hydrateFts5Hits } from "../store/sqlite/fts5-search.js";
+// The SQLite store is the source of truth (src/store.ts's same-named helper
+// reads the LEGACY gzipped-JSON DR snapshot, which is empty for live sessions —
+// importing it here would silently starve sources B and C). Mirrors the import
+// in vector-search.ts + tieredRouter.ts.
+import { listCheckpoints } from "../store/sqlite.js";
+import { computeContentDigest } from "../dedup/digest.js";
+import { recallRawHits } from "./readonly.js";
+import { Logger } from "../log.js";
+/** Per-source normalization: map raw scores to 0..1 via min-max within source. */
+function normalizeScores(scores) {
+    const map = new Map();
+    if (scores.length === 0)
+        return map;
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const span = max - min;
+    scores.forEach((s, i) => {
+        map.set(i, span === 0 ? 1 : (s - min) / span);
+    });
+    return map;
+}
+/**
+ * Run the three-source recall vote. Returns agreement winners + a per-id vote
+ * count + the names of sources that produced no winning candidate. Non-fatal:
+ * any search failure degrades to the remaining sources (empty winners allowed).
+ */
+export function voteRecall(opts, store) {
+    const logger = new Logger();
+    const limit = opts.limit ?? 3;
+    const recencyCount = opts.recencyCount ?? limit;
+    // ── Source A: vector (raw hits, cosine 0..1). ────────────────────────────
+    const vectorCands = recallRawHits({ sessionId: opts.sessionId, query: opts.query, limit }, store).map((h) => ({
+        checkpointId: h.checkpoint.checkpointId,
+        score: h.score,
+        source: "vector",
+    }));
+    // ── Source B: fts5 (BM25, hydrated to checkpointIds). ─────────────────────
+    // Dedup on L0 content digest so the SAME normalized text under two ids does
+    // not double-vote — collapse to one candidate per digest.
+    const fts5Cands = (() => {
+        try {
+            const reader = openStore(store.stateDir);
+            const hits = fts5SearchScoped(opts.query, reader, opts.sessionId, limit);
+            // FTS5 returns scores ordered best-first (bm25 asc); lower = better.
+            // We keep the raw score (negative-is-better) and flip in normalization.
+            const hydrated = hydrateFts5Hits(hits, opts.sessionId, store.stateDir);
+            // Dedup on checkpointId so the same checkpoint cannot double-count, AND
+            // on the L0 CONTENT digest so identical normalized text stored under two
+            // different ids collapses to one vote. The digest is taken over the
+            // joined `summary` (real content): hashing the id string would be a
+            // no-op tier, since ids are unique by definition.
+            const seenDigest = new Set();
+            const seenId = new Set();
+            const out = [];
+            for (const h of hydrated) {
+                if (seenId.has(h.checkpointId))
+                    continue;
+                seenId.add(h.checkpointId);
+                const digest = computeContentDigest(h.summary).contentHash;
+                if (seenDigest.has(digest))
+                    continue;
+                seenDigest.add(digest);
+                out.push({ checkpointId: h.checkpointId, score: h.score, source: "fts5" });
+            }
+            return out;
+        }
+        catch {
+            return [];
+        }
+    })();
+    // ── Source C: recency (N freshest checkpoints, query-independent). ────────
+    // Timestamp-ordered; the lower the index the fresher. Score = recency rank
+    // (fresh = high) so normalization treats newest as best.
+    const recencyCands = (() => {
+        try {
+            const cps = listCheckpoints(opts.sessionId, store.stateDir)
+                .filter((c) => c.dedupStatus !== "removed")
+                .sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0))
+                .slice(0, recencyCount);
+            return cps.map((cp, i) => ({
+                checkpointId: cp.checkpointId,
+                // Fresher => higher raw score (recency rank). Normalized below.
+                score: cps.length - i,
+                source: "recency",
+            }));
+        }
+        catch {
+            return [];
+        }
+    })();
+    const sources = [
+        { name: "vector", cands: vectorCands },
+        { name: "fts5", cands: fts5Cands },
+        { name: "recency", cands: recencyCands },
+    ];
+    // Per-source normalization to 0..1 so the three scales are comparable.
+    const perSource = sources.map((s) => ({
+        name: s.name,
+        norm: normalizeScores(s.cands.map((c) => c.score)),
+    }));
+    // Aggregate: best normalized score per source per checkpointId + vote count.
+    const bestScoreBySource = new Map();
+    const seenIds = new Set();
+    for (const src of sources) {
+        const norm = perSource.find((p) => p.name === src.name).norm;
+        const bestByCp = new Map();
+        src.cands.forEach((c, i) => {
+            const n = norm.get(i) ?? 0;
+            const prev = bestByCp.get(c.checkpointId);
+            if (prev === undefined || n > prev)
+                bestByCp.set(c.checkpointId, n);
+            seenIds.add(c.checkpointId);
+        });
+        bestScoreBySource.set(src.name, bestByCp);
+    }
+    // Vote count = number of DISTINCT sources naming each checkpointId.
+    const votes = {};
+    const sumByCp = new Map();
+    for (const id of seenIds) {
+        let count = 0;
+        let sum = 0;
+        for (const src of sources) {
+            const m = bestScoreBySource.get(src.name);
+            if (m.has(id)) {
+                count++;
+                sum += m.get(id);
+            }
+        }
+        votes[id] = count;
+        sumByCp.set(id, sum);
+    }
+    /** Mean normalized score across the sources that named `id`. */
+    const meanScore = (id) => (sumByCp.get(id) ?? 0) / (votes[id] ?? 1);
+    // Short-circuit: >=2 of 3 distinct sources => winner (agreement). Ranked by
+    // vote count first (stronger agreement wins), then by mean normalized score —
+    // the validator consumes this list in order and takes the first that passes,
+    // so the ordering IS the ranking and must not be Set-insertion order.
+    const winners = [];
+    const divergent = new Set(sources.map((s) => s.name));
+    const agreed = [...seenIds]
+        .filter((id) => (votes[id] ?? 0) >= 2)
+        .sort((a, b) => (votes[b] ?? 0) - (votes[a] ?? 0) || meanScore(b) - meanScore(a));
+    for (const id of agreed) {
+        const cand = (() => {
+            for (const src of sources) {
+                const c = src.cands.find((x) => x.checkpointId === id);
+                if (c)
+                    return c;
+            }
+            return null;
+        })();
+        if (cand)
+            winners.push(cand);
+    }
+    if (winners.length === 0) {
+        // Fallback (no 2-of-3 agreement): rank by cross-source MEAN normalized score.
+        const ranked = [...seenIds].sort((a, b) => meanScore(b) - meanScore(a));
+        for (const id of ranked) {
+            const cand = (() => {
+                for (const src of sources) {
+                    const c = src.cands.find((x) => x.checkpointId === id);
+                    if (c)
+                        return c;
+                }
+                return null;
+            })();
+            if (cand)
+                winners.push(cand);
+        }
+    }
+    // Divergence = a source that named NONE of the winning checkpoints. This must
+    // be computed per SOURCE against the winning ID SET, not from `winner.source`
+    // (a winner is one candidate object carrying a single source label, so an id
+    // agreed on by all three sources would still credit only one of them).
+    const winningIds = new Set(winners.map((w) => w.checkpointId));
+    for (const src of sources) {
+        if (src.cands.some((c) => winningIds.has(c.checkpointId))) {
+            divergent.delete(src.name);
+        }
+    }
+    if (divergent.size > 0) {
+        logger.info("recall_vote_divergence", {
+            divergentSources: [...divergent],
+            winnerCount: winners.length,
+        });
+    }
+    return {
+        winners,
+        votes,
+        divergentSources: [...divergent],
+    };
+}

package/dist/src/store/sqlite/fts5-search.js

@@ -11,6 +11,7 @@
  * time automatically — no manual n-gram splitting needed. The BM25 rank from
  * fts5 ranks results by trigram-overlap density.
  */
+import { listCheckpoints } from "./checkpoints.js";
 /**
  * Search the context_chunks_trgm FTS5 table for checkpoints whose
  * `normalized_text` matches `query` via trigram similarity.
@@ -66,3 +67,28 @@ export function fts5SearchScoped(query, reader, sessionId, limit = 10) {
     // No session filter — plain FTS5 search across all sessions.
     return fts5Search(query, reader, limit);
 }
+/**
+ * Hydrate FTS5 hits (which only carry checkpoint `id` + BM25 `score`, with NO
+ * checkpoint object) by joining against the real stored checkpoints. Mirrors the
+ * private `hydrateHits` in tieredRouter.ts (listCheckpoints → Map on
+ * checkpointId → join, dropping ids with no checkpoint).
+ *
+ * The joined `summary` is returned alongside the id because the 3WF-3 voter
+ * dedups candidates on the L0 CONTENT digest — hashing the id string instead
+ * would be a no-op tier (ids are already unique), silently disabling the check.
+ *
+ * @param hits      Raw Fts5Hit rows (id + BM25 score).
+ * @param sessionId Session scope used to fetch the checkpoint set.
+ * @param stateDir  On-disk state dir for the sync store.
+ */
+export function hydrateFts5Hits(hits, sessionId, stateDir) {
+    const cps = listCheckpoints(sessionId, stateDir);
+    const cpMap = new Map(cps.map((cp) => [cp.checkpointId, cp]));
+    const out = [];
+    for (const h of hits) {
+        const cp = cpMap.get(h.id);
+        if (cp)
+            out.push({ checkpointId: h.id, score: h.score, summary: cp.summary });
+    }
+    return out;
+}

package/extensions/dashboard-server/routes-rag-settings-helpers.ts

@@ -241,6 +241,7 @@ export const SETTINGS: ReadonlyArray<SettingGroup> = [
 			num("MEGACOMPACT_L2_THRESHOLD", "L2 Cosine Threshold", "L2 semantic dedup firing point", 0.85, 0, 1),
 			num("MEGACOMPACT_L1_JACCARD", "L1 Jaccard Threshold", "L1 MinHash near-dup threshold", 0.8, 0, 1),
 			num("MEGACOMPACT_DEDUP_SIM", "Dedup Similarity", "Legacy content-similarity fallback", 0.9, 0, 1),
+			num("MEGACOMPACT_RECALL_MIN_COSINE", "Recall Min Cosine (same-repo)", "3WF-3 same-repo floor the 3-source validator applies to the top winner (cross-repo 0.90 stays separate)", 0.12, 0, 1),
 			num("MEGACOMPACT_MMR_LAMBDA", "MMR Lambda", "Maximal Marginal Relevance diversity", 0.5, 0, 1),
 			num("MEGACOMPACT_SEMDEDUP_COSINE", "SemDeDup Cosine", "Offline SemDeDup pair threshold", 0.95, 0, 1),
 			num("MEGACOMPACT_CONSOLIDATE_COSINE", "Consolidate Cosine", "Memory consolidation merge threshold", 0.7, 0, 1),

package/extensions/mega-config-types.ts

@@ -119,6 +119,11 @@ export interface MegaConfig {
 	 *  tighter than same-repo so only genuinely-relevant cross-repo context is
 	 *  injected. */
 	crossRepoCosine: number;
+	/** Same-repo recall cosine floor (3WF-3). Default 0.12. SEPARATE from
+	 *  `crossRepoCosine` (S17, default 0.90 — stricter, cross-repo only). The
+	 *  3-source validator applies this to the top winner; hits below it are
+	 *  rejected in favor of the next-ranked candidate or the provenance floor. */
+	recallMinCosine: number;
 	/** Memory-RAG auto-review enabled (S20). Every memoryReviewInterval turns the
 	 *  conversation is auto-reviewed into durable add/replace/remove memories. */
 	memoryAutoReview: boolean;

package/extensions/mega-config.ts

@@ -217,6 +217,12 @@ export function loadConfig(): MegaConfig {
 		autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
 		crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
 		crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
+		// 3WF-3: SAME-repo recall cosine floor applied by the 3-source validator to
+		// the top winner. SEPARATE from crossRepoCosine (S17, default 0.90, stricter
+		// and cross-repo only). This same-repo floor is permissive by default (0.12)
+		// so recall still surfaces loosely-relevant within-repo context while
+		// rejecting effectively-unrelated hits. Mirrors src/config.ts RECALL_MIN_COSINE.
+		recallMinCosine: Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12"),
 		memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),
 		memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
 		recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),

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

@@ -0,0 +1,90 @@
+/**
+ * context-handler/injectionConfirm.fixture.ts — shared fixtures for the 3WF-4
+ * InjectionConfirm tests.
+ *
+ * Split out so each test file stays under the extensions/300-soft-cap the way
+ * src/recall/recall3wf.fixture.ts does for 3WF-3. These are REAL fixtures, not
+ * mocks/stubs: a REAL VectorStore over a temp stateDir with REAL checkpoints
+ * persisted via compactSession; the MegaRuntime is a minimal typed stub exposing
+ * only the fields confirmInjection touches (store, pendingRecallBlock,
+ * pendingMemoryRecallBlock, appendEvent), matching the triggerGuard/thrashGuard
+ * test conventions.
+ */
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { VectorStore } from "../../../src/vectorStore.js";
+import { compactSession } from "../../../src/engine.js";
+import type { MegaRuntime } from "../../mega-runtime.js";
+import type { MegaConfig } from "../../mega-config.js";
+
+/** Real EngineMessage fixture. */
+export function msg(role: "user" | "assistant", text: string): any {
+	return { role, text };
+}
+
+/** A user-role AgentMessage carrying `text` (the tail-block shape). */
+export function userMsg(text: string): AgentMessage {
+	return { role: "user", content: text, timestamp: 1 } as unknown as AgentMessage;
+}
+
+/** Recorded appendEvent calls, for telemetry assertions. */
+export interface RecordedEvent {
+	name: string;
+	payload: Record<string, unknown>;
+}
+
+/** Fresh isolated state dir per VectorStore. */
+export function freshStore(): { store: VectorStore; dir: string } {
+	const dir = mkdtempSync(join(tmpdir(), "mc-inject-"));
+	return { store: new VectorStore({ dedupSim: 0.9, stateDir: dir }), dir };
+}
+
+/** Persist N distinct checkpoints with ascending timestamps. */
+export function seed(store: VectorStore, topics: string[], sid = "sess_inject"): void {
+	topics.forEach((t, i) => {
+		compactSession(
+			{
+				sessionId: sid,
+				messages: [msg("user", t), msg("assistant", "ok")],
+				keepFrom: 2,
+				timestamp: i + 1,
+			},
+			store,
+		);
+	});
+}
+
+/** Minimal MegaRuntime stub exposing only the confirmInjection touch-points. */
+export function runtimeStub(
+	store: VectorStore,
+	over: Partial<{
+		pendingRecallBlock: string | undefined;
+		pendingMemoryRecallBlock: string | undefined;
+	}> = {},
+): { runtime: MegaRuntime; events: RecordedEvent[] } {
+	const events: RecordedEvent[] = [];
+	const runtime = {
+		store,
+		pendingRecallBlock: over.pendingRecallBlock,
+		pendingMemoryRecallBlock: over.pendingMemoryRecallBlock,
+		perfTurnStart: undefined,
+		rt: { recallInjectedThisTurn: false },
+		appendEvent: (name: string, payload: Record<string, unknown>) => {
+			events.push({ name, payload });
+		},
+	} as unknown as MegaRuntime;
+	return { runtime, events };
+}
+
+/** Config stub: only the flags confirmInjection reads. */
+export function configStub(
+	over: Partial<{ threeWayFailback: boolean; recallTailInject: boolean }> = {},
+): MegaConfig {
+	return {
+		threeWayFailback: over.threeWayFailback ?? true,
+		recallTailInject: over.recallTailInject ?? true,
+	} as unknown as MegaConfig;
+}

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

@@ -0,0 +1,168 @@
+/**
+ * context-handler/injectionConfirm.ts — 3WF-4 InjectionConfirm.
+ *
+ * QA amendment A3 (binding): pi exposes NO prompt readback API, so the only
+ * verifiable proxy for what the provider will actually receive is the pre-LLM
+ * message list. In DEFAULT tail mode (`recallTailInject` ON) the staged recall
+ * block rides in as a user-role tail message, so we assert the block's marker
+ * text is present in the message list we are about to return. In LEGACY prepend
+ * mode (`recallTailInject` OFF) the block never enters the message list at all,
+ * so the guard degrades to a string-contains check over our own composed return
+ * value and never reports a false miss.
+ *
+ * Recovery ladder when the marker is absent (tail mode only):
+ *   1. recomposed — rebuild the view from the runtime's pending blocks via the
+ *      SAME `buildTailResult` composition the handler uses (self-repair on this
+ *      event; the user sees nothing).
+ *   2. floor — nothing pending either: append the shared provenance floor text
+ *      (src/failback/floor.ts) as a user-role tail message so the model is never
+ *      silently left with no compacted-context provenance at all.
+ *
+ * Stack position: wraps the `tailResult` closure returned by buildTailResult, so
+ * EVERY return point of the context handler (gate / replay / debounce /
+ * thrash-guard / pipeline / live-trim) is verified with one wiring point.
+ *
+ * Non-fatal everywhere: any throw degrades to the unverified view (pre-sprint
+ * behavior). Flag OFF => the wrapper is never installed (byte-identical).
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { MegaRuntime } from "../../mega-runtime.js";
+import type { MegaConfig } from "../../mega-config.js";
+import type { InjectionVerdict } from "../../../src/failback/types.js";
+import { vectorList } from "../../../src/vectorStore.js";
+import { normalizeSessionId } from "../../../src/store.js";
+import { buildFloorBlock } from "../../../src/failback/floor.js";
+import { withRecallTail } from "../recall-tail.js";
+import { messageContentText } from "./messageText.js";
+
+/** A composed context view (the shape every handler return point produces). */
+export interface TailView {
+	messages: AgentMessage[];
+}
+
+/** The staged blocks + mode this pass verifies (pure inputs, no pi runtime). */
+export interface ConfirmInput {
+	/** The staged block text expected to have landed (null => nothing to verify). */
+	staged: string | null;
+	/** False in legacy prepend mode: verify the return string, not the list. */
+	tailMode: boolean;
+}
+
+/**
+ * The marker substring used to locate a staged block inside a message. The
+ * block's first non-empty line, capped, so prompt reshapes (cache striping /
+ * message separation) that regroup messages cannot defeat the match, while a
+ * genuinely dropped block still fails it.
+ */
+export function blockMarker(block: string): string {
+	const line = block
+		.split("\n")
+		.map((l) => l.trim())
+		.find((l) => l.length > 0);
+	return (line ?? "").slice(0, 80);
+}
+
+/**
+ * PURE decision function: did the staged block land in this view, and if not,
+ * which rung should repair it? Takes the already-extracted message texts so it
+ * stays free of pi types and is directly unit-testable.
+ */
+export function decideInjection(
+	input: ConfirmInput,
+	messageTexts: readonly string[],
+	hasPendingBlocks: boolean,
+): InjectionVerdict {
+	const marker = input.staged ? blockMarker(input.staged) : "";
+	// Nothing staged => nothing to assert; NOT a miss. Injecting a floor here
+	// would push provenance text into sessions that never had recall to lose.
+	if (!marker) return { landed: true, recovered: "none" };
+	const landed = messageTexts.some((t) => t.includes(marker));
+	if (landed) return { landed: true, recovered: "none" };
+	// Absent: recompose when the runtime still holds pending blocks, else floor.
+	return { landed: false, recovered: hasPendingBlocks ? "recomposed" : "floor" };
+}
+
+/** Append `text` as a user-role tail message (same shape as recall-tail.ts). */
+function withFloorTail(view: TailView, text: string): TailView {
+	const tailMsg = {
+		role: "user" as const,
+		content: text,
+		timestamp: Date.now(),
+	} as unknown as AgentMessage;
+	return { messages: [...view.messages, tailMsg] };
+}
+
+/**
+ * Thin caller: verify (and if needed repair) one composed view. Returns the view
+ * to actually return from the handler. `sessionId` sources the floor checkpoints.
+ *
+ * The recompose rung deliberately re-appends via `withRecallTail` onto the
+ * ALREADY-COMPOSED view rather than re-running `buildTailResult`: the reshape
+ * stages (cache striping / message separation) are the realistic way a tail
+ * message gets regrouped away, and re-running the same composition would
+ * reproduce the same loss. Appending after the reshape is the actual repair, and
+ * it keeps the PREVENT-PI-001/002 tail-append invariant (a single user-role
+ * message after a complete prefix can never split a toolCall/toolResult pair).
+ */
+export function confirmInjection(
+	runtime: MegaRuntime,
+	config: MegaConfig,
+	view: TailView,
+	sessionId: string,
+): TailView {
+	try {
+		if (!config.threeWayFailback) return view;
+		// What the tail composition was supposed to inject. BOTH staged blocks
+		// count: withRecallTail joins recall + memory blocks into one tail
+		// message, so either one going missing is a real injection failure.
+		const staged =
+			runtime.pendingRecallBlock ?? runtime.pendingMemoryRecallBlock ?? null;
+		// Can the recompose rung actually re-append? Only when a block is still
+		// staged on the runtime. When it is not (blocks consumed between
+		// composition and this check), or when withRecallTail declines to append,
+		// the ladder falls through to the floor rung below.
+		const hasPending =
+			runtime.pendingRecallBlock != null ||
+			runtime.pendingMemoryRecallBlock != null;
+		// Legacy prepend mode: the block is not expected in the message list —
+		// verify our composed return value contains it instead (A3 degrade path).
+		if (!config.recallTailInject) {
+			const composed = view.messages.map(messageContentText).join("\n");
+			const marker = staged ? blockMarker(staged) : "";
+			runtime.appendEvent("injection_confirmed", {
+				mode: "prepend",
+				landed: marker ? composed.includes(marker) : true,
+			});
+			return view;
+		}
+		const verdict = decideInjection(
+			{ staged, tailMode: true },
+			view.messages.map(messageContentText),
+			hasPending,
+		);
+		if (verdict.landed) {
+			runtime.appendEvent("injection_confirmed", { mode: "tail", landed: true });
+			return view;
+		}
+		if (verdict.recovered === "recomposed") {
+			const rebuilt = withRecallTail(view.messages, runtime, config);
+			// withRecallTail returns the input array unchanged on failure; only
+			// treat a genuine append as a recovery.
+			if (rebuilt.length > view.messages.length) {
+				runtime.appendEvent("injection_recovered", { via: "recomposed" });
+				return { messages: rebuilt };
+			}
+		}
+		const floor = buildFloorBlock(
+			vectorList(runtime.store, normalizeSessionId(sessionId)),
+		);
+		runtime.appendEvent("injection_recovered", {
+			via: "floor",
+			basis: floor.basis,
+		});
+		return withFloorTail(view, floor.text);
+	} catch {
+		// Non-fatal: return the unverified view (pre-sprint behavior).
+		return view;
+	}
+}

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

@@ -30,6 +30,10 @@ import { normalizeSessionId } from "../../../src/store.js";
 import { recall } from "../../../src/engine.js";
 import { formatRecallBlock } from "../../../src/recall.js";
 import { vectorStats, vectorList } from "../../../src/vectorStore.js";
+import {
+	buildFloorBlock as sharedFloorBlock,
+	FLOOR_UNAVAILABLE_TEXT,
+} from "../../../src/failback/floor.js";
 import { recentUserQuery } from "../../mega-runtime.js";
 
 /** One-shot completion marker per MegaRuntime (dies with the runtime). */
@@ -108,30 +112,18 @@ export function runTriggerGuard(
 	}
 }
 
-/** Build the provenance floor string from the session's newest checkpoint. */
+/**
+ * Build the provenance floor string from the session's newest checkpoint.
+ *
+ * 3WF-4: the text construction moved to the SHARED pure builder
+ * (src/failback/floor.ts) — this keeps the store read (`vectorList`, unfiltered,
+ * exactly as 3WF-1 shipped) and the string return type, so output is
+ * byte-identical to the pre-refactor version.
+ */
 function buildFloorBlock(runtime: MegaRuntime, sid: string): string {
 	try {
-		const cps = vectorList(runtime.store, sid);
-		let newest = cps[0];
-		for (const cp of cps) {
-			if (!newest || (cp.timestamp ?? 0) > (newest.timestamp ?? 0)) newest = cp;
-		}
-		const summary = newest?.summary?.trim();
-		if (summary) {
-			return (
-				"The following compacted context is the most recent checkpoint from " +
-				"this session (recall found no query-relevant match):\n\n" + summary
-			);
-		}
-		return (
-			"This session has compacted context but recall could not surface a " +
-			"checkpoint relevant to the current request; the most recent checkpoint " +
-			"summary is unavailable."
-		);
+		return sharedFloorBlock(vectorList(runtime.store, sid)).text;
 	} catch {
-		return (
-			"This session has compacted context but recall could not surface a " +
-			"checkpoint relevant to the current request."
-		);
+		return FLOOR_UNAVAILABLE_TEXT;
 	}
 }

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

@@ -24,6 +24,7 @@ import { piCompactWouldNoop } from "../mega-pipeline.js";
 import type { MegaConfig } from "../mega-config.js";
 import { buildTailResult } from "./context-handler/tailResult.js";
 import { runTriggerGuard } from "./context-handler/triggerGuard.js";
+import { confirmInjection } from "./context-handler/injectionConfirm.js";
 import { persistEpochAndMaintain } from "./context-handler/afterCompact.js";
 import { appendMirrorAndLedger } from "./context-handler/dbMirrorAppend.js";
 import { evaluateGate, thrashGuardBlocks } from "./context-handler/gateCheck.js";
@@ -72,7 +73,21 @@ export function registerContextHandler(
 		// 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.
-		const tailResult = buildTailResult(runtime, config, messages);
+		const composeTail = buildTailResult(runtime, config, messages);
+		// 3WF-4 InjectionConfirm: wrap the tail factory so EVERY return point of
+		// this handler (gate / replay / debounce / thrash-guard / pipeline /
+		// live-trim) is verified — the staged block's marker must be present in
+		// the message list pi will send (tail mode), else we re-compose from the
+		// runtime's pending blocks and finally fall back to the shared floor.
+		// A composition that yields nothing staged (undefined) is passed through
+		// untouched, so flag-OFF and no-recall paths are byte-identical.
+		const tailResult: typeof composeTail = config.threeWayFailback
+			? (msgs) => {
+					const view = composeTail(msgs);
+					if (!view) return view;
+					return confirmInjection(runtime, config, view, ctx.sessionManager.getSessionId());
+				}
+			: composeTail;
 		// 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.)