pi-mega-compact 0.11.4 → 0.11.5

package/extensions/dashboard-server/routes-repo.ts

@@ -13,7 +13,10 @@ import { ACTIVE_WINDOW_SEC } from "./types.js";
 import type { RouteContext } from "./routes-core.js";
 import type { LiveSnapshot } from "./types.js";
 import { readProviderCacheForRepo } from "../../src/store/sqlite/perf-samples.js";
-import { computeCacheSavings, lookupModelInputRate } from "../../src/pricing.js";
+import {
+	computeCacheSavings,
+	lookupModelInputRate,
+} from "../../src/pricing.js";
 import { latestModelSnapshot } from "../../src/store/sqlite/model-snapshots.js";
 
 // ---------------------------------------------------------------------------
@@ -154,43 +157,42 @@ export function handleRepoIndex(
 					try {
 						const p = join(r.stateDir, "dashboard.json");
 						if (existsSync(p)) {
-							const snap = JSON.parse(
-								readFileSync(p, "utf-8"),
-							) as LiveSnapshot;
+							const snap = JSON.parse(readFileSync(p, "utf-8")) as LiveSnapshot;
 							out.tier = snap.tier ?? null;
 							out.contextPct =
 								snap.context && snap.context.percent != null
 									? snap.context.percent
 									: null;
 							out.state = (snap.session && snap.session.state) || null;
-						out.cacheHits = snap.cacheHits ?? null;
-						out.compacts = snap.compacts ?? null;
-						out.timeSaved = snap.timeSaved ?? null;
-						out.updatedAt = snap.updatedAt ?? null;
-						// Provider cache per-repo lifetime (E.2)
-						try {
-							const pc = readProviderCacheForRepo(r.stateDir);
-							// Price from model snapshot if available
-							const modelSnap = latestModelSnapshot(r.stateDir);
-							const inputRate = modelSnap
-								? modelSnap.inputRate
-								: lookupModelInputRate(r.modelName ?? "") ?? 0;
-							const savings = computeCacheSavings(
-								pc.totalCacheRead,
-								pc.totalCacheWrite,
-								inputRate,
-							);
-							out.providerCache = {
-								avgHitPct: pc.avgHitPct,
-								cacheRead: pc.totalCacheRead,
-								cacheWrite: pc.totalCacheWrite,
-								totalInput: pc.totalInput,
-								sampleCount: pc.sampleCount,
-								estimatedSaved: savings.netSaved > 0 ? savings.netSaved : null,
-							};
-						} catch {
-							/* best-effort — repo may not have perf_samples */
-						}
+							out.cacheHits = snap.cacheHits ?? null;
+							out.compacts = snap.compacts ?? null;
+							out.timeSaved = snap.timeSaved ?? null;
+							out.updatedAt = snap.updatedAt ?? null;
+							// Provider cache per-repo lifetime (E.2)
+							try {
+								const pc = readProviderCacheForRepo(r.stateDir);
+								// Price from model snapshot if available
+								const modelSnap = latestModelSnapshot(r.stateDir);
+								const inputRate = modelSnap
+									? modelSnap.inputRate
+									: (lookupModelInputRate(r.modelName ?? "") ?? 0);
+								const savings = computeCacheSavings(
+									pc.totalCacheRead,
+									pc.totalCacheWrite,
+									inputRate,
+								);
+								out.providerCache = {
+									avgHitPct: pc.avgHitPct,
+									cacheRead: pc.totalCacheRead,
+									cacheWrite: pc.totalCacheWrite,
+									totalInput: pc.totalInput,
+									sampleCount: pc.sampleCount,
+									estimatedSaved:
+										savings.netSaved > 0 ? savings.netSaved : null,
+								};
+							} catch {
+								/* best-effort — repo may not have perf_samples */
+							}
 						}
 					} catch {
 						/* best-effort */
@@ -199,9 +201,7 @@ export function handleRepoIndex(
 				})
 				.sort((a, b) => (b.lastSeen as number) - (a.lastSeen as number));
 			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(
-				JSON.stringify({ updatedAt: new Date().toISOString(), servers }),
-			);
+			res.end(JSON.stringify({ updatedAt: new Date().toISOString(), servers }));
 		} catch {
 			res.writeHead(500, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ error: "servers_unavailable" }));
@@ -236,4 +236,4 @@ export function handleStatic(
 	res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
 	res.end(dashboardHtml(tier));
 	return true;
-}
+}

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

@@ -0,0 +1,181 @@
+/**
+ * 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 type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import type {
+	SetupStatusResponse,
+	SetupDetectResponse,
+	DetectResult,
+	OllamaDetectResult,
+} from "./api-contracts/setup.js";
+
+// ---------------------------------------------------------------------------
+// handleSetupStatus — "/api/setup-status"
+// ---------------------------------------------------------------------------
+
+function detectCurrentEmbedder(): SetupStatusResponse["currentEmbedder"] {
+	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: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	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: SetupStatusResponse = {
+		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(): OllamaDetectResult | null {
+	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: string[] = [];
+		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(): DetectResult | null {
+	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(): DetectResult | null {
+	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: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	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: string | null = null;
+	let ollama: OllamaDetectResult | null = null;
+	let llamaCpp: DetectResult | null = null;
+	let onnx: DetectResult | null = 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: SetupDetectResponse = { 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;
+}

package/extensions/dashboard-server/routes.ts

@@ -20,3 +20,5 @@ 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 } from "./routes-setup.js";

package/extensions/dashboard-server/server.ts

@@ -38,6 +38,9 @@ import {
 	handleTurns,
 	handleMaintenance,
 	handleProviderCache,
+	handleMemoryStatus,
+	handleSetupStatus,
+	handleSetupDetect,
 	handleStatic,
 } from "./routes.js";
 
@@ -227,6 +230,9 @@ export async function launchDashboardServer(
 		if (handleTurns(req, res, ctx)) return;
 		if (handleMaintenance(req, res, ctx)) return;
 		if (handleProviderCache(req, res, ctx)) return;
+		if (handleMemoryStatus(req, res, ctx)) return;
+		if (handleSetupStatus(req, res, ctx)) return;
+		if (handleSetupDetect(req, res, ctx)) return;
 		handleStatic(req, res, ctx);
 	});
 

package/extensions/mega-commands.ts

@@ -16,6 +16,11 @@ import { type MegaRuntime, C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
 import { vectorStats, vectorRepoStats, vectorDataInvariant } from "../src/vectorStore.js";
 import type { MegaConfig } from "./mega-config.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: MegaRuntime, sid: string, ref: string) {
@@ -79,7 +84,7 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
       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)}`);
@@ -275,6 +280,211 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
     },
   });
 
+  pi.registerCommand("mega-setup", {
+    description:
+      "Local embedding setup wizard — detect available embedders and configure mega-compact.",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+     try {
+      const log = (msg: string) => 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: string[] = [];
+      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
+      }
+
+      // --- 3. Build choices ---
+      interface Choice {
+        label: string;
+        value: string;
+      }
+      const choices: Choice[] = [];
+
+      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/extensions/mega-config.ts

@@ -111,6 +111,10 @@ export interface MegaConfig {
 	 *  advisory is sent to the user (distinct from the poisoned /clear advise).
 	 *  Default 3. `0` disables the advisory entirely. */
 	providerOutageAdviseThreshold: number;
+	/** R13: when true (default), poisoned-context and provider-outage advisories
+	 *  are dashboard-only (events tab + log) — no user-visible message injection.
+	 *  When false, the legacy sendUserMessage path runs (byte-identical pre-R13). */
+	advisoryChannel: boolean;
 	/** S29: override the auto-compact fire point for tiered configs, as a
 	 *  fraction of the context window (e.g. 0.85). null = inherit the tier's
 	 *  tierPct (default; preserves existing fire points). The context-handler
@@ -160,6 +164,10 @@ export interface MegaConfig {
 	 *  a hit whose summary is ≥ dedupSim similar to a live message — "dedupe on
 	 *  inline/read" so we never re-inject context already resident. */
 	windowDedupe: boolean;
+	/** S53: Recall Tail Injection — inject staged recall block as a user message at
+	 *  the tail of the view when auto is OFF AND no trim action is needed. Default ON
+	 *  (true). When false, restores the pre-sprint systemPrompt prepend behavior. */
+	recallTailInject: boolean;
 	debug: boolean;
 	/** Master reconciliation: TUI shutdown widget (MEGACOMPACT_TUI_WIDGET=0 to disable). */
 	tuiWidget: boolean;
@@ -306,6 +314,7 @@ export function loadConfig(): MegaConfig {
 			"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"),
@@ -322,6 +331,7 @@ export function loadConfig(): MegaConfig {
 		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),
 		tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
 		// D.1: env-overridable recompact delta (minimum context growth % before
 		// re-compacting instead of replaying the cached live trim). Default 50.

package/extensions/mega-events/agent-handlers.ts

@@ -189,7 +189,10 @@ export function registerAgentHandlers(
 							setTimeout(() => {
 								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
@@ -267,6 +270,16 @@ export function registerAgentHandlers(
 		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.
@@ -571,9 +584,12 @@ export function registerAgentHandlers(
 						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,

package/extensions/mega-events/compact-handlers.ts

@@ -69,6 +69,7 @@ async function nudgeResume(pi: ExtensionAPI, runtime: MegaRuntime): Promise<void
 		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.",