@danypops/pi-packed 0.19.12 → 0.20.0

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

@@ -0,0 +1,127 @@
+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 { ServiceInstallResult, ServiceSpec } from "@danypops/vehicle-server/service";
+import { daemonOptions } from "../src/daemon/daemon.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";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function fakePiHome(packages: string[]): string {
+	const piHome = mkdtempSync(join(tmpdir(), "packed-maintenance-"));
+	roots.push(piHome);
+	writeFileSync(join(piHome, "settings.json"), JSON.stringify({ packages }));
+	return piHome;
+}
+
+function fakePaths() {
+	const root = mkdtempSync(join(tmpdir(), "packed-maintenance-state-"));
+	roots.push(root);
+	return resolvePackedPaths({ env: { PI_PACKED_HOME: root } });
+}
+
+const registry: Registry = {
+	async search() {
+		return { total: 0, results: [] };
+	},
+	async searchPage() {
+		return { total: 0, results: [] };
+	},
+	async searchAll() {
+		return [];
+	},
+	async info(name) {
+		return { name, version: "1.0.0" };
+	},
+};
+
+const installer: Installer = {
+	async install(source) {
+		return `installed ${source}`;
+	},
+	async remove(source) {
+		return `removed ${source}`;
+	},
+	async update(source) {
+		return { output: `updated ${source}`, reloadRequired: false, alreadyUpToDate: true, pinned: false };
+	},
+};
+
+class RecordingDaemonServiceInstaller {
+	gotSources: string[] = [];
+	async install(
+		_piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		this.gotSources.push(source);
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+	async remove(): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+	async restart(): Promise<
+		{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }
+	> {
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+}
+
+describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle drift, not just per-package on demand)", () => {
+	it("includes a vehicle-reconcile task, defaulting to RECONCILE_INTERVAL_DEFAULT_MS", () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, maintenanceTasks: [] });
+		// maintenanceTasks: [] is itself the override under test setup convention (see
+		// daemon-kit-migration.test.ts) for every OTHER test in this file that needs the
+		// real default list; assert its shape directly here via a second, non-overridden call.
+		expect(options.maintenanceTasks).toEqual([]);
+	});
+
+	it("the default (non-overridden) maintenance list names vehicle-reconcile at the configured interval", () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		const task = options.maintenanceTasks?.find((t) => t.name === "vehicle-reconcile");
+		expect(task).toBeDefined();
+		expect(task?.intervalMs).toBe(RECONCILE_INTERVAL_DEFAULT_MS);
+	});
+
+	it("vehicle-reconcile sweeps every package declared in piHome's own settings through the injected installer", async () => {
+		const piHome = fakePiHome(["npm:@danypops/probe", "npm:@danypops/other"]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		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 vehicle-reconcile once automatically at startup, not just on its own interval -- the actual self-heal", async () => {
+		const piHome = fakePiHome(["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 });
+
+		// The startup fire-and-forget is intentionally not awaited by daemonOptions itself
+		// (matching every other default maintenance task) -- give its microtasks a turn.
+		await new Promise((resolveTick) => setTimeout(resolveTick, 10));
+
+		expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe"]);
+	});
+});

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ServiceInstallDeps } from "@danypops/vehicle-server/service";
-import { detectVehicleDaemonService, resolveDaemonServiceSpec, restartUserService } from "../src/daemon/daemon-service.ts";
+import type { VehicleRegistrar, VehicleRegistrationOutcome } from "@danypops/armada";
+import { detectVehicleDaemonService, RealDaemonServiceInstaller, resolveDaemonServiceSpec } from "../src/daemon/daemon-service.ts";
 
 function fakePiHome(): string {
 	return mkdtempSync(join(tmpdir(), "packed-daemon-service-"));
@@ -26,7 +26,12 @@ function writeRawPackage(dir: string, pkg: Record<string, unknown>): void {
 describe("resolveDaemonServiceSpec", () => {
 	it("builds a ServiceSpec from a package's packed.daemonService manifest", () => {
 		const piHome = fakePiHome();
-		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
+		writePackage(piHome, "@danypops/web-spider-daemon", {
+			binPath: "dist/cli.js",
+			args: ["serve"],
+			restartOnFailure: true,
+			restartSec: 2,
+		});
 
 		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/web-spider-daemon");
 		expect(result).toEqual({
@@ -34,9 +39,13 @@ describe("resolveDaemonServiceSpec", () => {
 			spec: {
 				name: "web-spider-daemon",
 				displayName: undefined,
+				version: "1.0.0",
 				binPath: join(piHome, "npm", "node_modules", "@danypops/web-spider-daemon", "dist/cli.js"),
 				args: ["serve"],
-				descriptorPath: expect.stringContaining("web-spider-daemon") as unknown as string,
+				handlePath: expect.stringContaining("web-spider-daemon") as unknown as string,
+				workingDirectory: undefined,
+				restartOnFailure: true,
+				restartSec: 2,
 			},
 		});
 	});
@@ -92,9 +101,11 @@ describe("resolveDaemonServiceSpec", () => {
 			spec: {
 				name: "papyrus",
 				displayName: undefined,
+				version: "1.0.0",
 				binPath: join(dir, "src/cli.ts"),
 				args: ["serve"],
-				descriptorPath: expect.stringContaining("papyrus") as unknown as string,
+				handlePath: expect.stringContaining("papyrus") as unknown as string,
+				workingDirectory: undefined,
 			},
 		});
 	});
@@ -189,50 +200,92 @@ describe("resolveDaemonServiceSpec", () => {
 	});
 });
 
-function fakeInstallDeps(over: Partial<ServiceInstallDeps> = {}): ServiceInstallDeps {
-	return {
-		platform: "linux",
-		writeFile: () => {},
-		readFile: () => null,
-		removeFile: () => {},
-		fileExists: () => false,
-		mkdirp: () => {},
-		runCommand: () => ({ ok: true, output: "" }),
-		which: () => true,
-		...over,
-	};
+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("restartUserService", () => {
-	const spec = { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/home/user/.config/systemd/user/probe.service" };
+describe("RealDaemonServiceInstaller -- Armada registration through the in-process registrar", () => {
+	it("install() resolves the package's Vehicle spec and registers it through Armada directly", 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");
 
-	it("restarts via systemctl --user restart, using the descriptor's basename as the unit name", () => {
-		const calls: Array<{ command: string; args: string[] }> = [];
-		const deps = fakeInstallDeps({
-			runCommand: (command, args) => {
-				calls.push({ command, args });
-				return { ok: true, output: "" };
-			},
-		});
+		expect(outcome).toMatchObject({ ok: true, result: { installed: true }, spec: { name: "web-spider-daemon" } });
+		expect(registrar.registered.has("web-spider-daemon")).toBe(true);
+	});
+
+	it("install() reports a non-daemon package without ever touching the registrar", 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);
+	});
+
+	it("remove() unregisters the resolved Vehicle through Armada directly", 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 result = restartUserService(spec, deps);
-		expect(result).toEqual({ restarted: true });
-		expect(calls).toEqual([{ command: "systemctl", args: ["--user", "restart", "probe.service"] }]);
+		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);
 	});
 
-	it("reports a real systemctl failure without throwing", () => {
-		const deps = fakeInstallDeps({ runCommand: () => ({ ok: false, output: "Unit probe.service not loaded" }) });
+	it("restart() is a no-op, in-band, when Armada has no registration for this Vehicle yet", 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");
 
-		const result = restartUserService(spec, deps);
-		expect(result.restarted).toBe(false);
-		expect(result.reason).toContain("Unit probe.service not loaded");
+		expect(outcome).toMatchObject({ ok: true, restarted: false });
 	});
 
-	it("refuses on a platform with no supported restart mechanism, rather than guessing at one", () => {
-		const deps = fakeInstallDeps({ platform: "darwin" });
+	it("restart() re-registers (picking up a fresh on-disk version) once already registered", 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 });
+	});
+
+	it("surfaces a failed Armada registration's diagnostics in-band, never as a thrown error", 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 installer = new RealDaemonServiceInstaller(registrar);
+
+		const outcome = await installer.install(piHome, "npm:@danypops/web-spider-daemon");
 
-		const result = restartUserService(spec, deps);
-		expect(result.restarted).toBe(false);
-		expect(result.reason).toContain('platform "darwin"');
+		expect(outcome).toMatchObject({ ok: true, result: { installed: false, reason: "native failure" } });
 	});
 });

package/service/test/public-client.test.ts

@@ -81,7 +81,7 @@ describe("ensureClient (packed daemon auto-spawn-or-wait decision)", () => {
 				retryAttempts: 2,
 				retryDelayMs: 0,
 			}),
-		).rejects.toThrow(/supervised service is installed/);
+		).rejects.toThrow(/managed service is installed/);
 	});
 
 	it("fails with a plain timeout message, and did spawn, when no service is installed and nothing ever becomes reachable", async () => {

package/service/test/security.test.ts

@@ -26,6 +26,7 @@ describe("package permission policy", () => {
 			"install",
 			"install_service",
 			"restart_service",
+			"reconcile_services",
 			"setup.apply",
 			"update",
 			"update.self",

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

@@ -2,7 +2,8 @@ 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 { checkServiceUnitPaths, parseExecStartTokens, type ServiceDoctorDeps } from "../src/adoption/service-doctor.ts";
+import type { ServiceDoctorDeps } from "../src/adoption/service-doctor.ts";
+import { checkServiceUnitPaths } from "../src/adoption/service-doctor.ts";
 
 const roots: string[] = [];
 afterEach(() => {
@@ -12,131 +13,88 @@ afterEach(() => {
 function piHome(settingsPackages: unknown[]): string {
 	const root = mkdtempSync(join(tmpdir(), "packed-service-doctor-"));
 	roots.push(root);
-	writeFileSync(join(root, "settings.json"), JSON.stringify({ packages: settingsPackages }, null, 2));
+	writeFileSync(join(root, "settings.json"), JSON.stringify({ packages: settingsPackages }));
 	return root;
 }
 
-/** A real installed package on disk, shaped so detectVehicleDaemonService recognizes it as a daemon (own bin + a real dependency on @danypops/vehicle-server). */
 function installDaemonPackage(home: string, name: string): string {
 	const dir = join(home, "npm", "node_modules", name);
 	mkdirSync(dir, { recursive: true });
 	writeFileSync(
 		join(dir, "package.json"),
-		JSON.stringify({ name, version: "1.0.0", bin: { [name]: "cli.ts" }, dependencies: { "@danypops/vehicle-server": "^0.7.0" } }, null, 2),
+		JSON.stringify({
+			name,
+			version: "1.0.0",
+			packed: { daemonService: { binPath: "cli.ts", handleFilename: "handle.json" } },
+		}),
 	);
-	writeFileSync(join(dir, "cli.ts"), "// real entrypoint, present on disk\n");
+	writeFileSync(join(dir, "cli.ts"), "// entrypoint\n");
 	return dir;
 }
 
-function fakeDeps(unitText: string | null): ServiceDoctorDeps {
+function fakeDeps(status: unknown, fileExists = true): ServiceDoctorDeps {
 	return {
-		fileExists: () => unitText !== null,
-		readFile: () => unitText,
-		platform: "linux",
+		armadaCliPath: "/armada/cli.js",
+		fileExists: () => fileExists,
+		runCommand: () => ({ ok: true, output: JSON.stringify(status) }),
 	};
 }
 
-describe("parseExecStartTokens", () => {
-	it("parses shell-quoted tokens, unescaping the same characters shellQuote escapes", () => {
-		const unit = ['[Service]', 'ExecStart="/home/x/.bun/bin/bun" "/home/x/pkg/cli.ts" "serve"', ''].join("\n");
-		expect(parseExecStartTokens(unit)).toEqual(["/home/x/.bun/bin/bun", "/home/x/pkg/cli.ts", "serve"]);
-	});
-
-	it("unescapes a backslash-escaped quote/backslash/dollar/backtick inside a token", () => {
-		const unit = 'ExecStart="/bin/bun" "/weird \\"path\\" with \\\\ and \\$ and \\`"';
-		expect(parseExecStartTokens(unit)).toEqual(["/bin/bun", '/weird "path" with \\ and $ and `']);
-	});
-
-	it("returns undefined when there is no ExecStart line at all", () => {
-		expect(parseExecStartTokens("[Service]\nType=simple\n")).toBeUndefined();
-	});
-
-	it("returns undefined for an ExecStart line with no quoted tokens", () => {
-		expect(parseExecStartTokens("ExecStart=\n")).toBeUndefined();
-	});
-});
-
 describe("checkServiceUnitPaths", () => {
-	it("is silent on a non-linux platform without even reading installed packages", () => {
-		const home = piHome(["npm:whatever"]);
-		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => true, readFile: () => "", platform: "darwin" });
-		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
-	});
-
-	it("skips a package that never resolves to a Vehicle-shaped daemon", () => {
+	it("skips packages with no Armada-managed Vehicle", () => {
 		const home = piHome(["npm:not-a-daemon"]);
 		const dir = join(home, "npm", "node_modules", "not-a-daemon");
 		mkdirSync(dir, { recursive: true });
-		writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "not-a-daemon", version: "1.0.0" }, null, 2));
-		const report = checkServiceUnitPaths(home, undefined, fakeDeps("ExecStart=\"/bin/true\"\n"));
-		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
+		writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "not-a-daemon", version: "1.0.0" }));
+		expect(checkServiceUnitPaths(home, undefined, fakeDeps({ vehicles: [], diagnostics: [] }))).toEqual({
+			ok: true,
+			diagnostics: [],
+			checked: 0,
+		});
 	});
 
-	it("skips a daemon-shaped package with no systemd unit currently installed", () => {
-		const home = piHome(["npm:fakedaemon"]);
-		installDaemonPackage(home, "fakedaemon");
-		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => false, readFile: () => null, platform: "linux" });
-		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
-	});
-
-	it("reports clean when the installed unit's ExecStart paths all still exist", () => {
+	it("reports a clean Armada-managed executable", () => {
 		const home = piHome(["npm:fakedaemon"]);
 		const dir = installDaemonPackage(home, "fakedaemon");
-		const unit = `ExecStart="/bin/sh" "${join(dir, "cli.ts")}" "serve"\n`;
-		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
-		expect(report.checked).toBe(1);
-		expect(report.diagnostics).toEqual([]);
-		expect(report.ok).toBe(true);
-	});
-
-	it("flags SERVICE_EXEC_PATH_MISSING with the exact missing path when ExecStart references a deleted file", () => {
-		const home = piHome(["npm:fakedaemon"]);
-		installDaemonPackage(home, "fakedaemon");
-		const missing = join(tmpdir(), "packed-service-doctor-definitely-missing", "cli.ts");
-		const unit = `ExecStart="/bin/sh" "${missing}" "serve"\n`;
-		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
-		expect(report.ok).toBe(false);
-		expect(report.diagnostics).toEqual([
-			{
-				code: "SERVICE_EXEC_PATH_MISSING",
-				severity: "error",
-				package: "fakedaemon",
-				unitName: "fakedaemon",
-				message: expect.stringContaining(missing),
-			},
-		]);
+		const report = checkServiceUnitPaths(
+			home,
+			undefined,
+			fakeDeps({ vehicles: [{ name: "fakedaemon", executable: join(dir, "cli.ts") }], diagnostics: [] }),
+		);
+		expect(report).toEqual({ ok: true, diagnostics: [], checked: 1 });
 	});
 
-	it("never flags a bare subcommand argument (no path separator) as a missing path", () => {
+	it("reports a missing Armada-managed executable", () => {
 		const home = piHome(["npm:fakedaemon"]);
 		const dir = installDaemonPackage(home, "fakedaemon");
-		// "serve" alone would resolve relative to this process's own cwd and could
-		// spuriously not exist there -- must never be treated as a path to check.
-		const unit = `ExecStart="/bin/sh" "${join(dir, "cli.ts")}" "serve"\n`;
-		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
-		expect(report.diagnostics.some((d) => d.message.includes('"serve"'))).toBe(false);
+		const executable = join(dir, "cli.ts");
+		const report = checkServiceUnitPaths(
+			home,
+			undefined,
+			fakeDeps({ vehicles: [{ name: "fakedaemon", executable }], diagnostics: [] }, false),
+		);
+		expect(report).toEqual({
+			ok: false,
+			checked: 1,
+			diagnostics: [
+				{
+					code: "SERVICE_EXEC_PATH_MISSING",
+					severity: "error",
+					package: "fakedaemon",
+					unitName: "fakedaemon",
+					message: expect.stringContaining(executable),
+				},
+			],
+		});
 	});
 
-	it("degrades an unparseable ExecStart to a warning, never a false error", () => {
+	it("reports Armada status failure without guessing from native descriptors", () => {
 		const home = piHome(["npm:fakedaemon"]);
 		installDaemonPackage(home, "fakedaemon");
-		const report = checkServiceUnitPaths(home, undefined, fakeDeps("[Service]\nType=simple\n"));
-		expect(report.ok).toBe(true);
-		expect(report.diagnostics).toEqual([
-			{
-				code: "SERVICE_EXEC_UNPARSEABLE",
-				severity: "warning",
-				package: "fakedaemon",
-				unitName: "fakedaemon",
-				message: expect.any(String),
-			},
-		]);
-	});
-
-	it("treats a raced fileExists=true/readFile=null as transient, not a finding", () => {
-		const home = piHome(["npm:fakedaemon"]);
-		installDaemonPackage(home, "fakedaemon");
-		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => true, readFile: () => null, platform: "linux" });
-		expect(report).toEqual({ ok: true, diagnostics: [], checked: 1 });
+		const deps = fakeDeps({});
+		deps.runCommand = () => ({ ok: false, output: "armada unavailable" });
+		const report = checkServiceUnitPaths(home, undefined, deps);
+		expect(report.ok).toBe(false);
+		expect(report.diagnostics[0]?.code).toBe("SERVICE_STATUS_UNAVAILABLE");
 	});
 });