pi-mega-compact 0.11.4 → 0.11.5

package/extensions/mega-teamrun.test.ts

@@ -1,176 +0,0 @@
-/**
- * mega-teamrun.test.ts — regression test for the "auto-compact runs but context
- * never relieves during a team run (sub-agents)" bug.
- *
- * Loads the REAL compiled extension (extensions/mega-compact.js) through a
- * faithful mock pi (mirrors mega-compact.test.ts's harness) and drives the
- * exact event sequence a long team run produces:
- *
- *   agent_start -> context (over threshold) xN -> agent_end   (repeat x3)
- *
- * Asserts the TWO fixes:
- *   1. live trim FIRES per-call (computeLiveTrimCut no longer returns null on
- *      the anchor floor — was `cutNull`, liveTrimFires===0 before the fix).
- *   2. the DURABLE trim fires at agent_end while idle + over threshold
- *      (mid-run durable trigger), not only at parent settle.
- *
- * The mock ctx.compact() drives session_before_compact so we observe the
- * durable truncation. Counters come from MegaRuntime.diag* (set behind the
- * real handler code, inert in production).
- *
- * MEGACOMPACT_PGLITE_DISABLED keeps the run fast (no WASM index init).
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createRequire } from "node:module";
-import { closeVectorIndex } from "../src/store/vectorIndex.js";
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-
-const require = createRequire(import.meta.url);
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-team-"));
-process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
-process.env.MEGACOMPACT_PGLITE_DISABLED = "true"; // fast: skip WASM index
-let counter = 0;
-
-function harness() {
-  const stateDir = join(baseTmp, `run-${counter++}`);
-  process.env.MEGACOMPACT_STATE_DIR = stateDir;
-  process.env.MEGACOMPACT_DEBUG = "true";
-  process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
-  process.env.MEGACOMPACT_FAST_GATE_PCT = "1";
-  // Strict race-guard mode double-counts diagAgentEndDurable (sync++ at branch
-  // entry + deferred++ in the setTimeout(500) callback = 6, not 3), lands
-  // compactCalls after the synchronous assertions, and leaks timers that hang
-  // `node --test`. The strict deferred path is covered by the two S38.5 tests
-  // in mega-compact.test.ts. Use the synchronous v0.7.4 path here.
-  process.env.MEGACOMPACT_RACE_GUARD_STRICT = "false";
-  process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
-  process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0"; // piCompactWouldNoop must not skip
-  process.env.MEGACOMPACT_MEMORY_AUTO_REVIEW = "false";
-  process.env.MEGACOMPACT_RAPTOR_ENABLED = "false";
-  delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
-
-  const handlers: Record<string, Function> = {};
-  const compactCalls: any[] = [];
-
-  function msg(role: string, text: string, toolName?: string): AgentMessage {
-    if (role === "assistant" && toolName) {
-      return { role: "assistant", content: [{ type: "toolCall", name: toolName, id: "c1", arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: 0 } as unknown as AgentMessage;
-    }
-    if (role === "toolResult" && toolName) {
-      return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "c1", toolName, isError: false, timestamp: 0 } as unknown as AgentMessage;
-    }
-    return { role: "user", content: text, timestamp: 0 } as unknown as AgentMessage;
-  }
-
-  const session: AgentMessage[] = [];
-  for (let i = 0; i < 14; i++) {
-    session.push(msg("user", `actually we decided to use approach ${i} for module ${i}`));
-    session.push(msg("assistant", `edited module ${i}`, "Edit"));
-    session.push(msg("toolResult", `edited module ${i}`, "Edit"));
-  }
-
-  const toEntry = (m: AgentMessage, i: number): any => ({ type: "message", id: `e${i}`, parentId: null, timestamp: String(i), message: m });
-  const sessionManager = {
-    getSessionId: () => "sess_team_001",
-    getEntries: () => session.map(toEntry),
-    getBranch: () => session.map(toEntry),
-  };
-
-  function makeCtx(over: Partial<any> = {}) {
-    return {
-      ui: { setStatus: () => {}, notify: () => {}, select: () => {}, confirm: async () => true, input: async () => "", setWidget: () => {} },
-      mode: "tui" as any, hasUI: true, cwd: stateDir, sessionManager,
-      modelRegistry: {} as any, model: undefined, isIdle: () => true, isProjectTrusted: () => true,
-      signal: undefined, abort: () => {}, hasPendingMessages: () => false, shutdown: () => {},
-      getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }),
-      // Mock ctx.compact() runs pi's flow and fires session_before_compact.
-      compact: (opts?: any) => {
-        compactCalls.push(opts);
-        if (handlers["session_before_compact"]) {
-          return handlers["session_before_compact"](
-            { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: session.slice(0, 2), tokensBefore: 500 } } as any,
-            makeCtx(),
-          );
-        }
-        return undefined;
-      },
-      getSystemPrompt: () => "system base",
-      ...over,
-    } as any;
-  }
-
-  const pi = {
-    on: (ev: string, h: Function) => { handlers[ev] = h; },
-    registerCommand: () => {}, registerTool: () => {}, registerShortcut: () => {},
-    registerFlag: () => {}, getFlag: () => undefined, registerMessageRenderer: () => {},
-    registerEntryRenderer: () => {}, sendMessage: () => {}, sendUserMessage: () => {},
-    appendEntry: () => {}, setSessionName: () => {}, getSessionName: () => undefined,
-    setLabel: () => {}, exec: async () => ({ stdout: "", stderr: "", code: 0 }),
-    getActiveTools: () => [], getAllTools: () => [], setActiveTools: () => {},
-    getCommands: () => [], setModel: async () => false, getThinkingLevel: () => "off" as any,
-    setThinkingLevel: () => {},
-  } as any;
-
-  const mod = require("./mega-compact.js") as { default: (p: any) => void };
-  mod.default(pi);
-  const { lastRuntime } = require("./mega-events.js") as { lastRuntime: any };
-
-  const fire = (ev: string, event: any, ctx: any) => handlers[ev](event, ctx);
-  return {
-    stateDir, handlers, compactCalls, fire, ctx: makeCtx, session,
-    runtime: lastRuntime, // MegaRuntime with diag* counters
-    // Advance the debounce so agent_end (same instant) can trigger durable trim.
-    clearDebounce: () => { if (lastRuntime) lastRuntime.debounceUntil = 0; },
-  };
-}
-
-test("team run: live trim fires AND durable trim fires per sub-agent (relieves context)", async () => {
-  const h = harness();
-  const ctx = h.ctx();
-  for (let a = 0; a < 3; a++) {
-    await h.fire("agent_start", { type: "agent_start", messages: [] }, ctx);
-    for (let i = 0; i < 4; i++) {
-      await h.fire("context", { type: "context", messages: h.session }, ctx);
-    }
-    // Real team runs settle seconds after the last context event; mimic that
-    // so the 2s debounce has elapsed and the durable trigger can fire.
-    await new Promise((r) => setTimeout(r, 2100));
-    h.clearDebounce();
-    await h.fire("agent_end", { type: "agent_end", messages: [] }, ctx);
-  }
-  const rt = h.runtime;
-  // FIX 1: live trim must actually fire (was 0 — computeLiveTrimCut returned null).
-  assert.ok(rt.diagLiveTrimFires > 0, "live trim fires during the team run (anchor-floor fix)");
-  assert.equal(rt.diagCtxCutNull, 0, "no live-trim cut skipped on anchor floor");
-  // FIX 2: durable trim must fire at each agent_end (was 0 — only at parent settle).
-  assert.equal(rt.diagAgentEndDurable, 3, "mid-run durable trigger fired at each agent_end");
-  assert.equal(rt.diagBeforeCompactSupplied, 3, "our durable trim supplied 3x (context relieved)");
-  assert.ok(h.compactCalls.length >= 3, "ctx.compact() invoked for durable trim between sub-agents");
-});
-
-test("control: session_before_compact supplies a durable compaction (parent settles)", async () => {
-  const h = harness();
-  const res = await h.fire(
-    "session_before_compact",
-    { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: h.session.slice(0, 4), tokensBefore: 500 } } as any,
-    h.ctx(),
-  );
-  assert.ok(res?.compaction, "compaction result returned to pi");
-  assert.equal(res.compaction.firstKeptEntryId, "e2", "reuses pi's boundary (PREVENT-PI-002)");
-});
-
-test("cleanup", async () => {
-  // Race closeVectorIndex with a timeout to prevent 40-min hangs.
-  try {
-    await Promise.race([
-      closeVectorIndex(),
-      new Promise((r) => setTimeout(r, 3000)),
-    ]);
-  } catch { /* ignore */ }
-  rmSync(baseTmp, { recursive: true, force: true });
-});

package/extensions/mega-trim.test.ts

@@ -1,64 +0,0 @@
-/**
- * mega-trim.test.ts — tests for the live compaction view builder (S16).
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { buildLiveTrimmedView } from "./mega-trim.js";
-import type { EngineMessage } from "../src/types.js";
-
-function m(role: EngineMessage["role"], text: string, extra: Partial<EngineMessage> = {}): EngineMessage {
-  return { role, text, toolName: undefined, input: undefined, output: undefined, ...extra };
-}
-
-test("buildLiveTrimmedView: prepends a compacted summary and keeps the recent anchor", () => {
-  const view: EngineMessage[] = [
-    m("user", "old request one"), m("assistant", "old answer one"),
-    m("user", "old request two"), m("assistant", "old answer two"),
-    m("user", "recent keep me"), m("assistant", "recent keep me too"),
-  ];
-  // Compacted region = first 4; recent anchor = last 2.
-  const result = buildLiveTrimmedView(view, {
-    compactedFrom: 4,        // index where the compacted region ends
-    summary: "<summary>earlier work on old requests</summary>",
-    anchorUserMessages: 1,
-  });
-  // First element is the injected compacted summary as a user-role message.
-  assert.equal(result[0].role, "user");
-  assert.ok(String(result[0].text).includes("earlier work on old requests"));
-  // Recent anchor preserved in order, no older messages leak through.
-  assert.equal(result.length, 1 + 2, "summary + 2 recent");
-  assert.ok(result.slice(1).some((x) => String(x.text).includes("recent keep me")));
-});
-
-test("buildLiveTrimmedView: empty summary returns the original view unchanged", () => {
-  const view = [m("user", "x"), m("assistant", "y")];
-  const result = buildLiveTrimmedView(view, { compactedFrom: 0, summary: "", anchorUserMessages: 1 });
-  assert.deepEqual(result, view);
-});
-
-test("buildLiveTrimmedView: never splits a toolCall/toolResult pair (PREVENT-PI-002)", () => {
-  const view: EngineMessage[] = [
-    m("user", "q"), m("assistant", "calls tool", { toolName: "read" }), m("tool", "result"),
-    m("user", "keep"), m("assistant", "ok"),
-  ];
-  // cut=3 would start the preserved run on the orphaned tool result at index 2 —
-  // the builder must snap back so the toolCall/toolResult pair is not split.
-  const result = buildLiveTrimmedView(view, { compactedFrom: 3, summary: "<summary>s</summary>", anchorUserMessages: 1 });
-  // The tool result must never appear preserved WITHOUT its preceding toolCall.
-  const preserved = result.slice(1);
-  const hasToolResult = preserved.some((x) => x.role === "tool");
-  const hasToolCall = preserved.some((x) => x.role === "assistant" && x.toolName);
-  // Either the tool pair is kept together, or the tool result is dropped into
-  // the compacted region — it is never left orphaned.
-  assert.ok(!(hasToolResult && !hasToolCall), "no orphaned tool result in the preserved run");
-});
-
-test("buildLiveTrimmedView: honors the anchor floor (PREVENT-PI-001)", () => {
-  // cut would leave zero user messages in the anchor — must skip the trim.
-  const view: EngineMessage[] = [
-    m("user", "old q"), m("assistant", "old a"),
-    m("assistant", "only assistant kept"),
-  ];
-  const result = buildLiveTrimmedView(view, { compactedFrom: 2, summary: "<summary>s</summary>", anchorUserMessages: 1 });
-  assert.deepEqual(result, view, "below anchor floor → no trim this call");
-});

package/extensions/mega-turn-store.test.ts

@@ -1,108 +0,0 @@
-/**
- * mega-turn-store.test.ts — S49C adapter routing tests.
- *
- * Proves the adapter writes to the isolated turns.db when turnsDbEnabled is
- * true and to the legacy main-db helpers when false. No network; temp dirs.
- */
-
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import {
-	ensureConversationIdFor,
-	recordTurnWrite,
-	recordRecallWrite,
-} from "./mega-turn-store.js";
-import { closeTurnStore, turnDbPath } from "../src/store/turns/index.js";
-import type { MegaConfig } from "./mega-config.js";
-
-let tmpDir: string;
-let counter = 0;
-
-beforeEach(() => {
-	tmpDir = mkdtempSync(join(tmpdir(), "mc-adapter-"));
-});
-
-afterEach(() => {
-	rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function stateDir(): string {
-	return join(tmpDir, `run-${counter++}`);
-}
-
-/** Minimal MegaConfig stub — only the flag the adapter reads. */
-function cfg(turnsDbEnabled: boolean): MegaConfig {
-	return { turnsDbEnabled } as unknown as MegaConfig;
-}
-
-test("flag ON → writes land in turns.db (not main sqlite.db)", () => {
-	const dir = stateDir();
-	const c = cfg(true);
-	const conv = ensureConversationIdFor(c, "sess_on", dir);
-	const turnId = recordTurnWrite(
-		c,
-		{
-			conversationId: conv,
-			sessionId: "sess_on",
-			turnIndex: 0,
-			role: "assistant",
-			endedAt: Date.now(),
-		},
-		dir,
-	);
-	recordRecallWrite(
-		c,
-		turnId,
-		[{ checkpointId: "cp_on", score: 0.5, source: "flat" }],
-		dir,
-	);
-	closeTurnStore(dir);
-	assert.ok(existsSync(turnDbPath(dir)), "turns.db should exist");
-	assert.ok(
-		!existsSync(join(dir, "sqlite.db")),
-		"main sqlite.db must NOT be created on the flag-ON path",
-	);
-});
-
-test("flag OFF → writes land in main sqlite.db (legacy S48 path)", () => {
-	const dir = stateDir();
-	const c = cfg(false);
-	const conv = ensureConversationIdFor(c, "sess_off", dir);
-	const turnId = recordTurnWrite(
-		c,
-		{
-			conversationId: conv,
-			sessionId: "sess_off",
-			turnIndex: 0,
-			role: "assistant",
-			endedAt: Date.now(),
-		},
-		dir,
-	);
-	recordRecallWrite(
-		c,
-		turnId,
-		[{ checkpointId: "cp_off", score: 0.5, source: "flat" }],
-		dir,
-	);
-	// Legacy helpers open the main sqlite.db.
-	assert.ok(
-		existsSync(join(dir, "sqlite.db")),
-		"main sqlite.db should exist on the flag-OFF path",
-	);
-	assert.ok(
-		!existsSync(turnDbPath(dir)),
-		"turns.db must NOT be created on the flag-OFF path",
-	);
-	// And the row is actually in the main db's turns table.
-	const main = new DatabaseSync(join(dir, "sqlite.db"));
-	const rows = main
-		.prepare("SELECT * FROM turns WHERE session_id = ?")
-		.all("sess_off") as unknown[];
-	assert.equal(rows.length, 1);
-	main.close();
-});

package/src/boundary.test.ts

@@ -1,187 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import type { EngineMessage } from "./types.js";
-import { computeDropRange, isBoundarySafe, dropBefore } from "./boundary.js";
-
-function user(t: string): EngineMessage { return { role: "user", text: t }; }
-function assistant(t: string): EngineMessage { return { role: "assistant", text: t }; }
-function toolUse(n: string, i = "{}"): EngineMessage { return { role: "assistant", text: "", toolName: n, input: i }; }
-function toolResult(n: string, o = "ok"): EngineMessage { return { role: "tool", text: "", toolName: n, output: o }; }
-function custom(t: string): EngineMessage { return { role: "custom", text: t }; }
-
-test("walks back so first preserved message is not an orphaned tool result", () => {
-  const messages = [
-    user("Search for files"),
-    toolUse("search"),
-    toolResult("search", "found 5 files"),
-    assistant("Done."),
-  ];
-  // keepFrom=2 would start the preserved run on the tool result at index 2,
-  // orphaning it. The guard walks back to include the assistant tool-call.
-  const [start, end] = computeDropRange(messages, 2, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 1);
-  const kept = messages.slice(end);
-  assert.notEqual(kept[0].role, "tool");
-  assert.equal(kept[0].toolName, "search"); // assistant tool-call preserved
-});
-
-test("isBoundarySafe: cut that drops a toolCall but keeps its toolResult is unsafe (PREVENT-PI-002)", () => {
-  const messages = [user("a"), toolUse("search"), toolResult("search")];
-  // keepFrom=2 drops the toolUse at index 1 but keeps the toolResult at index 2 →
-  // the preserved run starts on an orphaned tool result. This is the shape the old
-  // check mis-validated (it only compared messages[keepFrom] to messages[keepFrom-1]).
-  assert.equal(isBoundarySafe(messages, 2), false);
-  // keepFrom=1 keeps the toolCall together with its toolResult → safe.
-  assert.equal(isBoundarySafe(messages, 1), true);
-});
-
-test("isBoundarySafe: orphaned tool result without preceding tool use is unsafe", () => {
-  const messages = [user("a"), toolResult("search", "orphan")];
-  assert.equal(isBoundarySafe(messages, 1), false);
-});
-
-test("anchor floor preserves the last N user messages", () => {
-  const messages = [
-    user("u1"), user("u2"), user("u3"),
-    assistant("a1"), assistant("a2"), assistant("a3"), assistant("a4"), assistant("a5"),
-  ];
-  // Caller wants to keep from index 2 (would drop u2). Anchor=2 forces keeping
-  // from u2 (index 1) onward.
-  const out = dropBefore(messages, 2, 2);
-  assert.ok(out.some((m) => m.text === "u2"));
-  assert.ok(out.some((m) => m.text === "u3"));
-});
-
-test("anchor floor is a no-op when fewer users than anchor", () => {
-  const messages = [user("u1"), assistant("a1"), assistant("a2"), assistant("a3")];
-  const out = dropBefore(messages, 1, 2);
-  // only 1 user, anchor=2 → no floor; keep from index 1 (drop the user)
-  assert.ok(!out.some((m) => m.text === "u1"));
-  assert.equal(out.length, 3);
-});
-
-test("dropBefore returns original when range is empty", () => {
-  const messages = [user("a"), assistant("b")];
-  assert.equal(dropBefore(messages, 0, 1), messages);
-});
-
-// --- PREVENT-PI-002 regression cases for arbitrary interleavings ---
-
-test("interleaved custom message between toolCall and toolResult: walk-back keeps the call", () => {
-  // [user, assistant(tc=read), custom/bashExecution, tool(read-result)] with
-  // desired keepFrom=3. The old walk-back saw messages[2] was not a toolUse and
-  // broke at k=2, dropping the assistant toolCall at index 1 while KEEPING its
-  // tool result at index 3 → orphaned tool result → provider 400.
-  const messages = [
-    user("Search for files"),
-    toolUse("read"),
-    custom("bash: ls -la"),
-    toolResult("read", "file contents"),
-    assistant("Done."),
-  ];
-  const [start, end] = computeDropRange(messages, 3, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 1); // keep the assistant toolCall at index 1 with its result
-  const kept = messages.slice(end);
-  assert.equal(kept[0].toolName, "read"); // assistant tool-call preserved
-  assert.ok(kept.some((m) => m.role === "tool" && m.toolName === "read"));
-  // The toolCall and its toolResult are both in the kept run.
-  const callIdx = kept.findIndex((m) => m.role === "assistant" && m.toolName === "read");
-  const resultIdx = kept.findIndex((m) => m.role === "tool" && m.toolName === "read");
-  assert.ok(callIdx !== -1 && resultIdx !== -1 && callIdx < resultIdx);
-});
-
-test("consecutive tool results sharing one call: no-op when the call cannot be kept", () => {
-  // [assistant(tc), T1, T2] with keepFrom=1: dropping the call orphans BOTH T1
-  // and T2. No pair-safe positive cut exists below keepFrom → no-op compaction
-  // (the [start,end) contract preserves a non-zero result only when one exists).
-  const messages = [toolUse("multi"), toolResult("multi", "r1"), toolResult("multi", "r2")];
-  const [start, end] = computeDropRange(messages, 1, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 0); // no-op — pair rule outranks dropping
-  assert.equal(dropBefore(messages, 1, 0), messages);
-});
-
-test("consecutive tool results sharing one call: safe cut keeps the call with both results", () => {
-  // [user, assistant(tc), T1, T2, user2] — keepFrom=3 would orphan T2; the guard
-  // walks back to keep the call (dropEnd=1, only the first user is dropped).
-  const messages = [
-    user("u1"),
-    toolUse("multi"),
-    toolResult("multi", "r1"),
-    toolResult("multi", "r2"),
-    user("u2"),
-  ];
-  const [start, end] = computeDropRange(messages, 3, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 1); // keep [assistant(tc), T1, T2, user2]
-  const kept = messages.slice(end);
-  const callIdx = kept.findIndex((m) => m.role === "assistant" && m.toolName === "multi");
-  const r1Idx = kept.findIndex((m) => m.role === "tool" && m.output === "r1");
-  const r2Idx = kept.findIndex((m) => m.role === "tool" && m.output === "r2");
-  assert.ok(callIdx < r1Idx && r1Idx < r2Idx);
-});
-
-test("consecutive shared-call results: dropping call + all results together is safe", () => {
-  // keepFrom=4 preserves only the trailing user — the call and BOTH results are
-  // dropped together, so nothing is orphaned.
-  const messages = [
-    user("u1"),
-    toolUse("multi"),
-    toolResult("multi", "r1"),
-    toolResult("multi", "r2"),
-    user("u2"),
-  ];
-  const [start, end] = computeDropRange(messages, 4, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 4);
-  assert.deepEqual(messages.slice(end), [user("u2")]);
-});
-
-test("keepFrom landing on a call whose results follow is safe", () => {
-  // [user, assistant(tc1), T1, assistant(tc2), T2, user2] keepFrom=3 → preserved
-  // run starts on assistant(tc2) at index 3, whose result T2 follows. Safe.
-  const messages = [
-    user("u1"),
-    toolUse("read"),
-    toolResult("read", "r1"),
-    toolUse("write"),
-    toolResult("write", "r2"),
-    user("u2"),
-  ];
-  const [start, end] = computeDropRange(messages, 3, 0);
-  assert.equal(start, 0);
-  assert.equal(end, 3);
-  const kept = messages.slice(end);
-  assert.equal(kept[0].role, "assistant");
-  assert.equal(kept[0].toolName, "write");
-  assert.ok(kept.some((m) => m.role === "tool" && m.toolName === "write"));
-});
-
-test("anchor floor + pair-rule conflict: pair rule wins, drop less", () => {
-  // [assistant(tc), user, T] with anchor=1: the anchor floor wants dropEnd<=1
-  // (keep the user at index 1), but keeping from index 1 orphans T (its owner at
-  // index 0 would be dropped). The pair rule outranks the floor — we drop LESS,
-  // keeping everything (no-op) rather than cross a pair.
-  const messages = [toolUse("read"), user("keep me"), toolResult("read", "r")];
-  const out = dropBefore(messages, 2, 1);
-  assert.equal(out, messages, "anchor floor would orphan the tool result → no-op");
-});
-
-test("isBoundarySafe: interleaved custom between call and result is detected unsafe", () => {
-  const messages = [user("a"), toolUse("read"), custom("bash"), toolResult("read", "r")];
-  // keepFrom=3 drops the call at index 1, keeps the result at index 3 → unsafe.
-  assert.equal(isBoundarySafe(messages, 3), false);
-  // keepFrom=2 ALSO drops the call at index 1 (drop [0,2) = [user, toolUse]) and
-  // keeps the result at index 3 → still orphaned → unsafe.
-  assert.equal(isBoundarySafe(messages, 2), false);
-  // keepFrom=1 keeps the call (index 1) together with its result at index 3 → safe.
-  assert.equal(isBoundarySafe(messages, 1), true);
-});
-
-test("isBoundarySafe: cut before any tool result is safe", () => {
-  const messages = [user("a"), toolUse("read"), toolResult("read", "r"), assistant("done")];
-  assert.equal(isBoundarySafe(messages, 0), true); // out of range → safe
-  assert.equal(isBoundarySafe(messages, messages.length), true); // out of range → safe
-});

package/src/compact.test.ts

@@ -1,99 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import type { EngineMessage } from "./types.js";
-import {
-  formatCompactSummary,
-  summarizeMessages,
-  mergeCompactSummaries,
-  shouldCompact,
-  autoCompactCheck,
-  collectKeyFiles,
-  inferPendingWork,
-  extractFileCandidates,
-} from "./compact.js";
-import { estimateSessionTokens } from "./tokens.js";
-
-function user(text: string): EngineMessage { return { role: "user", text }; }
-function assistant(text: string): EngineMessage { return { role: "assistant", text }; }
-function toolUse(name: string, input: string): EngineMessage { return { role: "assistant", text: "", toolName: name, input }; }
-function toolResult(name: string, output: string): EngineMessage { return { role: "tool", text: "", toolName: name, output }; }
-
-test("formatCompactSummary strips analysis and formats summary block (claw-code parity)", () => {
-  const summary = "<analysis>scratch</analysis>\n<summary>Kept work</summary>";
-  assert.equal(formatCompactSummary(summary), "Summary:\nKept work");
-});
-
-test("leaves small sessions unchanged (shouldCompact false)", () => {
-  const messages = [user("hello")];
-  assert.equal(shouldCompact(messages, 1, 4), false);
-});
-
-test("compacts older messages into a summary with Scope + timeline", () => {
-  const messages = [
-    user("one ".repeat(200)),
-    assistant("two ".repeat(200)),
-    toolResult("bash", "ok ".repeat(200)),
-    assistant("recent"),
-  ];
-  assert.equal(shouldCompact(messages, 1, 2), true);
-  const summary = summarizeMessages(messages.slice(0, 2));
-  const formatted = formatCompactSummary(summary);
-  assert.ok(formatted.includes("Scope:"));
-  assert.ok(formatted.includes("Key timeline:"));
-});
-
-test("merge keeps previous compacted context when compacting again", () => {
-  const first = summarizeMessages([
-    user("Investigate src/compact.ts"),
-    assistant("I will inspect the compact flow."),
-  ]);
-  const second = summarizeMessages([
-    user("Also update src/boundary.ts"),
-    assistant("Next: preserve prior summary context."),
-  ]);
-  const merged = mergeCompactSummaries(first, second);
-  assert.ok(merged.includes("Previously compacted context:"));
-  assert.ok(merged.includes("Newly compacted context:"));
-  assert.ok(merged.includes("src/boundary.ts"));
-});
-
-test("infers pending work from recent messages", () => {
-  const pending = inferPendingWork([
-    user("done"),
-    assistant("Next: update tests and follow up on remaining CLI polish."),
-  ]);
-  assert.equal(pending.length, 1);
-  assert.ok(pending[0].includes("Next: update tests"));
-});
-
-test("extracts key files from message content", () => {
-  const files = collectKeyFiles([
-    user("Update src/compact.ts and extensions/mega-compact.ts next."),
-  ]);
-  assert.ok(files.includes("src/compact.ts"));
-  assert.ok(files.includes("extensions/mega-compact.ts"));
-});
-
-test("extractFileCandidates ignores plain words and non-interesting extensions", () => {
-  const files = extractFileCandidates("look at foo/bar.png and src/x.ts and justaword");
-  assert.deepEqual(files, ["src/x.ts"]);
-});
-
-test("summarizeMessages lists tool names sorted + deduped", () => {
-  const summary = summarizeMessages([toolUse("search", "{}"), toolUse("bash", "{}"), toolResult("search", "ok")]);
-  assert.ok(summary.includes("Tools mentioned: bash, search."));
-});
-
-test("autoCompactCheck reports utilization and threshold gate", () => {
-  const under = autoCompactCheck(10000, 50000);
-  assert.equal(under.shouldCompact, false);
-  assert.equal(under.utilizationPct, 20);
-  const over = autoCompactCheck(60000, 50000);
-  assert.equal(over.shouldCompact, true);
-});
-
-test("token estimator counts text + tool payloads", () => {
-  const total = estimateSessionTokens([user("abcd"), toolResult("bash", "abcd")]);
-  // "abcd"/4+1 = 2 for user; tool: name "bash"/4+1=2 plus output "abcd"/4+1=2 => 4
-  assert.equal(total, 2 + 4);
-});