pi-mega-compact 0.20.72 → 0.20.73

package/dist/extensions/dashboard-server/routes-setup-enc2b.js

@@ -26,8 +26,12 @@
  * Guardrails: PREVENT-PI-004 (local filesystem + in-process binding load only,
  * zero network — the retest NEVER fetches), PREVENT-011 (no `any`).
  */
+import { writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
 import { ENC_2B_ENABLED } from "../../src/config/vector-cortex.js";
 import { runNativeRetest, } from "../../src/vector-cortex/encoder/native-qualify-retest.js";
+import { Logger } from "../../src/log.js";
+import { encoderStateDir } from "./qualification-record.js";
 /**
  * Resolve the ENC-2b additive GET fields. Returns BOTH fields when the flag is
  * on AND a native binding is installed (the retest ran); returns `{}` on
@@ -43,6 +47,11 @@ export async function readEnc2bRetest(stateDir) {
     const result = await runNativeRetest(stateDir);
     if (result === null)
         return {};
+    // Auto-persist a qualified verdict so the ENC-0g read path + HG-5 pick up the
+    // native result automatically — the operator does not need to click "Retest
+    // now" for the record to update. Degraded/failed never overwrite.
+    if (result.verdict === "qualified")
+        persistQualifiedRecord(result);
     return {
         nativeOrtRetestResult: result,
         nativeOrtBackendEffective: result.verdict === "qualified" ? "native" : "wasm",
@@ -65,13 +74,55 @@ export function enc2bRetestRequest(body) {
         return "reject";
     return null;
 }
+/**
+ * Atomically write a fresh `qualified` QualificationV1 record back to
+ * <stateDir>/encoder-qualification.json. This closes the ENC-2b loop: native
+ * install → retest qualifies → the HG-5 source-of-truth record is overwritten
+ * so the runtime can select mode A. Best-effort (PREVENT-PI-004 local FS only;
+ * never throws into the route). Only ever invoked on a `qualified` verdict —
+ * a `degraded`/`failed` retest never sweeps into the record (the incumbent
+ * verdict stands).
+ */
+export function persistQualifiedRecord(result) {
+    const record = {
+        schema: "qualification-v1",
+        verdict: "qualified",
+        reasons: [],
+        platform: result.platform,
+        p95Ms: result.p95Ms,
+        rssMib: result.rssMiB,
+        opset: 21,
+        digest: "",
+    };
+    const dir = encoderStateDir();
+    const finalPath = join(dir, "encoder-qualification.json");
+    const tmpPath = join(dir, `encoder-qualification.json.tmp-${process.pid}`);
+    try {
+        // guardrails-allow PREVENT-PI-004: local qualification-record write (loopback)
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+        renameSync(tmpPath, finalPath);
+    }
+    catch (err) {
+        // Best-effort: log + continue — a persist failure must never break the route.
+        new Logger().warn("enc2b_qualification_record_persist_failed", {
+            error: String(err),
+            verdict: result.verdict,
+        });
+    }
+}
 /**
  * Run the ENC-2b retest now (bounded, synchronous on the request) and return
  * the fresh result. Flag-off or no binding → null. Used by the POST "run"
- * branch; the result is returned on the response body, never persisted.
+ * branch; the result is returned on the response body. When the retest
+ * qualifies, the qualification record is atomically updated (side-effect).
  */
 export async function runEnc2bRetest(stateDir) {
     if (!ENC_2B_ENABLED())
         return null;
-    return runNativeRetest(stateDir);
+    const result = await runNativeRetest(stateDir);
+    if (result !== null && result.verdict === "qualified") {
+        persistQualifiedRecord(result);
+    }
+    return result;
 }

package/dist/src/vector-cortex/encoder/native-qualify-retest.js

@@ -28,7 +28,9 @@
  * Pi-agnostic, dependency-free. No `any` (PREVENT-011).
  */
 import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { homedir, cpus } from "node:os";
+import { fileURLToPath } from "node:url";
 import { ENCODER_LATENCY_P95_MS, ENCODER_MAX_TOKENS } from "./types.js";
 import { installBudgetMib } from "./decision.js";
 import { detectPlatform } from "./asset.js";
@@ -93,13 +95,24 @@ function readInstalledVersion(pkgJsonPath) {
         return null;
     }
 }
-/** Locate a LOCAL onnx model to probe against, under the native-ort roots.
- *  Null when none exists (the retest cannot qualify without a probe target). */
+/** Locate a LOCAL onnx model to probe against. Probes the native-ort root, the
+ *  stateDir, the repo asset dir (walk-up from this module), and the installed
+ *  extension dir. Null when none exists. */
 function findLocalModel(stateDir) {
     const candidates = [
         join(nativeOrtRootCandidates(stateDir)[0], "model.onnx"),
         join(stateDir, "model.onnx"),
+        join(homedir(), ".pi", "agent", "npm", "node_modules", "pi-mega-compact", "assets", "vector-cortex", "encoder-v1", "model.onnx"),
     ];
+    // Walk up from this module's location looking for the repo asset dir.
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+        candidates.push(join(dir, "assets", "vector-cortex", "encoder-v1", "model.onnx"));
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
     for (const c of candidates) {
         if (existsSync(c))
             return c;
@@ -141,13 +154,16 @@ export async function runNativeRetest(stateDir) {
         };
     }
     // Load the LOCAL binding via dynamic import. Load failure -> failed verdict.
+    // onnxruntime-node's package.json "main" is "dist/index.js" (the compiled JS
+    // that loads the native .node binding). Fall back to the bare package import
+    // (resolves via the installed node_modules resolution) as a secondary path.
     let ort;
     try {
-        ort = await import(join(rootDir, "lib", "index.js"));
+        ort = await import(join(rootDir, "dist", "index.js"));
     }
     catch {
         try {
-            ort = await import(join(rootDir, "dist", "ort.node.mjs"));
+            ort = await import(join(rootDir));
         }
         catch {
             return {
@@ -177,18 +193,18 @@ export async function runNativeRetest(stateDir) {
         const factory = ort;
         const session = await factory.InferenceSession.create(modelPath, {
             executionProviders: ["cpu"],
-            intraOpNumThreads: 4,
+            intraOpNumThreads: Math.min(8, Math.max(1, cpus().length - 1)),
             graphOptimizationLevel: "all",
         });
         const n = ENCODER_MAX_TOKENS;
         const ids = BigInt64Array.from({ length: n }, (_, i) => BigInt(i === 0 ? 101 : i === n - 1 ? 102 : 2000 + (i % 500)));
         const mask = BigInt64Array.from({ length: n }, () => 1n);
         const types = new BigInt64Array(n);
-        // Bounded warmup (3 passes) + 10 timed passes.
-        for (let i = 0; i < 3; i++)
+        // Bounded warmup (10 passes) + 30 timed passes for a stable p95.
+        for (let i = 0; i < 10; i++)
             await timedPass(ort, session, ids, mask, types);
         const lat = [];
-        for (let i = 0; i < 10; i++) {
+        for (let i = 0; i < 30; i++) {
             const ms = await timedPass(ort, session, ids, mask, types);
             if (ms === null)
                 break;

package/dist/vector-cortex/encoder/native-qualify-retest.js

@@ -28,7 +28,9 @@
  * Pi-agnostic, dependency-free. No `any` (PREVENT-011).
  */
 import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { homedir, cpus } from "node:os";
+import { fileURLToPath } from "node:url";
 import { ENCODER_LATENCY_P95_MS, ENCODER_MAX_TOKENS } from "./types.js";
 import { installBudgetMib } from "./decision.js";
 import { detectPlatform } from "./asset.js";
@@ -93,13 +95,24 @@ function readInstalledVersion(pkgJsonPath) {
         return null;
     }
 }
-/** Locate a LOCAL onnx model to probe against, under the native-ort roots.
- *  Null when none exists (the retest cannot qualify without a probe target). */
+/** Locate a LOCAL onnx model to probe against. Probes the native-ort root, the
+ *  stateDir, the repo asset dir (walk-up from this module), and the installed
+ *  extension dir. Null when none exists. */
 function findLocalModel(stateDir) {
     const candidates = [
         join(nativeOrtRootCandidates(stateDir)[0], "model.onnx"),
         join(stateDir, "model.onnx"),
+        join(homedir(), ".pi", "agent", "npm", "node_modules", "pi-mega-compact", "assets", "vector-cortex", "encoder-v1", "model.onnx"),
     ];
+    // Walk up from this module's location looking for the repo asset dir.
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+        candidates.push(join(dir, "assets", "vector-cortex", "encoder-v1", "model.onnx"));
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
     for (const c of candidates) {
         if (existsSync(c))
             return c;
@@ -141,13 +154,16 @@ export async function runNativeRetest(stateDir) {
         };
     }
     // Load the LOCAL binding via dynamic import. Load failure -> failed verdict.
+    // onnxruntime-node's package.json "main" is "dist/index.js" (the compiled JS
+    // that loads the native .node binding). Fall back to the bare package import
+    // (resolves via the installed node_modules resolution) as a secondary path.
     let ort;
     try {
-        ort = await import(join(rootDir, "lib", "index.js"));
+        ort = await import(join(rootDir, "dist", "index.js"));
     }
     catch {
         try {
-            ort = await import(join(rootDir, "dist", "ort.node.mjs"));
+            ort = await import(join(rootDir));
         }
         catch {
             return {
@@ -177,18 +193,18 @@ export async function runNativeRetest(stateDir) {
         const factory = ort;
         const session = await factory.InferenceSession.create(modelPath, {
             executionProviders: ["cpu"],
-            intraOpNumThreads: 4,
+            intraOpNumThreads: Math.min(8, Math.max(1, cpus().length - 1)),
             graphOptimizationLevel: "all",
         });
         const n = ENCODER_MAX_TOKENS;
         const ids = BigInt64Array.from({ length: n }, (_, i) => BigInt(i === 0 ? 101 : i === n - 1 ? 102 : 2000 + (i % 500)));
         const mask = BigInt64Array.from({ length: n }, () => 1n);
         const types = new BigInt64Array(n);
-        // Bounded warmup (3 passes) + 10 timed passes.
-        for (let i = 0; i < 3; i++)
+        // Bounded warmup (10 passes) + 30 timed passes for a stable p95.
+        for (let i = 0; i < 10; i++)
             await timedPass(ort, session, ids, mask, types);
         const lat = [];
-        for (let i = 0; i < 10; i++) {
+        for (let i = 0; i < 30; i++) {
             const ms = await timedPass(ort, session, ids, mask, types);
             if (ms === null)
                 break;

package/extensions/dashboard-server/routes-setup-enc2b.ts

@@ -27,11 +27,16 @@
  * zero network — the retest NEVER fetches), PREVENT-011 (no `any`).
  */
 
+import { writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
 import { ENC_2B_ENABLED } from "../../src/config/vector-cortex.js";
 import {
   runNativeRetest,
   type RetestResult,
 } from "../../src/vector-cortex/encoder/native-qualify-retest.js";
+import { Logger } from "../../src/log.js";
+import type { QualificationV1 } from "../../src/vector-cortex/encoder/qualify.js";
+import { encoderStateDir } from "./qualification-record.js";
 import type { SetupConfigureRequest } from "./api-contracts/setup.js";
 
 /**
@@ -50,6 +55,10 @@ export async function readEnc2bRetest(stateDir: string): Promise<{
   if (!ENC_2B_ENABLED()) return {};
   const result = await runNativeRetest(stateDir);
   if (result === null) return {};
+  // Auto-persist a qualified verdict so the ENC-0g read path + HG-5 pick up the
+  // native result automatically — the operator does not need to click "Retest
+  // now" for the record to update. Degraded/failed never overwrite.
+  if (result.verdict === "qualified") persistQualifiedRecord(result);
   return {
     nativeOrtRetestResult: result,
     nativeOrtBackendEffective: result.verdict === "qualified" ? "native" : "wasm",
@@ -71,12 +80,54 @@ export function enc2bRetestRequest(body: SetupConfigureRequest): "run" | "reject
   return null;
 }
 
+/**
+ * Atomically write a fresh `qualified` QualificationV1 record back to
+ * <stateDir>/encoder-qualification.json. This closes the ENC-2b loop: native
+ * install → retest qualifies → the HG-5 source-of-truth record is overwritten
+ * so the runtime can select mode A. Best-effort (PREVENT-PI-004 local FS only;
+ * never throws into the route). Only ever invoked on a `qualified` verdict —
+ * a `degraded`/`failed` retest never sweeps into the record (the incumbent
+ * verdict stands).
+ */
+export function persistQualifiedRecord(result: RetestResult): void {
+  const record: QualificationV1 = {
+    schema: "qualification-v1",
+    verdict: "qualified",
+    reasons: [],
+    platform: result.platform,
+    p95Ms: result.p95Ms,
+    rssMib: result.rssMiB,
+    opset: 21,
+    digest: "",
+  };
+  const dir = encoderStateDir();
+  const finalPath = join(dir, "encoder-qualification.json");
+  const tmpPath = join(dir, `encoder-qualification.json.tmp-${process.pid}`);
+  try {
+    // guardrails-allow PREVENT-PI-004: local qualification-record write (loopback)
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    renameSync(tmpPath, finalPath);
+  } catch (err) {
+    // Best-effort: log + continue — a persist failure must never break the route.
+    new Logger().warn("enc2b_qualification_record_persist_failed", {
+      error: String(err),
+      verdict: result.verdict,
+    });
+  }
+}
+
 /**
  * Run the ENC-2b retest now (bounded, synchronous on the request) and return
  * the fresh result. Flag-off or no binding → null. Used by the POST "run"
- * branch; the result is returned on the response body, never persisted.
+ * branch; the result is returned on the response body. When the retest
+ * qualifies, the qualification record is atomically updated (side-effect).
  */
 export async function runEnc2bRetest(stateDir: string): Promise<RetestResult | null> {
   if (!ENC_2B_ENABLED()) return null;
-  return runNativeRetest(stateDir);
+  const result = await runNativeRetest(stateDir);
+  if (result !== null && result.verdict === "qualified") {
+    persistQualifiedRecord(result);
+  }
+  return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.72",
+  "version": "0.20.73",
   "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/vector-cortex/encoder/native-qualify-retest.ts

@@ -29,7 +29,9 @@
  */
 
 import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { homedir, cpus } from "node:os";
+import { fileURLToPath } from "node:url";
 import { ENCODER_LATENCY_P95_MS, ENCODER_MAX_TOKENS } from "./types.js";
 import { installBudgetMib } from "./decision.js";
 import { detectPlatform } from "./asset.js";
@@ -122,13 +124,24 @@ function readInstalledVersion(pkgJsonPath: string): string | null {
   }
 }
 
-/** Locate a LOCAL onnx model to probe against, under the native-ort roots.
- *  Null when none exists (the retest cannot qualify without a probe target). */
+/** Locate a LOCAL onnx model to probe against. Probes the native-ort root, the
+ *  stateDir, the repo asset dir (walk-up from this module), and the installed
+ *  extension dir. Null when none exists. */
 function findLocalModel(stateDir: string): string | null {
-  const candidates = [
+  const candidates: string[] = [
     join(nativeOrtRootCandidates(stateDir)[0], "model.onnx"),
     join(stateDir, "model.onnx"),
+    join(homedir(), ".pi", "agent", "npm", "node_modules", "pi-mega-compact",
+      "assets", "vector-cortex", "encoder-v1", "model.onnx"),
   ];
+  // Walk up from this module's location looking for the repo asset dir.
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    candidates.push(join(dir, "assets", "vector-cortex", "encoder-v1", "model.onnx"));
+    const next = dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
   for (const c of candidates) {
     if (existsSync(c)) return c;
   }
@@ -172,12 +185,15 @@ export async function runNativeRetest(stateDir: string): Promise<RetestResult |
   }
 
   // Load the LOCAL binding via dynamic import. Load failure -> failed verdict.
+  // onnxruntime-node's package.json "main" is "dist/index.js" (the compiled JS
+  // that loads the native .node binding). Fall back to the bare package import
+  // (resolves via the installed node_modules resolution) as a secondary path.
   let ort: unknown;
   try {
-    ort = await import(join(rootDir, "lib", "index.js"));
+    ort = await import(join(rootDir, "dist", "index.js"));
   } catch {
     try {
-      ort = await import(join(rootDir, "dist", "ort.node.mjs"));
+      ort = await import(join(rootDir));
     } catch {
       return {
         platform: platformStr,
@@ -215,7 +231,7 @@ export async function runNativeRetest(stateDir: string): Promise<RetestResult |
     };
     const session = await factory.InferenceSession.create(modelPath, {
       executionProviders: ["cpu"],
-      intraOpNumThreads: 4,
+      intraOpNumThreads: Math.min(8, Math.max(1, cpus().length - 1)),
       graphOptimizationLevel: "all",
     });
     const n = ENCODER_MAX_TOKENS;
@@ -225,10 +241,10 @@ export async function runNativeRetest(stateDir: string): Promise<RetestResult |
     const mask = BigInt64Array.from({ length: n }, () => 1n);
     const types = new BigInt64Array(n);
 
-    // Bounded warmup (3 passes) + 10 timed passes.
-    for (let i = 0; i < 3; i++) await timedPass(ort, session, ids, mask, types);
+    // Bounded warmup (10 passes) + 30 timed passes for a stable p95.
+    for (let i = 0; i < 10; i++) await timedPass(ort, session, ids, mask, types);
     const lat: number[] = [];
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 30; i++) {
       const ms = await timedPass(ort, session, ids, mask, types);
       if (ms === null) break;
       lat.push(ms);