pi-mega-compact 0.6.3 → 0.6.5

package/dist/extensions/mega-runtime.js

@@ -255,6 +255,25 @@ export class MegaRuntime {
             trigger: { armed, ready, currentTokens: this.lastCtxTokens, thresholdTokens: this.config.thresholdTokens, fastGatePct: this.config.fastGatePct },
             crew: { activeAgents: this.activeAgents, currentTurn: this.currentTurn },
             store: { checkpointCount: st.checkpointCount, totalTokenEstimate: st.totalTokenEstimate, originalTokens: st.originalTokens, tokensSaved: this.rt.tokensSaved, injectedCount: st.injectedCount, dedupHitRate: st.dedupHitRate, storageDedupRate: st.storageDedupRate, dedupAttempts: st.dedupAttempts, dedupCollapsed: st.dedupCollapsed },
+            // Reconciled token accounting (single canonical formula, session + repo).
+            // Freed = In − Out; In = Freed + Out. session.Freed = rt.tokensSaved (incl.
+            // deduped-away originals); repo.Freed = repo.tokensSaved meta counter.
+            compression: {
+                session: {
+                    tokensIn: this.rt.tokensSaved + st.totalTokenEstimate,
+                    tokensOut: st.totalTokenEstimate,
+                    tokensFreed: this.rt.tokensSaved,
+                    compressionPct: (this.rt.tokensSaved + st.totalTokenEstimate) > 0 ? this.rt.tokensSaved / (this.rt.tokensSaved + st.totalTokenEstimate) : 0,
+                    dedupPct: st.storageDedupRate,
+                },
+                repo: {
+                    tokensIn: repo.tokensSaved + repo.totalTokenEstimate,
+                    tokensOut: repo.totalTokenEstimate,
+                    tokensFreed: repo.tokensSaved,
+                    compressionPct: (repo.tokensSaved + repo.totalTokenEstimate) > 0 ? repo.tokensSaved / (repo.tokensSaved + repo.totalTokenEstimate) : 0,
+                    dedupPct: repo.storageDedupRate,
+                },
+            },
             repo: {
                 checkpointCount: repo.checkpointCount,
                 totalTokenEstimate: repo.totalTokenEstimate,
@@ -291,33 +310,41 @@ export class MegaRuntime {
             const dedupStr = storageRate * 100 >= 10
                 ? `${Math.round(storageRate * 100)}%`
                 : `${(storageRate * 100).toFixed(1)}%`;
-            // saved = tokens removed from context (cumulative original − stored).
-            // Show BOTH this-session (rt.tokensSaved) and repo-wide-total
-            // (repo.tokensSaved) so the user sees per-session progress vs the running
-            // repo total. "used" = stored checkpoint tokens (repo.totalTokenEstimate
-            // vs st.totalTokenEstimate). Use "k" only at/above 1000 so small-but-real
-            // numbers stay visible (previously Math.round(x/1000) zeroed <1000).
-            const fmt = (x) => (x >= 1000 ? `${(x / 1000).toFixed(1)}k` : `${x}`);
-            const savedStr = `${C.green}${fmt(this.rt.tokensSaved)} sess${C.reset} / ${C.blue}${fmt(repo.tokensSaved)} repo${C.reset}`;
-            const usedStr = `${C.cyan}${fmt(st.totalTokenEstimate)} sess${C.reset} / ${C.blue}${fmt(repo.totalTokenEstimate)} repo${C.reset}`;
+            // Reconciled token accounting — ONE canonical formula for session + repo,
+            // matching the dashboard so the two never disagree. unit format: M at/above
+            // 1e6, k at/above 1e3, raw below — so 5,472,700 → "5.5M", 24,100 → "24.1k",
+            // 142 → "142". Dropped (in) = Freed + Kept; Freed = rt.tokensSaved (session)
+            // / repo.tokensSaved meta (repo); Kept = totalTokenEstimate (stored).
+            const fmt = (x) => x >= 1_000_000 ? `${(x / 1_000_000).toFixed(1)}M`
+                : x >= 1000 ? `${(x / 1000).toFixed(1)}k`
+                    : `${Math.round(x)}`;
             const agentStr = this.activeAgents > 0 ? ` │ 🤖 ${this.activeAgents} agent${this.activeAgents === 1 ? "" : "s"}` : "";
             const turnStr = this.currentTurn > 0 ? ` │ turn ${this.currentTurn}` : "";
             // Phase 3 — pulsing status glyph while a compaction is in flight.
             const pulse = this.pulsing ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} ` : "";
+            // --- reconciled in/out view (session + repo) ---------------------------
+            const sessIn = this.rt.tokensSaved + st.totalTokenEstimate;
+            const sessKept = st.totalTokenEstimate;
+            const sessFreed = this.rt.tokensSaved;
+            const sessPct = sessIn > 0 ? sessFreed / sessIn : 0;
+            const repoIn = repo.tokensSaved + repo.totalTokenEstimate;
+            const repoKept = repo.totalTokenEstimate;
+            const repoFreed = repo.tokensSaved;
+            const repoPct = repoIn > 0 ? repoFreed / repoIn : 0;
             const lines = [
                 ` ${C.amber}⚡ ${tierLabel}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
-                `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset} │ ${C.gray}memory held:${C.reset} ${usedStr} │ ${C.gray}space freed:${C.reset} ${savedStr}`,
+                `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset}`,
+                `   ${C.gray}dropped ${fmt(sessIn)} → kept ${fmt(sessKept)} sess / ${fmt(repoKept)} repo · freed ${fmt(sessFreed)} sess / ${fmt(repoFreed)} repo${C.reset}`,
             ];
-            // Phase 3 — compact progress bar: session tokens saved toward the rolling goal.
-            if (this.rt.tokensSaved > 0) {
-                const goal = Math.max(this.savedGoal, 1);
-                const pct = Math.min(100, Math.round((this.rt.tokensSaved / goal) * 100));
-                const filled = Math.round((pct / 100) * 10);
-                const bar = "▓".repeat(filled) + "░".repeat(10 - filled);
-                // Session tokens saved, with the repo-wide total held alongside so the
-                // bar reads "saved X of goal" and the right side shows saved vs total.
-                const totalHeld = st.totalTokenEstimate > 0 ? st.totalTokenEstimate : repo.totalTokenEstimate;
-                lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)} ${C.gray}│${C.reset} ${C.blue}${fmt(this.rt.tokensSaved)}${C.reset}/${C.blue}${fmt(totalHeld)}${C.reset} tok held`);
+            // Compression meter — the single headline "% tokens saved" (Freed / In),
+            // same formula as the dashboard. Higher = better, so it reads green.
+            {
+                const w = 10;
+                const filled = Math.max(0, Math.min(w, Math.round(sessPct * w)));
+                const cbar = C.green + "▓".repeat(filled) + C.dim + "░".repeat(w - filled) + C.reset;
+                const sTxt = (sessPct * 100).toFixed(sessPct * 100 >= 10 ? 0 : 1);
+                const rTxt = (repoPct * 100).toFixed(repoPct * 100 >= 10 ? 0 : 1);
+                lines.push(`   ${cbar} ${sTxt}% tokens saved (sess) · ${rTxt}% repo${C.reset}`);
             }
             // Live "now processing" line + why + recent deduped/compacted events,
             // collapsed to ONE rotating line (fresh only). The ticker ring buffer
@@ -340,10 +367,11 @@ export class MegaRuntime {
             else if (this.pulsing) {
                 lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
             }
-            // Plain-language hint so first-time users understand the widget. Always
-            // last, dimmed. "/mega-help explains these terms."
+            // Token accounting summary, always last + dimmed. Shows the total
+            // tokens dropped (in) + kept (out) for this session, then the freed
+            // (saved) tokens for both this session and all-time across the repo.
             if (lines.length < 10) {
-                lines.push(`   ${C.dim}auto-compresses old context to free space · nothing deleted · /mega-help${C.reset}`);
+                lines.push(`   ${C.dim}session ↑${fmt(sessIn)} in ↓${fmt(sessKept)} out · saved ${fmt(sessFreed)} session / ${fmt(repoFreed)} all-time${C.reset}`);
             }
             ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "aboveEditor" });
         }

package/dist/src/compact.js

@@ -27,8 +27,14 @@ export function isChatty(text) {
     }
     return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
 }
-/** Extract plausible file paths (contain '/' + an interesting extension). */
+/** Extract plausible file paths (contain '/' + an interesting extension).
+ * Defensive against a missing/empty payload: pi's adapter can hand the engine
+ * a message whose `text`/`input`/`output` is undefined (e.g. a pure tool-call
+ * or tool-result message), and `.split` on undefined throws and takes down the
+ * whole compaction. Guard once at the source so every caller is safe. */
 export function extractFileCandidates(content) {
+    if (!content)
+        return [];
     const out = [];
     for (const raw of content.split(/\s+/)) {
         // Trim surrounding punctuation only — do NOT strip internal dots, or we

package/dist/src/supersede.js

@@ -9,6 +9,9 @@
 import { extractFileCandidates } from "./compact.js";
 /** Classify a message's relationship to a file path. */
 function fileOps(msg) {
+    // msg.text may be undefined for pure tool-call/result messages; the guard
+    // lives in extractFileCandidates, but the early return short-circuits the
+    // write-detection regex too so we never classify an empty message.
     const paths = extractFileCandidates(msg.text);
     if (paths.length === 0)
         return [];

package/extensions/conflict-scan.test.ts

@@ -0,0 +1,129 @@
+/**
+ * conflict-scan.test.ts — unit tests for the extension-conflict scanner.
+ *
+ * Fixture trees are written under a temp dir and scanned via
+ * MEGACOMPACT_EXT_SCAN_DIR (which makes collectScanRoots() return that
+ * single root). This covers the S24 follow-up fix:
+ *
+ *   1. node_modules-style code extensions (package.json + pi.extensions) are
+ *      still detected by source-marker grep (regression).
+ *   2. USER-LEVEL extensions installed outside npm (e.g. pi-hermes-memory)
+ *      now get scanned too — previously only `node_modules` was walked, so a
+ *      data-only memory store (MEMORY.md + sessions.db, no package.json)
+ *      was never flagged (the 5000-char file-buffer error slipped through).
+ *   3. The data-only memory-store signature is detected even with no source.
+ *   4. pi-mega-compact (selfName) is always skipped.
+ */
+
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectConflicts, collectScanRoots } from "./conflict-scan.js";
+
+const base = mkdtempSync(join(tmpdir(), "mc-scan-"));
+let n = 0;
+
+/** Make a fixture root containing one or more fake extensions, return its path. */
+function fixture(build: (root: string) => void): string {
+	const root = join(base, `case-${n++}`);
+	mkdirSync(root, { recursive: true });
+	build(root);
+	return root;
+}
+
+after(() => {
+	rmSync(base, { recursive: true, force: true });
+});
+
+test("scans a user-level, data-only memory store (no package.json)", () => {
+	const root = fixture((r) => {
+		const ext = join(r, "pi-hermes-memory");
+		mkdirSync(ext, { recursive: true });
+		// No package.json, no source — just pi's memory-store signature.
+		writeFileSync(join(ext, "MEMORY.md"), "# memory\n");
+		writeFileSync(join(ext, "sessions.db"), "");
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { conflicts } = detectConflicts();
+		assert.ok(conflicts.length >= 1, "expected a memory conflict");
+		const hit = conflicts.find((c) => c.kind === "memory");
+		assert.ok(hit, "expected a memory-kind conflict");
+		assert.equal(hit!.severity, "high");
+		assert.ok(
+			hit!.evidence.includes("MEMORY.md") ||
+				hit!.evidence.includes("sessions.db"),
+			"evidence should name the on-disk memory signature",
+		);
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("still detects a code extension by source marker (regression)", () => {
+	const root = fixture((r) => {
+		// A code extension is a DIRECT child of the scan root (mirrors the
+		// node_modules layout: packages live one level under the root).
+		const ext = join(r, "some-memory-ext");
+		mkdirSync(ext, { recursive: true });
+		writeFileSync(
+			join(ext, "package.json"),
+			JSON.stringify({ name: "some-memory-ext", pi: { extensions: ["x.ts"] } }),
+		);
+		writeFileSync(join(ext, "index.ts"), "export const MEMORY_TOOL = true;");
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { conflicts } = detectConflicts();
+		const hit = conflicts.find((c) => c.package === "some-memory-ext");
+		assert.ok(hit, "expected some-memory-ext to be flagged");
+		assert.equal(hit!.kind, "memory");
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("skips pi-mega-compact (selfName) and non-extension dirs", () => {
+	const root = fixture((r) => {
+		// selfName dir with a memory signature — must be ignored.
+		const me = join(r, "node_modules", "pi-mega-compact");
+		mkdirSync(me, { recursive: true });
+		writeFileSync(join(me, "sessions.db"), "");
+		// unrelated dir with no pi.extensions and no memory signature.
+		mkdirSync(join(r, "node_modules", "totally-fine"), { recursive: true });
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { scanned, conflicts } = detectConflicts();
+		assert.equal(conflicts.length, 0, "no conflicts expected");
+		assert.ok(
+			!scanned.some((s) => s.includes("pi-mega-compact")),
+			"selfName should not appear in scanned",
+		);
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("collectScanRoots honors MEGACOMPACT_EXT_SCAN_DIR override", () => {
+	const root = fixture(() => {});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const roots = collectScanRoots();
+		assert.deepEqual(roots, [root], "override replaces the whole root list");
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("collectScanRoots falls back to node_modules + user dir when no override", () => {
+	delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	delete process.env.MEGACOMPACT_EXT_USER_DIR;
+	// No override set and this test file lives under extensions/, so node_modules
+	// resolution walks up from here; the user dir (~/.pi/agent) may or may
+	// not exist in CI. We only assert the call returns a non-throwing array.
+	const roots = collectScanRoots();
+	assert.ok(Array.isArray(roots), "collectScanRoots must return an array");
+});