pi-mega-compact 0.21.1 → 0.21.3

package/dist/config.js

@@ -116,8 +116,19 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // 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(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+/**
+ * Same-repo recall cosine floor: top winner must be >= this to be injected.
+ *
+ * E1 follow-up (PR #18 review): NaN-safe + clamped to [0,1]. A typo'd env var
+ * yielded NaN before; `cosine < NaN` is false, which disabled gate 1 entirely
+ * (every candidate passed). Non-finite falls back to 0.12; out-of-range clamps.
+ */
+export const RECALL_MIN_COSINE = () => {
+    const n = Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+    if (!Number.isFinite(n))
+        return 0.12;
+    return Math.min(1, Math.max(0, n));
+};
 // ---------------------------------------------------------------------------
 // Vector-cortex flags + breaker constants (VC0A+). Positive sprint flags,
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts

package/dist/dedup/l1-minhash.js

@@ -19,6 +19,7 @@ export const SHINGLE_SIZE = 5; // char 5-grams
 const MAX_SHINGLES = 50_000; // QA #7/#15 complexity cap
 const SEED = 0xdeadbeef;
 const P = 2147483647; // 2^31 - 1, Mersenne prime
+const PBigInt = 2147483647n; // BigInt twin for overflow-safe modular reduction
 /** Per-index universal-hashing coefficients, derived deterministically from SEED. */
 function coeffA(i) {
     return (SEED + i * 2 + 1) % P;
@@ -67,10 +68,10 @@ export function minhashSignature(text) {
         const b = coeffB(i);
         let min = P;
         for (const x of grams) {
-            // (a*x + b) mod p — use Number math; a,x < 2^31 so a*x < 2^62, within
-            // double-precision integer range (2^53) only if reduced; reduce a*x first.
-            const ax = (a * (x % P)) % P;
-            const h = (ax + b) % P;
+            // (a*x + b) mod p. a, x < 2^31 so a*x < 2^62 — EXCEEDS 2^53. The naive
+            // (a*(x%P))%P loses precision (verified: a=x=p-1 → lossy 2147483644 vs
+            // exact 1). BigInt is correct + cheap (~5ms per signature).
+            const h = Number((BigInt(a) * BigInt(x % P) + BigInt(b)) % PBigInt);
             if (h < min)
                 min = h;
         }

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -138,6 +138,7 @@ export const SETTINGS = [
         name: "Three-Way Failback",
         settings: [
             boolDirect("MEGACOMPACT_THREE_WAY_FAILBACK", "Three-Way Failback", "Umbrella for the 3-way failback safety system: TriggerGuard (stages a recall block even when session_start never fires), the live-window ReductionValidator + persisted ThrashGuard (stops ineffective compaction re-fire loops), the 3-source read-only recall vote + same-repo relevance floor, and InjectionConfirm (asserts the staged block reached the message list pi sends). OFF = byte-identical pre-3WF behavior (v0.20.83). Runtime reads envBool(plain key), so this uses the plain-write convention (not _DISABLED).", true),
+            boolDirect("MEGACOMPACT_ITHACUS_BRIDGE", "ithacus Bridge", "Mega↔ithacus bridge: gate the child extension + bridge usage that tie this extension to ithacus's durable compaction. Default ON; OFF (=0/`=false`) is byte-identical to pre-bridge behavior — the bridge is only consulted when this is ON. Positive sprint flag. Runtime reads envBool(plain key), so this uses the plain-write convention (not _DISABLED).", true),
             boolDirect("MEGACOMPACT_RECALL_TAIL_INJECT", "Recall Tail Inject", "Compose the staged recall block as a trailing user message on the context event (tail inject) instead of the legacy system-prompt prepend. Tail mode keeps the cache prefix stable and is the mode InjectionConfirm verifies against ContextEvent.messages; OFF falls back to the legacy prepend path (verified by string-contains). Runtime reads envBool(plain key), so this uses the plain-write convention (not _DISABLED).", true),
         ],
     },

package/dist/extensions/mega-compact-child.js

@@ -0,0 +1,126 @@
+/**
+ * mega-compact-child.ts — minimal extension loaded ONLY into dispatched child
+ * pi subprocesses (spawned by ithacus with a second `-e` flag).
+ *
+ * Design: a child is a FRESH pi process started with `--no-extensions -e <this
+ * file>` (see ithacus-spawn.ts). It does NOT receive the parent's MegaConfig and
+ * is a separate process, so it reads its two control env vars directly and owns
+ * its own bridge. It gives children recall-at-start + compaction-on-shutdown via
+ * the mega-compact bridge, with NO tools and NO console output, so it never
+ * pollutes the child's `--mode json` JSONL stdout that ithacus-spawn parses.
+ *
+ * Per the teammate brief this mirrors ithacus-child-mailbox.ts (default export,
+ * no console, dispose on session_shutdown) but registers ZERO tools — registering
+ * any tool risks a pi duplicate-tool-name hard-fail and children need none.
+ *
+ * PREVENT-PI-004: no network. The bridge is a same-repo relative import over a
+ * local sqlite store; the only I/O is the read-only `git rev-parse` inside
+ * repoStateDir. Nothing to flag.
+ */
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import { createMegaBridge } from "../src/bridge.js";
+import { repoStateDir } from "./mega-config.js";
+import { STATE_DIR_DEFAULT } from "../src/config.js";
+/** Default-ON env bool: only `=false`/`=0` disables (matches mega-config envBool). */
+function envBool(name, fallback) {
+    const v = process.env[name];
+    if (v == null || v === "")
+        return fallback;
+    return v === "true" || v === "1";
+}
+/** Extract a recall query from a single AgentMessage (string or content blocks). */
+function messageToText(m) {
+    const c = m.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        return c.map((b) => b.text ?? "").join(" ");
+    return "";
+}
+/** Convert a session's AgentMessages into the bridge's lightweight shape. */
+function toBridgeMessages(ctx) {
+    const out = [];
+    try {
+        for (const entry of ctx.sessionManager.getEntries()) {
+            for (const m of sessionEntryToContextMessages(entry)) {
+                if (m.role === "user" || m.role === "assistant") {
+                    out.push({ role: m.role, text: messageToText(m) });
+                }
+            }
+        }
+    }
+    catch {
+        /* non-fatal: a child without a session manager yields no messages */
+    }
+    return out;
+}
+export default function (pi) {
+    // Flag read at LOAD time: a flag-OFF child registers nothing and a flag-ON
+    // child that never fires a hook pays zero cost (bridge is built lazily).
+    if (!envBool("MEGACOMPACT_ITHACUS_BRIDGE", true))
+        return;
+    let bridge;
+    // Build the bridge lazily on first hook fire so cost is opt-in by usage.
+    const getBridge = () => {
+        if (!bridge) {
+            bridge = createMegaBridge({
+                stateDir: repoStateDir(process.cwd(), STATE_DIR_DEFAULT),
+            });
+        }
+        return bridge;
+    };
+    // S52-style recall injection: prepend staged checkpoints + durable memories
+    // to the system prompt, mirroring the main entry's before_agent_start path.
+    // 4th-layer stability guard: an unset/empty sessionId makes recall silently
+    // useless (the openclaw Date.now() gotcha), so skip outright.
+    pi.on("before_agent_start", async (event) => {
+        try {
+            const sessionId = process.env.ITHACUS_MEGA_SESSION_ID;
+            if (!sessionId || sessionId === "")
+                return undefined;
+            // Prefer the event's raw prompt; fall back to a generic query.
+            const query = event.prompt && event.prompt.trim() ? event.prompt.trim() : "";
+            if (query === "")
+                return undefined;
+            const b = getBridge();
+            const cp = b.recallCheckpoints({ sessionId, query, limit: 3 });
+            const mem = await b.recallMemories({ query, limit: 5 });
+            const blocks = [];
+            if (!cp.empty && cp.block)
+                blocks.push(cp.block);
+            if (!mem.empty && mem.block)
+                blocks.push(mem.block);
+            if (blocks.length === 0)
+                return undefined;
+            return { systemPrompt: `${event.systemPrompt ?? ""}\n\n${blocks.join("\n\n")}` };
+        }
+        catch {
+            // layer b: non-fatal — never break the agent loop. No injection.
+            return undefined;
+        }
+    });
+    // Compaction on shutdown: persist the session's messages as a checkpoint.
+    // Best-effort; non-fatal. Releases the sqlite handle via close().
+    // The bridge is constructed lazily here too: a child that only compacts (no
+    // recall fired) still persists its session. Best-effort; non-fatal.
+    pi.on("session_shutdown", async (_event, ctx) => {
+        try {
+            const sessionId = process.env.ITHACUS_MEGA_SESSION_ID;
+            if (!sessionId || sessionId === "")
+                return;
+            const messages = toBridgeMessages(ctx);
+            if (messages.length === 0)
+                return;
+            await getBridge().compact({ sessionId, messages });
+        }
+        catch {
+            /* non-fatal */
+        }
+        finally {
+            if (bridge) {
+                bridge.close();
+                bridge = undefined;
+            }
+        }
+    });
+}

package/dist/extensions/mega-compact.js

@@ -83,6 +83,16 @@ export default function (pi) {
         console.warn("[mega-compact] MEGACOMPACT_POISONED_REPEAT_THRESHOLD must be >= 1; using default 3");
         config.poisonedContextRepeatThreshold = 3;
     }
+    // E1: validate similarity thresholds — NaN or out of range silently disables
+    // recall dedup (anything >= NaN is false). envFlag guards NaN; clamp the rest.
+    if (!(config.dedupSim > 0 && config.dedupSim <= 1)) {
+        console.warn("[mega-compact] MEGACOMPACT_DEDUP_SIM must be in (0,1]; using default 0.9");
+        config.dedupSim = 0.9;
+    }
+    if (!(config.crossRepoCosine >= 0 && config.crossRepoCosine <= 1)) {
+        console.warn("[mega-compact] MEGACOMPACT_CROSSREPO_COSINE must be in [0,1]; using default 0.9");
+        config.crossRepoCosine = 0.9;
+    }
     const runtime = new MegaRuntime(config);
     registerEventHandlers(pi, runtime, config);
     registerCommands(pi, runtime, config);

package/dist/extensions/mega-config.js

@@ -171,7 +171,7 @@ export function loadConfig() {
         advisoryChannel: envBool("MEGACOMPACT_ADVISORY_CHANNEL", true),
         autoPctTrigger,
         autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
-        dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
+        dedupSim: envFlag("MEGACOMPACT_DEDUP_SIM", 0.9),
         raptorEnabled: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),
         legacyDurableTrim: envBool("MEGACOMPACT_LEGACY_DURABLE_TRIM", false),
         dbMirror: envBool("MEGACOMPACT_DB_MIRROR", false),
@@ -180,13 +180,16 @@ export function loadConfig() {
         turnsDbEnabled: envBool("MEGACOMPACT_TURNS_DB", true),
         autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
         crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
-        crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
+        crossRepoCosine: envFlag("MEGACOMPACT_CROSSREPO_COSINE", 0.9),
         // 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"),
+        // E1 follow-up (PR #18 review): envFlag (Number.isFinite-guarded) like the
+        // dedupSim/crossRepoCosine fix in PR #18 — a typo'd env var must fall back
+        // to 0.12, not yield NaN.
+        recallMinCosine: envFlag("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),
@@ -195,6 +198,11 @@ export function loadConfig() {
         // 3WF-1: TriggerGuard — guarantee a staged recall block on every context
         // event even when session_start never fires. Default ON; OFF = byte-identical.
         threeWayFailback: envBool("MEGACOMPACT_THREE_WAY_FAILBACK", true),
+        // Sprint A: Mega↔ithacus bridge — gate the child extension + bridge usage.
+        // Default ON; OFF (=0/`=false`) = byte-identical pre-bridge behavior.
+        // Runtime reads envBool(plain key), mirroring threeWayFailback (plain-write
+        // convention, not _DISABLED).
+        ithacusBridge: envBool("MEGACOMPACT_ITHACUS_BRIDGE", true),
         // 3WF-2: ThrashGuard re-arm budget as a fraction of effectiveThreshold.
         // 0.10 default (10% of the effective threshold) — see mega-config-types.
         // Clamped to [0.01, 0.5]: below 1% the guard is almost never armed (any

package/dist/src/bridge/factory.js

@@ -0,0 +1,181 @@
+/**
+ * bridge/factory.ts — `createMegaBridge(opts)` implementation.
+ *
+ * A thin, pi-agnostic wrapper over the engine's compaction / recall / memory /
+ * fork / vector APIs. Stores are constructed lazily on first use (a consumer
+ * that only calls recallMemories pays no VectorStore cost). Exceptions
+ * propagate from every method except `fork` (catches ForkError by design) and
+ * `close` (swallows best-effort cleanup), so failures surface in tests.
+ */
+import { compactSession } from "../engine.js";
+import { recallAndInline, recallAndInlineAsync, recallMemoriesAndInline, } from "../recall.js";
+import { forkFromConversation, ForkError } from "../fork.js";
+import { createTurnStore } from "../store/turns/index.js";
+import { addMemory } from "../store/sqlite/memories.js";
+import { VectorStore, vectorSearch } from "../vectorStore.js";
+import { repoKey } from "../store/repoKey.js";
+/** Map a RecallInjectResult to the bridge's slimmer result contract. */
+function mapRecallResult(r) {
+    return {
+        block: r.block,
+        report: r.report,
+        hitCount: r.toInject.length,
+        empty: r.empty,
+    };
+}
+/** Map the memoryRecallAndInline tuple result to the bridge contract. */
+function mapMemoryResult(r) {
+    return {
+        block: r.block,
+        report: r.report,
+        hitCount: r.report.length,
+        empty: r.empty,
+    };
+}
+/** Map vectorSearch hits to the cortex result contract. */
+function mapCortexHits(hits, limit) {
+    const top = hits.slice(0, limit);
+    return {
+        results: top.map((h) => ({
+            checkpointId: h.checkpoint.checkpointId,
+            score: h.score,
+            summary: h.checkpoint.summary,
+        })),
+        hitCount: top.length,
+    };
+}
+/**
+ * Create a MegaBridge over a single stateDir.
+ *
+ * The VectorStore and TurnStore are lazy: constructed on first use and cached
+ * in closures. The stateDir is retained for memory recall, which needs it
+ * directly.
+ */
+export function createMegaBridge(opts) {
+    const stateDir = opts.stateDir;
+    let vectorStore;
+    let turnStore;
+    const getVectorStore = () => {
+        if (!vectorStore)
+            vectorStore = new VectorStore({ stateDir });
+        return vectorStore;
+    };
+    const getTurnStore = () => {
+        if (!turnStore)
+            turnStore = createTurnStore({ stateDir });
+        return turnStore;
+    };
+    return {
+        compact(input) {
+            const result = compactSession({
+                sessionId: input.sessionId,
+                messages: input.messages,
+                keepFrom: input.keepFrom,
+                summary: input.summary,
+                keyDecisions: input.keyDecisions,
+                nextSteps: input.nextSteps,
+                filesModified: input.filesModified,
+                compressionPressure: input.compressionPressure,
+            }, getVectorStore());
+            return {
+                skipped: result.skipped,
+                deduped: result.deduped,
+                summary: result.summary,
+                checkpointId: result.checkpointId,
+                tokenEstimate: result.tokenEstimate,
+                originalTokenEstimate: result.originalTokenEstimate,
+                compactedFrom: result.compactedFrom,
+            };
+        },
+        recallCheckpoints(opts) {
+            const recallOpts = {
+                sessionId: opts.sessionId,
+                query: opts.query,
+                limit: opts.limit ?? 3,
+                source: "command",
+                skipInjected: opts.skipInjected,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            return mapRecallResult(recallAndInline(recallOpts, getVectorStore()));
+        },
+        async recallMemories(opts) {
+            const memOpts = {
+                query: opts.query,
+                stateDir,
+                limit: opts.limit,
+                minSimilarity: opts.minSimilarity,
+                crossRepo: opts.crossRepo,
+                crossRepoCosine: opts.crossRepoCosine,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            const r = await recallMemoriesAndInline(memOpts);
+            return mapMemoryResult(r);
+        },
+        async recallAndInlineAsync(opts) {
+            const recallOpts = {
+                sessionId: opts.sessionId,
+                query: opts.query,
+                limit: opts.limit ?? 3,
+                source: "command",
+                skipInjected: opts.skipInjected,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            const r = await recallAndInlineAsync(recallOpts, getVectorStore());
+            return mapRecallResult(r);
+        },
+        fork(opts) {
+            try {
+                const outcome = forkFromConversation(getTurnStore(), opts.parentConversationId, opts.turnIndex);
+                return {
+                    childConversationId: outcome.childConversationId,
+                    checkpointIds: outcome.checkpointIds,
+                    forkTurnIndex: opts.turnIndex,
+                };
+            }
+            catch (e) {
+                if (e instanceof ForkError) {
+                    return { error: e.code };
+                }
+                throw e;
+            }
+        },
+        cortexQuery(opts) {
+            const limit = opts.limit ?? 3;
+            const scope = opts.repo ?? repoKey(stateDir);
+            const hits = vectorSearch(getVectorStore(), scope, opts.query, limit);
+            return mapCortexHits(hits, limit);
+        },
+        addMemory(input) {
+            // repo === null ⇒ stateDir-scoped durable memory (matches recallMemories).
+            return addMemory({
+                kind: input.kind,
+                content: input.content,
+                tags: input.tags,
+                category: input.category,
+            }, null, stateDir);
+        },
+        recordTurn(input) {
+            const turn = {
+                conversationId: input.conversationId,
+                sessionId: input.sessionId,
+                turnIndex: input.turnIndex,
+                role: input.role ?? "assistant",
+                endedAt: input.endedAt ?? Date.now(),
+                ctxTokens: input.ctxTokens,
+                ctxPercent: input.ctxPercent,
+                model: input.model,
+            };
+            getTurnStore().asWriter().appendTurn(turn);
+        },
+        close() {
+            if (turnStore) {
+                try {
+                    turnStore.close();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        },
+    };
+}

package/dist/src/bridge/types.js

@@ -0,0 +1,10 @@
+/**
+ * bridge/types.ts — contract types for the bidirectional mega-compact bridge.
+ *
+ * A pi-agnostic, unit-testable adapter surface that wraps the engine's
+ * compaction / recall / memory / fork / vector APIs behind one factory so an
+ * external host (ithacus) can drive them without importing pi-runtime types.
+ * Every type here mirrors a real engine signature (see factory.ts for the
+ * wiring).
+ */
+export {};

package/dist/src/bridge.js

@@ -0,0 +1 @@
+export { createMegaBridge } from "./bridge/factory.js";

package/dist/src/config.js

@@ -116,8 +116,19 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // 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(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+/**
+ * Same-repo recall cosine floor: top winner must be >= this to be injected.
+ *
+ * E1 follow-up (PR #18 review): NaN-safe + clamped to [0,1]. A typo'd env var
+ * yielded NaN before; `cosine < NaN` is false, which disabled gate 1 entirely
+ * (every candidate passed). Non-finite falls back to 0.12; out-of-range clamps.
+ */
+export const RECALL_MIN_COSINE = () => {
+    const n = Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+    if (!Number.isFinite(n))
+        return 0.12;
+    return Math.min(1, Math.max(0, n));
+};
 // ---------------------------------------------------------------------------
 // Vector-cortex flags + breaker constants (VC0A+). Positive sprint flags,
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts

package/dist/src/dedup/l1-minhash.js

@@ -19,6 +19,7 @@ export const SHINGLE_SIZE = 5; // char 5-grams
 const MAX_SHINGLES = 50_000; // QA #7/#15 complexity cap
 const SEED = 0xdeadbeef;
 const P = 2147483647; // 2^31 - 1, Mersenne prime
+const PBigInt = 2147483647n; // BigInt twin for overflow-safe modular reduction
 /** Per-index universal-hashing coefficients, derived deterministically from SEED. */
 function coeffA(i) {
     return (SEED + i * 2 + 1) % P;
@@ -67,10 +68,10 @@ export function minhashSignature(text) {
         const b = coeffB(i);
         let min = P;
         for (const x of grams) {
-            // (a*x + b) mod p — use Number math; a,x < 2^31 so a*x < 2^62, within
-            // double-precision integer range (2^53) only if reduced; reduce a*x first.
-            const ax = (a * (x % P)) % P;
-            const h = (ax + b) % P;
+            // (a*x + b) mod p. a, x < 2^31 so a*x < 2^62 — EXCEEDS 2^53. The naive
+            // (a*(x%P))%P loses precision (verified: a=x=p-1 → lossy 2147483644 vs
+            // exact 1). BigInt is correct + cheap (~5ms per signature).
+            const h = Number((BigInt(a) * BigInt(x % P) + BigInt(b)) % PBigInt);
             if (h < min)
                 min = h;
         }

package/dist/src/recall/validator.js

@@ -76,7 +76,14 @@ export function validateRecall(winners, opts, store) {
                 // No comparable cosine available => cannot clear a cosine gate.
                 continue;
             }
-            if (cosine < floor)
+            // E1 follow-up (PR #18 review): NaN/Infinity must NEVER clear the floor.
+            // `NaN < floor` is false, so an unguarded comparison lets a NaN cosine
+            // PASS gate 1 and inject — one NaN source poisons the whole 3WF-3
+            // quorum. Reject non-finite scores explicitly; the candidate is skipped
+            // and, if all fail, the provenance floor ("no recall") is returned —
+            // never a zero-score injection. The default TrigramEmbedder cannot
+            // produce NaN (zero-norm guard), but a BYO localhost embedder can.
+            if (!Number.isFinite(cosine) || cosine < floor)
                 continue;
             // Gate 2: not already resident in the live window.
             if (liveVecs.length > 0) {

package/dist/src/recall/vote.js

@@ -31,17 +31,36 @@ 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) {
+/**
+ * Per-source normalization: map raw scores to 0..1 via min-max within source.
+ *
+ * E1 follow-up (PR #18 review): non-finite scores (NaN/±Infinity) are DROPPED
+ * before the min/max fold — a single NaN silently propagates through Math.min/
+ * max and turns EVERY normalized score of that source into NaN (verified),
+ * poisoning the whole 3-source quorum. Dropping the bad entry degrades that
+ * source gracefully instead. Exported so the guard is unit-testable directly.
+ */
+export 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;
+    const finite = [];
     scores.forEach((s, i) => {
-        map.set(i, span === 0 ? 1 : (s - min) / span);
+        if (Number.isFinite(s))
+            finite.push({ idx: i, s });
     });
+    if (finite.length === 0)
+        return map;
+    let min = Infinity;
+    let max = -Infinity;
+    for (const { s } of finite) {
+        if (s < min)
+            min = s;
+        if (s > max)
+            max = s;
+    }
+    const span = max - min;
+    for (const { idx, s } of finite) {
+        map.set(idx, span === 0 ? 1 : (s - min) / span);
+    }
     return map;
 }
 /**
@@ -130,7 +149,13 @@ export function voteRecall(opts, store) {
         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;
+            // E1 follow-up: normalizeScores dropped non-finite scores; such a hit is
+            // NOT a valid nomination — skip it entirely instead of defaulting it to
+            // 0 (which would still name the checkpoint and let it rank last into the
+            // fallback ranking).
+            const n = norm.get(i);
+            if (n === undefined)
+                return;
             const prev = bestByCp.get(c.checkpointId);
             if (prev === undefined || n > prev)
                 bestByCp.set(c.checkpointId, n);

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

@@ -87,7 +87,12 @@ export function hydrateFts5Hits(hits, sessionId, stateDir) {
     const out = [];
     for (const h of hits) {
         const cp = cpMap.get(h.id);
-        if (cp)
+        // H1 follow-up (PR #18 review): exclude SemDeDup-'removed' rows. The FTS5
+        // index is NOT pruned by vectorSemDedup, so a removed row can still MATCH;
+        // hydrating it would let the fts5 voter NAME a dead checkpoint (a removed
+        // row plus a recency vote is a 2/3 agreement that passes the validator).
+        // Mirrors vectorSearch's read-time filter.
+        if (cp && cp.dedupStatus !== "removed")
             out.push({ checkpointId: h.id, score: h.score, summary: cp.summary });
     }
     return out;

package/dist/src/vector-read.js

@@ -72,7 +72,10 @@ export function vectorDedupe(store, sessionId, regionHashOrText, isText = false)
     const state = loadSessionState(sid, stateDir);
     if (state.storedRegionHashes.includes(hash))
         return true;
-    return listCheckpoints(sid, stateDir).some((c) => c.regionHash === hash);
+    // H1 follow-up (PR #18 review): a SemDeDup-'removed' row's regionHash must not
+    // report "already represented" — its content is excluded from recall, so the
+    // incoming region is NOT deduplicated in any retrievable sense.
+    return listCheckpoints(sid, stateDir).some((c) => c.dedupStatus !== "removed" && c.regionHash === hash);
 }
 // ---------------------------------------------------------------------------
 // Injection tracking
@@ -115,7 +118,8 @@ export function vectorTopSimilar(store, sessionId, n) {
     const ordered = [...checkpoints].sort((a, b) => a.checkpointId.localeCompare(b.checkpointId));
     const current = ordered[ordered.length - 1];
     const scored = ordered
-        .filter((cp) => cp.checkpointId !== current.checkpointId)
+        .filter((cp) => cp.checkpointId !== current.checkpointId &&
+        cp.dedupStatus !== "removed")
         .map((cp) => ({
         checkpoint: cp,
         score: cosineSimilarity(current.embedding, cp.embedding),

package/dist/src/vectorStore/add.js

@@ -40,7 +40,11 @@ export function addCheckpoint(store, input) {
     const t0 = Date.now();
     const sessionId = normalizeSessionId(input.sessionId);
     const regionHash = computeRegionHash(input.regionText);
-    const all = listCheckpoints(sessionId, store.stateDir);
+    // H1: exclude SemDeDup-'removed' rows from dedup matching. search() already
+    // filters these, but add() did NOT — so an L0/L1/L2 match against a previously
+    // removed duplicate would upsertCheckpoint it back to active, resurrecting it
+    // into recall and defeating SemDeDup.
+    const all = listCheckpoints(sessionId, store.stateDir).filter((cp) => cp.dedupStatus !== "removed");
     // Honest "tokens saved" base for this region. For a deduped add the whole
     // original region is discarded (nothing new stored); for a new checkpoint
     // we persist (orig − stored). Falls back to stored when orig is unknown.

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

@@ -305,6 +305,12 @@ export const SETTINGS: ReadonlyArray<SettingGroup> = [
 				"Umbrella for the 3-way failback safety system: TriggerGuard (stages a recall block even when session_start never fires), the live-window ReductionValidator + persisted ThrashGuard (stops ineffective compaction re-fire loops), the 3-source read-only recall vote + same-repo relevance floor, and InjectionConfirm (asserts the staged block reached the message list pi sends). OFF = byte-identical pre-3WF behavior (v0.20.83). Runtime reads envBool(plain key), so this uses the plain-write convention (not _DISABLED).",
 				true,
 			),
+			boolDirect(
+				"MEGACOMPACT_ITHACUS_BRIDGE",
+				"ithacus Bridge",
+				"Mega↔ithacus bridge: gate the child extension + bridge usage that tie this extension to ithacus's durable compaction. Default ON; OFF (=0/`=false`) is byte-identical to pre-bridge behavior — the bridge is only consulted when this is ON. Positive sprint flag. Runtime reads envBool(plain key), so this uses the plain-write convention (not _DISABLED).",
+				true,
+			),
 			boolDirect(
 				"MEGACOMPACT_RECALL_TAIL_INJECT",
 				"Recall Tail Inject",