pi-mega-compact 0.11.4 → 0.11.6

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

@@ -0,0 +1,267 @@
+/**
+ * dashboard-server/routes-setup.ts — Setup wizard route handlers.
+ *
+ * GET /api/setup-status  — Returns current embedder configuration from env.
+ * GET /api/setup-detect  — Runs best-effort detection of local embedder backends.
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON).
+ * The detection commands run local subprocesses via spawnSync, NOT network calls.
+ * Each decoration line carries a guardrails-allow annotation.
+ */
+import { spawnSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: local subprocess detection only
+import { createRequire } from "node:module";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+// ---------------------------------------------------------------------------
+// handleSetupStatus — "/api/setup-status"
+// ---------------------------------------------------------------------------
+function detectCurrentEmbedder() {
+    const url = process.env["MEGACOMPACT_EMBEDDING_URL"];
+    const minilm = process.env["MEGACOMPACT_MINILM"];
+    if (url && url.trim().length > 0)
+        return "http";
+    if (minilm && ["1", "true", "yes"].includes(minilm.trim().toLowerCase()))
+        return "minilm";
+    return "trigram";
+}
+export function handleSetupStatus(req, res, _ctx) {
+    if (req.url !== "/api/setup-status")
+        return false;
+    if (req.method !== "GET") {
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "method_not_allowed" }));
+        return true;
+    }
+    const body = {
+        currentEmbedder: detectCurrentEmbedder(),
+        embeddingUrl: process.env["MEGACOMPACT_EMBEDDING_URL"] ?? null,
+        embedCache: process.env["MEGACOMPACT_EMBED_CACHE"] ?? null,
+        minilm: ["1", "true", "yes"].includes((process.env["MEGACOMPACT_MINILM"] ?? "").trim().toLowerCase()),
+    };
+    // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+    return true;
+}
+// ---------------------------------------------------------------------------
+// handleSetupDetect — "/api/setup-detect"
+// ---------------------------------------------------------------------------
+function detectOllama() {
+    try {
+        const version = spawnSync("ollama", ["--version"], {
+            timeout: 5000,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (version.status !== 0) {
+            return { installed: false, models: [], running: false, detail: version.stderr?.trim() || "not found" };
+        }
+        // Check for running server
+        let running = false;
+        let models = [];
+        try {
+            const listResult = spawnSync("ollama", ["list"], {
+                timeout: 5000,
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            if (listResult.status === 0) {
+                running = true;
+                // Parse lines: NAME  ID  SIZE  MODIFIED
+                const lines = listResult.stdout?.split("\n") ?? [];
+                for (const line of lines) {
+                    const name = line.split(/\s+/)[0];
+                    if (name && name !== "NAME")
+                        models.push(name);
+                }
+            }
+        }
+        catch {
+            // ollama list failed — server may not be running
+            running = false;
+        }
+        return {
+            installed: true,
+            models,
+            running,
+            detail: version.stdout?.trim() || null,
+        };
+    }
+    catch {
+        return { installed: false, models: [], running: false, detail: "detection error" };
+    }
+}
+function detectLlamaCpp() {
+    try {
+        const which = spawnSync("which", ["llama-server", "llama.cpp"], {
+            timeout: 3000,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const installed = which.status === 0 && which.stdout.trim().length > 0;
+        return {
+            installed,
+            detail: installed ? which.stdout.trim() : null,
+        };
+    }
+    catch {
+        return { installed: false, detail: "detection error" };
+    }
+}
+function detectOnnx() {
+    try {
+        // Check for onnxruntime-node in a parent node_modules
+        const req = createRequire(import.meta.url);
+        try {
+            req.resolve("onnxruntime-node");
+            return { installed: true, detail: "onnxruntime-node found in node_modules" };
+        }
+        catch {
+            return { installed: false, detail: "onnxruntime-node not found in node_modules" };
+        }
+    }
+    catch {
+        return { installed: false, detail: "detection error" };
+    }
+}
+export function handleSetupDetect(req, res, _ctx) {
+    if (req.url !== "/api/setup-detect")
+        return false;
+    if (req.method !== "GET") {
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "method_not_allowed" }));
+        return true;
+    }
+    let error = null;
+    let ollama = null;
+    let llamaCpp = null;
+    let onnx = null;
+    try {
+        ollama = detectOllama();
+    }
+    catch (e) {
+        error = `ollama detection failed: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    try {
+        llamaCpp = detectLlamaCpp();
+    }
+    catch (e) {
+        error = error ?? `llama.cpp detection failed: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    try {
+        onnx = detectOnnx();
+    }
+    catch (e) {
+        error = error ?? `onnx detection failed: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    const body = { ollama, llamaCpp, onnx, error };
+    // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+    return true;
+}
+// ---------------------------------------------------------------------------
+// handleSetupConfigure — POST "/api/setup-configure"
+// ---------------------------------------------------------------------------
+const OLLAMA_DEFAULT_URL = "http://localhost:11434/api/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+const LLAMA_DEFAULT_URL = "http://localhost:8080/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+function readJsonBody(req, cb) {
+    let body = "";
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        if (body.length > 65536) {
+            tooBig = true;
+            return;
+        }
+        body += chunk.toString();
+    });
+    req.on("end", () => {
+        if (tooBig)
+            return cb({ ok: false, error: "body_too_large" });
+        try {
+            const v = body ? JSON.parse(body) : {}; // PREVENT-001: parsed value type-checked below
+            if (typeof v !== "object" || v === null || Array.isArray(v)) {
+                return cb({ ok: false, error: "invalid_object" });
+            }
+            cb({ ok: true, value: v });
+        }
+        catch {
+            cb({ ok: false, error: "invalid_json" });
+        }
+    });
+    req.on("error", () => cb({ ok: false, error: "read_error" }));
+}
+export function handleSetupConfigure(req, res, ctx) {
+    if (req.url !== "/api/setup-configure")
+        return false;
+    if (req.method !== "POST") {
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "method_not_allowed" }));
+        return true;
+    }
+    readJsonBody(req, (parsed) => {
+        if (!parsed.ok) {
+            // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: parsed.error }));
+            return;
+        }
+        const body = parsed.value;
+        const embedder = body.embedder;
+        if (embedder !== "ollama" && embedder !== "llama" && embedder !== "trigram") {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "invalid_embedder" }));
+            return;
+        }
+        const url = body.url;
+        let resolvedUrl;
+        if (embedder === "ollama")
+            resolvedUrl = typeof url === "string" && url ? url : OLLAMA_DEFAULT_URL;
+        else if (embedder === "llama")
+            resolvedUrl = typeof url === "string" && url ? url : LLAMA_DEFAULT_URL;
+        else
+            resolvedUrl = null;
+        // Write .mega-compact.env to the state dir (loaded by env-loader at next startup).
+        const stateDir = ctx.stateDir;
+        const envPath = join(stateDir, ".mega-compact.env");
+        const lines = [
+            "# Mega-Compact Embedder Configuration",
+            `# Configured via dashboard Setup tab at ${new Date().toISOString()}`,
+        ];
+        if (resolvedUrl) {
+            lines.push(`export MEGACOMPACT_EMBEDDING_URL="${resolvedUrl}"`);
+        }
+        else {
+            lines.push("# trigram: built-in embedder, no URL needed");
+            lines.push("# unset MEGACOMPACT_EMBEDDING_URL (commented to override any shell-set value)");
+            lines.push("# export MEGACOMPACT_EMBEDDING_URL=");
+        }
+        lines.push("");
+        try {
+            mkdirSync(stateDir, { recursive: true });
+            writeFileSync(envPath, lines.join("\n"), "utf-8");
+        }
+        catch (e) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `write_failed: ${e instanceof Error ? e.message : String(e)}` }));
+            return;
+        }
+        // Detect if the new config matches what's already active (no restart needed).
+        const currentUrl = process.env["MEGACOMPACT_EMBEDDING_URL"];
+        const alreadyActive = (resolvedUrl === null && !currentUrl) || (resolvedUrl !== null && currentUrl === resolvedUrl);
+        const resp = {
+            embedder,
+            url: resolvedUrl,
+            envPath,
+            restartRequired: !alreadyActive,
+            alreadyActive,
+        };
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(resp));
+    });
+    return true;
+}

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

@@ -12,3 +12,7 @@ export { handleTopics } from "./routes-topics.js";
 export { handleTurns } from "./routes-turns.js";
 export { handleMaintenance } from "./routes-maintenance.js";
 export { handleProviderCache } from "./routes-cache.js";
+export { handleMemoryStatus } from "./routes-memory.js";
+export { handleSetupStatus, handleSetupDetect, handleSetupConfigure } from "./routes-setup.js";
+export { handleMemoryMap } from "./routes-memory-map.js";
+export { handleCacheStripes } from "./routes-cache.js";

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

@@ -12,7 +12,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
-import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleStatic, } from "./routes.js";
+import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleStatic, } from "./routes.js";
 export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
@@ -195,6 +195,18 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleProviderCache(req, res, ctx))
             return;
+        if (handleMemoryStatus(req, res, ctx))
+            return;
+        if (handleCacheStripes(req, res, ctx))
+            return;
+        if (handleSetupStatus(req, res, ctx))
+            return;
+        if (handleSetupDetect(req, res, ctx))
+            return;
+        if (handleSetupConfigure(req, res, ctx))
+            return;
+        if (handleMemoryMap(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,

package/dist/extensions/mega-commands.js

@@ -13,6 +13,11 @@ import { loadMetrics, fpRate, p95, defaultMetricsPath } from "../src/monitoring.
 import { C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
 import { vectorStats, vectorRepoStats, vectorDataInvariant } from "../src/vectorStore.js";
+import { spawnSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: local subprocess detection only (no network)
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createRequire } from "node:module";
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime, sid, ref) {
     const all = listCheckpoints(sid, runtime.currentStateDir);
@@ -73,7 +78,7 @@ export function registerCommands(pi, runtime, config) {
                 runtime.logger.info("recall", { query, crossRepo, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
                 runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossRepo ? " (cross-repo)" : ""}`);
                 ctx.ui.notify(`[mega-compact] recall staged ${r.toInject.length} checkpoint(s) for "${query}"${crossRepo ? " (cross-repo)" : ""}:\n${list}\n` +
-                    `(injected at the next turn via system prompt)`);
+                    `(injected at the tail of the next turn's context)`);
             }
             catch (e) {
                 ctx.ui.notify(`[mega-compact] /mega-recall failed: ${String(e)}`);
@@ -255,6 +260,189 @@ export function registerCommands(pi, runtime, config) {
                 `• data safety — every compressed region is kept verbatim; nothing is permanently deleted. /mega-restore brings any of it back.`);
         },
     });
+    pi.registerCommand("mega-setup", {
+        description: "Local embedding setup wizard — detect available embedders and configure mega-compact.",
+        handler: async (_args, ctx) => {
+            try {
+                const log = (msg) => ctx.ui.notify(msg);
+                // --- 1. Current config ---
+                const embeddingUrl = process.env["MEGACOMPACT_EMBEDDING_URL"];
+                const minilm = process.env["MEGACOMPACT_MINILM"];
+                let currentEmbedder = "TrigramEmbedder (heuristic, default)";
+                if (embeddingUrl)
+                    currentEmbedder = `httpEmbedder → ${embeddingUrl}`;
+                else if (minilm)
+                    currentEmbedder = "MiniLM (experimental)";
+                // --- 2. Detection ---
+                let ollamaDetected = false;
+                let ollamaModels = [];
+                let ollamaRunning = false;
+                let llamaDetected = false;
+                let onnxDetected = false;
+                try {
+                    const ollamaVer = spawnSync("ollama", ["--version"], {
+                        timeout: 5000,
+                        encoding: "utf-8",
+                        stdio: ["ignore", "pipe", "pipe"],
+                    }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+                    if (ollamaVer.status === 0) {
+                        ollamaDetected = true;
+                        try {
+                            const listResult = spawnSync("ollama", ["list"], {
+                                timeout: 5000,
+                                encoding: "utf-8",
+                                stdio: ["ignore", "pipe", "pipe"],
+                            }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+                            if (listResult.status === 0) {
+                                ollamaRunning = true;
+                                const lines = listResult.stdout?.split("\n") ?? [];
+                                for (const line of lines) {
+                                    const name = line.split(/\s+/)[0];
+                                    if (name && name !== "NAME")
+                                        ollamaModels.push(name);
+                                }
+                            }
+                        }
+                        catch {
+                            // ollama list fails if server not running — that's fine
+                        }
+                    }
+                }
+                catch {
+                    // ollama not found
+                }
+                try {
+                    const whichLlama = spawnSync("which", ["llama-server"], {
+                        timeout: 3000,
+                        encoding: "utf-8",
+                        stdio: ["ignore", "pipe", "pipe"],
+                    }); // guardrails-allow PREVENT-PI-004: local subprocess detection only
+                    llamaDetected = whichLlama.status === 0;
+                }
+                catch {
+                    // not found
+                }
+                try {
+                    const req = createRequire(import.meta.url);
+                    try {
+                        req.resolve("onnxruntime-node");
+                        onnxDetected = true;
+                    }
+                    catch {
+                        // not in node_modules
+                    }
+                }
+                catch {
+                    // require error
+                }
+                const choices = [];
+                if (ollamaDetected && ollamaRunning) {
+                    const model = ollamaModels.find((m) => m.includes("nomic-embed") ||
+                        m.includes("embed") ||
+                        m.includes("mxbai"));
+                    const suggestedModel = model ?? "nomic-embed-text";
+                    choices.push({
+                        label: `Use Ollama (${suggestedModel}) at localhost:11434`,
+                        value: `ollama:${suggestedModel}`,
+                    });
+                }
+                else if (ollamaDetected && !ollamaRunning) {
+                    choices.push({
+                        label: "Ollama detected but server is not running — start it first",
+                        value: "ollama:offline",
+                    });
+                }
+                if (llamaDetected) {
+                    choices.push({
+                        label: "Use llama.cpp server at localhost:8080",
+                        value: "llama:default",
+                    });
+                }
+                if (onnxDetected) {
+                    choices.push({
+                        label: "Use ONNX Runtime (experimental, requires config)",
+                        value: "onnx:default",
+                    });
+                }
+                choices.push({
+                    label: "Keep TrigramEmbedder (default, no setup)",
+                    value: "trigram",
+                });
+                // --- 4. Prompt user ---
+                log(`Current embedder: ${currentEmbedder}`);
+                let selected = "trigram";
+                if (choices.length > 1) {
+                    try {
+                        const labels = choices.map((c) => c.label);
+                        const picked = await ctx.ui.select("Select an embedder to configure:", labels);
+                        if (picked === undefined) {
+                            log("Setup cancelled by user.");
+                            return;
+                        }
+                        const match = choices.find((c) => c.label === picked);
+                        selected = match?.value ?? "trigram";
+                    }
+                    catch {
+                        log("Setup cancelled by user.");
+                        return;
+                    }
+                }
+                else {
+                    log("No local embedders detected. Keeping TrigramEmbedder default.");
+                }
+                // --- 5. Apply selection ---
+                if (selected.startsWith("ollama:")) {
+                    const model = selected.split(":")[1];
+                    const url = `http://localhost:11434/api/embeddings`; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+                    const lines = [
+                        `# Mega-Compact Embedder Configuration — Ollama`,
+                        `# Generated by /megasetup at ${new Date().toISOString()}`,
+                        `export MEGACOMPACT_EMBEDDING_URL="${url}"`,
+                        `# Optional: uncomment to set cache size (default 1000)`,
+                        `# export MEGACOMPACT_EMBED_CACHE=1000`,
+                    ];
+                    const envContent = lines.join("\n") + "\n";
+                    // Write .mega-compact.env to state dir
+                    const stateDir = process.env["MEGACOMPACT_STATE_DIR"] ?? path.join(os.homedir(), ".pi", "mega-compact");
+                    try {
+                        mkdirSync(stateDir, { recursive: true });
+                        writeFileSync(path.join(stateDir, ".mega-compact.env"), envContent, "utf-8");
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    log(`Configured for Ollama (${model}).\n\nAdd to your shell profile (~/.bashrc, ~/.zshrc, or ~/.config/fish/config.fish):\n\n  source "${path.join(stateDir, ".mega-compact.env")}"\n\nOr export manually:\n\n  export MEGACOMPACT_EMBEDDING_URL="${url}"\n\nThen restart pi to activate the http embedder.`);
+                }
+                else if (selected.startsWith("llama:")) {
+                    const url = "http://localhost:8080/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+                    const lines = [
+                        `# Mega-Compact Embedder Configuration — llama.cpp`,
+                        `# Generated by /megasetup at ${new Date().toISOString()}`,
+                        `export MEGACOMPACT_EMBEDDING_URL="${url}"`,
+                    ];
+                    const envContent = lines.join("\n") + "\n";
+                    const stateDir = process.env["MEGACOMPACT_STATE_DIR"] ?? path.join(os.homedir(), ".pi", "mega-compact");
+                    try {
+                        mkdirSync(stateDir, { recursive: true });
+                        writeFileSync(path.join(stateDir, ".mega-compact.env"), envContent, "utf-8");
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    log(`Configured for llama.cpp server.\n\nAdd to your shell profile:\n\n  source "${path.join(stateDir, ".mega-compact.env")}"\n\nOr export manually:\n\n  export MEGACOMPACT_EMBEDDING_URL="${url}"\n\nThen restart pi to activate the http embedder.`);
+                }
+                else if (selected.startsWith("onnx:")) {
+                    log("ONNX Runtime configuration is experimental.\n\nSet MEGACOMPACT_EMBEDDING_URL to your local ONNX server URL, or see docs for manual setup.\nKeeping TrigramEmbedder for now.");
+                }
+                else {
+                    log("Keeping TrigramEmbedder (default). No configuration needed.");
+                }
+            }
+            catch (e) {
+                ctx.ui.notify(`[mega-compact] /mega-setup failed: ${String(e)}`);
+            }
+        },
+    });
     // NOTE: /mega-tier was removed in S24. The tier the user sees is now the LIVE
     // pressure band (low/medium/high/ultra/mega), which climbs automatically as
     // context fills — there is no manual tier to set. See docs/specs/s24-unified-pressure.md.

package/dist/extensions/mega-compact.js

@@ -28,6 +28,7 @@
 import { closeVectorIndex } from "../src/store/vectorIndex.js";
 import { closeMemoryIndex } from "../src/store/memoryIndex.js";
 import { loadConfig } from "./mega-config.js";
+import { loadMegaEnv } from "./mega-runtime/env-loader.js";
 import { MegaRuntime } from "./mega-runtime.js";
 import { registerEventHandlers } from "./mega-events.js";
 import { registerCommands } from "./mega-commands.js";
@@ -38,6 +39,10 @@ import { registerGameCommands } from "./mega-game-cmds.js";
 import { registerMetricsCommands } from "./mega-metrics-cmds.js";
 import { registerTopicsCommands } from "./mega-topics-cmds.js";
 export default function (pi) {
+    // Load .mega-compact.env (written by /mega-setup + dashboard Setup tab) BEFORE
+    // config resolution so the wizard's choices take effect. Shell env wins over
+    // the file (see env-loader.ts). Non-fatal: missing/malformed file is a no-op.
+    loadMegaEnv(loadConfig().stateDir);
     const config = loadConfig();
     // S38.9: preflight env validation — check for obviously invalid values at startup.
     // Non-fatal: log warnings and fall back to defaults.

package/dist/extensions/mega-config.js

@@ -149,6 +149,7 @@ export function loadConfig() {
         errorRetrySessionMax: envFlag("MEGACOMPACT_ERROR_RETRY_SESSION_MAX", 3),
         poisonedContextRepeatThreshold: envFlag("MEGACOMPACT_POISONED_REPEAT_THRESHOLD", 3),
         providerOutageAdviseThreshold: envFlag("MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD", 3),
+        advisoryChannel: envBool("MEGACOMPACT_ADVISORY_CHANNEL", true),
         autoPctTrigger,
         autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
         dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
@@ -165,7 +166,13 @@ export function loadConfig() {
         memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
         recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
         windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
+        recallTailInject: envBool("MEGACOMPACT_RECALL_TAIL_INJECT", true),
+        messageSeparation: envBool("MEGACOMPACT_MESSAGE_SEPARATION", false),
         tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
+        ragQueryReformulation: envBool("MEGACOMPACT_QUERY_REFORMULATION", false),
+        ragTieredRouter: envBool("MEGACOMPACT_TIERED_ROUTER", false),
+        ragRecallMetrics: envBool("MEGACOMPACT_RECALL_METRICS", false),
+        ragMemoryGraph: envBool("MEGACOMPACT_MEMORY_GRAPH", false),
         // D.1: env-overridable recompact delta (minimum context growth % before
         // re-compacting instead of replaying the cached live trim). Default 50.
         recompactPctDelta: envFlag("MEGACOMPACT_RECOMPACT_PCT_DELTA", 50),

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

@@ -154,7 +154,10 @@ export function registerAgentHandlers(pi, runtime, config) {
                                 try {
                                     if (runtime.rt.sessionId !== liveSid)
                                         return; // session reset
-                                    const since2 = now - (runtime.rt.lastNativeCompactAt ?? 0);
+                                    // IMPORTANT: recompute Date.now() inside the timeout.
+                                    // `now` above is the durable-trim handler's timestamp and can be
+                                    // ~500ms stale by the time this callback runs.
+                                    const since2 = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
                                     if (runtime.rt.lastNativeCompactAt !== stamp &&
                                         since2 < cooldownMs)
                                         return;
@@ -227,6 +230,15 @@ export function registerAgentHandlers(pi, runtime, config) {
     pi.on("turn_end", async (event, ctx) => {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
+        // S53: consume staged recall blocks ONLY if they were actually injected
+        // into a view this turn. If no context event fired (edge: turn ended
+        // before any LLM call), recallInjectedThisTurn stays false and the blocks
+        // remain staged for the next turn's first context event.
+        if (config.recallTailInject && runtime.rt.recallInjectedThisTurn) {
+            runtime.pendingRecallBlock = undefined;
+            runtime.pendingMemoryRecallBlock = undefined;
+            runtime.rt.recallInjectedThisTurn = false;
+        }
         // S43 (per-turn tracking): record one turn row with the cached metrics so
         // the turn layer is queryable + forkable. Best-effort + non-fatal: a write
         // failure never breaks the agent loop.
@@ -518,9 +530,12 @@ export function registerAgentHandlers(pi, runtime, config) {
                         rawText: (errSig || '').slice(0, 500),
                         ...(detail.httpStatus !== undefined ? { httpStatus: detail.httpStatus } : {}),
                     });
-                    // (b) one-per-session advise message (throttled by poisonedAdviseSent)
-                    if (!runtime.rt.poisonedAdviseSent) {
-                        runtime.rt.poisonedAdviseSent = true;
+                    // (b) throttle flag: set unconditionally so the advise fires at
+                    // most once per session regardless of channel.
+                    runtime.rt.poisonedAdviseSent = true;
+                    // Legacy flag-OFF path: user-role advise message.
+                    // 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.");
                     }

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

@@ -46,6 +46,7 @@ async function nudgeResume(pi, runtime) {
         const now = Date.now();
         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.");
         }
     }