@danypops/pi-packed 0.19.12 → 0.20.1

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");
 	});
 });

package/service/test/service.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ServiceSpec } from "@danypops/vehicle-server/service";
@@ -62,30 +62,45 @@ class FakeDaemonServiceInstaller implements DaemonServiceInstaller {
 	gotPiHome = "";
 	gotSource = "";
 	resolveFailure: string | undefined;
+	notADaemon = false;
 	installFailure: string | undefined;
+	removeGotPiHome = "";
+	removeGotSource = "";
 	restartGotPiHome = "";
 	restartGotSource = "";
 	restartResolveFailure: string | undefined;
+	restartNotADaemon = false;
 	restartReason: string | undefined;
 	restarted = true;
-	spec: ServiceSpec = { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" };
-	install(
+	spec: ServiceSpec = {
+		name: "probe",
+		version: "1.0.0",
+		binPath: "/opt/probe/cli.js",
+		handlePath: "/tmp/probe.handle.json",
+	};
+	async install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: { installed: true } | { installed: false; reason: string }; spec: ServiceSpec } | { ok: false; reason: string } {
+	): Promise<{ ok: true; result: { installed: true } | { installed: false; reason: string }; spec: ServiceSpec } | { ok: false; reason: string }> {
 		this.gotPiHome = piHome;
 		this.gotSource = source;
-		if (this.resolveFailure) return { ok: false, reason: this.resolveFailure };
+		if (this.resolveFailure) return { ok: false, reason: this.resolveFailure, ...(this.notADaemon ? { notADaemon: true } : {}) };
 		if (this.installFailure) return { ok: true, result: { installed: false, reason: this.installFailure }, spec: this.spec };
 		return { ok: true, result: { installed: true }, spec: this.spec };
 	}
-	restart(
+	async remove(piHome: string, source: string): Promise<{ ok: true; result: { installed: true }; spec: ServiceSpec }> {
+		this.removeGotPiHome = piHome;
+		this.removeGotSource = source;
+		return { ok: true, result: { installed: true }, spec: this.spec };
+	}
+	async restart(
 		piHome: string,
 		source: string,
-	): { ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean } {
+	): Promise<{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		this.restartGotPiHome = piHome;
 		this.restartGotSource = source;
-		if (this.restartResolveFailure) return { ok: false, reason: this.restartResolveFailure };
+		if (this.restartResolveFailure)
+			return { ok: false, reason: this.restartResolveFailure, ...(this.restartNotADaemon ? { notADaemon: true } : {}) };
 		return { ok: true, restarted: this.restarted, reason: this.restartReason, spec: this.spec };
 	}
 }
@@ -224,7 +239,10 @@ describe("service app", () => {
 
 	it("POST /install accepts valid sources, reports failures in-band", async () => {
 		const inst = new FakeInstaller();
-		const app = createApp(deps({ inst }));
+		const service = new FakeDaemonServiceInstaller();
+		service.resolveFailure = "not a Vehicle";
+		service.notADaemon = true;
+		const app = createApp(deps({ inst, daemonServiceInstaller: service }));
 		for (const source of ["npm:foo", "npm:@scope/pkg@1.2.3", "git:github.com/u/r@v1", "https://github.com/u/r"]) {
 			const res = await app.fetch(
 				new Request("http://x/install", {
@@ -252,6 +270,23 @@ describe("service app", () => {
 		expect(body.output).toContain("npm ERR! 404");
 	});
 
+	it("POST /install configures an npm package's persistent Vehicle under the same approval", async () => {
+		const svc = new FakeDaemonServiceInstaller();
+		const piHome = mkdtempSync(join(tmpdir(), "packed-install-vehicle-"));
+		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
+		const response = await app.fetch(
+			new Request("http://x/install", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:probe", approved: true }),
+			}),
+		);
+		expect(response.status).toBe(200);
+		expect(await response.json()).toMatchObject({ ok: true, service: { name: "probe", binPath: "/opt/probe/cli.js" } });
+		expect(svc.gotPiHome).toBe(piHome);
+		expect(svc.gotSource).toBe("npm:probe");
+	});
+
 	it("POST /install-service rejects invalid sources and requires approval, matching /install's own guard", async () => {
 		const svc = new FakeDaemonServiceInstaller();
 		const app = createApp(deps({ daemonServiceInstaller: svc }));
@@ -307,7 +342,7 @@ describe("service app", () => {
 		const body = (await res.json()) as any;
 		expect(body.ok).toBe(true);
 		expect(body.output).toContain("probe");
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 		expect(svc.gotPiHome).toBe(piHome);
 		expect(svc.gotSource).toBe("npm:web-spider-daemon");
 	});
@@ -340,7 +375,7 @@ describe("service app", () => {
 		const body = (await installFailure.json()) as any;
 		expect(body.ok).toBe(false);
 		expect(body.output).toContain("no supported Linux init system");
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 	});
 
 	it("POST /restart-service rejects invalid sources and requires approval, matching /install-service's own guard", async () => {
@@ -385,7 +420,7 @@ describe("service app", () => {
 		const body = (await res.json()) as any;
 		expect(body.ok).toBe(true);
 		expect(body.restarted).toBe(true);
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 		expect(svc.restartGotPiHome).toBe(piHome);
 		expect(svc.restartGotSource).toBe("npm:web-spider-daemon");
 	});
@@ -424,7 +459,10 @@ describe("service app", () => {
 
 	it("POST /update validates, authorizes, and delegates one Pi package source", async () => {
 		const inst = new FakeInstaller();
-		const app = createApp(deps({ inst }));
+		const service = new FakeDaemonServiceInstaller();
+		service.restartResolveFailure = "not a Vehicle";
+		service.restartNotADaemon = true;
+		const app = createApp(deps({ inst, daemonServiceInstaller: service }));
 		const denied = await app.fetch(
 			new Request("http://x/update", {
 				method: "POST",
@@ -452,6 +490,22 @@ describe("service app", () => {
 		expect(inst.updated).toBe("npm:pi-lsp");
 	});
 
+	it("POST /update reconciles an installed Vehicle after a real package change", async () => {
+		const svc = new FakeDaemonServiceInstaller();
+		const piHome = mkdtempSync(join(tmpdir(), "packed-update-vehicle-"));
+		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
+		const response = await app.fetch(
+			new Request("http://x/update", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:probe", approved: true }),
+			}),
+		);
+		expect(await response.json()).toMatchObject({ ok: true, serviceReconciled: true });
+		expect(svc.restartGotPiHome).toBe(piHome);
+		expect(svc.restartGotSource).toBe("npm:probe");
+	});
+
 	it("POST /update reports an honest no-op instead of trusting pi's always-0-exit-code text", async () => {
 		const inst = new FakeInstaller();
 		inst.updateOutcome = { reloadRequired: false, alreadyUpToDate: true, pinned: true, previousVersion: "1.0.0", currentVersion: "1.0.0" };
@@ -527,6 +581,28 @@ describe("service app", () => {
 		expect(inst.removed).toBe("npm:pi-lsp");
 	});
 
+	it("POST /remove removes declared Vehicle state before deleting the package", async () => {
+		const piHome = mkdtempSync(join(tmpdir(), "packed-remove-vehicle-"));
+		const packageDir = join(piHome, "npm", "node_modules", "probe");
+		mkdirSync(packageDir, { recursive: true });
+		writeFileSync(
+			join(packageDir, "package.json"),
+			JSON.stringify({ name: "probe", version: "1.0.0", packed: { daemonService: { binPath: "cli.js" } } }),
+		);
+		const svc = new FakeDaemonServiceInstaller();
+		const app = createApp(deps({ piHome, daemonServiceInstaller: svc }));
+		const response = await app.fetch(
+			new Request("http://x/remove", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ name: "probe", approved: true }),
+			}),
+		);
+		expect((await response.json()) as unknown).toMatchObject({ ok: true, serviceRemoved: true });
+		expect(svc.removeGotPiHome).toBe(piHome);
+		expect(svc.removeGotSource).toBe("npm:probe");
+	});
+
 	it("GET /catalog serves the SQLite mirror", async () => {
 		const d = deps();
 		const db = openDb(dbPath(d.stateDir));