pi-mega-compact 0.9.0 → 0.9.2

package/src/compact.ts

@@ -14,30 +14,31 @@ const INTERESTING_EXT = new Set(["rs", "ts", "tsx", "js", "json", "md"]);
 const PENDING_WORDS = ["todo", "next", "pending", "follow up", "remaining"];
 
 const COMPACT_PREAMBLE =
-  "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
+	"This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
 const RECENT_NOTE = "Recent messages are preserved verbatim.";
-const DIRECT_RESUME = "Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
+const DIRECT_RESUME =
+	"Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
 
 function truncate(s: string, max: number): string {
-  return s.length <= max ? s : `${s.slice(0, max)}…`;
+	return s.length <= max ? s : `${s.slice(0, max)}…`;
 }
 
 function firstText(m: EngineMessage): string | undefined {
-  // PREVENT crash: pi can hand us a message with text: undefined (pure
-  // tool-call/tool-result). Guard the trim so the legacy summarizeMessages
-  // path can't throw the same undefined-text crash the extractive path did.
-  const raw = m.text ?? "";
-  const t = raw.trim();
-  return t.length > 0 ? t : undefined;
+	// PREVENT crash: pi can hand us a message with text: undefined (pure
+	// tool-call/tool-result). Guard the trim so the legacy summarizeMessages
+	// path can't throw the same undefined-text crash the extractive path did.
+	const raw = m.text ?? "";
+	const t = raw.trim();
+	return t.length > 0 ? t : undefined;
 }
 
 /** Heuristic: does this text look like chatty filler we can collapse? */
 export function isChatty(text: string): boolean {
-  const low = text.toLowerCase();
-  if (low.includes("hello") || low.includes("thanks") || low.includes("great") || low.includes("ok")) {
-    return true;
-  }
-  return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
+	const low = text.toLowerCase();
+	if (/\b(hello|thanks|great|ok)\b/i.test(low)) {
+		return true;
+	}
+	return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
 }
 
 /** Extract plausible file paths (contain '/' + an interesting extension).
@@ -45,101 +46,110 @@ export function isChatty(text: string): boolean {
  * 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: string | undefined | null): string[] {
-  if (!content) return [];
-  const out: string[] = [];
-  for (const raw of content.split(/\s+/)) {
-    // Trim surrounding punctuation only — do NOT strip internal dots, or we
-    // would erase the extension separator (src/server.ts -> src/server/ts).
-    const token = raw.replace(/^[^A-Za-z0-9/]+|[^A-Za-z0-9/]+$/g, "");
-    if (!token.includes("/") || !token.includes(".")) continue;
-    const ext = token.split(".").pop()?.toLowerCase() ?? "";
-    if (INTERESTING_EXT.has(ext)) out.push(token);
-  }
-  return out;
+export function extractFileCandidates(
+	content: string | undefined | null,
+): string[] {
+	if (!content) return [];
+	const out: string[] = [];
+	for (const raw of content.split(/\s+/)) {
+		// Trim surrounding punctuation only — do NOT strip internal dots, or we
+		// would erase the extension separator (src/server.ts -> src/server/ts).
+		const token = raw.replace(/^[^A-Za-z0-9/]+|[^A-Za-z0-9/]+$/g, "");
+		if (!token.includes("/") || !token.includes(".")) continue;
+		const ext = token.split(".").pop()?.toLowerCase() ?? "";
+		if (INTERESTING_EXT.has(ext)) out.push(token);
+	}
+	return out;
 }
 
 /** Collect unique key files referenced across a set of messages. */
 export function collectKeyFiles(messages: EngineMessage[]): string[] {
-  const files = new Set<string>();
-  for (const m of messages) {
-    for (const c of [m.text, m.input, m.output]) {
-      if (!c) continue;
-      for (const f of extractFileCandidates(c)) files.add(f);
-    }
-  }
-  return [...files].slice(0, 8);
+	const files = new Set<string>();
+	for (const m of messages) {
+		for (const c of [m.text, m.input, m.output]) {
+			if (!c) continue;
+			for (const f of extractFileCandidates(c)) files.add(f);
+		}
+	}
+	return [...files].slice(0, 8);
 }
 
 /** Infer pending work from recent messages via keyword scan. */
 export function inferPendingWork(messages: EngineMessage[]): string[] {
-  const out: string[] = [];
-  for (const m of [...messages].reverse()) {
-    const t = firstText(m);
-    if (!t) continue;
-    const low = t.toLowerCase();
-    if (PENDING_WORDS.some((w) => low.includes(w))) {
-      out.push(truncate(t, 160));
-      if (out.length >= 3) break;
-    }
-  }
-  return out.reverse();
+	const out: string[] = [];
+	for (const m of [...messages].reverse()) {
+		const t = firstText(m);
+		if (!t) continue;
+		const low = t.toLowerCase();
+		if (PENDING_WORDS.some((w) => low.includes(w))) {
+			out.push(truncate(t, 160));
+			if (out.length >= 3) break;
+		}
+	}
+	return out.reverse();
 }
 
 /** Latest user request (for "current work" line). */
-export function inferCurrentWork(messages: EngineMessage[]): string | undefined {
-  for (const m of [...messages].reverse()) {
-    const t = firstText(m);
-    if (t && m.role === "user") return truncate(t, 200);
-  }
-  return undefined;
+export function inferCurrentWork(
+	messages: EngineMessage[],
+): string | undefined {
+	for (const m of [...messages].reverse()) {
+		const t = firstText(m);
+		if (t && m.role === "user") return truncate(t, 200);
+	}
+	return undefined;
 }
 
 /** Last N user requests, in original order. */
-export function collectRecentUserRequests(messages: EngineMessage[], limit: number): string[] {
-  const reqs = messages
-    .filter((m) => m.role === "user")
-    .map((m) => firstText(m))
-    .filter((t): t is string => Boolean(t))
-    .map((t) => truncate(t, 160));
-  return reqs.slice(-limit);
+export function collectRecentUserRequests(
+	messages: EngineMessage[],
+	limit: number,
+): string[] {
+	const reqs = messages
+		.filter((m) => m.role === "user")
+		.map((m) => firstText(m))
+		.filter((t): t is string => Boolean(t))
+		.map((t) => truncate(t, 160));
+	return reqs.slice(-limit);
 }
 
 /** Summarize a block to a one-line description. */
 function summarizeBlock(m: EngineMessage): string {
-  if (m.role === "tool") return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
-  if (m.toolName) return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
-  return truncate(m.text, 160);
+	if (m.role === "tool")
+		return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
+	if (m.toolName)
+		return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
+	return truncate(m.text, 160);
 }
 
 function stripTag(block: string, tag: string): string {
-  const start = `<${tag}>`;
-  const end = `</${tag}>`;
-  const s = block.indexOf(start);
-  const e = block.indexOf(end);
-  if (s === -1 || e === -1) return block;
-  return block.slice(0, s) + block.slice(e + end.length);
+	const start = `<${tag}>`;
+	const end = `</${tag}>`;
+	const s = block.indexOf(start);
+	const e = block.indexOf(end);
+	if (s === -1 || e === -1) return block;
+	return block.slice(0, s) + block.slice(e + end.length);
 }
 
 function extractTag(block: string, tag: string): string | undefined {
-  const s = block.indexOf(`<${tag}>`);
-  const e = block.indexOf(`</${tag}>`);
-  if (s === -1 || e === -1) return undefined;
-  return block.slice(s + `<${tag}>`.length, e);
+	const s = block.indexOf(`<${tag}>`);
+	const e = block.indexOf(`</${tag}>`);
+	if (s === -1 || e === -1) return undefined;
+	return block.slice(s + `<${tag}>`.length, e);
 }
 
 /** Normalize a raw summary into user-facing "Summary: ..." text. */
 export function formatCompactSummary(summary: string): string {
-  const withoutAnalysis = stripTag(summary, "analysis");
-  let formatted = withoutAnalysis;
-  const content = extractTag(withoutAnalysis, "summary");
-  if (content !== undefined) {
-    formatted = withoutAnalysis.replace(
-      `<summary>${content}</summary>`,
-      `Summary:\n${content.trim()}`,
-    );
-  }
-  return formatted.replace(/\n{3,}/g, "\n\n").trim();
+	const withoutAnalysis = stripTag(summary, "analysis");
+	let formatted = withoutAnalysis;
+	const content = extractTag(withoutAnalysis, "summary");
+	if (content !== undefined) {
+		formatted = withoutAnalysis.replace(
+			`<summary>${content}</summary>`,
+			`Summary:\n${content.trim()}`,
+		);
+	}
+	return formatted.replace(/\n{3,}/g, "\n\n").trim();
 }
 
 /**
@@ -147,125 +157,150 @@ export function formatCompactSummary(summary: string): string {
  * Mirrors claw-code summarize_messages.
  */
 export function summarizeMessages(messages: EngineMessage[]): string {
-  const users = messages.filter((m) => m.role === "user").length;
-  const assistants = messages.filter((m) => m.role === "assistant").length;
-  const tools = messages.filter((m) => m.role === "tool").length;
+	const users = messages.filter((m) => m.role === "user").length;
+	const assistants = messages.filter((m) => m.role === "assistant").length;
+	const tools = messages.filter((m) => m.role === "tool").length;
 
-  const toolNames = [...new Set(messages.flatMap((m) => (m.toolName ? [m.toolName] : [])))].sort();
+	const toolNames = [
+		...new Set(messages.flatMap((m) => (m.toolName ? [m.toolName] : []))),
+	].sort();
 
-  const lines: string[] = [
-    "<summary>",
-    "Conversation summary:",
-    `- Scope: ${messages.length} earlier messages compacted (user=${users}, assistant=${assistants}, tool=${tools}).`,
-  ];
-  if (toolNames.length) lines.push(`- Tools mentioned: ${toolNames.join(", ")}.`);
+	const lines: string[] = [
+		"<summary>",
+		"Conversation summary:",
+		`- Scope: ${messages.length} earlier messages compacted (user=${users}, assistant=${assistants}, tool=${tools}).`,
+	];
+	if (toolNames.length)
+		lines.push(`- Tools mentioned: ${toolNames.join(", ")}.`);
 
-  const recent = collectRecentUserRequests(messages, 3);
-  if (recent.length) {
-    lines.push("- Recent user requests:");
-    recent.forEach((r) => lines.push(`  - ${r}`));
-  }
+	const recent = collectRecentUserRequests(messages, 3);
+	if (recent.length) {
+		lines.push("- Recent user requests:");
+		recent.forEach((r) => lines.push(`  - ${r}`));
+	}
 
-  const pending = inferPendingWork(messages);
-  if (pending.length) {
-    lines.push("- Pending work:");
-    pending.forEach((p) => lines.push(`  - ${p}`));
-  }
+	const pending = inferPendingWork(messages);
+	if (pending.length) {
+		lines.push("- Pending work:");
+		pending.forEach((p) => lines.push(`  - ${p}`));
+	}
 
-  const files = collectKeyFiles(messages);
-  if (files.length) lines.push(`- Key files referenced: ${files.join(", ")}.`);
+	const files = collectKeyFiles(messages);
+	if (files.length) lines.push(`- Key files referenced: ${files.join(", ")}.`);
 
-  const current = inferCurrentWork(messages);
-  if (current) lines.push(`- Current work: ${current}`);
+	const current = inferCurrentWork(messages);
+	if (current) lines.push(`- Current work: ${current}`);
 
-  lines.push("- Key timeline:");
-  for (const m of messages) {
-    const role = m.role;
-    lines.push(`  - ${role}: ${summarizeBlock(m)}`);
-  }
-  lines.push("</summary>");
-  return lines.join("\n");
+	lines.push("- Key timeline:");
+	for (const m of messages) {
+		const role = m.role;
+		lines.push(`  - ${role}: ${summarizeBlock(m)}`);
+	}
+	lines.push("</summary>");
+	return lines.join("\n");
 }
 
 /** Extract the prior "highlights" + "timeline" sections from an existing summary. */
 function extractSummaryHighlights(summary: string): string[] {
-  const lines = formatCompactSummary(summary).split("\n");
-  const out: string[] = [];
-  let inTimeline = false;
-  for (const line of lines) {
-    const t = line.trimEnd();
-    if (!t || t === "Summary:" || t === "Conversation summary:") continue;
-    if (t === "- Key timeline:") { inTimeline = true; continue; }
-    if (inTimeline) continue;
-    out.push(t);
-  }
-  return out;
+	const lines = formatCompactSummary(summary).split("\n");
+	const out: string[] = [];
+	let inTimeline = false;
+	for (const line of lines) {
+		const t = line.trimEnd();
+		if (!t || t === "Summary:" || t === "Conversation summary:") continue;
+		if (t === "- Key timeline:") {
+			inTimeline = true;
+			continue;
+		}
+		if (inTimeline) continue;
+		out.push(t);
+	}
+	return out;
 }
 
 function extractSummaryTimeline(summary: string): string[] {
-  const lines = formatCompactSummary(summary).split("\n");
-  const out: string[] = [];
-  let inTimeline = false;
-  for (const line of lines) {
-    const t = line.trimEnd();
-    if (t === "- Key timeline:") { inTimeline = true; continue; }
-    if (!inTimeline) continue;
-    if (!t) break;
-    out.push(t);
-  }
-  return out;
+	const lines = formatCompactSummary(summary).split("\n");
+	const out: string[] = [];
+	let inTimeline = false;
+	for (const line of lines) {
+		const t = line.trimEnd();
+		if (t === "- Key timeline:") {
+			inTimeline = true;
+			continue;
+		}
+		if (!inTimeline) continue;
+		if (!t) break;
+		out.push(t);
+	}
+	return out;
 }
 
 /** Merge an existing compact summary with a new one (accumulate, don't overwrite). */
-export function mergeCompactSummaries(existing: string | undefined, newSummary: string): string {
-  if (!existing) return newSummary;
-  const prevHighlights = extractSummaryHighlights(existing);
-  const newHighlights = extractSummaryHighlights(formatCompactSummary(newSummary));
-  const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
+export function mergeCompactSummaries(
+	existing: string | undefined,
+	newSummary: string,
+): string {
+	if (!existing) return newSummary;
+	const prevHighlights = extractSummaryHighlights(existing);
+	const newHighlights = extractSummaryHighlights(
+		formatCompactSummary(newSummary),
+	);
+	const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
 
-  const lines = ["<summary>", "Conversation summary:"];
-  if (prevHighlights.length) {
-    lines.push("- Previously compacted context:");
-    prevHighlights.forEach((l) => lines.push(`  ${l}`));
-  }
-  if (newHighlights.length) {
-    lines.push("- Newly compacted context:");
-    newHighlights.forEach((l) => lines.push(`  ${l}`));
-  }
-  if (newTimeline.length) {
-    lines.push("- Key timeline:");
-    newTimeline.forEach((l) => lines.push(`  ${l}`));
-  }
-  lines.push("</summary>");
-  return lines.join("\n");
+	const lines = ["<summary>", "Conversation summary:"];
+	if (prevHighlights.length) {
+		lines.push("- Previously compacted context:");
+		prevHighlights.forEach((l) => lines.push(`  ${l}`));
+	}
+	if (newHighlights.length) {
+		lines.push("- Newly compacted context:");
+		newHighlights.forEach((l) => lines.push(`  ${l}`));
+	}
+	if (newTimeline.length) {
+		lines.push("- Key timeline:");
+		newTimeline.forEach((l) => lines.push(`  ${l}`));
+	}
+	lines.push("</summary>");
+	return lines.join("\n");
 }
 
 /** True when the compactable portion exceeds the budget. */
-export function shouldCompact(messages: EngineMessage[], maxEstimatedTokens: number, preserveRecent: number): boolean {
-  if (messages.length <= preserveRecent) return false;
-  const compactable = messages.slice(0, messages.length - preserveRecent);
-  return estimateSessionTokens(compactable) >= maxEstimatedTokens;
+export function shouldCompact(
+	messages: EngineMessage[],
+	maxEstimatedTokens: number,
+	preserveRecent: number,
+): boolean {
+	if (messages.length <= preserveRecent) return false;
+	const compactable = messages.slice(0, messages.length - preserveRecent);
+	return estimateSessionTokens(compactable) >= maxEstimatedTokens;
 }
 
 /** Local reimplementation of memory-mcp auto_compact_check. */
-export function autoCompactCheck(currentTokens: number, threshold = 50000): {
-  shouldCompact: boolean;
-  currentTokens: number;
-  threshold: number;
-  utilizationPct: number;
+export function autoCompactCheck(
+	currentTokens: number,
+	threshold = 50000,
+): {
+	shouldCompact: boolean;
+	currentTokens: number;
+	threshold: number;
+	utilizationPct: number;
 } {
-  return {
-    shouldCompact: currentTokens >= threshold,
-    currentTokens,
-    threshold,
-    utilizationPct: Math.round((currentTokens / threshold) * 1000) / 10,
-  };
+	return {
+		shouldCompact: currentTokens >= threshold,
+		currentTokens,
+		threshold,
+		utilizationPct: Math.round((currentTokens / threshold) * 1000) / 10,
+	};
 }
 
 /** Build the synthetic continuation message (system-prompt prepend form). */
-export function getContinuationMessage(summary: string, suppressFollowUp: boolean, recentPreserved: boolean): string {
-  let base = COMPACT_PREAMBLE + formatCompactSummary(summary);
-  if (recentPreserved) base += `\n\n${RECENT_NOTE}`;
-  if (suppressFollowUp) base += `\n${DIRECT_RESUME}`;
-  return base;
+export function getContinuationMessage(
+	summary: string,
+	suppressFollowUp: boolean,
+	recentPreserved: boolean,
+): string {
+	let base = COMPACT_PREAMBLE + formatCompactSummary(summary);
+	if (recentPreserved) base += `\n\n${RECENT_NOTE}`;
+	if (suppressFollowUp) base += `\n${DIRECT_RESUME}`;
+	return base;
 }

package/src/memoryOps.test.ts

@@ -1,3 +1,18 @@
+// This file exercises the sync node:sqlite memory ops only, but every
+// applyMemoryOps() write also fires indexMemoryWrite() → upsertMemoryEmbedding()
+// at the machine-wide PGlite index, fire-and-forget, keyed by repoKey(stateDir)
+// — which for these tmp state dirs is the tmp path itself. Left alone that lands
+// in the developer's real ~/.pi/mega-compact-vector, where the rows stay
+// eligible for cross-repo recall forever: a live session can be handed
+// "threshold is 50k" and "the threshold is 100k" from this file as if they were
+// another project's memories. scripts/run-tests.mjs sets MEGACOMPACT_INDEX_DIR
+// per child, so the suite was already safe; running the file directly was not.
+//
+// Disabling PGlite is the same guard memoryRoundtrip.test.ts uses for the same
+// reason, and it also keeps the file's exit clean (no WASM handle, and no
+// initdb still running when the first test ends). MEGACOMPACT_INDEX_DIR is set
+// as well so the isolation holds if a later test needs the index re-enabled.
+process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -13,6 +28,7 @@ import {
 } from "./store/sqlite.js";
 
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
 
 test("applyMemoryOps: ADD inserts a new memory", async () => {
   const dir = join(baseTmp, "add");

package/src/store/memoryIndex.ts

@@ -45,6 +45,8 @@ export interface MemoryIndexHit {
   score: number;
 }
 
+import { withOpenTimeout } from "./pgOpenGuard.js";
+
 let db: PGliteInstance | undefined;
 let initPromise: Promise<PGliteInstance | undefined> | undefined;
 let disabled = false;
@@ -135,12 +137,19 @@ async function openPgLite(
     if (!mod) return undefined;
     const dir = indexDir();
     mkdirSync(dir, { recursive: true });
-    const pg = await new mod.PGlite({
-      dataDir: dir,
-      extensions: { vector: mod.vector },
-    });
-    await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
-    await pg.exec(`
+    // Bounded open: PGlite is single-writer over a shared dataDir, so a second
+    // pi process on the same dir can block here forever. Without the ceiling the
+    // never-settling promise gets cached in initPromise and every later caller
+    // awaits it — which is how a stalled index wedged a whole pi turn.
+    let openTimedOut = false;
+    const pg = await withOpenTimeout(
+      (async () => {
+        const inst = await new mod.PGlite({
+          dataDir: dir,
+          extensions: { vector: mod.vector },
+        });
+        await inst.exec("CREATE EXTENSION IF NOT EXISTS vector;");
+        await inst.exec(`
       CREATE TABLE IF NOT EXISTS memory_index (
         repo_id    TEXT NOT NULL,
         memory_id  INTEGER NOT NULL,
@@ -149,9 +158,26 @@ async function openPgLite(
         PRIMARY KEY (repo_id, memory_id)
       );
     `);
-    await pg.exec(
-      "CREATE INDEX IF NOT EXISTS memory_index_hnsw ON memory_index USING hnsw (embedding vector_cosine_ops);",
+        await inst.exec(
+          "CREATE INDEX IF NOT EXISTS memory_index_hnsw ON memory_index USING hnsw (embedding vector_cosine_ops);",
+        );
+        return inst;
+      })(),
+      (reason) => {
+        openTimedOut = true;
+        logWarn(`init ${reason}`);
+      },
     );
+    if (!pg) {
+      if (openTimedOut) {
+        // Don't leave the dead open cached, and don't retry on the next call —
+        // a contended dataDir would just burn another full timeout per caller.
+        // Same terminal state as any other init failure: fall back to the scan.
+        initPromise = undefined;
+        disabled = true;
+      }
+      return undefined;
+    }
     db = pg;
     return pg;
   } catch (err) {

package/src/store/pgOpenGuard.test.ts

@@ -0,0 +1,89 @@
+/**
+ * pgOpenGuard.test.ts — the PGlite open must never hang a turn.
+ *
+ * Regression cover for the wedge: a stalled `await new PGlite(...)` was cached
+ * in initPromise, so every later caller awaited a promise that could not settle
+ * and the pi turn awaiting it never ended.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { withOpenTimeout, pgOpenTimeoutMs, DEFAULT_PG_OPEN_TIMEOUT_MS } from "./pgOpenGuard.js";
+
+test("a never-settling open resolves to undefined instead of hanging", async () => {
+  const never = new Promise<string>(() => {
+    /* deliberately never settles — the wedge */
+  });
+  const reasons: string[] = [];
+  const t0 = Date.now();
+
+  const result = await withOpenTimeout(never, (r) => reasons.push(r), 50);
+
+  assert.equal(result, undefined, "caller gets undefined and can fall back");
+  assert.ok(Date.now() - t0 < 5_000, "returned promptly rather than hanging");
+  assert.equal(reasons.length, 1, "onTimeout fired exactly once");
+  assert.match(reasons[0], /timed out after 50ms/);
+});
+
+test("a successful open passes its value through untouched", async () => {
+  const reasons: string[] = [];
+  const result = await withOpenTimeout(Promise.resolve("pg"), (r) => reasons.push(r), 5_000);
+  assert.equal(result, "pg");
+  assert.deepEqual(reasons, [], "no timeout reported on the happy path");
+});
+
+test("a rejected open propagates so the corrupt-dir retry still runs", async () => {
+  const reasons: string[] = [];
+  await assert.rejects(
+    () => withOpenTimeout(Promise.reject(new Error("Aborted()")), (r) => reasons.push(r), 5_000),
+    /Aborted/,
+    "rejection reaches the caller's catch, which owns the wipe-and-retry path",
+  );
+  assert.deepEqual(reasons, [], "a rejection is not reported as a timeout");
+});
+
+test("an abandoned open is closed if it settles after the timeout", async () => {
+  let closed = false;
+  let release: (v: { close: () => void }) => void = () => {};
+  const late = new Promise<{ close: () => void }>((r) => {
+    release = r;
+  });
+
+  const result = await withOpenTimeout(late, () => {}, 25);
+  assert.equal(result, undefined, "timed out first");
+
+  // The open finally completes, long after we stopped waiting for it.
+  release({
+    close: () => {
+      closed = true;
+    },
+  });
+  await late;
+  await new Promise((r) => setImmediate(r));
+
+  assert.ok(closed, "the orphaned instance was closed, not left holding the dataDir");
+});
+
+test("timeout of 0 disables the guard (unbounded, original behavior)", async () => {
+  const result = await withOpenTimeout(Promise.resolve("pg"), () => {}, 0);
+  assert.equal(result, "pg");
+});
+
+test("pgOpenTimeoutMs honors the env override and rejects junk", async () => {
+  const prev = process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
+  try {
+    process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "1234";
+    assert.equal(pgOpenTimeoutMs(), 1234);
+
+    process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "0";
+    assert.equal(pgOpenTimeoutMs(), 0, "0 is a valid opt-out, not junk");
+
+    for (const junk of ["", "   ", "abc", "-5"]) {
+      process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = junk;
+      assert.equal(pgOpenTimeoutMs(), DEFAULT_PG_OPEN_TIMEOUT_MS, `junk "${junk}" falls back`);
+    }
+  } finally {
+    if (prev === undefined) delete process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
+    else process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = prev;
+  }
+});