pi-mega-compact 0.20.64 → 0.20.66

package/README.md

@@ -90,7 +90,7 @@ Set env vars before starting pi. Defaults are in `src/config/dedup.ts`.
 | `MEGACOMPACT_WIKI_INCREMENTAL` | `true` | Incremental wiki updates (no full rebuild) |
 | `MEGACOMPACT_AUTO_WIKI` | `true` | Auto-generate wiki from turns |
 | `MEGACOMPACT_NEW_UI` | `true` | Use the new Tailwind/shadcn dashboard shell |
-| `MEGACOMPACT_COST_API_ENABLED` | `false` | Opt-in: fetch model pricing from an external API (PREVENT-PI-004 network exception). Enriches dashboard cost data for models not in the local pricing table |
+| `MEGACOMPACT_COST_API_ENABLED` | `false` | Opt-in: fetch model pricing from an external API (PREVENT-PI-004 applies to defaults; opt-in features are exempt). Enriches dashboard cost data for models not in the local pricing table |
 | `MEGACOMPACT_COST_API_URL` | _(unset)_ | OpenRouter-compatible model pricing endpoint (e.g. `https://openrouter.ai/api/v1/models`). Only contacted when `MEGACOMPACT_COST_API_ENABLED=true` |
 
 Full config reference: [`docs/CONFIGURATION.md`](docs/CONFIGURATION.md)

package/dist/config/vector-cortex-enc2b.js

@@ -0,0 +1,36 @@
+/**
+ * config/vector-cortex-enc2b.ts — ENC-2b native onnxruntime qualification
+ * retest flag.
+ *
+ * Sibling of vector-cortex-enc2a.ts / vector-cortex-enc2budget.ts so
+ * vector-cortex.ts stays under the 300-line soft limit (soft-as-hard gate).
+ * vector-cortex.ts re-exports the flag below and root src/config.ts re-exports
+ * it, so no consumer import path changes.
+ *
+ * ENC-2b re-probes and re-qualifies the installed native onnxruntime binding
+ * (`onnxruntime-node` in `~/.pi/mega-compact/native-ort/`, operator-installed
+ * via the ENC-2a guide). When the operator installs the binding the read path
+ * does not automatically re-evaluate the qualification verdict; this sprint
+ * delivers a reader-only retest that loads the LOCAL on-disk binding, runs a
+ * bounded warmup + p95 probe against it, measures RSS, computes a fresh
+ * qualification verdict against the ENC-0f p95 budget + the operator
+ * install-budget, and surfaces it on the Setup Cortex sub-tab and the GET
+ * `/api/setup-status` response.
+ *
+ * `MEGACOMPACT_ENC_2B=0` disables: the GET omits both new retest fields, the
+ * POST ignores the retest-request key, the Cortex sub-tab renders no retest
+ * card — byte-identical to the ENC-2a predecessor. The flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS
+ * — see `feedback_dashboard-flags-toggleable` memory).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ENC-2b — native onnxruntime qualification retest (detect installed binding,
+ * re-probe p95/RSS, re-qualify). Default ON. `MEGACOMPACT_ENC_2B=0` disables and
+ * is byte-identical to the ENC-2a predecessor: no retest GET fields, no retest
+ * POST branch, no retest card. This flag MUST also be a dashboard SETTINGS
+ * toggle (visible in config UI, never in EXCLUDED_SETTINGS).
+ */
+export const ENC_2B_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_2B");

package/dist/config/vector-cortex.js

@@ -52,5 +52,7 @@ export { ENC_1B_ENABLED, ENC_1B_MAX_EMBEDDING_DIM, ENC_1B_EMBEDDING_DIM_ENV, ENC
 export { ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX_MIB, ENC_2BUDGET_DEFAULT_MIB, } from "./vector-cortex-enc2budget.js";
 // ENC-2a native onnxruntime install-guide flag extracted to vector-cortex-enc2a.ts.
 export { ENC_2A_ENABLED } from "./vector-cortex-enc2a.js";
+// ENC-2b native onnxruntime qualification-retest flag extracted to vector-cortex-enc2b.ts.
+export { ENC_2B_ENABLED } from "./vector-cortex-enc2b.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, ENC_0D_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED, ENC_1A_ENABLED, ENC_1B_ENABLED, ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX_MIB, ENC_2BUDGET_DEFAULT_MIB, ENC_2A_ENABLED, COSINE_FP_BENCH_ENABLED, COSINE_FP_REAL_ENABLED, REPO_CORPUS_ENABLED, DASH_0A_ENABLED, DASH_0B_ENABLED, DASH_0C_ENABLED, DASH_0D_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, ENC_0D_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED, ENC_1A_ENABLED, ENC_1B_ENABLED, ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX_MIB, ENC_2BUDGET_DEFAULT_MIB, ENC_2A_ENABLED, ENC_2B_ENABLED, COSINE_FP_BENCH_ENABLED, COSINE_FP_REAL_ENABLED, REPO_CORPUS_ENABLED, DASH_0A_ENABLED, DASH_0B_ENABLED, DASH_0C_ENABLED, DASH_0D_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

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

@@ -71,6 +71,7 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_ENC_1B", "ENC-1b ONNX runtime backend + embedder API settings", "ENC-1b completes the embedder API Settings surface (dim / headers / allow-remote persisted to the per-repo .mega-compact.env) and surfaces the ONNX runtime selection knob (MEGACOMPACT_ENCODER_NATIVE) as a toggle plus the current effective backend + demotion reason. OFF = no new GET fields, no writer branch, no new Settings rows or toggle (byte-identical ENC-1a predecessor).", true),
         boolDirect("MEGACOMPACT_ENC_2BUDGET", "ENC-2a operator-configurable native install-budget knob", "ENC-2a exposes the runtime operator knob MEGACOMPACT_NATIVE_ORT_BUDGET_MIB (default 300 MiB, clamp 8192) as a dashboard Settings field. The knob gates budgetOk in the encoder runtime decision (decision.ts installBudgetMib + runtime-select.ts selectRuntimeBackend). Persisted to the per-repo .mega-compact.env via the setup-configure writer branch; the GET status route surfaces the persisted value AND the effective integer installBudgetMib() resolves to (so the dashboard shows the runtime's actual operand). OFF = no new GET fields, no writer branch, no new Settings rows (byte-identical ENC-1b predecessor).", true),
         boolDirect("MEGACOMPACT_ENC_2A", "ENC-2a native onnxruntime install GUIDE (detect + copy-paste)", "ENC-2a surfaces the platform-matched native onnxruntime install-guide (three copy-paste steps + script path) on the Setup Cortex sub-tab when the operator opted into the native backend but the effective runtime is still wasm (onnxruntime-node absent). Pure guidance — the extension NEVER executes or fetches (PREVENT-PI-004 unchanged); the committed operator script scripts/encoder/install-native-ort.mjs runs in the USER's shell. OFF = no guide GET fields, no guide-request POST branch, no install card (byte-identical ENC-1b predecessor).", true),
+        boolDirect("MEGACOMPACT_ENC_2B", "ENC-2b native ONNX runtime qualification retest (detect + re-qualify)", "ENC-2b re-probes and re-qualifies the installed native onnxruntime binding (onnxruntime-node in ~/.pi/mega-compact/native-ort/, operator-installed via the ENC-2a guide): loads the LOCAL on-disk binding, runs a bounded warmup + p95 probe, measures RSS, and computes a fresh qualification verdict against the ENC-0f p95 budget + the operator install-budget. Never downloads or trains (PREVENT-PI-004 / HG-1 unchanged); surfaces nativeOrtRetestResult + nativeOrtBackendEffective on the GET /api/setup-status. OFF = no retest GET fields, no retest POST branch, no retest card (byte-identical ENC-2a predecessor).", true),
         boolDirect("MEGACOMPACT_COSINE_FP_BENCH", "COS-FP-A Synthetic FP Bench", "Synthetic FP harness + L2 cosine threshold calibration (COS-FP-A): drives the deterministic synthetic-corpus grid sweep (scripts/cosine-fp/bench.mjs) that measures L2 cosine false-positive rates and emits a recommended default, and serves the reader-only GET /api/cosine-fp-report. Synthetic-corpus-only — never reads real session/ledger bytes. OFF = bench inert, endpoint 404s, no report write, L2_COSINE plain MEGACOMPACT_L2_THRESHOLD (byte-identical predecessor).", true),
         boolDirect("MEGACOMPACT_COSINE_FP_REAL", "COS-FP-R Real-Corpus Validation", "Real-corpus L2 cosine FP validation (COS-FP-R): runs the real-corpus grid sweep (scripts/cosine-fp/real-bench.mjs) against donated, consent-approved sessions only (SECURITY_PRIVACY Lifecycle/Consent), scoring FP/FN with Wilson intervals + session-grouped bootstrap, and appends CI-backed per-content-type recommendations to the cosine-threshold report. Runs only when a valid consented corpus exists; absent corpus = no_corpus (normative pre-donation state, nothing written). OFF = script inert, nothing executes, no writes (byte-identical predecessor).", true),
         boolDirect("MEGACOMPACT_REPO_CORPUS", "Cross-Repo Corpus (REPO-A)", "Cross-repo corpus preparation (REPO-A): the governed, consent-gated reader-only path that builds a pseudonymous corpus manifest from per-repo events.log slices and serves GET /api/repo-corpus answering which pseudonymous repos/sessions are in the corpus, what cross-repo overlap exists, and whether consent is active for each — counts + IDs + status only, never payload content. Consent is append-only (consent.mjs, CLI/ops-only); revocation freezes the builder + route. OFF = builder refuses to run, reader route 404s, single-repo recall untouched (byte-identical predecessor).", true),

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

@@ -0,0 +1,77 @@
+/**
+ * dashboard-server/routes-setup-enc2b.ts — ENC-2b native onnxruntime
+ * qualification retest (reader-only probe) + POST retest action.
+ *
+ * Extracted out of routes-setup.ts (which hovers at the 300-line source soft
+ * cap, mirroring the ENC-1b/ENC-2a sibling extracts) so the ENC-2b additive
+ * GET field — the native qualification retest result + effective backend —
+ * lives in a sibling impl file and routes-setup.ts stays a thin host.
+ *
+ * The retest's job is RE-QUALIFICATION: when the operator installed
+ * onnxruntime-node via the ENC-2a guide, the encoder read path does not
+ * automatically re-evaluate the qualification verdict. This sibling surface
+ * runs `runNativeRetest` (a bounded, reader-only, local probe) and:
+ *
+ *   - surfaces `nativeOrtRetestResult` + `nativeOrtBackendEffective` on the GET
+ *     when the flag is on AND a binding is installed — absent otherwise
+ *     (byte-identical to the ENC-2a-era shape on flag-off/none);
+ *   - handles the POST `nativeOrtRetest` key (`false` → 400
+ *     `retest_rejected_false_nothing_to_do`; `true` → run + echo the fresh
+ *     result; flag-off → the key is unrecognized, byte-identical predecessor).
+ *
+ * `nativeOrtBackendEffective` is `"native"` only when the retest verdict is
+ * `qualified`; any `degraded`/`failed` verdict keeps the backend `"wasm"` — the
+ * runtime never silently switches to a backend whose retest failed.
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem + in-process binding load only,
+ * zero network — the retest NEVER fetches), PREVENT-011 (no `any`).
+ */
+import { ENC_2B_ENABLED } from "../../src/config/vector-cortex.js";
+import { runNativeRetest, } from "../../src/vector-cortex/encoder/native-qualify-retest.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
+ * flag-off AND when no binding is installed — both fields are OMITTED (absent,
+ * not null), so the GET stays byte-identical to the ENC-2a-era shape and the
+ * client hides the retest card. Flag-off omits, never nulls: the ENC-2a-era
+ * host spreads `...{}` so no new key appears. Mirror of the ENC-2a/ENC-1b
+ * sibling idiom; async because the retest loads the binding in-process.
+ */
+export async function readEnc2bRetest(stateDir) {
+    if (!ENC_2B_ENABLED())
+        return {};
+    const result = await runNativeRetest(stateDir);
+    if (result === null)
+        return {};
+    return {
+        nativeOrtRetestResult: result,
+        nativeOrtBackendEffective: result.verdict === "qualified" ? "native" : "wasm",
+    };
+}
+/**
+ * ENC-2b POST retest-action key handling (flag-gated, additive).
+ *
+ * `true`  → { action: "run" } (the host runs the retest and returns the result)
+ * `false` → { action: "reject" } (400 `retest_rejected_false_nothing_to_do`)
+ * other   → null (key absent or flag off — falls through unrecognized,
+ *            byte-identical ENC-2a-era predecessor).
+ */
+export function enc2bRetestRequest(body) {
+    if (!ENC_2B_ENABLED())
+        return null;
+    if (body.nativeOrtRetest === true)
+        return "run";
+    if (body.nativeOrtRetest === false)
+        return "reject";
+    return null;
+}
+/**
+ * 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.
+ */
+export async function runEnc2bRetest(stateDir) {
+    if (!ENC_2B_ENABLED())
+        return null;
+    return runNativeRetest(stateDir);
+}

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

@@ -15,6 +15,7 @@ import { enc1aStatusFields, writeEnc1aEnv, tryEnc1aConfigure, wantsEnc1a } from
 import { enc1bStatusFields, tryEnc1bConfigure, tryEnc1bInto, enc1bValidateCombined } from "./routes-setup-enc1b.js";
 import { enc2BudgetStatusFields, tryEnc2BudgetInto, enc2BudgetValidateCombined, } from "./routes-setup-enc2budget.js";
 import { readEnc2aGuide, enc2aGuideRequest } from "./routes-setup-enc2a.js";
+import { readEnc2bRetest, enc2bRetestRequest, runEnc2bRetest } from "./routes-setup-enc2b.js";
 import { writeEmbedderEnv } from "./routes-setup-env-upsert.js";
 import { detectOllama, detectLlamaCpp, detectOnnx, memoizedDetectOllama, memoizedDetectLlamaCpp, memoizedDetectOnnx, } from "./routes-setup-detect-cache.js";
 // ---------------------------------------------------------------------------
@@ -69,7 +70,7 @@ export function handleSetupStatus(req, res, ctx) {
     // ENC-1a (flag-gated, additive): echo the persisted endpoint URL and an
     // embeddingApiKeySet boolean ONLY — the raw API key is never returned. When
     // the flag is off (or neither is set) both fields are simply omitted.
-    const body = {
+    const base = {
         currentEmbedder: active,
         configuredEmbedder: configured.embedder,
         configuredUrl: configured.url,
@@ -82,9 +83,20 @@ export function handleSetupStatus(req, res, ctx) {
         ...(enc2a.guide !== null ? { nativeOrtInstallGuide: enc2a.guide } : {}),
         ...(enc2a.installedVersion !== null ? { nativeOrtInstalledVersion: enc2a.installedVersion } : {}),
     };
+    // ENC-2b (flag-gated, additive): the native qualification retest fields. The
+    // retest loads the on-disk binding in-process (bounded, never a fetch), so
+    // readEnc2bRetest is async; the handler returns true synchronously for the
+    // dispatch and writes the response after the await. Flag-off/none mutates
+    // the body additively and stays byte-identical to the ENC-2a-era shape.
     // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(body));
+    readEnc2bRetest(ctx.stateDir).then((enc2b) => {
+        const body = { ...base, ...enc2b };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+    }).catch(() => {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(base));
+    });
     return true;
 }
 // ---------------------------------------------------------------------------
@@ -204,6 +216,30 @@ export function handleSetupConfigure(req, res, ctx) {
             res.end(JSON.stringify({ nativeOrtInstallGuide: readEnc2aGuide(ctx.stateDir).guide }));
             return;
         }
+        // ENC-2b retest-action key (flag-gated, additive): `false` → 400 (an
+        // operator-driven no-op — nothing to retest), `true` → run the bounded
+        // retest synchronously and return the fresh result. Flag-off: the key
+        // falls through unrecognized (byte-identical ENC-2a-era predecessor).
+        // The retest never fetches — the binding is on disk from the ENC-2a
+        // install (PREVENT-PI-004 clean).
+        const retestReq = enc2bRetestRequest(body);
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        if (retestReq === "reject") {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "retest_rejected_false_nothing_to_do" }));
+            return;
+        }
+        if (retestReq === "run") {
+            // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+            runEnc2bRetest(ctx.stateDir).then((fresh) => {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ nativeOrtRetestResult: fresh }));
+            }).catch(() => {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "retest_failed" }));
+            });
+            return;
+        }
         if (tryEnc1aConfigure(body, res, ctx))
             return;
         if (tryEnc1bConfigure(body, res, ctx))

package/dist/extensions/mega-compact-s38.test/_helpers.js

@@ -131,7 +131,8 @@ export function harness(opts = {}) {
         registerCommand: () => { }, registerTool: () => { }, registerShortcut: () => { },
         registerFlag: () => { }, getFlag: () => undefined,
         registerMessageRenderer: () => { }, registerEntryRenderer: () => { },
-        sendMessage: () => { }, sendUserMessage: (m) => { sendUserMessages.push(m); },
+        sendMessage: (m) => { if (typeof m?.content === "string")
+            sendUserMessages.push(m.content); }, sendUserMessage: (m) => { sendUserMessages.push(m); },
         appendEntry: (t, d) => appended.push({ t, d }),
         setSessionName: () => { }, getSessionName: () => undefined, setLabel: () => { },
         exec: async () => ({ stdout: "", stderr: "", code: 0 }),

package/dist/extensions/mega-compact.test/_helpers.js

@@ -186,7 +186,10 @@ export function harness(opts = {}) {
         getFlag: () => undefined,
         registerMessageRenderer: () => { },
         registerEntryRenderer: () => { },
-        sendMessage: (_m) => { },
+        sendMessage: (m) => {
+            if (typeof m?.content === "string")
+                sendUserMessages.push(m.content);
+        },
         sendUserMessage: (m) => {
             sendUserMessages.push(m);
         },

package/dist/extensions/mega-events/agent-handlers/agentEndHandler.js

@@ -1,5 +1,5 @@
 import { piCompactWouldNoop } from "../../mega-pipeline.js";
-import { safeSendUserMessage } from "../send-safe.js";
+import { safeSendInvisibleMessage } from "../send-safe.js";
 /** Handle the `agent_end` pi event. Non-fatal end-to-end. */
 export async function handleAgentEnd(ctx, pi, runtime, config) {
     runtime.activeAgents = Math.max(0, runtime.activeAgents - 1);
@@ -200,7 +200,7 @@ export async function handleAgentEnd(ctx, pi, runtime, config) {
                 const nudgeMsg = lengthStop && !didDurableTrim
                     ? "[mega-compact] the last response hit the output-token cap; continue from where it stopped."
                     : "[mega-compact] continue from the compacted context above.";
-                await safeSendUserMessage(pi, nudgeMsg);
+                await safeSendInvisibleMessage(pi, nudgeMsg);
             }
         }
         catch {

package/dist/extensions/mega-events/agent-handlers/turnEndHandler/errorRetry-transient.js

@@ -0,0 +1,131 @@
+import { errorRetryBackoffMs } from "../../error-classifier.js";
+import { safeSendInvisibleMessage } from "../../send-safe.js";
+import { maybeSendProviderOutageAdvisory } from "../../outage-advisor.js";
+/** Handle the transient or permanent error-retry path. Non-fatal. */
+export async function transientRetry(event, _ctx, pi, runtime, config, tc) {
+    const { effectiveCategory, detail, errSig } = tc;
+    // S38.7: hard-stop switch — bypass ALL retry logic when set.
+    if (config.errorRetryHardStop) {
+        runtime.rt.errorRetryCount = 0;
+        runtime.dashboard.event("error_retry_disabled", {
+            category: effectiveCategory,
+            turnIndex: event.turnIndex,
+            reason: "hard-stop",
+        });
+        return; // early exit — no retry
+    }
+    // S38.6: circuit-breaker — stop retrying after too many consecutive errors.
+    runtime.rt.consecutiveErrors++;
+    // R10: send calm "provider outage" advisory once per episode.
+    await maybeSendProviderOutageAdvisory(effectiveCategory, runtime, pi, config, { signal: detail.signal, rawText: (errSig || '').slice(0, 500) });
+    if (runtime.rt.consecutiveErrors > config.maxConsecutiveErrors) {
+        runtime.dashboard.event("error_retry_circuit_open", {
+            consecutive: runtime.rt.consecutiveErrors,
+            max: config.maxConsecutiveErrors,
+            turnIndex: event.turnIndex,
+        });
+        runtime.logger.warn("error-retry-circuit-open", {
+            sessionId: runtime.rt.sessionId,
+            consecutive: runtime.rt.consecutiveErrors,
+            max: config.maxConsecutiveErrors,
+        });
+        return; // early exit — circuit breaker tripped
+    }
+    const max = effectiveCategory === "transient"
+        ? config.autoRetryTransientMax
+        : config.autoRetryPermanentMax;
+    // max === 0 disables the category entirely (revert to S28-only).
+    if (max <= 0) {
+        runtime.rt.errorRetryCount = 0;
+        return;
+    }
+    runtime.rt.errorRetryCount++;
+    if (runtime.rt.errorRetryCount > max) {
+        // Exhausted — surface the error, reset for the next burst.
+        runtime.dashboard.event("error_retry_exhausted", {
+            category: effectiveCategory,
+            count: runtime.rt.errorRetryCount,
+            max,
+            turnIndex: event.turnIndex,
+        });
+        runtime.logger.info("error-retry-exhausted", {
+            sessionId: runtime.rt.sessionId,
+            category: effectiveCategory,
+            count: runtime.rt.errorRetryCount,
+            max,
+        });
+        runtime.rt.errorRetryCount = 0;
+        return;
+    }
+    // R2: session-global cap — total S38 nudges per session across ALL bursts.
+    // Independent of the per-burst max and the circuit breaker. Hitting it is
+    // terminal for the session: log + dashboard event, stop nudging. `0` disables.
+    if (config.errorRetrySessionMax > 0 &&
+        runtime.rt.errorRetrySessionCount >= config.errorRetrySessionMax) {
+        runtime.dashboard.event("error_retry_session_exhausted", {
+            count: runtime.rt.errorRetrySessionCount,
+            max: config.errorRetrySessionMax,
+            category: effectiveCategory,
+            turnIndex: event.turnIndex,
+        });
+        runtime.logger.warn("error-retry-session-exhausted", {
+            sessionId: runtime.rt.sessionId,
+            count: runtime.rt.errorRetrySessionCount,
+            max: config.errorRetrySessionMax,
+            category: effectiveCategory,
+        });
+        runtime.rt.errorRetryCount = 0;
+        return; // terminal for the session — no nudge
+    }
+    // R1: in-flight nudge dedup — a nudge queued via deliverAs:'followUp' must
+    // not be re-sent until consumed by an actual new agent turn (turn_start
+    // resets retryNudgePending). Without this, a fast-erroring provider + a
+    // per-turn nudge → N nudges queue up and pi dispatches N retry turns, each
+    // re-submitting the same failing prompt (the 2026-07-28 incident).
+    if (runtime.rt.retryNudgePending) {
+        runtime.dashboard.event("error_retry_dedup_skip", {
+            category: effectiveCategory,
+            count: runtime.rt.errorRetryCount,
+            max,
+            turnIndex: event.turnIndex,
+        });
+        return; // pending nudge not yet consumed — skip
+    }
+    // R1: gating backoff — errorRetryUntil is GATING. A nudge cannot fire before
+    // the previous backoff elapses. Paces retries (5s/10s/20s/30s default).
+    const now = Date.now();
+    if (now < runtime.rt.errorRetryUntil) {
+        runtime.dashboard.event("error_retry_backoff_skip", {
+            category: effectiveCategory,
+            count: runtime.rt.errorRetryCount,
+            max,
+            turnIndex: event.turnIndex,
+        });
+        return; // backoff not elapsed — skip
+    }
+    // Fire the retry nudge. Set pending (R1 dedup) + backoff (R1 pacing) +
+    // session count (R2 cap) BEFORE the await so a re-entrant turn_end during
+    // the send can't double-fire.
+    runtime.rt.retryNudgePending = true;
+    runtime.rt.lastErrorRetryAt = now;
+    runtime.rt.errorRetryUntil =
+        now +
+            errorRetryBackoffMs(runtime.rt.errorRetryCount, config.errorRetryBackoffMs);
+    runtime.rt.errorRetrySessionCount++;
+    runtime.dashboard.event("error_retry", {
+        category: effectiveCategory,
+        count: runtime.rt.errorRetryCount,
+        max,
+        turnIndex: event.turnIndex,
+    });
+    runtime.logger.info("error-retry", {
+        sessionId: runtime.rt.sessionId,
+        category: effectiveCategory,
+        count: runtime.rt.errorRetryCount,
+        max,
+    });
+    // PREVENT-PI-003: user-role only (queued + catch-guarded).
+    // Invisible: display:false so the retry trigger fires without
+    // rendering "Follow-up:" spam in the conversation UI.
+    await safeSendInvisibleMessage(pi, "[mega-compact] the last turn ended with an error; please retry.");
+}

package/dist/extensions/mega-events/agent-handlers/turnEndHandler/errorRetry.js

@@ -1,7 +1,7 @@
 import { piCompactWouldNoop } from "../../../mega-pipeline.js";
-import { classifyError, classifyErrorDetailed, errorRetryBackoffMs, extractErrorSignature, isKnownRetryableTransient, } from "../../error-classifier.js";
-import { safeSendUserMessage } from "../../send-safe.js";
-import { maybeSendProviderOutageAdvisory } from "../../outage-advisor.js";
+import { classifyError, classifyErrorDetailed, extractErrorSignature, isKnownRetryableTransient, } from "../../error-classifier.js";
+import { safeSendInvisibleMessage } from "../../send-safe.js";
+import { transientRetry } from "./errorRetry-transient.js";
 /** S38: broader error-retry safety net. Non-fatal end-to-end. */
 export async function errorRetry(event, ctx, pi, runtime, config) {
     // S38: broader error-retry safety net. S28 only catches stopReason==='length';
@@ -209,7 +209,10 @@ export async function errorRetry(event, ctx, pi, runtime, config) {
                 // Default ON (advisoryChannel=true): dashboard-only, no user message.
                 if (!config.advisoryChannel) {
                     // PREVENT-PI-003: user-role sendUserMessage only.
-                    await safeSendUserMessage(pi, "[mega-compact] this session's context may be poisoned (the provider is rejecting every request). Run /clear or /new to start a fresh context.");
+                    // Invisible: display:false — the dashboard event + log already
+                    // capture the poisoned-context signal; the user does not need a
+                    // visible "Follow-up:" message.
+                    await safeSendInvisibleMessage(pi, "[mega-compact] this session's context may be poisoned (the provider is rejecting every request). Run /clear or /new to start a fresh context.");
                 }
                 // (c) one guarded compact per error signature (attempt to remove
                 // the poisoned region). Race-guarded + deferred, mirroring the
@@ -245,139 +248,12 @@ export async function errorRetry(event, ctx, pi, runtime, config) {
             }
             else {
                 // (5) transient or permanent — retry with exponential backoff.
-                // S38.7: hard-stop switch — bypass ALL retry logic when set.
-                if (config.errorRetryHardStop) {
-                    runtime.rt.errorRetryCount = 0;
-                    runtime.dashboard.event("error_retry_disabled", {
-                        category: effectiveCategory,
-                        turnIndex: event.turnIndex,
-                        reason: "hard-stop",
-                    });
-                    return; // early exit — no retry
-                }
-                // S38.6: circuit-breaker — stop retrying after too many consecutive errors.
-                runtime.rt.consecutiveErrors++;
-                // R10: send calm "provider outage" advisory once per episode.
-                await maybeSendProviderOutageAdvisory(effectiveCategory, runtime, pi, config, { signal: detail.signal, rawText: (errSig || '').slice(0, 500) });
-                if (runtime.rt.consecutiveErrors > config.maxConsecutiveErrors) {
-                    runtime.dashboard.event("error_retry_circuit_open", {
-                        consecutive: runtime.rt.consecutiveErrors,
-                        max: config.maxConsecutiveErrors,
-                        turnIndex: event.turnIndex,
-                    });
-                    runtime.logger.warn("error-retry-circuit-open", {
-                        sessionId: runtime.rt.sessionId,
-                        consecutive: runtime.rt.consecutiveErrors,
-                        max: config.maxConsecutiveErrors,
-                    });
-                    return; // early exit — circuit breaker tripped
-                }
-                const max = effectiveCategory === "transient"
-                    ? config.autoRetryTransientMax
-                    : config.autoRetryPermanentMax;
-                // max === 0 disables the category entirely (revert to S28-only).
-                if (max <= 0) {
-                    runtime.rt.errorRetryCount = 0;
-                }
-                else {
-                    runtime.rt.errorRetryCount++;
-                    if (runtime.rt.errorRetryCount > max) {
-                        // Exhausted — surface the error, reset for the next burst.
-                        runtime.dashboard.event("error_retry_exhausted", {
-                            category: effectiveCategory,
-                            count: runtime.rt.errorRetryCount,
-                            max,
-                            turnIndex: event.turnIndex,
-                        });
-                        runtime.logger.info("error-retry-exhausted", {
-                            sessionId: runtime.rt.sessionId,
-                            category: effectiveCategory,
-                            count: runtime.rt.errorRetryCount,
-                            max,
-                        });
-                        runtime.rt.errorRetryCount = 0;
-                    }
-                    else {
-                        // R2: session-global cap — total S38 nudges per session across
-                        // ALL bursts. Independent of the per-burst max and the circuit
-                        // breaker. Hitting it is terminal for the session: log +
-                        // dashboard event, stop nudging. `0` disables (reverts to
-                        // per-burst + circuit-breaker only).
-                        if (config.errorRetrySessionMax > 0 &&
-                            runtime.rt.errorRetrySessionCount >= config.errorRetrySessionMax) {
-                            runtime.dashboard.event("error_retry_session_exhausted", {
-                                count: runtime.rt.errorRetrySessionCount,
-                                max: config.errorRetrySessionMax,
-                                category: effectiveCategory,
-                                turnIndex: event.turnIndex,
-                            });
-                            runtime.logger.warn("error-retry-session-exhausted", {
-                                sessionId: runtime.rt.sessionId,
-                                count: runtime.rt.errorRetrySessionCount,
-                                max: config.errorRetrySessionMax,
-                                category: effectiveCategory,
-                            });
-                            runtime.rt.errorRetryCount = 0;
-                            return; // terminal for the session — no nudge
-                        }
-                        // R1: in-flight nudge dedup — a nudge queued via
-                        // deliverAs:'followUp' must not be re-sent until it has been
-                        // consumed by an actual new agent turn (turn_start resets
-                        // retryNudgePending). Without this, a fast-erroring provider +
-                        // a per-turn nudge → N nudges queue up and pi dispatches N
-                        // retry turns, each re-submitting the same failing prompt
-                        // (the 2026-07-28 incident). errorRetryCount still advances
-                        // (this IS an error turn), so the per-burst max + circuit
-                        // breaker still bound the burst.
-                        if (runtime.rt.retryNudgePending) {
-                            runtime.dashboard.event("error_retry_dedup_skip", {
-                                category: effectiveCategory,
-                                count: runtime.rt.errorRetryCount,
-                                max,
-                                turnIndex: event.turnIndex,
-                            });
-                            return; // pending nudge not yet consumed — skip
-                        }
-                        // R1: gating backoff — errorRetryUntil is now GATING
-                        // (previously documented as non-gating). A nudge cannot fire
-                        // before the previous backoff elapses. This paces retries
-                        // (5s/10s/20s/30s by default) so a fast-erroring provider
-                        // doesn't slam N nudges in <1s.
-                        const now = Date.now();
-                        if (now < runtime.rt.errorRetryUntil) {
-                            runtime.dashboard.event("error_retry_backoff_skip", {
-                                category: effectiveCategory,
-                                count: runtime.rt.errorRetryCount,
-                                max,
-                                turnIndex: event.turnIndex,
-                            });
-                            return; // backoff not elapsed — skip
-                        }
-                        // Fire the retry nudge. Set pending (R1 dedup) + backoff
-                        // (R1 pacing) + session count (R2 cap) BEFORE the await so a
-                        // re-entrant turn_end during the send can't double-fire.
-                        runtime.rt.retryNudgePending = true;
-                        runtime.rt.lastErrorRetryAt = now;
-                        runtime.rt.errorRetryUntil =
-                            now +
-                                errorRetryBackoffMs(runtime.rt.errorRetryCount, config.errorRetryBackoffMs);
-                        runtime.rt.errorRetrySessionCount++;
-                        runtime.dashboard.event("error_retry", {
-                            category: effectiveCategory,
-                            count: runtime.rt.errorRetryCount,
-                            max,
-                            turnIndex: event.turnIndex,
-                        });
-                        runtime.logger.info("error-retry", {
-                            sessionId: runtime.rt.sessionId,
-                            category: effectiveCategory,
-                            count: runtime.rt.errorRetryCount,
-                            max,
-                        });
-                        // PREVENT-PI-003: user-role sendUserMessage only (queued + catch-guarded).
-                        await safeSendUserMessage(pi, "[mega-compact] the last turn ended with an error; please retry.");
-                    }
-                }
+                // Delegated to errorRetry-transient.ts (delegate-shell split).
+                await transientRetry(event, ctx, pi, runtime, config, {
+                    effectiveCategory,
+                    detail,
+                    errSig,
+                });
             }
         }
     }

package/dist/extensions/mega-events/compact-handlers.js

@@ -3,7 +3,7 @@ import { estimateBlockTokens } from "../../src/tokens.js";
 import { recordScore, getDedupStats } from "../../src/store/sqlite.js";
 import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
 import { resolveRepoRoot } from "../mega-config.js";
-import { safeSendUserMessage } from "./send-safe.js";
+import { safeSendInvisibleMessage } from "./send-safe.js";
 /**
  * Build a minimal fallback compaction so pi never runs its throwing compact().
  *
@@ -36,7 +36,7 @@ function fallbackCompaction(event) {
  * Debounced resume-nudge: restart the agent loop after a compaction (which
  * may have stopped it). Idempotent — one nudge per 30s, never blocks.
  *
- * Uses safeSendUserMessage ({ deliverAs: 'followUp' } + catch-guard) so that a
+ * Uses safeSendInvisibleMessage ({ deliverAs: 'followUp' } + catch-guard) so that a
  * nudge fired during session_before_compact (which is mid-prompt-submission,
  * so the agent can be busy) QUEUES instead of throwing
  * "Agent is already processing. Specify streamingBehavior (steer or followUp)".
@@ -47,7 +47,7 @@ async function nudgeResume(pi, runtime) {
         if (now >= runtime.resumeNudgeUntil) {
             runtime.resumeNudgeUntil = now + 30_000;
             runtime.rt.extensionInitiatedTurn = true; // R13: suppress self-classification
-            await safeSendUserMessage(pi, "[mega-compact] continue from the compacted context above.");
+            await safeSendInvisibleMessage(pi, "[mega-compact] continue from the compacted context above.");
         }
     }
     catch {

package/dist/extensions/mega-events/outage-advisor.js

@@ -9,10 +9,10 @@
  * Distinct from the poisoned-context /clear advise: the outage advisory is
  * for transient errors where the user's context is fine.
  *
- * PREVENT-PI-003: sends via safeSendUserMessage (user-role only).
+ * PREVENT-PI-003: sends via safeSendInvisibleMessage (user-role only).
  * PREVENT-PI-004: local ctx call, no network.
  */
-import { safeSendUserMessage } from "./send-safe.js";
+import { safeSendInvisibleMessage } from "./send-safe.js";
 /**
  * Check the provider-outage advisory condition and fire once per episode.
  *
@@ -21,7 +21,7 @@ import { safeSendUserMessage } from "./send-safe.js";
  *
  * @param effectiveCategory — must be "transient" for the advisory to fire.
  * @param runtime   — the live MegaRuntime (mutated on advisory fire).
- * @param pi        — pi ExtensionAPI for safeSendUserMessage.
+ * @param pi        — pi ExtensionAPI for safeSendInvisibleMessage.
  * @param config    — providerOutageAdviseThreshold config.
  * @param detail    — R11: optional signal + rawText for forensics.
  */
@@ -53,7 +53,7 @@ export async function maybeSendProviderOutageAdvisory(effectiveCategory, runtime
     // injecting into the conversation scares users and triggers false-positive
     // re-classification of the resulting turn (2026-07-31 incident).
     if (!config.advisoryChannel) {
-        // Legacy path (flag OFF): user-role message injection.
-        await safeSendUserMessage(pi, `[mega-compact] the provider is having issues (${runtime.rt.consecutiveErrors} consecutive failures — timeouts/5xx/rate-limits). Retries are bounded and continue automatically; your context is fine — do NOT clear or reset it. Work resumes as soon as the provider recovers.`);
+        // Legacy path (flag OFF): invisible user-role message (display:false).
+        await safeSendInvisibleMessage(pi, `[mega-compact] the provider is having issues (${runtime.rt.consecutiveErrors} consecutive failures — timeouts/5xx/rate-limits). Retries are bounded and continue automatically; your context is fine — do NOT clear or reset it. Work resumes as soon as the provider recovers.`);
     }
 }