pi-mega-compact 0.7.1 → 0.7.3

package/dist/extensions/mega-pipeline.js

@@ -8,13 +8,13 @@
  */
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
-import { recallAndInline, recallAndInlineAsync, formatRecallBlock, } from "../src/recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
 import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import { consolidateMemories } from "../src/memory.js";
-import { C, MARKER_TYPE } from "./mega-runtime.js";
-import { resolveRepoRoot, preserveRecentForPressure, } from "./mega-config.js";
+import { C, MARKER_TYPE, } from "./mega-runtime.js";
+import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
 import { runRaptor } from "../src/dedup/raptor/index.js";
 import { loadDedupConfig } from "../src/config/dedup.js";
 import { upsertEmbedding as indexUpsertEmbedding } from "../src/store/vectorIndex.js";
@@ -110,17 +110,13 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // Grow the rolling "saved" goal so the progress bar always has a fresh
     // denominator (we don't want it pinned at 100% once we pass an old target).
     if (runtime.rt.tokensSaved > runtime.savedGoal)
-        runtime.savedGoal =
-            Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
+        runtime.savedGoal = Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
     // Live toolbar activity: what file/region just got compacted or deduped.
     // Rendered via the rotating ticker line (see snapshot); the ring buffer is
     // cycled one-per-repaint so the single line scrolls through recent files.
     const files = result.filesModified ?? [];
     const fileLabel = files.length
-        ? files
-            .map((f) => f.split("/").pop() ?? f)
-            .slice(0, 2)
-            .join(", ")
+        ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ")
         : result.regionHash.slice(0, 8);
     runtime.lastActivityAt = Date.now();
     // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
@@ -172,10 +168,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // waiting for the next turn-cadence tick. Uses the shared runMemoryReview
     // helper (fire-and-forget; doCompact is sync). Best-effort + non-fatal. Only
     // fires above the `high` band so low-pressure compactions don't pay the cost.
-    if (!result.deduped &&
-        config.memoryAutoReview &&
-        runtime.pressureBand !== "low" &&
-        runtime.pressureBand !== "medium") {
+    if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
         void runMemoryReview(runtime, view, "pressure");
     }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
@@ -203,9 +196,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
                 // S25: stamp the tree with the newest checkpoint epoch so the
                 // freshness guard in raptorSearchHits can reject stale trees after a
                 // later compaction adds newer checkpoints.
-                const builtAt = all.length > 0
-                    ? Math.max(...all.map((c) => c.timestamp))
-                    : Date.now();
+                const builtAt = all.length > 0 ? Math.max(...all.map((c) => c.timestamp)) : Date.now();
                 runRaptor(leaves, {
                     stateDir: runtime.currentStateDir,
                     sessionId: sid,
@@ -323,8 +314,7 @@ export function piCompactWouldNoop(ctx) {
                 if (m.role !== "toolResult")
                     isCut = true;
                 const c = m.content;
-                const text = typeof c === "string"
-                    ? c
+                const text = typeof c === "string" ? c
                     : Array.isArray(c)
                         ? c.map((b) => b?.text ?? "").join(" ")
                         : "";
@@ -377,22 +367,12 @@ export function doRecall(runtime, config, ctx, query, source) {
         liveWindow,
         dedupSim: config.dedupSim,
     }, runtime.store);
-    runtime.dashboard.event("recall", {
-        source,
-        query: query.slice(0, 120),
-        injected: result.toInject.length,
-        empty: result.empty,
-    });
+    runtime.dashboard.event("recall", { source, query: query.slice(0, 120), injected: result.toInject.length, empty: result.empty });
     if (!result.empty && result.toInject.length > 0) {
         const top = result.toInject[0];
         const scorePct = Math.round((top.score ?? 0) * 100);
         const files = top.checkpoint.filesModified ?? [];
-        const label = files.length
-            ? files
-                .map((f) => f.split("/").pop() ?? f)
-                .slice(0, 2)
-                .join(", ")
-            : top.checkpoint.checkpointId;
+        const label = files.length ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ") : top.checkpoint.checkpointId;
         runtime.pushTicker(`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`);
         runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
     }
@@ -415,15 +395,9 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
     // Sync same-repo first (fast, never blocks).
     const sameRepo = recallAndInline({
-        sessionId: sid,
-        query,
-        limit: config.autoInlineK,
-        source,
-        skipInjected: true,
-        recallMaxTokens: config.recallMaxTokens,
-        windowDedupe: config.windowDedupe,
-        liveWindow,
-        dedupSim: config.dedupSim,
+        sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+        recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+        liveWindow, dedupSim: config.dedupSim,
     }, runtime.store);
     if (!config.crossRepoEnabled || !opts.crossRepo)
         return sameRepo;
@@ -432,22 +406,13 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     // Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
     try {
         const x = await recallAndInlineAsync({
-            sessionId: sid,
-            query,
-            limit: config.autoInlineK,
-            source,
-            skipInjected: true,
-            recallMaxTokens: config.recallMaxTokens,
-            windowDedupe: config.windowDedupe,
-            liveWindow,
-            dedupSim: config.crossRepoCosine,
-            crossRepo: true,
+            sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+            recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+            liveWindow, dedupSim: config.crossRepoCosine, crossRepo: true,
             globalIndexDir: process.env.MEGACOMPACT_INDEX_DIR,
         }, runtime.store);
         runtime.dashboard.event("recall-crossrepo", {
-            source,
-            query: query.slice(0, 120),
-            injected: x.toInject.length,
+            source, query: query.slice(0, 120), injected: x.toInject.length,
             sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
         });
         // Merge, dedup by checkpointId, respect the same token cap by reformatting.

package/dist/extensions/mega-runtime.js

@@ -93,6 +93,33 @@ function visibleWidth(s) {
     return w;
 }
 /** Pad a content string (with ANSI colors) to `width` cells using panel bg. */
+/** Wrap a string (with ANSI codes) to fit within `maxWidth` visible chars.
+ *  Splits at │ separators or whitespace when possible. */
+function wrapLine(text, maxWidth) {
+    if (maxWidth <= 0)
+        return [text];
+    const result = [];
+    let current = "";
+    let currentW = 0;
+    // Split at │ boundaries first
+    const segments = text.split("│");
+    for (let i = 0; i < segments.length; i++) {
+        const seg = (i > 0 ? "│" : "") + segments[i];
+        const segW = visibleWidth(PANEL_BG + seg.replace(/\x1b\[0m/g, PANEL_RST));
+        if (currentW + segW <= maxWidth || currentW === 0) {
+            current += seg;
+            currentW += segW;
+        }
+        else {
+            result.push(current);
+            current = seg;
+            currentW = segW;
+        }
+    }
+    if (current)
+        result.push(current);
+    return result;
+}
 function panelLine(content, width) {
     const withBg = PANEL_BG + content.replace(/\x1b\[0m/g, PANEL_RST);
     const pad = Math.max(0, width - visibleWidth(withBg));
@@ -603,15 +630,26 @@ export class MegaRuntime {
         const pulse = wd.pulsing
             ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} `
             : "";
+        const sep = ` ${C.dim}│${C.reset} `;
+        // Build one long content line — let terminal wrap it naturally
+        const content = [
+            `${C.amber}⚡ ${wd.tierLabel}${C.reset} v${C.bold}${wd.version}${C.reset} ${ramp(wd.ctxPct, 20)} ${C.bold}${wd.pctStr}${C.reset} ${wd.tokStr}/${wd.maxStr}`,
+            wd.triggerLabel,
+            `${C.cyan}${wd.modelStr}${C.reset}`,
+            `${wd.chk} chk${wd.agentStr}${wd.turnStr}`,
+            `${C.magenta}dup ${wd.dedupStr}${C.reset}`,
+            `${C.gray}sess${C.reset} ${fmtTokens(wd.sessIn)}→${fmtTokens(wd.sessKept)} kept ${C.green}(${wd.sTxt}% freed)${C.reset}`,
+            `${C.gray}all-time${C.reset} ${fmtTokens(wd.repoIn)}→${fmtTokens(wd.repoKept)} kept ${C.blue}(${wd.rTxt}% freed)${C.reset}`,
+            `${wd.repoChk} chk/${wd.repoSess} sess`,
+            `${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset}`,
+            `${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
+            `${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`,
+        ].join(sep);
+        // Wrap to terminal width and pad each line
+        const wrapped = wrapLine(content, width - 2); // 2-char indent
         const lines = [
-            // top border
             panelBar(width, "─"),
-            // L1 — header: tier + ctx bar + pct/tokens + status + model + chk + agents/turn
-            panelLine(` ${C.amber}⚡ ${wd.tierLabel}${C.reset} v${C.bold}${wd.version}${C.reset} ${ramp(wd.ctxPct, 20)} ${C.bold}${wd.pctStr}${C.reset} ${wd.tokStr}/${wd.maxStr} │ ${wd.triggerLabel} │ ${C.cyan}${wd.modelStr}${C.reset} │ ${wd.chk} chk${wd.agentStr}${wd.turnStr}`, width),
-            // L2 — savings reconciled (session + all-time)
-            panelLine(`   ${C.magenta}dup ${wd.dedupStr}${C.reset} │ ${C.gray}sess${C.reset} ${fmtTokens(wd.sessIn)}→${fmtTokens(wd.sessKept)} kept ${C.green}(${wd.sTxt}% freed)${C.reset} · ${C.gray}all-time${C.reset} ${fmtTokens(wd.repoIn)}→${fmtTokens(wd.repoKept)} kept ${C.blue}(${wd.rTxt}% freed)${C.reset} │ ${wd.repoChk} chk/${wd.repoSess} sess`, width),
-            // L3 — memory store + compression + drift + since-compact (NEW)
-            panelLine(`   ${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset} │ ${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset} │ ${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`, width),
+            ...wrapped.map((l) => panelLine(l, width)),
         ];
         // L4 — agents block (S27, count + status; per-agent tokens gated on P0)
         if (wd.agentsActive) {

package/extensions/mega-compact-driver.ts

@@ -30,13 +30,13 @@ import type { MegaConfig } from "./mega-config.js";
 import { recallRaptorRootSummary } from "../src/dedup/raptor/index.js";
 
 export interface NativeCompactionResult {
-	/** Our trimmed summary + the pi entry to keep from (durable trim). */
-	compaction: {
-		summary: string;
-		firstKeptEntryId: string;
-		tokensBefore: number;
-		estimatedTokensAfter: number;
-	};
+  /** Our trimmed summary + the pi entry to keep from (durable trim). */
+  compaction: {
+    summary: string;
+    firstKeptEntryId: string;
+    tokensBefore: number;
+    estimatedTokensAfter: number;
+  };
 }
 
 /**
@@ -46,61 +46,61 @@ export interface NativeCompactionResult {
  * own native compaction, or skip). Never throws for "empty" — best-effort.
  */
 export function driveNativeCompaction(
-	event: SessionBeforeCompactEvent,
-	runtime: MegaRuntime,
-	config: MegaConfig,
+  event: SessionBeforeCompactEvent,
+  runtime: MegaRuntime,
+  config: MegaConfig,
 ): NativeCompactionResult | undefined {
-	const prep = event.preparation;
-	if (!prep) return undefined;
+  const prep = event.preparation;
+  if (!prep) return undefined;
 
-	const sid = runtime.rt.sessionId;
-	const messagesToSummarize: AgentMessage[] = prep.messagesToSummarize ?? [];
-	if (messagesToSummarize.length === 0) return undefined;
+  const sid = runtime.rt.sessionId;
+  const messagesToSummarize: AgentMessage[] = prep.messagesToSummarize ?? [];
+  if (messagesToSummarize.length === 0) return undefined;
 
-	const engineView = toEngineMessages(messagesToSummarize);
-	// We don't drop anything here — pi keeps from prep.firstKeptEntryId. We only
-	// summarize the region pi is about to discard.
-	const keepFrom = engineView.length;
+  const engineView = toEngineMessages(messagesToSummarize);
+  // We don't drop anything here — pi keeps from prep.firstKeptEntryId. We only
+  // summarize the region pi is about to discard.
+  const keepFrom = engineView.length;
 
-	const result = compactSession(
-		{
-			sessionId: sid,
-			messages: engineView,
-			keepFrom,
-			timestamp: Date.now(),
-			useExtractiveSummary: true,
-		},
-		runtime.store,
-	);
-	if (result.skipped) return undefined;
+  const result = compactSession(
+    {
+      sessionId: sid,
+      messages: engineView,
+      keepFrom,
+      timestamp: Date.now(),
+      useExtractiveSummary: true,
+    },
+    runtime.store,
+  );
+  if (result.skipped) return undefined;
 
-	// Prefer the RAPTOR root summary when the tree is built + enabled (Fix D):
-	// it is a session-level compressed summary, broader than one slice's. Fall
-	// back to the extractive topicSummary of this slice.
-	let summary = result.summary;
-	if (config.raptorEnabled) {
-		const root = recallRaptorRootSummary(sid, runtime.currentStateDir);
-		if (root) summary = root;
-	}
+  // Prefer the RAPTOR root summary when the tree is built + enabled (Fix D):
+  // it is a session-level compressed summary, broader than one slice's. Fall
+  // back to the extractive topicSummary of this slice.
+  let summary = result.summary;
+  if (config.raptorEnabled) {
+    const root = recallRaptorRootSummary(sid, runtime.currentStateDir);
+    if (root) summary = root;
+  }
 
-	const tokensBefore = prep.tokensBefore ?? estimateSessionTokens(engineView);
-	const summaryTokens = estimateBlockTokens(summary);
-	// pi keeps the tail from firstKeptEntryId; our summary replaces the discarded
-	// region. Honest saved = discarded-region tokens − our summary tokens.
-	const savedTokens = Math.max(0, tokensBefore - summaryTokens);
+  const tokensBefore = prep.tokensBefore ?? estimateSessionTokens(engineView);
+  const summaryTokens = estimateBlockTokens(summary);
+  // pi keeps the tail from firstKeptEntryId; our summary replaces the discarded
+  // region. Honest saved = discarded-region tokens − our summary tokens.
+  const savedTokens = Math.max(0, tokensBefore - summaryTokens);
 
-	runtime.rt.lastCompactedFrom = keepFrom;
-	runtime.rt.lastCompactedTokens = tokensBefore;
-	runtime.rt.tokensSaved += savedTokens;
-	runtime.rt.lastCompactAt = Date.now();
-	runtime.rt.persistedThisSession = true;
+  runtime.rt.lastCompactedFrom = keepFrom;
+  runtime.rt.lastCompactedTokens = tokensBefore;
+  runtime.rt.tokensSaved += savedTokens;
+  runtime.rt.lastCompactAt = Date.now();
+  runtime.rt.persistedThisSession = true;
 
-	return {
-		compaction: {
-			summary,
-			firstKeptEntryId: prep.firstKeptEntryId,
-			tokensBefore,
-			estimatedTokensAfter: summaryTokens,
-		},
-	};
+  return {
+    compaction: {
+      summary,
+      firstKeptEntryId: prep.firstKeptEntryId,
+      tokensBefore,
+      estimatedTokensAfter: summaryTokens,
+    },
+  };
 }