pi-mega-compact 0.20.85 → 0.20.87

package/extensions/mega-pipeline/recall/impl.ts

@@ -0,0 +1,312 @@
+/**
+ * recall/impl.ts — unified Layer-5 recall pipeline implementation (3WF-3 split).
+ *
+ * Behavior is UNCHANGED from the pre-split recall.ts. `doRecall` is the ONE path
+ * that injects (sync). `doRecallAsync` augments with optional cross-repo HNSW
+ * on resume / /mega-recall --cross-repo. Both mutate the shared MegaRuntime
+ * (token accounting, ticker, dashboard events). The shell recall.ts re-exports
+ * these names so `export * from "./mega-pipeline/recall.js"` stays byte-stable.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import {
+	recallAndInline,
+	recallAndInlineAsync,
+	formatRecallBlock,
+	type RecallInjectResult,
+} from "../../../src/recall.js";
+import { normalizeSessionId } from "../../../src/store.js";
+import {
+	incRecallInjected,
+	incCacheHitTokens,
+	getIndexDir,
+} from "../../../src/store/sqlite.js";
+import {
+	ensureConversationIdFor,
+	recordTurnWrite,
+	recordRecallWrite,
+} from "../../mega-turn-store.js";
+import { type MegaRuntime, C } from "../../mega-runtime.js";
+import { recordRecallLatency } from "../../mega-runtime/vc-observer.js";
+import type { MegaConfig } from "../../mega-config.js";
+
+/**
+ * Unified recall (Layer 5). The ONE path that injects. Returns the recall
+ * result; callers decide whether to stage it for before_agent_start (resume)
+ * or report it (command).
+ */
+export function doRecall(
+	runtime: MegaRuntime,
+	config: MegaConfig,
+	ctx: ExtensionContext,
+	query: string,
+	source: "resume" | "command",
+) {
+	runtime.bindRepo(ctx.cwd);
+	const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+	// Live window text for inline dedupe (Fix C): drop recalled checkpoints that
+	// are already resident in the session, so recall never re-injects context the
+	// model can already see. Best-effort — an empty window just skips dedupe.
+	const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+	const recallStartMs = Date.now();
+	const result = recallAndInline(
+		{
+			sessionId: sid,
+			query,
+			limit: config.autoInlineK,
+			source,
+			skipInjected: true,
+			recallMaxTokens: config.recallMaxTokens,
+			windowDedupe: config.windowDedupe,
+			liveWindow,
+			dedupSim: config.dedupSim,
+		},
+		runtime.store,
+	);
+	runtime.dashboard.event("recall", {
+		source,
+		query: query.slice(0, 120),
+		injected: result.toInject.length,
+		empty: result.empty,
+	});
+	if (config.ragRecallMetrics && result.hydeInfo) {
+		runtime.dashboard.event("hyde_executed", {
+			sessionId: sid,
+			ran: result.hydeInfo.ran,
+			skipped: result.hydeInfo.skipped,
+			reason: result.hydeInfo.reason,
+			hypotheticalDoc: result.hydeInfo.hypotheticalDoc.slice(0, 400),
+			generationMs: result.hydeInfo.generationMs,
+			rawHitCount: result.hydeInfo.rawHitCount,
+			hydeHitCount: result.hydeInfo.hydeHitCount,
+			fusedHitCount: result.hydeInfo.fusedHitCount,
+			lift: result.hydeInfo.lift,
+		});
+	}
+	if (config.ragRecallMetrics && result.recallMetrics) {
+		runtime.dashboard.event("recall_metrics", {
+			sessionId: sid,
+			hitCount: result.recallMetrics.hitCount,
+			score: result.recallMetrics.score,
+			pass: result.recallMetrics.pass,
+			relevance: result.recallMetrics.relevance,
+			coverage: result.recallMetrics.coverage,
+			diversity: result.recallMetrics.diversity,
+			specificity: result.recallMetrics.specificity,
+		});
+	}
+	if (!result.empty && result.toInject.length > 0) {
+		const top = result.toInject[0];
+		const scorePct = Math.round((top.score ?? 0) * 100);
+		const files = top.checkpoint.filesModified ?? [];
+		const label = files.length
+			? files
+					.map((f) => f.split("/").pop() ?? f)
+					.slice(0, 2)
+					.join(", ")
+			: top.checkpoint.checkpointId;
+		runtime.pushTicker(
+			`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`,
+		);
+		runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
+	}
+	let sumTokens = 0;
+	for (const h of result.toInject) sumTokens += h.checkpoint.tokenEstimate;
+	if (result.toInject.length > 0) {
+		runtime.rt.recallInjections += result.toInject.length;
+		runtime.rt.cacheHitTokens += sumTokens;
+		incRecallInjected(result.toInject.length, runtime.currentStateDir);
+		incCacheHitTokens(sumTokens, runtime.currentStateDir);
+	}
+	// S43: record recall provenance — which checkpoints/summaries served this
+	// turn, their score + source path. Linked to the turn row written at
+	// turn_end via the conversation+turnIndex. Best-effort + non-fatal.
+	// Persists telemetry (HyDE + recall metrics) even when recall returned
+	// no hits, so empty-recall HyDE invocations are still visible in the
+	// dashboard Turns/Metrics tabs.
+	const hasTelemetry =
+		result.hydeInfo != null || result.recallMetrics != null;
+	if (result.toInject.length > 0 || hasTelemetry) {
+		try {
+			const convId = ensureConversationIdFor(
+				config,
+				sid,
+				runtime.currentStateDir,
+			);
+			const turnId = recordTurnWrite(
+				config,
+				{
+					conversationId: convId,
+					sessionId: sid,
+					turnIndex: runtime.currentTurn,
+					role: "assistant",
+					startedAt: Date.now(),
+					hyde: result.hydeInfo ?? undefined,
+					recallMetrics: result.recallMetrics ?? undefined,
+				},
+				runtime.currentStateDir,
+			);
+			if (result.toInject.length > 0) {
+				recordRecallWrite(
+					config,
+					turnId,
+					result.toInject.map((h) => ({
+						checkpointId: h.checkpoint.checkpointId,
+						score: h.score,
+						source:
+							h.raptorLevel !== undefined
+								? "raptor"
+								: h.repoId
+									? "cross-repo"
+									: "flat",
+						raptorLevel: h.raptorLevel,
+					})),
+					runtime.currentStateDir,
+				);
+			}
+		} catch {
+			/* non-fatal: recall provenance never breaks the recall path */
+		}
+	}
+	// VC0A: record recall latency on the eval observer (mode A) so the dashboard
+	// histogram reflects real data. No-op when the observer is absent (flag off /
+	// construction failure).
+	try {
+		recordRecallLatency(runtime, Date.now() - recallStartMs, sid, 0);
+	} catch {
+		/* non-fatal: latency recording never breaks recall */
+	}
+	return result;
+}
+
+/**
+ * S17: async recall with optional cross-repo augmentation. Used on resume
+ * (session_start) and /mega-recall --cross-repo — NEVER from the mid-turn
+ * context handler (that stays sync). Runs the sync same-repo scan first; if it
+ * returns < config.autoInlineK hits AND crossRepo is enabled, awaits the PGlite
+ * HNSW cross-repo path and merges (source-labeled, deduped by checkpointId). The
+ * recallMaxTokens cap + windowDedupe apply to the merged set so cross-repo can
+ * never net-inflate the window. Cross-repo uses a stricter cosine floor
+ * (config.crossRepoCosine) than same-repo. Non-fatal: any async failure returns
+ * the same-repo result unchanged.
+ */
+export async function doRecallAsync(
+	runtime: MegaRuntime,
+	config: MegaConfig,
+	ctx: ExtensionContext,
+	query: string,
+	source: "resume" | "command",
+	opts: { crossRepo?: boolean } = {},
+): Promise<RecallInjectResult> {
+	runtime.bindRepo(ctx.cwd);
+	const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+	const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+	// Sync same-repo first (fast, never blocks).
+	const sameRepo = recallAndInline(
+		{
+			sessionId: sid,
+			query,
+			limit: config.autoInlineK,
+			source,
+			skipInjected: true,
+			recallMaxTokens: config.recallMaxTokens,
+			windowDedupe: config.windowDedupe,
+			liveWindow,
+			dedupSim: config.dedupSim,
+		},
+		runtime.store,
+	);
+	if (!config.crossRepoEnabled || !opts.crossRepo) return sameRepo;
+	if (sameRepo.toInject.length >= config.autoInlineK) return sameRepo; // same-repo satisfied
+	// Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
+	try {
+		const x = await recallAndInlineAsync(
+			{
+				sessionId: sid,
+				query,
+				limit: config.autoInlineK,
+				source,
+				skipInjected: true,
+				recallMaxTokens: config.recallMaxTokens,
+				windowDedupe: config.windowDedupe,
+				liveWindow,
+				dedupSim: config.crossRepoCosine,
+				crossRepo: true,
+				// F2: resolve the machine-wide index dir via the shared resolver so the
+				// cross-repo injected-set dedup works even when MEGACOMPACT_INDEX_DIR is
+				// unset. The env var still wins when set (getIndexDir checks it first);
+				// the default (~/.mega-compact-index) is the same DB mega-commands and the
+				// dashboard read, so injection counts stay consistent. Without this, a
+				// bare `process.env` read returns undefined → cross-repo hits re-inject in
+				// every new session (the global injected-set is never consulted).
+				globalIndexDir: getIndexDir(),
+			},
+			runtime.store,
+		);
+		runtime.dashboard.event("recall-crossrepo", {
+			source,
+			query: query.slice(0, 120),
+			injected: x.toInject.length,
+			sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
+		});
+		// Merge, dedup by checkpointId, respect the same token cap by reformatting.
+		const seen = new Set(
+			sameRepo.toInject.map((h) => h.checkpoint.checkpointId),
+		);
+		const merged = [...sameRepo.toInject];
+		for (const h of x.toInject) {
+			if (!seen.has(h.checkpoint.checkpointId)) {
+				merged.push(h);
+				seen.add(h.checkpoint.checkpointId);
+			}
+		}
+		const block = merged.length ? formatRecallBlock(merged) : "";
+		if (merged.length > 0) {
+			let sumTokens = 0;
+			for (const h of merged) sumTokens += h.checkpoint.tokenEstimate;
+			runtime.rt.recallInjections += merged.length;
+			runtime.rt.cacheHitTokens += sumTokens;
+			incRecallInjected(merged.length, runtime.currentStateDir);
+			incCacheHitTokens(sumTokens, runtime.currentStateDir);
+		}
+		return {
+			toInject: merged,
+			report: merged.map(
+				(h) =>
+					`  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`,
+			),
+			block,
+			empty: merged.length === 0,
+			// H1: merged cross-repo result reuses the same-repo pass's telemetry.
+			hydeInfo: sameRepo.hydeInfo,
+			recallMetrics: sameRepo.recallMetrics,
+		};
+	} catch {
+		return sameRepo; // cross-repo failure → same-repo only (non-fatal)
+	}
+}
+
+/**
+ * Extract the live-window message texts from the session manager (Fix C),
+ * for inline-dedupe of recalled checkpoints. Best-effort: returns [] on any
+ * error so recall falls back to unbounded (still correct, just no dedupe).
+ * Mirrors recentUserQuery's use of sessionEntryToContextMessages.
+ */
+export function extractLiveWindow(ctx: ExtensionContext): string[] {
+	try {
+		const entries = ctx.sessionManager.getEntries();
+		const texts: string[] = [];
+		for (const e of entries) {
+			for (const m of sessionEntryToContextMessages(e)) {
+				const c = (m as { content?: unknown }).content;
+				if (typeof c === "string") texts.push(c);
+				else if (Array.isArray(c))
+					texts.push(c.map((b: { text?: string }) => b.text ?? "").join(" "));
+			}
+		}
+		return texts;
+	} catch {
+		return [];
+	}
+}

package/extensions/mega-pipeline/recall.ts

@@ -1,310 +1,14 @@
 /**
- * recall.ts — unified Layer-5 recall pipeline.
+ * recall.ts — shell re-export for the unified Layer-5 recall pipeline (3WF-3 split).
  *
- * `doRecall` is the ONE path that injects (sync). `doRecallAsync` augments with
- * optional cross-repo HNSW on resume / /mega-recall --cross-repo. Both mutate
- * the shared MegaRuntime (token accounting, ticker, dashboard events).
+ * Delegate-shell pattern: the implementation lives in ./recall/impl.ts (kept
+ * under the 300-line soft cap). All public symbols are re-exported here so
+ * `export * from "./mega-pipeline/recall.js"` (mega-pipeline.ts) and any direct
+ * importers keep resolving with byte-identical names.
  */
 
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
-import {
-	recallAndInline,
-	recallAndInlineAsync,
-	formatRecallBlock,
-	type RecallInjectResult,
-} from "../../src/recall.js";
-import { normalizeSessionId } from "../../src/store.js";
-import {
-	incRecallInjected,
-	incCacheHitTokens,
-	getIndexDir,
-} from "../../src/store/sqlite.js";
-import {
-	ensureConversationIdFor,
-	recordTurnWrite,
-	recordRecallWrite,
-} from "../mega-turn-store.js";
-import { type MegaRuntime, C } from "../mega-runtime.js";
-import { recordRecallLatency } from "../mega-runtime/vc-observer.js";
-import type { MegaConfig } from "../mega-config.js";
-
-/**
- * Unified recall (Layer 5). The ONE path that injects. Returns the recall
- * result; callers decide whether to stage it for before_agent_start (resume)
- * or report it (command).
- */
-export function doRecall(
-	runtime: MegaRuntime,
-	config: MegaConfig,
-	ctx: ExtensionContext,
-	query: string,
-	source: "resume" | "command",
-) {
-	runtime.bindRepo(ctx.cwd);
-	const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
-	// Live window text for inline dedupe (Fix C): drop recalled checkpoints that
-	// are already resident in the session, so recall never re-injects context the
-	// model can already see. Best-effort — an empty window just skips dedupe.
-	const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
-	const recallStartMs = Date.now();
-	const result = recallAndInline(
-		{
-			sessionId: sid,
-			query,
-			limit: config.autoInlineK,
-			source,
-			skipInjected: true,
-			recallMaxTokens: config.recallMaxTokens,
-			windowDedupe: config.windowDedupe,
-			liveWindow,
-			dedupSim: config.dedupSim,
-		},
-		runtime.store,
-	);
-	runtime.dashboard.event("recall", {
-		source,
-		query: query.slice(0, 120),
-		injected: result.toInject.length,
-		empty: result.empty,
-	});
-	if (config.ragRecallMetrics && result.hydeInfo) {
-		runtime.dashboard.event("hyde_executed", {
-			sessionId: sid,
-			ran: result.hydeInfo.ran,
-			skipped: result.hydeInfo.skipped,
-			reason: result.hydeInfo.reason,
-			hypotheticalDoc: result.hydeInfo.hypotheticalDoc.slice(0, 400),
-			generationMs: result.hydeInfo.generationMs,
-			rawHitCount: result.hydeInfo.rawHitCount,
-			hydeHitCount: result.hydeInfo.hydeHitCount,
-			fusedHitCount: result.hydeInfo.fusedHitCount,
-			lift: result.hydeInfo.lift,
-		});
-	}
-	if (config.ragRecallMetrics && result.recallMetrics) {
-		runtime.dashboard.event("recall_metrics", {
-			sessionId: sid,
-			hitCount: result.recallMetrics.hitCount,
-			score: result.recallMetrics.score,
-			pass: result.recallMetrics.pass,
-			relevance: result.recallMetrics.relevance,
-			coverage: result.recallMetrics.coverage,
-			diversity: result.recallMetrics.diversity,
-			specificity: result.recallMetrics.specificity,
-		});
-	}
-	if (!result.empty && result.toInject.length > 0) {
-		const top = result.toInject[0];
-		const scorePct = Math.round((top.score ?? 0) * 100);
-		const files = top.checkpoint.filesModified ?? [];
-		const label = files.length
-			? files
-					.map((f) => f.split("/").pop() ?? f)
-					.slice(0, 2)
-					.join(", ")
-			: top.checkpoint.checkpointId;
-		runtime.pushTicker(
-			`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`,
-		);
-		runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
-	}
-	let sumTokens = 0;
-	for (const h of result.toInject) sumTokens += h.checkpoint.tokenEstimate;
-	if (result.toInject.length > 0) {
-		runtime.rt.recallInjections += result.toInject.length;
-		runtime.rt.cacheHitTokens += sumTokens;
-		incRecallInjected(result.toInject.length, runtime.currentStateDir);
-		incCacheHitTokens(sumTokens, runtime.currentStateDir);
-	}
-	// S43: record recall provenance — which checkpoints/summaries served this
-	// turn, their score + source path. Linked to the turn row written at
-	// turn_end via the conversation+turnIndex. Best-effort + non-fatal.
-	// Persists telemetry (HyDE + recall metrics) even when recall returned
-	// no hits, so empty-recall HyDE invocations are still visible in the
-	// dashboard Turns/Metrics tabs.
-	const hasTelemetry =
-		result.hydeInfo != null || result.recallMetrics != null;
-	if (result.toInject.length > 0 || hasTelemetry) {
-		try {
-			const convId = ensureConversationIdFor(
-				config,
-				sid,
-				runtime.currentStateDir,
-			);
-			const turnId = recordTurnWrite(
-				config,
-				{
-					conversationId: convId,
-					sessionId: sid,
-					turnIndex: runtime.currentTurn,
-					role: "assistant",
-					startedAt: Date.now(),
-					hyde: result.hydeInfo ?? undefined,
-					recallMetrics: result.recallMetrics ?? undefined,
-				},
-				runtime.currentStateDir,
-			);
-			if (result.toInject.length > 0) {
-				recordRecallWrite(
-					config,
-					turnId,
-					result.toInject.map((h) => ({
-						checkpointId: h.checkpoint.checkpointId,
-						score: h.score,
-						source:
-							h.raptorLevel !== undefined
-								? "raptor"
-								: h.repoId
-									? "cross-repo"
-									: "flat",
-						raptorLevel: h.raptorLevel,
-					})),
-					runtime.currentStateDir,
-				);
-			}
-		} catch {
-			/* non-fatal: recall provenance never breaks the recall path */
-		}
-	}
-	// VC0A: record recall latency on the eval observer (mode A) so the dashboard
-	// histogram reflects real data. No-op when the observer is absent (flag off /
-	// construction failure).
-	try {
-		recordRecallLatency(runtime, Date.now() - recallStartMs, sid, 0);
-	} catch {
-		/* non-fatal: latency recording never breaks recall */
-	}
-	return result;
-}
-
-/**
- * S17: async recall with optional cross-repo augmentation. Used on resume
- * (session_start) and /mega-recall --cross-repo — NEVER from the mid-turn
- * context handler (that stays sync). Runs the sync same-repo scan first; if it
- * returns < config.autoInlineK hits AND crossRepo is enabled, awaits the PGlite
- * HNSW cross-repo path and merges (source-labeled, deduped by checkpointId). The
- * recallMaxTokens cap + windowDedupe apply to the merged set so cross-repo can
- * never net-inflate the window. Cross-repo uses a stricter cosine floor
- * (config.crossRepoCosine) than same-repo. Non-fatal: any async failure returns
- * the same-repo result unchanged.
- */
-export async function doRecallAsync(
-	runtime: MegaRuntime,
-	config: MegaConfig,
-	ctx: ExtensionContext,
-	query: string,
-	source: "resume" | "command",
-	opts: { crossRepo?: boolean } = {},
-): Promise<RecallInjectResult> {
-	runtime.bindRepo(ctx.cwd);
-	const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
-	const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
-	// Sync same-repo first (fast, never blocks).
-	const sameRepo = recallAndInline(
-		{
-			sessionId: sid,
-			query,
-			limit: config.autoInlineK,
-			source,
-			skipInjected: true,
-			recallMaxTokens: config.recallMaxTokens,
-			windowDedupe: config.windowDedupe,
-			liveWindow,
-			dedupSim: config.dedupSim,
-		},
-		runtime.store,
-	);
-	if (!config.crossRepoEnabled || !opts.crossRepo) return sameRepo;
-	if (sameRepo.toInject.length >= config.autoInlineK) return sameRepo; // same-repo satisfied
-	// Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
-	try {
-		const x = await recallAndInlineAsync(
-			{
-				sessionId: sid,
-				query,
-				limit: config.autoInlineK,
-				source,
-				skipInjected: true,
-				recallMaxTokens: config.recallMaxTokens,
-				windowDedupe: config.windowDedupe,
-				liveWindow,
-				dedupSim: config.crossRepoCosine,
-				crossRepo: true,
-				// F2: resolve the machine-wide index dir via the shared resolver so the
-				// cross-repo injected-set dedup works even when MEGACOMPACT_INDEX_DIR is
-				// unset. The env var still wins when set (getIndexDir checks it first);
-				// the default (~/.mega-compact-index) is the same DB mega-commands and the
-				// dashboard read, so injection counts stay consistent. Without this, a
-				// bare `process.env` read returns undefined → cross-repo hits re-inject in
-				// every new session (the global injected-set is never consulted).
-				globalIndexDir: getIndexDir(),
-			},
-			runtime.store,
-		);
-		runtime.dashboard.event("recall-crossrepo", {
-			source,
-			query: query.slice(0, 120),
-			injected: x.toInject.length,
-			sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
-		});
-		// Merge, dedup by checkpointId, respect the same token cap by reformatting.
-		const seen = new Set(
-			sameRepo.toInject.map((h) => h.checkpoint.checkpointId),
-		);
-		const merged = [...sameRepo.toInject];
-		for (const h of x.toInject) {
-			if (!seen.has(h.checkpoint.checkpointId)) {
-				merged.push(h);
-				seen.add(h.checkpoint.checkpointId);
-			}
-		}
-		const block = merged.length ? formatRecallBlock(merged) : "";
-		if (merged.length > 0) {
-			let sumTokens = 0;
-			for (const h of merged) sumTokens += h.checkpoint.tokenEstimate;
-			runtime.rt.recallInjections += merged.length;
-			runtime.rt.cacheHitTokens += sumTokens;
-			incRecallInjected(merged.length, runtime.currentStateDir);
-			incCacheHitTokens(sumTokens, runtime.currentStateDir);
-		}
-		return {
-			toInject: merged,
-			report: merged.map(
-				(h) =>
-					`  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`,
-			),
-			block,
-			empty: merged.length === 0,
-			// H1: merged cross-repo result reuses the same-repo pass's telemetry.
-			hydeInfo: sameRepo.hydeInfo,
-			recallMetrics: sameRepo.recallMetrics,
-		};
-	} catch {
-		return sameRepo; // cross-repo failure → same-repo only (non-fatal)
-	}
-}
-
-/**
- * Extract the live-window message texts from the session manager (Fix C),
- * for inline-dedupe of recalled checkpoints. Best-effort: returns [] on any
- * error so recall falls back to unbounded (still correct, just no dedupe).
- * Mirrors recentUserQuery's use of sessionEntryToContextMessages.
- */
-function extractLiveWindow(ctx: ExtensionContext): string[] {
-	try {
-		const entries = ctx.sessionManager.getEntries();
-		const texts: string[] = [];
-		for (const e of entries) {
-			for (const m of sessionEntryToContextMessages(e)) {
-				const c = (m as { content?: unknown }).content;
-				if (typeof c === "string") texts.push(c);
-				else if (Array.isArray(c))
-					texts.push(c.map((b: { text?: string }) => b.text ?? "").join(" "));
-			}
-		}
-		return texts;
-	} catch {
-		return [];
-	}
-}
+export {
+	doRecall,
+	doRecallAsync,
+	extractLiveWindow,
+} from "./recall/impl.js";

package/package.json

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

package/src/config.ts

@@ -144,6 +144,18 @@ export const RAG_HYDE_ENABLED = (): boolean =>
 /** Spec 1: vbrainstorm visual design migration for the dashboard. */
 export const NEW_UI = (): boolean => ragEnabled("MEGACOMPACT_NEW_UI");
 
+// ---------------------------------------------------------------------------
+// 3WF-3 same-repo recall cosine floor. SEPARATE from the S17 cross-repo floor
+// (config.crossRepoCosine, default 0.90 — stricter, cross-repo only). This is
+// the same-repo floor the 3-source validator applies to the top winner. A low
+// default (0.12) keeps recall permissive within a repo while still rejecting
+// effectively-unrelated hits. Call-time read so tests can set the env per-test.
+// ---------------------------------------------------------------------------
+
+/** Same-repo recall cosine floor: top winner must be >= this to be injected. */
+export const RECALL_MIN_COSINE = (): number =>
+	Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+
 // ---------------------------------------------------------------------------
 // Vector-cortex flags + breaker constants (VC0A+). Positive sprint flags,
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts