@danypops/pi-packed 0.21.11 → 0.21.13

package/extension/src/tui.ts

@@ -29,12 +29,13 @@
  * inline next to the row currently updating, settling into a real ✓/✗
  * plus a bounded tail of that row's own actual captured stdout/stderr
  * once it finishes, never a determinate bar (a single subprocess call has
- * no knowable percentage). Rows render through Malevich's Table (real
- * column-aligned Package/Version/status cells, per-row selection styling
- * baked into each cell since Table's own cellStyle is column-wide, not
- * row-wide) inside this tab's own scroll-window slice -- Table
- * deliberately owns no pagination of its own, so the visible-window-
- * around-selectedIndex math stays here. u/x/d and the Enter action menu
+ * no knowable percentage). Rows render as a column-major grid of
+ * Malevich Cards (computeCardColumns/renderCardGrid, below) -- one card
+ * per package, as many side by side as `width` allows above a fixed
+ * minimum card width, rather than one full-width card per line -- inside
+ * this tab's own scroll-window slice. No pagination baked into the grid
+ * helpers themselves, so the visible-window-around-selectedIndex math
+ * stays here. u/x/d and the Enter action menu
  * all run their whole approve+mutate+confirmReload flow inline, via the
  * shared TabHost's inlineCtx -- every confirm() along the way renders as
  * a real Malevich Dialog on this SAME overlay, dispatched by literal y/n
@@ -407,6 +408,87 @@ async function showActionMenu(ctx: ExtensionCommandContext, row: Row): Promise<"
 	);
 }
 
+/** A card narrower than this wastes more space on border/padding than it
+ * shows of a real scoped package name ("@scope/pi-longer-name") plus its
+ * version/status -- the floor `computeCardColumns` uses when deciding how
+ * many side-by-side columns actually fit `width`, rather than guessing a
+ * fixed row/page count independent of the panel's real width. */
+const MIN_CARD_WIDTH = 28;
+const CARD_GRID_GAP = 1;
+
+/** How many side-by-side card columns fit `width` without any of them
+ * dropping below MIN_CARD_WIDTH, capped at `itemCount` -- never more
+ * columns than there are real items to fill them (a wide terminal with
+ * only 2 packages installed gets 2 columns, not 4 mostly-empty ones). */
+function computeCardColumns(width: number, itemCount: number): number {
+	if (itemCount <= 0) return 1;
+	const fits = Math.floor((width + CARD_GRID_GAP) / (MIN_CARD_WIDTH + CARD_GRID_GAP));
+	return Math.max(1, Math.min(fits, itemCount));
+}
+
+/** Exact per-column widths for `columns` side-by-side cards inside `width`,
+ * every gap included -- sums (with CARD_GRID_GAP between each) to exactly
+ * `width`, distributing any remainder across the leading columns instead
+ * of leaving it as slack nobody renders into (the same exact-width
+ * contract every other line in this panel already holds, verified by this
+ * file's own "every rendered line at the exact same real width" test). */
+function distributeColumnWidths(width: number, columns: number): number[] {
+	const available = width - CARD_GRID_GAP * (columns - 1);
+	const base = Math.floor(available / columns);
+	const remainder = available - base * columns;
+	return Array.from({ length: columns }, (_, i) => base + (i < remainder ? 1 : 0));
+}
+
+/** Lays `items` into a column-major grid of exactly `columns` columns
+ * (column 0 filled top-to-bottom first, then column 1, ...) -- the same
+ * fill order `ls -C` uses, so a flat Up/Down cycle through `items` moves
+ * down one column at a time instead of snaking left-to-right through a
+ * row-major grid, with no new keybinding needed (Left/Right stay reserved
+ * for the panel's own tab-cycling -- see this file's own header comment).
+ * `columns` is always the caller's own already-computed computeCardColumns
+ * result, never re-derived here from `items.length` -- a caller windowing
+ * `items` into a page shorter than its full list must still render that
+ * page at the same column count the rest of the list uses, or the grid
+ * would reflow mid-scroll. `selectedIndex` is an index into `items`
+ * itself, or -1 when nothing in this grid is selected. */
+function renderCardGrid<T>(
+	items: T[],
+	columns: number,
+	width: number,
+	selectedIndex: number,
+	renderCard: (item: T, columnWidth: number, selected: boolean) => string[],
+): string[] {
+	if (items.length === 0) return [];
+	const columnWidths = distributeColumnWidths(width, columns);
+	const rowsPerColumn = Math.ceil(items.length / columns);
+	const rendered: string[][] = [];
+	for (let c = 0; c < columns; c++) {
+		const columnWidth = columnWidths[c] ?? MIN_CARD_WIDTH;
+		const lines: string[] = [];
+		for (let r = 0; r < rowsPerColumn; r++) {
+			const index = c * rowsPerColumn + r;
+			const item = items[index];
+			if (item === undefined) break;
+			lines.push(...renderCard(item, columnWidth, index === selectedIndex));
+		}
+		rendered.push(lines);
+	}
+	const height = Math.max(0, ...rendered.map((lines) => lines.length));
+	const out: string[] = [];
+	for (let row = 0; row < height; row++) {
+		out.push(
+			rendered
+				.map((lines, c) => {
+					const line = lines[row] ?? "";
+					const pad = Math.max(0, (columnWidths[c] ?? MIN_CARD_WIDTH) - visibleWidth(line));
+					return line + " ".repeat(pad);
+				})
+				.join(" ".repeat(CARD_GRID_GAP)),
+		);
+	}
+	return out;
+}
+
 /** Packages -- the panel's default/"home" tab. A real Component (not the
  * panel's own top-level ctx.ui.custom owner anymore); the shared TabHost
  * gives it inline approval/reload dialogs and a way to signal the overlay
@@ -509,33 +591,42 @@ export class PackagesTab implements Component {
 			lines.push(theme.fg("muted", "  No packages"));
 			return lines;
 		}
-		// No scrolling of its own (Malevich's Table is deliberately
-		// unopinionated about pagination) -- the visible window around
-		// selectedIndex stays this tab's own job.
-		const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filtered.length - this.maxVisible));
-		const end = Math.min(start + this.maxVisible, this.filtered.length);
-		for (const [offset, row] of this.filtered.slice(start, end).entries()) {
-			const selected = start + offset === this.selectedIndex;
-			// A settled row shows its real outcome even for the instant before
-			// the next row's "start" event moves updatingRowName off it.
-			const rowSettled = this.settled.get(row.name);
-			const isUpdating = !rowSettled && this.updatingRowName === row.name;
-			const status = isUpdating
-				? theme.fg("accent", `${this.spinner.glyph()} updating…`)
-				: rowSettled
-					? theme.fg(rowSettled.ok ? "success" : "error", `${rowSettled.ok ? "✓" : "✗"}${rowSettled.tail ? ` ${rowSettled.tail}` : ""}`)
-					: row.hasUpdate
-						? theme.fg("warning", `↑${row.latest}`)
-						: theme.fg("muted", "installed");
-			const card = new Card({
-				title: theme.bold(row.name),
-				content: [`${theme.fg("dim", row.version)} · ${status}`],
-				selected,
-				theme: cardTheme(theme),
-				measure: this.measure,
-			});
-			lines.push(...card.render(width));
-		}
+		// Column count is derived from `width` (and the total item count, so a
+		// short list never gets more columns than it has items) once per
+		// render, then held fixed across the whole page -- otherwise scrolling
+		// through a filtered list would reflow the grid mid-scroll. No
+		// scrolling of its own beyond that: the visible-window-around-
+		// selectedIndex math stays this tab's own job, same as before, just
+		// now counting grid rows (maxVisible) times columns instead of a flat
+		// one-card-per-line count.
+		const columns = computeCardColumns(width, this.filtered.length);
+		const pageSize = columns * this.maxVisible;
+		const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(pageSize / 2), this.filtered.length - pageSize));
+		const end = Math.min(start + pageSize, this.filtered.length);
+		const page = this.filtered.slice(start, end);
+		lines.push(
+			...renderCardGrid(page, columns, width, this.selectedIndex - start, (row, columnWidth, selected) => {
+				// A settled row shows its real outcome even for the instant before
+				// the next row's "start" event moves updatingRowName off it.
+				const rowSettled = this.settled.get(row.name);
+				const isUpdating = !rowSettled && this.updatingRowName === row.name;
+				const status = isUpdating
+					? theme.fg("accent", `${this.spinner.glyph()} updating…`)
+					: rowSettled
+						? theme.fg(rowSettled.ok ? "success" : "error", `${rowSettled.ok ? "✓" : "✗"}${rowSettled.tail ? ` ${rowSettled.tail}` : ""}`)
+						: row.hasUpdate
+							? theme.fg("warning", `↑${row.latest}`)
+							: theme.fg("muted", "installed");
+				const card = new Card({
+					title: theme.bold(row.name),
+					content: [`${theme.fg("dim", row.version)} · ${status}`],
+					selected,
+					theme: cardTheme(theme),
+					measure: this.measure,
+				});
+				return card.render(columnWidth);
+			}),
+		);
 		const hasScroll = start > 0 || end < this.filtered.length;
 		lines.push(theme.fg("dim", `  ${hasScroll ? `${this.selectedIndex + 1}/${this.filtered.length} ` : ""}${this.mode}`));
 		return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.21.11",
+  "version": "0.21.13",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -31,6 +31,7 @@
     "@danypops/packed": "^0.7.0",
     "@danypops/pi-extension-harness": "^0.2.0",
     "@danypops/vehicle-client": "^0.5.2",
+    "@danypops/vehicle-client-pi": "^0.16.9",
     "@danypops/vehicle-core": "^0.12.3",
     "@danypops/vehicle-server": "^0.17.1",
     "jiti": "^2.7.0",
@@ -40,7 +41,6 @@
   },
   "devDependencies": {
     "@danypops/pi-tui-harness": "^0.0.1",
-    "@danypops/vehicle-client-pi": "^0.16.2",
     "@types/semver": "^7.7.1"
   },
   "peerDependencies": {

package/service/src/adoption/install-validation.ts

@@ -7,7 +7,10 @@
  * @danypops/pi-extension-harness's own mock-pi-cli
  * subprocess -- a real, isolated process exercising the same production
  * jiti load path Pi's own binary uses -- against every declared
- * pi.extensions entry.
+ * pi.extensions entry. Also runs @danypops/vehicle-client-pi's
+ * pi-load-harness (native ESM, jiti tryNative:false) in its own isolated
+ * subprocess as non-gating, observational evidence alongside that gating
+ * check -- see ExtensionLoadResult.additionalLoadPaths.
  */
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -18,6 +21,26 @@ export interface ExtensionLoadResult {
 	path: string;
 	ok: boolean;
 	message?: string;
+	/** Non-gating: @danypops/vehicle-client-pi's pi-load-harness checks two
+	 * further Pi extension load paths (native ESM, jiti tryNative:false)
+	 * beyond the one path above (jiti tryNative:true) already gates install.
+	 * Surfaced as observational evidence only, for two independent reasons:
+	 * (1) native-esm can legitimately fail for a perfectly loadable extension
+	 * on an older Node without TS type-stripping support, with no real-world
+	 * signal yet on how often that's a false alarm; (2) this check only
+	 * verifies the module *imports* cleanly -- unlike the gating check above,
+	 * it never calls the extension's exported factory, so it cannot catch a
+	 * factory that throws once actually registered (confirmed directly: the
+	 * BROKEN test fixture, whose factory always throws, reports ok:true on
+	 * every one of these paths). Complementary evidence for an import-time
+	 * failure class, not a broader replacement for the gating check. */
+	additionalLoadPaths?: PiLoadPathResult[];
+}
+
+export interface PiLoadPathResult {
+	path: "native-esm" | "jiti-try-native-false" | "jiti-try-native-true";
+	ok: boolean;
+	error?: string;
 }
 
 export interface InstallValidationResult {
@@ -151,6 +174,28 @@ export async function validateExtensionLoadsHeadless(entryPath: string, timeoutM
 	};
 }
 
+/** Runs the extra two Pi extension load paths @danypops/vehicle-client-pi's
+ * pi-load-harness knows about (native ESM, jiti tryNative:false) against
+ * one entry point, in their own isolated subprocess -- same trust boundary
+ * as validateExtensionLoadsHeadless, never inside the daemon process.
+ * Returns undefined (not a failure) when the probe subprocess itself
+ * couldn't run at all -- vehicle-client-pi is an optional enrichment here,
+ * not a hard requirement the way pi-extension-harness is. */
+async function verifyAllLoadPathsHeadless(entryPath: string, timeoutMs?: number): Promise<PiLoadPathResult[] | undefined> {
+	const bound = bounded(timeoutMs, DEFAULT_LOAD_TIMEOUT_MS, MAX_LOAD_TIMEOUT_MS);
+	const childPath = new URL("verify-load-paths-child.mjs", import.meta.url).pathname;
+	const result = await runCommand(["node", childPath, "--extension", entryPath], tmpdir(), bound);
+	if (result.timedOut) return undefined;
+	const lastLine = result.stdout.trim().split("\n").at(-1);
+	if (!lastLine) return undefined;
+	try {
+		const parsed = JSON.parse(lastLine) as { results?: PiLoadPathResult[]; error?: string };
+		return Array.isArray(parsed.results) ? parsed.results : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Stages the real npm tarball in isolation and headlessly load-checks
  * every pi.extensions entry it declares. A package with no pi.extensions
  * (most npm packages) or a non-npm source has nothing to validate and
@@ -194,7 +239,8 @@ export class HeadlessInstallValidator implements InstallValidator {
 				// path into a throwaway temp stage dir -- meaningful to a caller,
 				// matches what package.json itself says.
 				const loadResult = await validateExtensionLoadsHeadless(entryPath, this.timeoutMs);
-				extensions.push({ ...loadResult, path: entry });
+				const additionalLoadPaths = await verifyAllLoadPathsHeadless(entryPath, this.timeoutMs);
+				extensions.push({ ...loadResult, path: entry, ...(additionalLoadPaths ? { additionalLoadPaths } : {}) });
 			}
 			const ok = extensions.every((extension) => extension.ok);
 			return { ok, source, extensions, ...(ok ? {} : { message: "one or more declared extensions failed a headless load check" }) };

package/service/src/adoption/verify-load-paths-child.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * verify-load-paths-child.mjs — spawned in isolation by install-validation.ts
+ * to check a staged candidate's extension entry against every Pi extension
+ * load path @danypops/vehicle-client-pi's pi-load-harness knows about
+ * (native ESM, jiti tryNative:false, jiti tryNative:true) -- not just the
+ * single tryNative:true path mock-pi-cli's own headless check exercises.
+ *
+ * Runs as its own subprocess, same trust boundary as mock-pi-cli: the
+ * candidate's real code executes here, never inside the trusted daemon
+ * process. Uses jiti itself (the same technique mock-pi-cli.mjs already
+ * relies on) to import pi-load-harness's raw TypeScript source -- that
+ * package deliberately ships this subpath uncompiled, since its intended
+ * consumers already run through a TS-transforming toolchain.
+ *
+ * Accepts:
+ *   --extension <path>   candidate extension entry point to check
+ *
+ * Emits exactly one JSON line on stdout, then exits 0 (a probe failure is
+ * data, not a process failure -- the caller decides what a failing path
+ * means):
+ *   { "results": [{ "path": "native-esm", "ok": true }, ...] }
+ * or, if the harness itself couldn't even be loaded/invoked:
+ *   { "error": "..." }
+ */
+
+import { createJiti } from "jiti";
+
+const args = process.argv.slice(2);
+const get = (flag) => {
+	const i = args.indexOf(flag);
+	return i !== -1 ? args[i + 1] : null;
+};
+
+const extensionPath = get("--extension");
+if (!extensionPath) {
+	process.stderr.write("--extension required\n");
+	process.exit(1);
+}
+
+function emit(obj) {
+	process.stdout.write(`${JSON.stringify(obj)}\n`);
+}
+
+try {
+	const jiti = createJiti(import.meta.url, { moduleCache: false });
+	const { verifyLoadableUnderPi } = await jiti.import("@danypops/vehicle-client-pi/pi-load-harness");
+	const results = await verifyLoadableUnderPi(extensionPath);
+	emit({ results });
+	process.exit(0);
+} catch (err) {
+	emit({ error: err?.message ?? String(err) });
+	process.exit(1);
+}

package/service/test/advisories.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
@@ -36,11 +36,18 @@ class NoopInstaller implements Installer {
 }
 
 let server: Server<undefined> | undefined;
+const roots: string[] = [];
 afterEach(() => {
 	server?.stop(true);
 	server = undefined;
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 const daysAgo = (n: number) => new Date(Date.now() - n * 24 * 60 * 60 * 1000).toISOString();
 
 describe("fetchBulkAdvisories", () => {
@@ -221,6 +228,7 @@ describe("scanInstalledPackages", () => {
 describe("advisories.scan operation (real daemon route)", () => {
 	it("resolves real installed npm packages' on-disk versions and routes through the authenticated operation registry", async () => {
 		const piHome = mkdtempSync(join(tmpdir(), "packed-advisories-daemon-"));
+		roots.push(piHome);
 		writeFileSync(join(piHome, "settings.json"), JSON.stringify({ packages: ["npm:pi-vuln"] }));
 		const pkgDir = join(piHome, "npm", "node_modules", "pi-vuln");
 		mkdirSync(pkgDir, { recursive: true });
@@ -231,8 +239,8 @@ describe("advisories.scan operation (real daemon route)", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-advisories-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-advisories-data-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-data-"))),
 			piHome,
 			// injected exactly like pi.status's piVersion seam -- never a real
 			// network call to the live npm registry from an automated test.
@@ -258,9 +266,9 @@ describe("advisories.scan operation (real daemon route)", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-advisories-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-advisories-data-")),
-			piHome: mkdtempSync(join(tmpdir(), "packed-advisories-pihome-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-data-"))),
+			piHome: track(mkdtempSync(join(tmpdir(), "packed-advisories-pihome-"))),
 		});
 		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {
 			label: "Packed",
@@ -274,9 +282,9 @@ describe("advisories.scan operation (real daemon route)", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-advisories-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-advisories-data-")),
-			piHome: mkdtempSync(join(tmpdir(), "packed-advisories-pihome-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-advisories-data-"))),
+			piHome: track(mkdtempSync(join(tmpdir(), "packed-advisories-pihome-"))),
 		});
 		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {
 			label: "Packed",

package/service/test/cleanup.test.ts

@@ -12,6 +12,11 @@ afterEach(() => {
 	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 function pkg(manifest: Record<string, unknown>): string {
 	const root = mkdtempSync(join(tmpdir(), "packed-cleanup-"));
 	roots.push(root);
@@ -169,8 +174,8 @@ describe("packed remove applies pi.cleanup before delegating to pi remove (real
 			reg: new NoopRegistry(),
 			inst,
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-cleanup-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-cleanup-data-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-cleanup-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-cleanup-data-"))),
 			piHome,
 		});
 		return new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {

package/service/test/cli.test.ts

@@ -1,6 +1,6 @@
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { writeDaemonHandle } from "@danypops/vehicle-server/paths";
@@ -125,6 +125,16 @@ class FakeDaemonServiceInstaller {
 	}
 }
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 function deps(over: Partial<CliDeps> = {}): CliDeps {
 	return {
 		reg: new FakeRegistry(),
@@ -138,8 +148,8 @@ function deps(over: Partial<CliDeps> = {}): CliDeps {
 				return { mutationApproval };
 			},
 		},
-		stateDir: mkdtempSync(join(tmpdir(), "packed-")),
-		piHome: mkdtempSync(join(tmpdir(), "packed-pihome-")),
+		stateDir: track(mkdtempSync(join(tmpdir(), "packed-"))),
+		piHome: track(mkdtempSync(join(tmpdir(), "packed-pihome-"))),
 		...over,
 	};
 }
@@ -389,7 +399,7 @@ describe("CLI", () => {
 	it("updates --project also checks a project's own .pi/settings.json pins -- global-only misses them entirely", async () => {
 		const d = deps();
 		writeFileSync(join(d.piHome, "settings.json"), JSON.stringify({ packages: ["npm:pi-global@1.0.0"] }));
-		const projectRoot = mkdtempSync(join(tmpdir(), "packed-project-"));
+		const projectRoot = track(mkdtempSync(join(tmpdir(), "packed-project-")));
 		const projectHome = join(projectRoot, ".pi");
 		mkdirSync(projectHome, { recursive: true });
 		writeFileSync(join(projectHome, "settings.json"), JSON.stringify({ packages: ["npm:papyrus@0.21.2"] }));
@@ -938,7 +948,7 @@ describe("CLI", () => {
 	});
 
 	it("advisories runs standalone without a daemon and degrades to zero findings, never a real network call, when nothing is installed", async () => {
-		const d = deps({ piHome: mkdtempSync(join(tmpdir(), "packed-advisories-cli-")) });
+		const d = deps({ piHome: track(mkdtempSync(join(tmpdir(), "packed-advisories-cli-"))) });
 		const result = await cliRun(["advisories", "--json"], d);
 		expect(result.code).toBe(0);
 		expect(JSON.parse(result.out)).toEqual({ scanned: 0, findings: [], diagnostics: [], truncated: false });
@@ -956,7 +966,7 @@ describe("CLI", () => {
 	});
 
 	it("resources list and toggle run standalone without a daemon (CLI parity for the daemon-only resources.list/toggle operations)", async () => {
-		const piHome = mkdtempSync(join(tmpdir(), "packed-resources-cli-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-resources-cli-")));
 		writeFileSync(join(piHome, "settings.json"), JSON.stringify({ packages: ["npm:pi-demo"] }));
 		const pkgDir = join(piHome, "npm", "node_modules", "pi-demo");
 		mkdirSync(pkgDir, { recursive: true });
@@ -998,7 +1008,7 @@ describe("CLI", () => {
 	(bwrapUsable ? it : it.skip)(
 		"doctor runs standalone without a daemon and reproduces the jittor incident through the real CLI (CLI parity for the daemon-only doctor.run operation)",
 		async () => {
-			const piHome = mkdtempSync(join(tmpdir(), "packed-doctor-cli-"));
+			const piHome = track(mkdtempSync(join(tmpdir(), "packed-doctor-cli-")));
 			writeFileSync(join(piHome, "settings.json"), JSON.stringify({ packages: ["npm:pi-papyrus"] }));
 			const globalPkg = join(piHome, "npm", "node_modules", "pi-papyrus");
 			mkdirSync(join(globalPkg, "extension"), { recursive: true });
@@ -1007,7 +1017,7 @@ describe("CLI", () => {
 				JSON.stringify({ name: "pi-papyrus", version: "1.0.0", pi: { extensions: ["extension/index.ts"] } }),
 			);
 			writeFileSync(join(globalPkg, "extension", "index.ts"), 'export default function (pi: any) { pi.registerTool({ name: "tasks" }); }');
-			const projectRoot = mkdtempSync(join(tmpdir(), "packed-doctor-cli-project-"));
+			const projectRoot = track(mkdtempSync(join(tmpdir(), "packed-doctor-cli-project-")));
 			const projectHome = join(projectRoot, ".pi");
 			mkdirSync(projectHome, { recursive: true });
 			writeFileSync(join(projectHome, "settings.json"), JSON.stringify({ packages: ["npm:papyrus"] }));
@@ -1063,12 +1073,14 @@ describe("CLI", () => {
 describe("daemon client", () => {
 	let server: Server<undefined>;
 	let daemonDir: string;
+	let daemonPiHome: string;
 	let daemonPaths: PackedPaths;
 	let daemonInstaller: FakeInstaller;
 	const daemonToken = "d".repeat(64);
 
 	beforeAll(async () => {
 		daemonDir = mkdtempSync(join(tmpdir(), "packed-daemon-"));
+		daemonPiHome = mkdtempSync(join(tmpdir(), "packed-daemon-pi-"));
 		daemonPaths = resolvePackedPaths({ env: { PI_PACKED_HOME: daemonDir } });
 		writeFileSync(daemonPaths.token, `${daemonToken}\n`);
 		daemonInstaller = new FakeInstaller();
@@ -1100,7 +1112,7 @@ describe("daemon client", () => {
 			},
 			token: daemonToken,
 			stateDir: daemonDir,
-			piHome: mkdtempSync(join(tmpdir(), "packed-daemon-pi-")),
+			piHome: daemonPiHome,
 			packer: {
 				async verify(path) {
 					return {
@@ -1169,7 +1181,11 @@ describe("daemon client", () => {
 		server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: (req) => app.fetch(req) });
 		writeDaemonHandle(daemonPaths.handle, { host: "127.0.0.1", port: server.port!, pid: process.pid });
 	});
-	afterAll(() => server.stop(true));
+	afterAll(() => {
+		server.stop(true);
+		rmSync(daemonDir, { recursive: true, force: true });
+		rmSync(daemonPiHome, { recursive: true, force: true });
+	});
 
 	it("probe finds a live daemon", async () => {
 		const found = await probe(daemonPaths);
@@ -1188,7 +1204,7 @@ describe("daemon client", () => {
 	});
 
 	it("probe rejects dead state", async () => {
-		const directory = mkdtempSync(join(tmpdir(), "packed-"));
+		const directory = track(mkdtempSync(join(tmpdir(), "packed-")));
 		expect(await probe(resolvePackedPaths({ env: { PI_PACKED_HOME: directory } }))).toBeUndefined();
 	});
 
@@ -1260,7 +1276,7 @@ describe("daemon client", () => {
 	it("resolveRegistry prefers daemon, falls back direct", async () => {
 		const viaDaemon = await resolveRegistry(daemonPaths, "https://registry.npmjs.org");
 		expect(viaDaemon).toBeInstanceOf(DaemonRegistry);
-		const directory = mkdtempSync(join(tmpdir(), "packed-"));
+		const directory = track(mkdtempSync(join(tmpdir(), "packed-")));
 		const direct = await resolveRegistry(resolvePackedPaths({ env: { PI_PACKED_HOME: directory } }), "https://registry.npmjs.org");
 		expect(direct).toBeInstanceOf(HttpRegistry);
 	});

package/service/test/db.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { syncCatalog } from "../src/packages/catalog.ts";
@@ -127,9 +127,15 @@ class PagedRegistry implements Registry {
 	}
 }
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
 describe("syncCatalog → SQLite", () => {
 	it("accumulates pages into the DB and records sync meta", async () => {
 		const dir = mkdtempSync(join(tmpdir(), "packed-"));
+		roots.push(dir);
 		const reg = new PagedRegistry({ 0: PKGS.slice(0, 2), 2: PKGS.slice(2) }, 3);
 		expect(await syncCatalog(reg, dir)).toBe(3);
 		expect(existsSync(dbPath(dir))).toBe(true);

package/service/test/doctor.test.ts

@@ -13,6 +13,11 @@ afterEach(() => {
 	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 // Same sandbox-availability probe as smoke.test.ts: binary presence alone
 // doesn't prove bwrap actually works under this host's user namespaces.
 function bwrapUsable(): boolean {
@@ -216,8 +221,8 @@ describeIfSandboxed("doctor.run (daemon RPC wiring)", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-doctor-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-doctor-data-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-doctor-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-doctor-data-"))),
 			piHome: home,
 		});
 		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {