pi-mega-compact 0.11.7 → 0.11.9

package/dist/extensions/mega-events/context-handler.js

@@ -7,11 +7,26 @@ import { stampTurnsEpochFor } from "../mega-turn-store.js";
 import { TurnsConfig } from "../../src/config/turns.js";
 import { openTurnStore } from "../../src/store/turns/connection.js";
 import { buildTopicModel, createTopicStore, bumpWikiCompactCounter, } from "../../src/topics/index.js";
+import { TrigramEmbedder } from "../../src/embedder.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "../mega-trim.js";
 import { pressureFromPct, pressureRatio, } from "../mega-config.js";
 import { appendMirrorMessages } from "./mirror-append.js";
 import { stagedForTail, withRecallTail } from "./recall-tail.js";
-import { buildSeparatedPrompt } from "./separated-prompt.js";
+import { buildSeparatedPrompt, buildCacheOptimizedPrompt } from "./separated-prompt.js";
+/** Best-effort text extraction from an AgentMessage for analytics/logging.
+ *  AgentMessage is a discriminated union; .content exists only on some
+ *  variants (user/assistant/toolResult/custom). Narrow by role, never assume. */
+function messageContentText(m) {
+    const c = m.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c)) {
+        return c
+            .map((b) => (b && typeof b === "object" && "text" in b ? String(b.text ?? "") : ""))
+            .join(" ");
+    }
+    return "";
+}
 /** Register the context event handler (live-trim auto-trigger). */
 export function registerContextHandler(pi, runtime, config) {
     // ---- Auto-trigger: live trim (compact and continue) + native durable ----
@@ -40,14 +55,32 @@ export function registerContextHandler(pi, runtime, config) {
         // reaches raw_transcript (PREVENT-PI: append-only, view-only).
         const tailResult = (msgs) => {
             const base = msgs ?? messages;
-            if (!stagedForTail(runtime, config) && !config.messageSeparation)
+            if (!stagedForTail(runtime, config) && !config.messageSeparation && !config.cacheStriping)
                 return undefined;
             let result = stagedForTail(runtime, config)
                 ? withRecallTail(base, runtime, config)
                 : base;
-            if (config.messageSeparation) {
+            if (config.cacheStriping) {
+                result = buildCacheOptimizedPrompt(result);
+            }
+            else if (config.messageSeparation) {
                 result = buildSeparatedPrompt(result);
             }
+            // P2.5: log prefix stability (fire-and-forget, non-fatal).
+            // tailResult is sync, so use .then().catch() on the dynamic import.
+            if (result.length > 1) {
+                import("../../src/cache-stripe-impl.js").then(({ computeStabilityScore }) => {
+                    const stableScore = computeStabilityScore({ content: messageContentText(result[0] ?? result[0]), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 }, result.slice(0, 2).map((m) => ({ content: messageContentText(m), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 })));
+                    runtime.logger.info("prefix_stability", {
+                        stableScore: Number.isFinite(stableScore) ? stableScore : 0,
+                        prefixMessages: result.length,
+                        separation: config.messageSeparation ? "v2" : "off",
+                        striping: config.cacheStriping ? "v3" : "off",
+                    });
+                }).catch(() => {
+                    // Non-fatal: stability logging is best-effort.
+                });
+            }
             return { messages: result };
         };
         // Always track context for the dashboard/widget, even when auto is off.
@@ -88,6 +121,30 @@ export function registerContextHandler(pi, runtime, config) {
             try {
                 const db = openStore(runtime.currentStateDir);
                 appendMirrorMessages(db, messages, runtime.rt.sessionId, epochIdFor(runtime.rt.sessionId), runtime.currentTurn);
+                // P2.2: populate conversation_thread + tool_results tables for
+                // prompt-cache analytics and durable separation. The live-array
+                // separation (buildSeparatedPrompt / buildCacheOptimizedPrompt in
+                // tailResult above) is sufficient for the prompt-construction path;
+                // these DB writes persist the split for post-hoc analysis, dashboard
+                // queries, and future readers. Non-fatal — failure here never breaks
+                // the agent loop (PREVENT-PI-004: zero network, local SQLite only).
+                {
+                    const sid = runtime.rt.sessionId;
+                    const turn = runtime.currentTurn;
+                    const now = Date.now();
+                    const threadStmt = db.prepare("INSERT OR IGNORE INTO conversation_thread (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)");
+                    const toolStmt = db.prepare("INSERT OR IGNORE INTO tool_results (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)");
+                    for (const m of messages) {
+                        const role = m.role;
+                        const content = messageContentText(m);
+                        if (role === "user" || role === "assistant") {
+                            threadStmt.run(sid, role, content, turn, now);
+                        }
+                        else if (role === "toolResult" || role === "bashExecution") {
+                            toolStmt.run(sid, role, content, turn, now);
+                        }
+                    }
+                }
             }
             catch (e) {
                 runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
@@ -250,6 +307,70 @@ export function registerContextHandler(pi, runtime, config) {
                         error: String(wikiErr),
                     });
                 }
+                // D1: seed the topic model from raw_transcript when context_chunks is
+                // thin (pre-compaction). Gated on WIKI_SEED_FROM_TURNS; non-fatal.
+                // Seeds buildTopicModel with on-the-fly trigram embeddings from
+                // recent raw_transcript rows for the current session.
+                try {
+                    if (config.autoWikiEnabled &&
+                        config.turnsDbEnabled &&
+                        TurnsConfig.WIKI_SEED_FROM_TURNS) {
+                        const floor = 50;
+                        const countRow = db
+                            .prepare(`SELECT COUNT(*) AS cnt FROM context_chunks WHERE session_id = ?`)
+                            .get(runtime.rt.sessionId);
+                        const chunkCount = countRow?.cnt ?? 0;
+                        if (chunkCount < floor) {
+                            const transcriptRows = db
+                                .prepare(`SELECT DISTINCT content_bytes
+			       FROM raw_transcript
+			       WHERE session_id = ?
+			         AND length(content_bytes) > 10
+			       ORDER BY seq ASC
+			       LIMIT 200`)
+                                .all(runtime.rt.sessionId);
+                            if (transcriptRows.length > 0) {
+                                const embedder = new TrigramEmbedder();
+                                const seedChunks = [];
+                                for (let i = 0; i < transcriptRows.length; i++) {
+                                    const text = transcriptRows[i].content_bytes.trim();
+                                    if (text.length === 0)
+                                        continue;
+                                    const vec = embedder.embed(text);
+                                    seedChunks.push({
+                                        chunkId: `seed_transcript_${i}`,
+                                        sessionId: runtime.rt.sessionId,
+                                        vec,
+                                        text,
+                                    });
+                                }
+                                if (seedChunks.length > 0) {
+                                    const model = buildTopicModel(db, {
+                                        kRange: [
+                                            TurnsConfig.WIKI_K_MIN,
+                                            TurnsConfig.WIKI_K_MAX,
+                                        ],
+                                        labelTopTerms: TurnsConfig.WIKI_LABEL_TOP_TERMS,
+                                        restarts: 5,
+                                        seed: 0x9e3779b9,
+                                    }, seedChunks);
+                                    createTopicStore(runtime.currentStateDir).replaceTopicModel(model);
+                                    runtime.logger.info("wiki_seed", {
+                                        clusterCount: model.k,
+                                        sourceChunks: seedChunks.length,
+                                        totalChunks: model.totalChunks,
+                                        method: "kmeans+tfidf",
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (seedErr) {
+                    runtime.logger.warn("wiki_seed_failed", {
+                        error: String(seedErr),
+                    });
+                }
                 // S27 Task 6: Fire-and-forget dedup pipeline.
                 // Deduplicates raw_transcript rows for the compacted range.
                 try {
@@ -336,6 +457,13 @@ export function registerContextHandler(pi, runtime, config) {
                 compactedFrom: ran.result.compactedFrom,
                 summary: ran.result.summary,
                 anchorUserMessages,
+                // CRITICAL-OVER ESCAPE HATCH: when context is at/over ~90% of the
+                // window, relief takes priority over the anchor floor. Without this,
+                // computeLiveTrimCut bails to null (can't satisfy the floor) and the
+                // model is fed a raw overflow that errors every turn — the
+                // "Already compacted" + overflow death-spiral (2026-08-01 incident).
+                // A thin anchor is recoverable; an overflowed session is not.
+                criticalOver: (pct ?? 0) >= 90,
             });
             if (cut === null) {
                 runtime.diagCtxCutNull++;
@@ -344,6 +472,7 @@ export function registerContextHandler(pi, runtime, config) {
                     compactedFrom: ran.result.compactedFrom,
                     viewLen: view.length,
                     anchorUserMessages,
+                    criticalOver: (pct ?? 0) >= 90,
                 });
                 return tailResult() ?? undefined; // unsafe / below anchor floor — no trim this call
             }

package/dist/extensions/mega-runtime/snapshot.js

@@ -131,7 +131,7 @@ export function computeMegaSnapshot(p) {
         cachePct,
         megaCacheFlare: p.megaCacheFlare,
         megaCacheFlarePct: p.megaCacheFlarePct,
-        perTurnCacheHitPct: p.perTurnCacheHitPct ?? cachePct,
+        perTurnCacheHitPct: p.perTurnCacheHitPct,
         levelUpFlare: p.levelUpFlare,
         achievementFlare: p.achievementFlare,
         achievementFlareTitles: p.achievementFlareTitles,

package/dist/extensions/mega-trim.js

@@ -48,10 +48,20 @@ export function computeLiveTrimCut(view, opts) {
         if (cut > 1) {
             const finalRecent = view.slice(cut);
             if (finalRecent.filter((m) => m.role === "user").length < opts.anchorUserMessages) {
+                // CRITICAL-OVER ESCAPE HATCH: when context is critically over the window,
+                // return the boundary-safe cut even though it's below the anchor floor.
+                // Bailing to null here would feed the model the raw overflow and trap the
+                // session in an unrecoverable error loop ("Already compacted" + overflow).
+                // A thin anchor is recoverable; an overflowed session is not.
+                if (opts.criticalOver && cut > 0)
+                    return cut;
                 return null; // cannot satisfy the floor without dropping too much — retry next call
             }
         }
         else {
+            // Same escape hatch for the cut > 1 false branch.
+            if (opts.criticalOver && cut > 0)
+                return cut;
             return null;
         }
     }

package/dist/src/config/turns.js

@@ -42,7 +42,8 @@ export function loadTurnsConfig() {
         WIKI_K_MIN: kMin,
         WIKI_K_MAX: kMax,
         WIKI_LABEL_TOP_TERMS: envNum("MEGACOMPACT_WIKI_LABEL_TOP_TERMS", 5),
-        WIKI_REBUILD_EVERY_N_COMPACTS: envNum("MEGACOMPACT_WIKI_REBUILD_EVERY", 10),
+        WIKI_REBUILD_EVERY_N_COMPACTS: envNum("MEGACOMPACT_WIKI_REBUILD_EVERY", 3),
+        WIKI_SEED_FROM_TURNS: envBool("MEGACOMPACT_WIKI_SEED_FROM_TURNS", true),
     };
 }
 export const TurnsConfig = loadTurnsConfig();

package/dist/src/memoryGraph/embedding.js

@@ -0,0 +1,50 @@
+import { TrigramEmbedder } from "../embedder.js";
+let _trigramEmbedder = null;
+function lazyEmbedder() {
+    if (!_trigramEmbedder) {
+        _trigramEmbedder = new TrigramEmbedder();
+    }
+    return _trigramEmbedder;
+}
+function simpleHash(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return h.toString(36);
+}
+/** Compute or retrieve a cached embedding vector for a text string.
+ *  Uses the embedding_cache table (created by the A2 migration) for
+ *  persistence. Falls back to uncached TrigramEmbedder on table error. */
+export function getOrComputeEmbedding(db, content) {
+    try {
+        const hash = simpleHash(content);
+        const cached = db
+            .prepare("SELECT embedding FROM embedding_cache WHERE content_hash = ?")
+            .get(hash);
+        if (cached && typeof cached.embedding === "string") {
+            return JSON.parse(cached.embedding);
+        }
+        const vec = lazyEmbedder().embed(content);
+        db.prepare("INSERT OR REPLACE INTO embedding_cache (content_hash, content, embedding) VALUES (?, ?, ?)").run(hash, content, JSON.stringify(vec));
+        return vec;
+    }
+    catch {
+        return lazyEmbedder().embed(content);
+    }
+}
+/** Cosine similarity between two equal-length vectors. */
+export function cosineSimilarity(a, b) {
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    return denom > 0 ? dot / denom : 0;
+}

package/dist/src/memoryGraph/gates.js

@@ -0,0 +1,379 @@
+import { Logger } from "../log.js";
+const log = new Logger();
+// ---------------------------------------------------------------------------
+// Gate 1 — Source availability guard (informational, no drop)
+// ---------------------------------------------------------------------------
+export function gateSourceAvailable(ws) {
+    if (ws.nodes.length === 0) {
+        log.warn("graph_source_unavailable", {
+            detail: "No nodes from any source — graph will be empty",
+        });
+        return { ok: false, dropped: 0, reason: "No nodes from any source" };
+    }
+    return { ok: true, dropped: 0 };
+}
+// ---------------------------------------------------------------------------
+// Gate 2 — Identity merge: duplicate nodes with same id → richest wins
+// ---------------------------------------------------------------------------
+export function gateIdentityMerge(ws) {
+    const { nodes } = ws;
+    const seen = new Map();
+    let dropped = 0;
+    for (const n of nodes) {
+        const existing = seen.get(n.id);
+        if (!existing) {
+            seen.set(n.id, n);
+            continue;
+        }
+        const existingScore = fieldScore(existing);
+        const currentScore = fieldScore(n);
+        if (currentScore > existingScore) {
+            seen.set(n.id, n);
+        }
+        dropped++;
+        log.warn("graph_identity_leak", {
+            nodeId: n.id,
+            dropped: currentScore > existingScore ? existing.id : n.id,
+        });
+    }
+    ws.nodes = [...seen.values()];
+    return { ok: dropped === 0, dropped, reason: dropped > 0 ? `${dropped} duplicate node ids merged` : undefined };
+}
+function fieldScore(n) {
+    // Base score by nodeType — richer sources win ties (spec: "richest available
+    // source wins"). checkpoint > turn-content > memory > turn-structural.
+    let s = 0;
+    switch (n.nodeType) {
+        case "checkpoint":
+            s += 4;
+            break;
+        case "turn-content":
+            s += 3;
+            break;
+        case "memory":
+            s += 2;
+            break;
+        case "turn":
+            s += 1;
+            break;
+    }
+    if (n.summaryTruncated)
+        s++;
+    if (n.textSnippet)
+        s++;
+    if (n.topicSummary)
+        s++;
+    if (n.tokenEstimate > 0)
+        s++;
+    if (n.decisionCount > 0)
+        s++;
+    if (n.dedupStatus)
+        s++;
+    return s;
+}
+// ---------------------------------------------------------------------------
+// Gate 3 — Promotion guard: suppress turns with epoch_id if checkpoint exists
+// ---------------------------------------------------------------------------
+export function gatePromotionGuard(ws) {
+    const checkpointIds = new Set();
+    for (const n of ws.nodes) {
+        if (n.nodeType === "checkpoint")
+            checkpointIds.add(n.id);
+    }
+    const keep = [];
+    const droppedIds = new Set();
+    let dropped = 0;
+    for (const n of ws.nodes) {
+        if (n.nodeType !== "turn" && n.nodeType !== "turn-content") {
+            keep.push(n);
+            continue;
+        }
+        const epochId = n.epochId;
+        if (epochId && checkpointIds.has(epochId)) {
+            droppedIds.add(n.id);
+            dropped++;
+            log.warn("graph_orphaned_epoch", {
+                nodeId: n.id,
+                epochId,
+                detail: "Turn suppressed because its checkpoint exists in the graph",
+            });
+        }
+        else {
+            if (epochId && !checkpointIds.has(epochId)) {
+                log.warn("graph_orphaned_epoch", {
+                    nodeId: n.id,
+                    epochId,
+                    detail: "Orphaned epoch — no matching checkpoint; keeping turn",
+                });
+            }
+            keep.push(n);
+        }
+    }
+    ws.nodes = keep;
+    ws.edges = ws.edges.filter((e) => !droppedIds.has(e.source) && !droppedIds.has(e.target));
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} turn nodes suppressed (checkpoint exists)` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 4 — Node type / field completeness
+// ---------------------------------------------------------------------------
+export function gateNodeCompleteness(ws) {
+    const validNodes = [];
+    let dropped = 0;
+    for (const n of ws.nodes) {
+        if (!n.nodeType || !n.sessionId) {
+            dropped++;
+            log.warn("graph_node_double", {
+                nodeId: n.id,
+                detail: "Missing nodeType or sessionId",
+            });
+            continue;
+        }
+        validNodes.push(n);
+    }
+    ws.nodes = validNodes;
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} nodes dropped for missing fields` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 5 — Dangling edge guard
+// ---------------------------------------------------------------------------
+export function gateDanglingEdges(ws) {
+    const validIds = new Set(ws.nodes.map((n) => n.id));
+    const validEdges = [];
+    let dropped = 0;
+    for (const e of ws.edges) {
+        if (validIds.has(e.source) && validIds.has(e.target)) {
+            validEdges.push(e);
+        }
+        else {
+            dropped++;
+            log.warn("graph_dangling_edge", {
+                source: e.source,
+                target: e.target,
+                detail: "Edge references non-existent node(s)",
+            });
+        }
+    }
+    ws.edges = validEdges;
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} dangling edges removed` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 6 — Edge type / threshold enforcement
+// ---------------------------------------------------------------------------
+function envThreshold(name, def) {
+    const v = process.env[name];
+    if (v === undefined)
+        return def;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : def;
+}
+export function gateEdgeThresholds(ws, options) {
+    const withinThreshold = options?.withinTypeThreshold ?? envThreshold("MEGACOMPACT_MEMORY_GRAPH_WITHIN_TYPE_THRESHOLD", 0.7);
+    const crossThreshold = options?.crossTypeThreshold ?? envThreshold("MEGACOMPACT_MEMORY_GRAPH_CROSS_TYPE_THRESHOLD", 0.85);
+    const nodeTypeMap = new Map(ws.nodes.map((n) => [n.id, n.nodeType]));
+    const validEdges = [];
+    let dropped = 0;
+    for (const e of ws.edges) {
+        if (e.type !== "semantic") {
+            validEdges.push(e);
+            continue;
+        }
+        const srcType = nodeTypeMap.get(e.source);
+        const tgtType = nodeTypeMap.get(e.target);
+        if (srcType === "turn" || tgtType === "turn") {
+            dropped++;
+            log.warn("graph_structural_semantic_edge", {
+                nodeId: srcType === "turn" ? e.source : e.target,
+                source: e.source,
+                target: e.target,
+                score: e.weight,
+                detail: "Semantic edge on structural (turn) node",
+            });
+            continue;
+        }
+        const sameType = srcType != null && srcType === tgtType;
+        const threshold = sameType ? withinThreshold : crossThreshold;
+        if (e.weight < threshold) {
+            dropped++;
+            log.warn("graph_edge_below_threshold", {
+                source: e.source,
+                target: e.target,
+                score: e.weight,
+                typePair: `${String(srcType)}↔${String(tgtType)}`,
+                threshold,
+                detail: `Edge below ${sameType ? "within-type" : "cross-type"} threshold`,
+            });
+            continue;
+        }
+        validEdges.push(e);
+    }
+    ws.edges = validEdges;
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} edges below threshold removed` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 7 — Dedup mirror cross-check
+// ---------------------------------------------------------------------------
+export function gateDedupRedundant(ws, options) {
+    const redundant = options?.redundantIds ?? new Set();
+    if (redundant.size === 0)
+        return { ok: true, dropped: 0 };
+    const keep = [];
+    const droppedIds = new Set();
+    let dropped = 0;
+    for (const n of ws.nodes) {
+        if (n.nodeType === "turn-content" && redundant.has(n.id)) {
+            dropped++;
+            droppedIds.add(n.id);
+            log.warn("graph_dedup_redundant", {
+                nodeId: n.id,
+                contentHash: n.id,
+                detail: "Turn content already collapsed into checkpoint",
+            });
+        }
+        else {
+            keep.push(n);
+        }
+    }
+    if (droppedIds.size > 0) {
+        ws.edges = ws.edges.filter((e) => !droppedIds.has(e.source) && !droppedIds.has(e.target));
+    }
+    ws.nodes = keep;
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} turn-content nodes redundant with checkpoints` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 8 — Structural vs semantic edge consistency
+// ---------------------------------------------------------------------------
+export function gateStructuralSemanticEdges(ws) {
+    const structuralTypes = new Set(["checkpoint", "turn"]);
+    const keep = [];
+    let dropped = 0;
+    for (const e of ws.edges) {
+        if (e.type !== "semantic") {
+            keep.push(e);
+            continue;
+        }
+        const srcNode = ws.nodes.find((n) => n.id === e.source);
+        const tgtNode = ws.nodes.find((n) => n.id === e.target);
+        if (srcNode && structuralTypes.has(srcNode.nodeType)) {
+            dropped++;
+            log.warn("graph_structural_semantic_edge", {
+                nodeId: srcNode.id,
+                nodeType: srcNode.nodeType,
+                detail: "Structural node has semantic edge",
+            });
+        }
+        else if (tgtNode && structuralTypes.has(tgtNode.nodeType)) {
+            dropped++;
+            log.warn("graph_structural_semantic_edge", {
+                nodeId: tgtNode.id,
+                nodeType: tgtNode.nodeType,
+                detail: "Structural node has semantic edge",
+            });
+        }
+        else {
+            keep.push(e);
+        }
+    }
+    ws.edges = keep;
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} semantic edges on structural nodes removed` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Gate 9 — Same-type edge deduplication
+// ---------------------------------------------------------------------------
+export function gateDedupEdges(ws) {
+    const best = new Map();
+    let dropped = 0;
+    for (const e of ws.edges) {
+        const key = `${e.source}|${e.target}|${e.type}`;
+        const existing = best.get(key);
+        if (!existing || e.weight > existing.weight) {
+            if (existing)
+                dropped++;
+            best.set(key, e);
+        }
+        else {
+            dropped++;
+        }
+    }
+    if (dropped > 0) {
+        log.warn("graph_dedup_redundant", {
+            count: dropped,
+            detail: "Redundant edges deduplicated",
+        });
+    }
+    ws.edges = [...best.values()];
+    return {
+        ok: dropped === 0,
+        dropped,
+        reason: dropped > 0 ? `${dropped} redundant edges deduplicated` : undefined,
+    };
+}
+/** Run all 9 gates in order over a working set. Returns validated set + stats.
+ *  Gate 7 uses optional redundantIds from the caller. */
+export function runValidationPipeline(ws, options) {
+    const gatesRun = [];
+    const gatesPassed = [];
+    const warnings = [];
+    let totalDroppedNodes = 0;
+    let totalDroppedEdges = 0;
+    const gates = [
+        { name: "source_available", fn: () => gateSourceAvailable(ws) },
+        { name: "identity_merge", fn: () => gateIdentityMerge(ws) },
+        { name: "promotion_guard", fn: () => gatePromotionGuard(ws) },
+        { name: "node_completeness", fn: () => gateNodeCompleteness(ws) },
+        { name: "dangling_edges", fn: () => gateDanglingEdges(ws) },
+        { name: "edge_thresholds", fn: () => gateEdgeThresholds(ws, { withinTypeThreshold: options?.withinTypeThreshold, crossTypeThreshold: options?.crossTypeThreshold }) },
+        { name: "dedup_redundant", fn: () => gateDedupRedundant(ws, { redundantIds: options?.redundantIds }) },
+        { name: "structural_semantic", fn: () => gateStructuralSemanticEdges(ws) },
+        { name: "dedup_edges", fn: () => gateDedupEdges(ws) },
+    ];
+    for (const gate of gates) {
+        gatesRun.push(gate.name);
+        const r = gate.fn();
+        if (r.ok) {
+            gatesPassed.push(gate.name);
+        }
+        if (r.reason) {
+            warnings.push({ gate: gate.name, code: "gate_warning", count: r.dropped || 1 });
+        }
+        // Track by category
+        if (["identity_merge", "promotion_guard", "node_completeness"].includes(gate.name)) {
+            totalDroppedNodes += r.dropped;
+        }
+        if (["dangling_edges", "edge_thresholds", "dedup_redundant", "structural_semantic", "dedup_edges"].includes(gate.name)) {
+            totalDroppedEdges += r.dropped;
+        }
+    }
+    return {
+        ws,
+        stats: {
+            gatesRun,
+            gatesPassed,
+            dropped: { nodes: totalDroppedNodes, edges: totalDroppedEdges },
+            warnings,
+        },
+    };
+}