@danypops/pi-packed 0.21.3 → 0.21.4

package/extension/src/tabs/discover.ts

@@ -68,6 +68,7 @@ export class FindTab implements Component {
 	private busy = false;
 	private queryActive = true;
 	private readonly maxVisible = 4;
+	private readonly idleWaiters = new Set<() => void>();
 
 	constructor(
 		private readonly natives: Natives,
@@ -99,6 +100,17 @@ export class FindTab implements Component {
 
 	invalidate(): void {}
 
+	whenIdle(): Promise<void> {
+		if (!this.searching && !this.busy) return Promise.resolve();
+		return new Promise((resolve) => this.idleWaiters.add(resolve));
+	}
+
+	private signalIdle(): void {
+		if (this.searching || this.busy) return;
+		for (const resolve of this.idleWaiters) resolve();
+		this.idleWaiters.clear();
+	}
+
 	render(width: number): string[] {
 		const theme = this._theme;
 		const hint = this.queryActive
@@ -177,6 +189,7 @@ export class FindTab implements Component {
 		} finally {
 			this.searching = false;
 			this.host.requestRender();
+			this.signalIdle();
 		}
 	}
 
@@ -196,6 +209,7 @@ export class FindTab implements Component {
 		} finally {
 			this.busy = false;
 			this.host.requestRender();
+			this.signalIdle();
 		}
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.21.3",
+  "version": "0.21.4",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
     "typecheck": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@danypops/armada": "^0.2.0",
+    "@danypops/armada": "^0.3.1",
     "@danypops/packed": "^0.6.0",
     "@danypops/pi-extension-harness": "^0.2.0",
     "@danypops/vehicle-client": "^0.5.1",

package/service/src/daemon/daemon.ts

@@ -100,17 +100,6 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 	];
 	const maintenanceTasks = configuredMaintenanceTasks.filter((task) => task.intervalMs > 0);
 
-	if (options.maintenanceTasks === undefined) {
-		for (const task of maintenanceTasks) {
-			// Armada reconciles the whole desired fleet. Running this before Packed
-			// publishes its readiness handle makes Armada replace Packed mid-startup.
-			if (task.name === "vehicle-reconcile") continue;
-			void Promise.resolve(task.run()).catch((error) =>
-				logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
-			);
-		}
-	}
-
 	return {
 		daemonLabel: "Packed",
 		handlePath: paths.handle,
@@ -123,18 +112,18 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 	};
 }
 
-function runReadyVehicleReconcile(maintenanceTasks: MaintenanceTask[] | undefined): void {
-	const task = maintenanceTasks?.find((candidate) => candidate.name === "vehicle-reconcile");
-	if (!task) return;
-	void Promise.resolve(task.run()).catch((error) =>
-		logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
-	);
+function runInitialMaintenance(maintenanceTasks: MaintenanceTask[] | undefined): void {
+	for (const task of maintenanceTasks ?? []) {
+		void Promise.resolve(task.run()).catch((error) =>
+			logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
+		);
+	}
 }
 
 export async function startPackedDaemon(options: StartPackedDaemonOptions = {}): Promise<RunningDaemon> {
 	const configured = daemonOptions(options);
 	const running = await startDaemon(configured);
-	runReadyVehicleReconcile(configured.maintenanceTasks);
+	runInitialMaintenance(configured.maintenanceTasks);
 	return running;
 }
 
@@ -144,7 +133,7 @@ export function serveMain(): void {
 		...configured,
 		onListen: ({ host, port }) => {
 			logger.info("listening", { host, port });
-			runReadyVehicleReconcile(configured.maintenanceTasks);
+			runInitialMaintenance(configured.maintenanceTasks);
 		},
 	});
 }

package/service/src/daemon/watcher.ts

@@ -68,6 +68,7 @@ export function checkUpdates(latestOf: (name: string) => string | undefined, ins
 export interface WatcherOptions {
 	intervalMs: number;
 	onError?: (e: unknown) => void;
+	onTick?: (snapshot: UpdatesSnapshot) => void;
 }
 
 /** Producer loop: immediate check, then on a timer. Returns a stop function. */
@@ -80,7 +81,9 @@ export function startWatcher(
 	async function check(): Promise<void> {
 		try {
 			const updates = checkUpdates(latestOf, readInstalled());
-			await saveUpdates(stateDir, { checkedAt: new Date().toISOString(), updates });
+			const snapshot = { checkedAt: new Date().toISOString(), updates };
+			await saveUpdates(stateDir, snapshot);
+			opts.onTick?.(snapshot);
 			log.info("updates check", { updates: updates.length });
 		} catch (e) {
 			opts.onError?.(e);

package/service/src/shared/cache.ts

@@ -3,12 +3,15 @@ import { CACHE_TTL_MS } from "./constants.ts";
 
 export class TTLCache {
 	private m = new Map<string, { body: string; expires: number }>();
-	constructor(private ttlMs = CACHE_TTL_MS) {}
+	constructor(
+		private ttlMs = CACHE_TTL_MS,
+		private readonly now: () => number = Date.now,
+	) {}
 
 	get(key: string): string | undefined {
 		const e = this.m.get(key);
 		if (!e) return undefined;
-		if (Date.now() > e.expires) {
+		if (this.now() > e.expires) {
 			this.m.delete(key);
 			return undefined;
 		}
@@ -16,6 +19,6 @@ export class TTLCache {
 	}
 
 	set(key: string, body: string): void {
-		this.m.set(key, { body, expires: Date.now() + this.ttlMs });
+		this.m.set(key, { body, expires: this.now() + this.ttlMs });
 	}
 }

package/service/test/core.test.ts

@@ -23,11 +23,12 @@ describe("clampLimit", () => {
 });
 
 describe("TTLCache", () => {
-	it("stores and expires", async () => {
-		const c = new TTLCache(20); // ms
+	it("stores and expires against an injected clock", () => {
+		let now = 1_000;
+		const c = new TTLCache(20, () => now);
 		c.set("k", "v");
 		expect(c.get("k")).toBe("v");
-		await Bun.sleep(30);
+		now += 21;
 		expect(c.get("k")).toBeUndefined();
 	});
 });

package/service/test/daemon-maintenance.test.ts

@@ -2,8 +2,15 @@ import { afterEach, describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createArmadaTestHarness } from "@danypops/armada/testing";
+import type { MaintenanceTask } from "@danypops/vehicle-server/daemon";
 import type { ServiceInstallResult, ServiceSpec } from "@danypops/vehicle-server/service";
 import { daemonOptions, startPackedDaemon } from "../src/daemon/daemon.ts";
+import {
+	type DaemonServiceInstaller,
+	RealDaemonServiceInstaller,
+	reconcileAllDaemonServices,
+} from "../src/daemon/daemon-service.ts";
 import type { Installer, Registry } from "../src/packages/package.ts";
 import { RECONCILE_INTERVAL_DEFAULT_MS } from "../src/shared/constants.ts";
 import { resolvePackedPaths } from "../src/shared/paths.ts";
@@ -26,6 +33,30 @@ function fakePaths() {
 	return resolvePackedPaths({ env: { PI_PACKED_HOME: root } });
 }
 
+function vehicleReconcileTask(piHome: string, daemonServiceInstaller: DaemonServiceInstaller): MaintenanceTask {
+	return {
+		name: "vehicle-reconcile",
+		intervalMs: RECONCILE_INTERVAL_DEFAULT_MS,
+		run: async () => {
+			await reconcileAllDaemonServices(piHome, undefined, daemonServiceInstaller);
+		},
+	};
+}
+
+function installMockDaemon(piHome: string, name: string): void {
+	const directory = join(piHome, "npm", "node_modules", name);
+	mkdirSync(directory, { recursive: true });
+	writeFileSync(
+		join(directory, "package.json"),
+		JSON.stringify({
+			name,
+			version: "1.0.0",
+			packed: { daemonService: { binPath: "cli.ts", args: ["serve"] } },
+		}),
+	);
+	writeFileSync(join(directory, "cli.ts"), "// Mock Vehicle entry point; Armada's test controller never executes it.\n");
+}
+
 const registry: Registry = {
 	async search() {
 		return { total: 0, results: [] };
@@ -101,40 +132,89 @@ describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle dr
 		const task = options.maintenanceTasks?.find((t) => t.name === "vehicle-reconcile");
 		expect(task).toBeDefined();
 
-		// daemonOptions() also fires every default task once at startup (see the dedicated
-		// startup-self-heal test below) -- let that finish, then isolate this test's own
-		// explicit invocation from it rather than racing the two.
-		await new Promise((resolveTick) => setTimeout(resolveTick, 20));
-		installerSpy.gotSources = [];
 		await task?.run();
 
 		expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe", "npm:@danypops/other"]);
 	});
 
+	it("runs initial maintenance only after publishing the daemon handle", async () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		let resolveRun: (() => void) | undefined;
+		const ran = new Promise<void>((resolve) => {
+			resolveRun = resolve;
+		});
+		const task: MaintenanceTask = {
+			name: "probe-initial-maintenance",
+			intervalMs: RECONCILE_INTERVAL_DEFAULT_MS,
+			run: () => {
+				expect(existsSync(paths.handle)).toBe(true);
+				resolveRun?.();
+			},
+		};
+
+		const running = await startPackedDaemon({ paths, reg: registry, inst: installer, piHome, maintenanceTasks: [task] });
+		try {
+			await Promise.race([
+				ran,
+				new Promise<never>((_, reject) => setTimeout(() => reject(new Error("initial maintenance did not run")), 250)),
+			]);
+		} finally {
+			await running.stop();
+		}
+	});
+
 	it("does not reconcile Armada before the daemon has published its readiness handle", async () => {
 		const piHome = fakePiHome(["npm:@danypops/pi-packed", "npm:@danypops/probe"]);
 		const paths = fakePaths();
-		const installerSpy = new RecordingDaemonServiceInstaller();
-		mkdirSync(join(piHome, "npm", "node_modules"), { recursive: true });
-		daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
-
-		// Give pre-listen maintenance enough time to expose an accidental Armada call.
-		await new Promise((resolveTick) => setTimeout(resolveTick, 10));
+		installMockDaemon(piHome, "@danypops/pi-packed");
+		installMockDaemon(piHome, "@danypops/probe");
+		const harness = await createArmadaTestHarness();
+		try {
+			const serviceInstaller = new RealDaemonServiceInstaller(harness.registrar);
+			daemonOptions({
+				paths,
+				reg: registry,
+				inst: installer,
+				piHome,
+				daemonServiceInstaller: serviceInstaller,
+				maintenanceTasks: [vehicleReconcileTask(piHome, serviceInstaller)],
+			});
 
-		expect(installerSpy.gotSources).toEqual([]);
+			expect(existsSync(paths.handle)).toBe(false);
+			expect(harness.events()).toEqual([]);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
 	it("reconciles Armada only after the real daemon handle is ready", async () => {
 		const piHome = fakePiHome(["npm:@danypops/pi-packed", "npm:@danypops/probe"]);
 		const paths = fakePaths();
-		const installerSpy = new RecordingDaemonServiceInstaller();
-		const running = await startPackedDaemon({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		installMockDaemon(piHome, "@danypops/pi-packed");
+		installMockDaemon(piHome, "@danypops/probe");
+		const harness = await createArmadaTestHarness();
+		const serviceInstaller = new RealDaemonServiceInstaller(harness.registrar);
+		const running = await startPackedDaemon({
+			paths,
+			reg: registry,
+			inst: installer,
+			piHome,
+			daemonServiceInstaller: serviceInstaller,
+			maintenanceTasks: [vehicleReconcileTask(piHome, serviceInstaller)],
+		});
 		try {
-			await new Promise((resolveTick) => setTimeout(resolveTick, 10));
+			await harness.waitForEvent("ready:probe");
 			expect(existsSync(paths.handle)).toBe(true);
-			expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe"]);
+			expect(harness.events()).toEqual([
+				"replace:armada-probe.service",
+				"start:armada-probe.service",
+				"ready:probe",
+			]);
+			expect(await harness.registrar.isRegistered("pi-packed")).toBe(false);
 		} finally {
 			await running.stop();
+			await harness.dispose();
 		}
 	});
 });

package/service/test/daemon-service.test.ts

@@ -1,12 +1,20 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { VehicleRegistrar, VehicleRegistrationOutcome } from "@danypops/armada";
+import type { VehicleRegistrar } from "@danypops/armada";
+import { createArmadaTestHarness } from "@danypops/armada/testing";
 import { detectVehicleDaemonService, RealDaemonServiceInstaller, resolveDaemonServiceSpec } from "../src/daemon/daemon-service.ts";
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
 function fakePiHome(): string {
-	return mkdtempSync(join(tmpdir(), "packed-daemon-service-"));
+	const root = mkdtempSync(join(tmpdir(), "packed-daemon-service-"));
+	roots.push(root);
+	return root;
 }
 
 function writePackage(piHome: string, name: string, manifest: unknown): void {
@@ -200,100 +208,128 @@ describe("resolveDaemonServiceSpec", () => {
 	});
 });
 
-class FakeVehicleRegistrar implements VehicleRegistrar {
-	registered = new Map<string, unknown>();
-	outcome: VehicleRegistrationOutcome = { ok: true, manifestHash: "hash" as never, applied: [], diagnostics: [] };
-	async register(vehicle: unknown): Promise<VehicleRegistrationOutcome> {
-		if (this.outcome.ok) this.registered.set((vehicle as { name: string }).name, vehicle);
-		return this.outcome;
-	}
-	async unregister(name: string): Promise<VehicleRegistrationOutcome> {
-		if (this.outcome.ok) this.registered.delete(name);
-		return this.outcome;
-	}
-	async isRegistered(name: string): Promise<boolean> {
-		return this.registered.has(name);
-	}
-}
-
 describe("RealDaemonServiceInstaller -- Armada registration through the in-process registrar", () => {
-	it("install() resolves the package's Vehicle spec and registers it through Armada directly", async () => {
+	it("install() resolves the package and drives Armada's real registrar/reconciler through the isolated harness", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-
-		const outcome = await installer.install(piHome, "npm:@danypops/web-spider-daemon");
-
-		expect(outcome).toMatchObject({ ok: true, result: { installed: true }, spec: { name: "web-spider-daemon" } });
-		expect(registrar.registered.has("web-spider-daemon")).toBe(true);
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			const outcome = await installer.install(piHome, "npm:@danypops/web-spider-daemon");
+
+			expect(outcome).toMatchObject({ ok: true, result: { installed: true }, spec: { name: "web-spider-daemon" } });
+			expect(harness.application("web-spider-daemon").state()).toBe("ready");
+			expect(harness.events()).toEqual([
+				"replace:armada-web-spider-daemon.service",
+				"start:armada-web-spider-daemon.service",
+				"ready:web-spider-daemon",
+			]);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
 	it("install() never asks Armada to replace Packed from inside Packed's own process", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/pi-packed", { binPath: "service/src/cli/cli.ts", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-
-		const outcome = await installer.install(piHome, "npm:@danypops/pi-packed");
-
-		expect(outcome).toMatchObject({ ok: true, result: { installed: false }, spec: { name: "pi-packed" } });
-		expect(registrar.registered.size).toBe(0);
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			const outcome = await installer.install(piHome, "npm:@danypops/pi-packed");
+
+			expect(outcome).toMatchObject({ ok: true, result: { installed: false }, spec: { name: "pi-packed" } });
+			expect(harness.events()).toEqual([]);
+			expect(await harness.registrar.isRegistered("pi-packed")).toBe(false);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
-	it("install() reports a non-daemon package without ever touching the registrar", async () => {
+	it("install() reports a non-daemon package without touching Armada", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "some-pkg", undefined);
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-
-		const outcome = await installer.install(piHome, "npm:some-pkg");
-
-		expect(outcome).toMatchObject({ ok: false, notADaemon: true });
-		expect(registrar.registered.size).toBe(0);
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			const outcome = await installer.install(piHome, "npm:some-pkg");
+
+			expect(outcome).toMatchObject({ ok: false, notADaemon: true });
+			expect(harness.events()).toEqual([]);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
-	it("remove() unregisters the resolved Vehicle through Armada directly", async () => {
+	it("remove() unregisters the resolved Vehicle through Armada's real registrar", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-		await installer.install(piHome, "npm:@danypops/web-spider-daemon");
-
-		const outcome = await installer.remove(piHome, "npm:@danypops/web-spider-daemon");
-
-		expect(outcome).toMatchObject({ ok: true, result: { installed: true } });
-		expect(registrar.registered.has("web-spider-daemon")).toBe(false);
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			await installer.install(piHome, "npm:@danypops/web-spider-daemon");
+			const outcome = await installer.remove(piHome, "npm:@danypops/web-spider-daemon");
+
+			expect(outcome).toMatchObject({ ok: true, result: { installed: true } });
+			expect(await harness.registrar.isRegistered("web-spider-daemon")).toBe(false);
+			expect(harness.events().at(-1)).toBe("remove:armada-web-spider-daemon.service");
+		} finally {
+			await harness.dispose();
+		}
 	});
 
-	it("restart() is a no-op, in-band, when Armada has no registration for this Vehicle yet", async () => {
+	it("restart() is a no-op when Armada has no registration for this Vehicle", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-
-		const outcome = await installer.restart(piHome, "npm:@danypops/web-spider-daemon");
-
-		expect(outcome).toMatchObject({ ok: true, restarted: false });
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			const outcome = await installer.restart(piHome, "npm:@danypops/web-spider-daemon");
+
+			expect(outcome).toMatchObject({ ok: true, restarted: false });
+			expect(harness.events()).toEqual([]);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
-	it("restart() re-registers (picking up a fresh on-disk version) once already registered", async () => {
+	it("restart() re-registers a changed on-disk version through Armada's update plan", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		const installer = new RealDaemonServiceInstaller(registrar);
-		await installer.install(piHome, "npm:@danypops/web-spider-daemon");
-
-		const outcome = await installer.restart(piHome, "npm:@danypops/web-spider-daemon");
-
-		expect(outcome).toMatchObject({ ok: true, restarted: true });
+		const harness = await createArmadaTestHarness();
+		try {
+			const installer = new RealDaemonServiceInstaller(harness.registrar);
+			await installer.install(piHome, "npm:@danypops/web-spider-daemon");
+			const packagePath = join(piHome, "npm", "node_modules", "@danypops/web-spider-daemon", "package.json");
+			writeFileSync(
+				packagePath,
+				JSON.stringify({
+					name: "@danypops/web-spider-daemon",
+					version: "1.1.0",
+					packed: { daemonService: { binPath: "dist/cli.js", args: ["serve"] } },
+				}),
+			);
+			const outcome = await installer.restart(piHome, "npm:@danypops/web-spider-daemon");
+
+			expect(outcome).toMatchObject({ ok: true, restarted: true, spec: { version: "1.1.0" } });
+			expect(harness.events().slice(-4)).toEqual([
+				"stop:armada-web-spider-daemon.service",
+				"replace:armada-web-spider-daemon.service",
+				"start:armada-web-spider-daemon.service",
+				"ready:web-spider-daemon",
+			]);
+		} finally {
+			await harness.dispose();
+		}
 	});
 
-	it("surfaces a failed Armada registration's diagnostics in-band, never as a thrown error", async () => {
+	it("surfaces a failed Armada registration's diagnostics in-band", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
-		const registrar = new FakeVehicleRegistrar();
-		registrar.outcome = { ok: false, diagnostics: [{ code: "X", severity: "error", path: "/", message: "native failure" }] };
+		const registrar: VehicleRegistrar = {
+			register: async () => ({ ok: false, diagnostics: [{ code: "X", severity: "error", path: "/", message: "native failure" }] }),
+			unregister: async () => ({ ok: false, diagnostics: [] }),
+			isRegistered: async () => false,
+		};
 		const installer = new RealDaemonServiceInstaller(registrar);
 
 		const outcome = await installer.install(piHome, "npm:@danypops/web-spider-daemon");

package/service/test/domain.test.ts

@@ -260,21 +260,23 @@ describe("updates store", () => {
 describe("watcher producer", () => {
 	it("writes a snapshot on tick", async () => {
 		const dir = mkdtempSync(join(tmpdir(), "packed-"));
+		let signalTick: ((snapshot: UpdatesSnapshot) => void) | undefined;
+		const tick = new Promise<UpdatesSnapshot>((resolve) => {
+			signalTick = resolve;
+		});
 		const stop = startWatcher(
 			() => "0.9.0",
 			dir,
 			() => [{ name: "pi-extension-manager", pinned: "0.8.2" }],
-			{ intervalMs: 60_000 },
+			{ intervalMs: 60_000, onTick: (snapshot) => signalTick?.(snapshot) },
 		);
-		const deadline = Date.now() + 2000;
-		let snap: UpdatesSnapshot | undefined;
-		while (Date.now() < deadline) {
-			snap = await loadUpdates(dir);
-			if (snap?.updates.length) break;
-			await Bun.sleep(25);
+		try {
+			const snap = await tick;
+			expect(snap.updates[0]?.latest).toBe("0.9.0");
+			expect(await loadUpdates(dir)).toEqual(snap);
+		} finally {
+			stop();
 		}
-		stop();
-		expect(snap?.updates[0]?.latest).toBe("0.9.0");
 	});
 });
 

package/service/test/index.test.ts

@@ -165,13 +165,22 @@ describe("buildIndex bounds", () => {
 		replaceAll(db, [{ name: "pi-one", version: "1.0.0" }], "test");
 		db.close();
 		let infoCalls = 0;
+		let releaseResponse: (() => void) | undefined;
+		let signalRequest: (() => void) | undefined;
+		const responseGate = new Promise<void>((resolve) => {
+			releaseResponse = resolve;
+		});
+		const requestReceived = new Promise<void>((resolve) => {
+			signalRequest = resolve;
+		});
 		const server = Bun.serve({
 			port: 0,
 			async fetch(req) {
 				const url = new URL(req.url);
 				if (url.pathname.endsWith("/latest")) {
 					infoCalls++;
-					await Bun.sleep(30);
+					signalRequest?.();
+					await responseGate;
 					return Response.json({ name: "pi-one", version: "1.0.0" });
 				}
 				return new Response("not found", { status: 404 });
@@ -179,7 +188,11 @@ describe("buildIndex bounds", () => {
 		});
 		try {
 			const reg = new HttpRegistry(`http://127.0.0.1:${server.port}`, 250, 0, 1, `http://127.0.0.1:${server.port}`);
-			const [a, b] = await Promise.all([buildIndex(reg, dir, { delayMs: 0 }), buildIndex(reg, dir, { delayMs: 0 })]);
+			const first = buildIndex(reg, dir, { delayMs: 0 });
+			await requestReceived;
+			const second = buildIndex(reg, dir, { delayMs: 0 });
+			releaseResponse?.();
+			const [a, b] = await Promise.all([first, second]);
 			expect(a).toBe(b); // the very same result object -- one real run, not two
 			expect(infoCalls).toBe(1); // never doubled
 		} finally {

package/service/test/service-doctor.test.ts

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createArmadaTestHarness } from "@danypops/armada/testing";
 import type { ServiceDoctorDeps } from "../src/adoption/service-doctor.ts";
 import { checkServiceUnitPaths } from "../src/adoption/service-doctor.ts";
 
@@ -64,27 +65,40 @@ describe("checkServiceUnitPaths", () => {
 		expect(report).toEqual({ ok: true, diagnostics: [], checked: 1 });
 	});
 
-	it("reports an Armada-managed Vehicle that is declared but not running", () => {
+	it("reports a stopped Vehicle from Armada's real status projection", async () => {
 		const home = piHome(["npm:fakedaemon"]);
 		const dir = installDaemonPackage(home, "fakedaemon");
-		const report = checkServiceUnitPaths(
-			home,
-			undefined,
-			fakeDeps({ vehicles: [{ name: "fakedaemon", executable: join(dir, "cli.ts"), nativeStatus: "stopped", ready: false }], diagnostics: [] }),
-		);
-		expect(report).toEqual({
-			ok: false,
-			checked: 1,
-			diagnostics: [
-				{
-					code: "SERVICE_NOT_RUNNING",
-					severity: "error",
-					package: "fakedaemon",
-					unitName: "fakedaemon",
-					message: expect.stringContaining("stopped"),
-				},
-			],
-		});
+		const harness = await createArmadaTestHarness();
+		try {
+			const registered = await harness.registrar.register({
+				name: "fakedaemon",
+				version: "1.0.0",
+				executable: join(dir, "cli.ts"),
+				arguments: ["serve"],
+				handlePath: join(harness.root, "fakedaemon", "handle.json"),
+				restart: { policy: "on-failure", delayMs: 100, maxAttempts: 2, windowMs: 1_000 },
+				readiness: { timeoutMs: 100, pollIntervalMs: 50 },
+			});
+			expect(registered.ok).toBe(true);
+			harness.application("fakedaemon").exitCleanly();
+
+			const report = checkServiceUnitPaths(home, undefined, fakeDeps(await harness.status()));
+			expect(report).toEqual({
+				ok: false,
+				checked: 1,
+				diagnostics: [
+					{
+						code: "SERVICE_NOT_RUNNING",
+						severity: "error",
+						package: "fakedaemon",
+						unitName: "fakedaemon",
+						message: expect.stringContaining("stopped"),
+					},
+				],
+			});
+		} finally {
+			await harness.dispose();
+		}
 	});
 
 	it("reports a missing Armada-managed executable", () => {

package/service/test/vehicle-registration.test.ts

@@ -1,11 +1,22 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { OPERATION_NAMES } from "../src/daemon/service.ts";
 import { createApp, type Deps } from "../src/daemon/service.ts";
 import type { Installer, Pkg, PkgInfo, Registry, SearchPage, UpdateOutcome } from "../src/packages/package.ts";
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function temporaryRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	roots.push(root);
+	return root;
+}
+
 class FakeRegistry implements Registry {
 	constructor(
 		private results: Pkg[] = [],
@@ -42,7 +53,7 @@ function deps(over: Partial<Deps> = {}): Deps {
 		reg: new FakeRegistry([{ name: "pi-lsp", version: "1.0.0", description: "An LSP package" }], 1),
 		inst: new FakeInstaller(),
 		token: "test-token",
-		stateDir: mkdtempSync(join(tmpdir(), "packed-vehicle-")),
+		stateDir: temporaryRoot("packed-vehicle-"),
 		...over,
 	};
 }
@@ -78,7 +89,7 @@ describe("packed's daemon operation surface, through the real Vehicle wire proto
 	});
 
 	it("package.installed and pi.status (daemon-only, never a Pi tool) are still reachable through /vehicle/invoke", async () => {
-		const app = createApp(deps({ piHome: mkdtempSync(join(tmpdir(), "packed-vehicle-pihome-")) }));
+		const app = createApp(deps({ piHome: temporaryRoot("packed-vehicle-pihome-") }));
 		const installed = await invoke(app, "package.installed", {});
 		expect(installed.status).toBe(200);
 		expect(installed.body.output).toEqual([]);