pi-mega-compact 0.7.6 → 0.7.8

package/extensions/mega-runtime.ts

@@ -24,6 +24,10 @@ import {
 	latestModelSnapshot,
 	upsertRepoRegistry,
 	recordRepoModel,
+	getDedupStats,
+	getCompactCount,
+	getRecallInjected,
+	getCacheHitTokensSaved,
 	type ModelSnapshot,
 } from "../src/store/sqlite.js";
 import { detectCrossRepoDrift } from "../src/driftDetection.js";
@@ -73,6 +77,11 @@ interface SessionRuntime {
 	tokensSaved: number; // this session-instance only: reset on session_start
 	lastCompactAt: number | null; // wall-clock ms of the last compaction this session
 	lastNativeCompactAt: number | null; // COMPACT-DEDUP FIX: wall-clock ms of the last NATIVE pi compaction (session_compact event) — used by the agent_end/legacy race guard to skip a redundant ctx.compact() that would throw "Already compacted".
+	// S25: live dashboard counters (reset on session_start, mirrored to SQLite).
+	compactCount: number; // compactions performed this session-instance
+	recallInjections: number; // recall blocks injected this session-instance
+	cacheHitTokens: number; // tokens saved via cache hits (dedup + recall) this session
+	lengthStopPending: boolean; // S28: set on turn_end when stopReason==='length'
 }
 
 /** ANSI palette for the toolbar. The pi TUI's Text component preserves ANSI
@@ -94,6 +103,11 @@ export const C = {
 
 const PULSE = ["◐", "◓", "◑", "◒"];
 
+// Rough tokens-processed-per-second heuristic for the dashboard's "time saved"
+// estimate. Throughput varies by model/hardware; this is order-of-magnitude so
+// the dashboard can show a human-readable figure, not a precise measurement.
+const TOKENS_PER_SEC_ESTIMATE = 2000;
+
 // ── Full-width widget panel helpers ────────────────────────────────────────
 // pi's above-editor widget renderer (a Container of Text lines) does NOT pass
 // a terminal width to setWidget(), so lines render left-aligned by default. To
@@ -274,6 +288,10 @@ export class MegaRuntime {
 		tokensSaved: 0,
 		lastCompactAt: null,
 		lastNativeCompactAt: null,
+		compactCount: 0,
+		recallInjections: 0,
+		cacheHitTokens: 0,
+		lengthStopPending: false,
 	};
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -485,6 +503,12 @@ export class MegaRuntime {
 		const st = this.store.stats(this.rt.sessionId);
 		const repo = this.store.repoStats();
 		const di = this.store.dataInvariant();
+		// Live + store-wide cache-hit / compaction counters for the dashboard.
+		const ds = getDedupStats(this.currentStateDir);
+		const cacheHitsTotal = ds.deduped + getRecallInjected(this.currentStateDir);
+		const cacheHitsTotalTokens = getCacheHitTokensSaved(this.currentStateDir);
+		const cacheHitsSession = this.rt.dedupSkips + this.rt.recallInjections;
+		const sec = (tok: number) => (tok || 0) / TOKENS_PER_SEC_ESTIMATE;
 		// Active model/provider for the current-repo card + the multi-repo table.
 		const modelSnap = latestModelSnapshot(this.currentStateDir);
 		const model = modelSnap
@@ -497,9 +521,13 @@ export class MegaRuntime {
 				}
 			: undefined;
 		// effectiveThresholdPct: the live fire point as a % of the window (null for
-		// `custom`, which has no tierPct). Used by armed/ready + the dashboard.
+		// `custom`, which has no tierPct). S29: honors MEGACOMPACT_AUTO_PCT_TRIGGER
+		// override so the dashboard's armed/ready match the context-handler gate
+		// (which fires on this same %). Used by armed/ready + the dashboard.
 		const effectiveThresholdPct =
-			this.config.tierPct != null ? this.config.tierPct * 100 : null;
+			this.config.tierPct != null
+				? (this.config.autoPctTrigger ?? this.config.tierPct) * 100
+				: null;
 		// armed lights at/above the REAL fire point: max(effectiveThresholdPct,
 		// fastGatePct). fastGatePct already equals tierPct*100 by default, but a
 		// MEGACOMPACT_FAST_GATE_PCT override can raise it, so we take the max.
@@ -507,7 +535,15 @@ export class MegaRuntime {
 			this.lastCtxPercent != null &&
 			this.lastCtxPercent >=
 				Math.max(effectiveThresholdPct ?? 0, this.config.fastGatePct);
-		const ready = armed && (this.lastCtxTokens ?? 0) >= this.effectiveThreshold;
+		// S29: ready mirrors the context-handler gate's basis — percent for tiered
+		// (the gate fires on pct), tokens for custom (the gate fires on tokens).
+		// Previously this always required tokens, so the dashboard could show
+		// "armed" (percent high) but never "ready" when tokens were under-reported
+		// — the same inconsistency the S29 gate fix removes.
+		const ready =
+			this.config.tierPct != null
+				? armed && (this.lastCtxPercent ?? 0) >= (effectiveThresholdPct ?? 0)
+				: armed && (this.lastCtxTokens ?? 0) >= this.effectiveThreshold;
 		this.dashboard.snapshot({
 			version: 1,
 			updatedAt: new Date().toISOString(),
@@ -604,6 +640,20 @@ export class MegaRuntime {
 				duplicatesCollapsed: di.duplicatesCollapsed,
 				bytesPermanentlyDeleted: di.bytesPermanentlyDeleted,
 			},
+			cacheHits: {
+				session: cacheHitsSession,
+				total: cacheHitsTotal,
+				sessionTokensSaved: this.rt.cacheHitTokens,
+				totalTokensSaved: cacheHitsTotalTokens,
+			},
+			compacts: {
+				session: this.rt.compactCount,
+				total: getCompactCount(this.currentStateDir),
+			},
+			timeSaved: {
+				compact: { sessionSec: sec(this.rt.tokensSaved), totalSec: sec(this.store.repoStats().tokensSaved) },
+				cacheHit: { sessionSec: sec(this.rt.cacheHitTokens), totalSec: sec(cacheHitsTotalTokens) },
+			},
 			model,
 		} as DashboardSnapshot);
 
@@ -620,7 +670,9 @@ export class MegaRuntime {
 					: "?";
 			const pctStr =
 				this.lastCtxPercent != null
-					? `${Math.round(this.lastCtxPercent * 10) / 10}%`
+					? this.lastCtxPercent > 100
+						? `>100%` // S29: overshoot warning, not a raw "250%" — the percent trigger now compacts before 100%, so this is the residual case where it can't keep up.
+						: `${Math.round(this.lastCtxPercent * 10) / 10}%`
 					: "?%";
 			// S24: the tier label is the LIVE pressure band (low/medium/high/ultra/
 			// mega), not the static env preset. It climbs as context fills.
@@ -849,7 +901,11 @@ export class MegaRuntime {
 			tokensSaved: 0,
 			lastCompactAt: null,
 			lastNativeCompactAt: null,
-		};
+			compactCount: 0,
+			recallInjections: 0,
+			cacheHitTokens: 0,
+			lengthStopPending: false,
+	};
 		this.statusKey = undefined;
 		this.activeAgents = 0;
 		this.currentTurn = 0;

package/package.json

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

package/src/store/sqlite.cachehit.test.ts

@@ -0,0 +1,68 @@
+/**
+ * sqlite.cachehit.test.ts — tests for the live dashboard counters
+ * (incCompactCount / getCompactCount, incRecallInjected / getRecallInjected,
+ * incCacheHitTokens / getCacheHitTokensSaved). These reuse the schemaless
+ * `meta` integer counter, so no migration is required and the same on-disk
+ * SQLite store persists the tallies across (re)opens.
+ */
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	openStore,
+	incCompactCount,
+	getCompactCount,
+	incRecallInjected,
+	getRecallInjected,
+	incCacheHitTokens,
+	getCacheHitTokensSaved,
+} from "./sqlite.js";
+
+describe("live dashboard counters (meta integers)", () => {
+	let dir: string;
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "cachehit-test-"));
+	});
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("increments + reads compact_count and persists on reopen", () => {
+		incCompactCount(dir);
+		incCompactCount(dir);
+		assert.equal(getCompactCount(dir), 2);
+		// Ensure the store handle is (re)opened and the value is read back from disk.
+		openStore(dir);
+		assert.equal(getCompactCount(dir), 2);
+	});
+
+	it("accumulates recall injections + cache-hit tokens", () => {
+		incRecallInjected(3, dir);
+		incRecallInjected(2, dir);
+		assert.equal(getRecallInjected(dir), 5);
+		incCacheHitTokens(1200, dir);
+		incCacheHitTokens(800, dir);
+		assert.equal(getCacheHitTokensSaved(dir), 2000);
+	});
+
+	it("ignores non-positive increments (no-op)", () => {
+		incRecallInjected(0, dir);
+		incRecallInjected(-5, dir);
+		incCacheHitTokens(0, dir);
+		assert.equal(getRecallInjected(dir), 0);
+		assert.equal(getCacheHitTokensSaved(dir), 0);
+	});
+
+	it("persists all three counters across a fresh openStore handle", () => {
+		incCompactCount(dir);
+		incRecallInjected(4, dir);
+		incCacheHitTokens(500, dir);
+		// openStore returns the canonical (on-disk) handle; reading back proves durability.
+		openStore(dir);
+		assert.equal(getCompactCount(dir), 1);
+		assert.equal(getRecallInjected(dir), 4);
+		assert.equal(getCacheHitTokensSaved(dir), 500);
+	});
+});

package/src/store/sqlite.ts

@@ -704,6 +704,34 @@ export function bumpDedupStats(deduped: boolean, stateDir: string = getStateDir(
   if (deduped) incMeta("deduped", 1, stateDir);
 }
 
+// --- Live dashboard counters (schemaless meta key/value — NO migration) -----
+// These reuse the private `incMeta` atomically-incrementing integer counter so
+// all cumulative tallies live in the same `meta` table as tokens_saved etc.
+
+export function incCompactCount(stateDir: string = getStateDir()): void {
+  incMeta("compact_count", 1, stateDir);
+}
+
+export function getCompactCount(stateDir: string = getStateDir()): number {
+  return getMetaNumber("compact_count", stateDir);
+}
+
+export function incRecallInjected(n: number, stateDir: string = getStateDir()): void {
+  if (n > 0) incMeta("recall_injected", n, stateDir);
+}
+
+export function getRecallInjected(stateDir: string = getStateDir()): number {
+  return getMetaNumber("recall_injected", stateDir);
+}
+
+export function incCacheHitTokens(delta: number, stateDir: string = getStateDir()): void {
+  if (delta > 0) incMeta("cache_hit_tokens_saved", delta, stateDir);
+}
+
+export function getCacheHitTokensSaved(stateDir: string = getStateDir()): number {
+  return getMetaNumber("cache_hit_tokens_saved", stateDir);
+}
+
 // --- Future-feature foundation (resume sessions / daily log / lessons) -------
 // Scaffolded tables + minimal helpers so all store data lives in SQLite from
 // day one. Full UI/recall for these lands in later sprints.

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

@@ -1,291 +0,0 @@
-/**
- * openclaw-mega-compact — OpenClaw plugin adapter for the pi-mega-compact engine.
- *
- * Wires the pi-agnostic Trident engine (src/) into OpenClaw's plugin lifecycle:
- *  - Registers a CompactionProvider that replaces the built-in summarizeInStages.
- *  - Exposes `mega_status` and `mega_recall` tools for on-demand inspection.
- *  - Hooks into `before_compaction` / `after_compaction` for diagnostics.
- *
- * Design constraints:
- *  - NO imports from `@earendil-works/pi-coding-agent` or pi-agent-core.
- *  - The engine core (src/) is pi-agnostic; this file is the sole OpenClaw boundary.
- *  - No network at runtime — everything is local (stores + extractive summarizer).
- */
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { compactSession, setDefaultStore, } from "../src/engine.js";
-import { recallAndInline } from "../src/recall.js";
-import { VectorStore } from "../src/vectorStore.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const PLUGIN_ID = "mega-compact";
-const PLUGIN_LABEL = "Mega Compact (Trident)";
-/** Default state directory for vector store persistence. */
-const STATE_DIR = process.env.MEGA_COMPACT_STATE_DIR ?? undefined;
-/** Minimum messages before we bother compacting. */
-const MIN_MESSAGES_FOR_COMPACT = 6;
-// ---------------------------------------------------------------------------
-// Message conversion — OpenClaw unknown[] → EngineMessage[]
-// ---------------------------------------------------------------------------
-/**
- * Best-effort conversion from OpenClaw's opaque message array to our
- * EngineMessage shape. OpenClaw messages are typed as `unknown[]` so we
- * handle whatever shape comes through gracefully.
- */
-function toEngineMessages(messages) {
-    return messages.map((msg) => {
-        if (!msg || typeof msg !== "object") {
-            // Primitive fallback — treat as custom text.
-            return {
-                role: "custom",
-                text: String(msg ?? ""),
-            };
-        }
-        const m = msg;
-        const role = typeof m.role === "string" ? m.role : "custom";
-        // Normalize role to one of our four engine roles.
-        let engineRole;
-        switch (role) {
-            case "user":
-                engineRole = "user";
-                break;
-            case "assistant":
-                engineRole = "assistant";
-                break;
-            case "tool":
-            case "function":
-                engineRole = "tool";
-                break;
-            default:
-                engineRole = "custom";
-                break;
-        }
-        // Extract text content from common message shapes.
-        const text = typeof m.content === "string"
-            ? m.content
-            : typeof m.text === "string"
-                ? m.text
-                : Array.isArray(m.content)
-                    ? m.content
-                        .filter((part) => part.type === "text" && typeof part.text === "string")
-                        .map((part) => part.text)
-                        .join("\n")
-                    : "";
-        // Preserve tool metadata when present.
-        const toolName = typeof m.name === "string"
-            ? m.name
-            : typeof m.toolName === "string"
-                ? m.toolName
-                : undefined;
-        const input = typeof m.input === "string"
-            ? m.input
-            : typeof m.arguments === "string"
-                ? m.arguments
-                : m.arguments !== undefined
-                    ? JSON.stringify(m.arguments)
-                    : undefined;
-        const output = typeof m.output === "string"
-            ? m.output
-            : engineRole === "tool" && typeof m.content === "string"
-                ? m.content
-                : undefined;
-        return { role: engineRole, text, toolName, input, output };
-    });
-}
-// ---------------------------------------------------------------------------
-// Compaction provider
-// ---------------------------------------------------------------------------
-function createCompactionProvider(store) {
-    return {
-        id: PLUGIN_ID,
-        label: PLUGIN_LABEL,
-        async summarize({ messages, signal, compressionRatio, }) {
-            // Abort check — bail early if the caller cancelled.
-            if (signal?.aborted) {
-                throw new DOMException("Aborted", "AbortError");
-            }
-            const engineMessages = toEngineMessages(messages);
-            // Nothing meaningful to compact.
-            if (engineMessages.length < MIN_MESSAGES_FOR_COMPACT) {
-                return "";
-            }
-            // Map compression ratio → keepFrom boundary.
-            // compressionRatio=0.5 means "compact the oldest 50%".
-            // Default to compacting the oldest half if not specified.
-            const ratio = compressionRatio ?? 0.5;
-            const keepFrom = Math.max(MIN_MESSAGES_FOR_COMPACT, Math.floor(engineMessages.length * (1 - ratio)));
-            // Abort check after conversion (conversion is cheap but check anyway).
-            if (signal?.aborted) {
-                throw new DOMException("Aborted", "AbortError");
-            }
-            const sessionId = `openclaw-${Date.now()}`;
-            const input = {
-                sessionId,
-                messages: engineMessages,
-                keepFrom,
-            };
-            const result = compactSession(input, store);
-            if (result.skipped) {
-                return "";
-            }
-            return result.summary;
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Plugin entry
-// ---------------------------------------------------------------------------
-export default definePluginEntry({
-    id: PLUGIN_ID,
-    name: "Mega Compact",
-    description: "Layered, local, vector-backed context compressor (Trident engine) for OpenClaw compaction.",
-    register(api) {
-        const logger = api.logger;
-        // Resolve state directory — prefer plugin config override.
-        const pluginCfg = (api.pluginConfig ?? {});
-        const stateDir = typeof pluginCfg.stateDir === "string" && pluginCfg.stateDir.length > 0
-            ? pluginCfg.stateDir
-            : STATE_DIR;
-        // Initialize vector store.
-        let store;
-        try {
-            store = new VectorStore({ stateDir });
-            setDefaultStore(store);
-            logger.info?.(`${PLUGIN_ID}: vector store initialized (stateDir=${stateDir ?? "default"})`);
-        }
-        catch (err) {
-            logger.error?.(`${PLUGIN_ID}: failed to init vector store:`, err);
-            return; // Hard bail — no point registering if store is broken.
-        }
-        // -----------------------------------------------------------------------
-        // Register compaction provider
-        // -----------------------------------------------------------------------
-        const provider = createCompactionProvider(store);
-        api.registerCompactionProvider(provider);
-        logger.info?.(`${PLUGIN_ID}: registered compaction provider "${provider.id}"`);
-        // -----------------------------------------------------------------------
-        // Hooks — before / after compaction diagnostics
-        // -----------------------------------------------------------------------
-        api.registerHook({
-            event: "before_compaction",
-            handler: async (ctx) => {
-                const msgCount = Array.isArray(ctx?.messages) ? ctx.messages.length : 0;
-                logger.info?.(`${PLUGIN_ID}: before_compaction — ${msgCount} messages in scope`);
-            },
-        });
-        api.registerHook({
-            event: "after_compaction",
-            handler: async (ctx) => {
-                const summaryLen = typeof ctx?.summary === "string" ? ctx.summary.length : 0;
-                logger.info?.(`${PLUGIN_ID}: after_compaction — summary ${summaryLen} chars`);
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Tool: mega_status
-        // -----------------------------------------------------------------------
-        api.registerTool({
-            name: "mega_status",
-            description: "Show the current status of the mega-compact engine: vector store stats, checkpoint count, and recent compaction activity.",
-            parameters: {
-                type: "object",
-                properties: {
-                    sessionId: {
-                        type: "string",
-                        description: "Optional session ID to scope stats to.",
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const sessionId = args?.sessionId ?? "global";
-                try {
-                    const stats = store.stats(sessionId);
-                    const parts = [
-                        `**Mega Compact Status**`,
-                        `Session: ${sessionId}`,
-                        `Checkpoints: ${stats.checkpointCount}`,
-                        `Total tokens saved: ${stats.totalTokenEstimate}`,
-                        `Last checkpoint: ${stats.lastCheckpointId ?? "—"}`,
-                        `Injected count: ${stats.injectedCount}`,
-                        `Dedup hit rate: ${(stats.dedupHitRate * 100).toFixed(0)}%`,
-                    ];
-                    if (stats.lastSummary) {
-                        parts.push(`\nLast summary (truncated):\n  ${stats.lastSummary.slice(0, 120).replace(/\n/g, " ")}…`);
-                    }
-                    return { content: [{ type: "text", text: parts.join("\n") }] };
-                }
-                catch (err) {
-                    return {
-                        content: [{ type: "text", text: `Error reading mega-compact status: ${err}` }],
-                        isError: true,
-                    };
-                }
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Tool: mega_recall
-        // -----------------------------------------------------------------------
-        api.registerTool({
-            name: "mega_recall",
-            description: "Recall and inline relevant context from the mega-compact vector store for the current session.",
-            parameters: {
-                type: "object",
-                properties: {
-                    sessionId: {
-                        type: "string",
-                        description: "Session ID to recall context for.",
-                    },
-                    query: {
-                        type: "string",
-                        description: "Natural language query for relevant context.",
-                    },
-                    limit: {
-                        type: "number",
-                        description: "Max checkpoints to recall (default 3).",
-                    },
-                },
-                required: ["sessionId", "query"],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const { sessionId, query, limit } = args;
-                if (!sessionId || !query) {
-                    return {
-                        content: [{ type: "text", text: "Both `sessionId` and `query` are required." }],
-                        isError: true,
-                    };
-                }
-                try {
-                    const result = recallAndInline({ sessionId, query, limit: limit ?? 3, source: "command", skipInjected: false }, store);
-                    if (result.toInject.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No relevant context found in the mega-compact store." }],
-                        };
-                    }
-                    const parts = [
-                        `**Recalled ${result.toInject.length} checkpoint(s):**`,
-                        ...result.report,
-                        "",
-                        "---",
-                        result.block,
-                    ];
-                    return { content: [{ type: "text", text: parts.join("\n") }] };
-                }
-                catch (err) {
-                    return {
-                        content: [{ type: "text", text: `Error during mega-recall: ${err}` }],
-                        isError: true,
-                    };
-                }
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Cleanup on shutdown
-        // -----------------------------------------------------------------------
-        api.on("shutdown", () => {
-            logger.info?.(`${PLUGIN_ID}: shutting down — clearing default store`);
-            setDefaultStore(undefined);
-        });
-        logger.info?.(`${PLUGIN_ID}: plugin registered (tools: mega_status, mega_recall)`);
-    },
-});

package/dist/src/minilm.js

@@ -1,92 +0,0 @@
-/**
- * minilm.ts — local MiniLM (all-MiniLM-L6-v2) sentence embedder (Sprint 12).
- *
- * Implements the `Embedder` interface so it drops into the existing VectorStore
- * dedup cascade and search with no call-site changes. Inference is 100% local:
- * the ONNX model + WordPiece vocab are on-disk artifacts fetched once by
- * scripts/setup-minilm.mjs. There is NO network call at runtime (PREVENT-PI-004).
- *
- * Inputs (dynamic): input_ids, attention_mask, token_type_ids (int64).
- * Output: last_hidden_state (batch, seq, 384). We mean-pool over non-padded
- * tokens (attention_mask == 1) and L2-normalize → 384-dim unit vector.
- *
- * The ONNX session + tokenizer are loaded LAZILY on first embed() so the default
- * TrigramEmbedder path (and its zero native-init cost) is untouched unless
- * MEGACOMPACT_EMBEDDER=minilm is selected.
- */
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-import { l2Normalize, awaitSync } from "./embedder.js";
-import { WordPieceTokenizer } from "./wordpiece.js";
-export const MINILM_DIM = 384;
-export const MINILM_MAX_LEN = 256;
-/** Resolve the model directory: MEGACOMPACT_MINILM_DIR > ./models/minilm > ~/.pi … */
-function resolveModelDir() {
-    if (process.env.MEGACOMPACT_MINILM_DIR)
-        return process.env.MEGACOMPACT_MINILM_DIR;
-    // Repo-local vendored path (gitignored).
-    const local = join(process.cwd(), "models", "minilm");
-    if (existsSync(local))
-        return local;
-    return join(homedir(), ".pi", "agent", "extensions", "mega-compact", "models", "minilm");
-}
-export class MiniLMEmbedder {
-    dim = MINILM_DIM;
-    session = null;
-    tokenizer = null;
-    modelDir;
-    loadPromise = null;
-    constructor(modelDir = resolveModelDir()) {
-        this.modelDir = modelDir;
-    }
-    async ensureLoaded() {
-        if (this.session && this.tokenizer)
-            return;
-        if (this.loadPromise)
-            return this.loadPromise;
-        this.loadPromise = (async () => {
-            const ort = await import("onnxruntime-node");
-            const modelPath = join(this.modelDir, "model_quantized.onnx");
-            const vocabPath = join(this.modelDir, "vocab.txt");
-            if (!existsSync(modelPath) || !existsSync(vocabPath)) {
-                throw new Error(`MiniLM artifacts missing in ${this.modelDir}. Run: node scripts/setup-minilm.mjs`);
-            }
-            // 1 thread is plenty for a single short-region embed and bounds CPU.
-            this.session = await ort.InferenceSession.create(modelPath, {
-                executionProviders: ["cpu"],
-                graphOptimizationLevel: "all",
-            });
-            this.tokenizer = WordPieceTokenizer.fromVocabFile(vocabPath);
-        })();
-        return this.loadPromise;
-    }
-    embed(text) {
-        awaitSync(this.ensureLoaded());
-        const enc = this.tokenizer.encode(text, MINILM_MAX_LEN);
-        const n = enc.inputIds.length;
-        const BigInt64 = (arr) => arr.map((x) => BigInt(x));
-        const ort = awaitSync(import("onnxruntime-node"));
-        const tensors = {
-            input_ids: new ort.Tensor("int64", BigInt64(enc.inputIds), [1, n]),
-            attention_mask: new ort.Tensor("int64", BigInt64(enc.attentionMask), [1, n]),
-            token_type_ids: new ort.Tensor("int64", BigInt64(enc.tokenTypeIds), [1, n]),
-        };
-        const out = awaitSync(this.session.run(tensors));
-        const hidden = out.last_hidden_state.data;
-        // hidden shape: [1, n, 384]. Mean-pool over non-padded positions.
-        const pooled = new Array(MINILM_DIM).fill(0);
-        let count = 0;
-        for (let i = 0; i < n; i++) {
-            if (enc.attentionMask[i] === 0)
-                continue;
-            const base = i * MINILM_DIM;
-            for (let d = 0; d < MINILM_DIM; d++)
-                pooled[d] += hidden[base + d];
-            count++;
-        }
-        if (count === 0)
-            return l2Normalize(new Array(MINILM_DIM).fill(0));
-        return l2Normalize(pooled.map((x) => x / count));
-    }
-}