@danypops/pi-packed 0.19.12 → 0.20.0

package/service/src/daemon/vehicle-registration.ts

@@ -0,0 +1,173 @@
+/**
+ * packed's full 29-operation daemon surface projected onto the real Vehicle
+ * protocol. Every operation delegates to the exact same executeOperation()
+ * function /api/v1/ops already calls (one implementation, two projections --
+ * the same shape every other Vehicle-migrated daemon in this ecosystem
+ * uses) -- no behavior change, only a second real transport served
+ * alongside (not replacing) the existing /api/v1/ops route.
+ *
+ * Every operation's input is already a well-typed OperationInputs[Name] that
+ * executeOperation() validates and dispatches internally (throwing
+ * PackageOperationError on a bad shape/denied approval) -- there is no
+ * separate Vehicle-side schema to duplicate that logic, so both input and
+ * output use passthroughVehicleSchema and let executeOperation's own
+ * validation (already covered by service.test.ts) be the single source of
+ * truth for what's accepted.
+ *
+ * Effect classification is grounded in security.ts's own PACKAGE_OPERATIONS
+ * classification (read/maintenance/code-execution/settings-mutation/
+ * security-mutation) -- the codebase's own, already-deployed risk model --
+ * translated to Vehicle's effect vocabulary rather than independently
+ * re-derived, with two deliberate refinements documented at each entry
+ * where Vehicle's own taxonomy draws a finer distinction Packed's doesn't
+ * (package.remove -> destructive, since Vehicle has a dedicated category
+ * for irreversible deletion; restart_service/reconcile_services ->
+ * external-write rather than open-world, since restarting/reconciling an
+ * ALREADY-installed, already-vetted service introduces no new code, unlike
+ * install/install_service/update/setup.apply which can fetch and run
+ * arbitrary newly-published code).
+ *
+ * Approval/authorization is NOT reimplemented here: executeOperation()
+ * (and the route()-based operations it delegates to internally) already
+ * calls authorize()/assertPackagePermission() and throws
+ * PackageOperationError(status: 403) on a denied mutation -- reusing
+ * executeOperation() verbatim means this Vehicle surface automatically
+ * inherits the exact same approval gate, with zero duplicated policy logic
+ * to drift out of sync.
+ */
+
+import type { VehicleEffect, VehicleIdempotency } from "@danypops/vehicle-core";
+import { bindVehicleOperation, defineVehicleOperation, passthroughVehicleSchema, VehicleError } from "@danypops/vehicle-core";
+import type { VehicleRegistry } from "@danypops/vehicle-server";
+import { OPERATION_NAMES, type OperationInputs, type OperationName, type OperationOutputs } from "./service.ts";
+
+/** Thrown by executeOperation() with an HTTP-shaped .status; preserves /api/v1/ops's own status->meaning exactly instead of letting VehicleRegistry.invoke()'s catch-all flatten every failure into a generic internal/500 with the message discarded. */
+interface StatusCarryingError extends Error {
+	readonly status: number;
+}
+
+function hasStatus(error: unknown): error is StatusCarryingError {
+	return error instanceof Error && typeof (error as { status?: unknown }).status === "number";
+}
+
+async function withPackedErrorParity<T>(run: () => T | Promise<T>): Promise<T> {
+	try {
+		return await run();
+	} catch (error) {
+		if (error instanceof VehicleError) throw error;
+		if (hasStatus(error)) {
+			const category =
+				error.status === 403
+					? "authorization"
+					: error.status === 404
+						? "not_found"
+						: error.status === 400
+							? "validation"
+							: error.status >= 500
+								? "unavailable"
+								: "validation";
+			throw new VehicleError("operation-rejected", error.message, { category, cause: error });
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		throw new VehicleError("operation-rejected", message, { category: "validation", cause: error });
+	}
+}
+
+const OWNER = "packed";
+const LIMITS = { defaultTimeoutMs: 30_000, maxTimeoutMs: 120_000, maxRequestBytes: 65_536, maxResponseBytes: 4_194_304 };
+
+const READ: VehicleIdempotency = { mode: "safe" };
+const WRITE: VehicleIdempotency = { mode: "unsafe" };
+
+interface OperationMeta {
+	readonly description: string;
+	readonly effect: VehicleEffect;
+}
+
+/**
+ * One entry per OPERATION_NAMES member. See this file's own doc comment for
+ * the general translation rule (security.ts's PACKAGE_OPERATIONS
+ * classification) and its two deliberate refinements.
+ */
+const OPERATION_META: Record<OperationName, OperationMeta> = {
+	"package.search": { description: "Searches Pi packages on npm.", effect: "read" },
+	"package.info": { description: "Reads bounded metadata for one package.", effect: "read" },
+	"package.installed": { description: "Lists locally installed Pi packages.", effect: "read" },
+	"package.catalog": { description: "Reads the local SQLite catalog mirror.", effect: "read" },
+	"package.catalog.sync": {
+		description: "Refreshes the local catalog mirror from the Pi-package-tagged npm registry subset.",
+		effect: "external-write",
+	},
+	"package.index": { description: "Reads the locally built adoption-score index, if one exists.", effect: "read" },
+	"package.index.build": {
+		description: "Builds the adoption-score index by scoring catalog entries against the npm registry.",
+		effect: "external-write",
+	},
+	"package.updates": { description: "Reads the last background update-check snapshot.", effect: "read" },
+	"package.check": { description: "Runs static (and optionally smoke-test) quality checks against a local package path.", effect: "read" },
+	"package.pack": { description: "Verifies a local package path via npm pack.", effect: "read" },
+	"package.score": { description: "Computes an adoption-readiness score for a local path or registry package.", effect: "read" },
+	"setup.export": { description: "Exports the current Pi setup as a portable manifest.", effect: "local-write" },
+	"setup.update": { description: "Updates an existing setup manifest in place.", effect: "local-write" },
+	"setup.plan": { description: "Computes a setup manifest's install/update/remove plan without applying it.", effect: "read" },
+	"setup.apply": {
+		description: "Applies a setup manifest's plan -- can install, update, or remove packages.",
+		effect: "open-world",
+	},
+	"package.security.get": { description: "Reads this daemon's mutation-approval security settings.", effect: "read" },
+	"package.security.set": { description: "Writes this daemon's mutation-approval security settings.", effect: "local-write" },
+	"package.install": { description: "Installs a Pi package from an npm, git, or https source.", effect: "open-world" },
+	"package.install_service": {
+		description: "Installs a persistent supervised service for an already-installed daemon package.",
+		effect: "open-world",
+	},
+	"package.restart_service": {
+		description: "Restarts an already-installed package's persistent service -- no new code introduced.",
+		effect: "external-write",
+	},
+	"package.reconcile_services": {
+		description: "Reconciles every installed daemon package's persistent service against desired state.",
+		effect: "external-write",
+	},
+	"package.remove": { description: "Removes an installed Pi package. Irreversible.", effect: "destructive" },
+	"package.update": { description: "Updates a configured Pi package to its latest available version.", effect: "open-world" },
+	"resources.list": { description: "Lists global and project-scoped Pi resources (extensions, skills, prompts, themes).", effect: "read" },
+	"resources.toggle": { description: "Enables or disables one Pi resource in a settings file.", effect: "local-write" },
+	"pi.status": { description: "Reports the locally running Pi version against the latest published release.", effect: "read" },
+	"advisories.scan": { description: "Scans installed package versions against known advisories.", effect: "read" },
+	"doctor.run": { description: "Runs diagnostic health checks (service install drift, resource config, ...).", effect: "read" },
+	"package.updates.project": { description: "Checks for updates across every scope visible to one project.", effect: "read" },
+};
+
+/** Read effects need only packed:read; every other effect needs both (writes commonly also read first). */
+function permissionsFor(effect: VehicleEffect): readonly string[] {
+	return effect === "read" ? ["packed:read"] : ["packed:read", "packed:write"];
+}
+
+export function registerPackedVehicleOperations(
+	registry: VehicleRegistry,
+	executeOperation: <Name extends OperationName>(op: Name, input: OperationInputs[Name]) => Promise<OperationOutputs[Name]>,
+): void {
+	for (const name of OPERATION_NAMES) {
+		const meta = OPERATION_META[name];
+		const operation = defineVehicleOperation({
+			name,
+			version: 1,
+			description: meta.description,
+			input: passthroughVehicleSchema,
+			output: passthroughVehicleSchema,
+			permissions: permissionsFor(meta.effect),
+			effect: meta.effect,
+			idempotency: meta.effect === "read" ? READ : WRITE,
+			limits: LIMITS,
+		});
+		registry.register(
+			OWNER,
+			bindVehicleOperation(
+				operation,
+				() => async (context) =>
+					withPackedErrorParity(() => executeOperation(name, context.input as OperationInputs[typeof name])),
+			),
+		);
+	}
+}

package/service/src/public/client.ts

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
 import { readDaemonHandle, resolveDaemonPaths } from "@danypops/vehicle-server/paths";
-import { isServiceInstalled as vehicleIsServiceInstalled } from "@danypops/vehicle-server/service";
+import { createNodeServiceInstallDeps, isServiceInstalled as vehicleIsServiceInstalled } from "@danypops/vehicle-server/service";
 import type {
 	ExtensionOperationInputs,
 	ExtensionOperationName,
@@ -89,21 +89,9 @@ export function resolvePackedClientPaths(options: PackedPathOptions = {}): Packe
 	return { token: paths.token, handle: paths.handle, serviceDescriptor: paths.serviceDescriptor };
 }
 
-/** Real, file-existence-only check on Linux/macOS (Windows checks a
- * registry Run key instead) -- cheap, synchronous, no subprocess. */
-function isPackedServiceInstalled(serviceDescriptor: string): boolean {
-	return vehicleIsServiceInstalled(
-		{ name: SERVICE_NAME, binPath: "", descriptorPath: serviceDescriptor },
-		{
-			fileExists: existsSync,
-			writeFile: () => {},
-			readFile: () => null,
-			removeFile: () => {},
-			mkdirp: () => {},
-			runCommand: () => ({ ok: false, output: "" }),
-			which: () => false,
-		},
-	);
+/** Checks Armada's authoritative desired fleet rather than native descriptor files. */
+function isPackedServiceInstalled(): boolean {
+	return vehicleIsServiceInstalled(SERVICE_NAME, createNodeServiceInstallDeps());
 }
 
 export type FetchTransport = (request: Request) => Promise<Response>;
@@ -251,7 +239,7 @@ export async function ensureClient(deps: EnsureClientDeps): Promise<PackedClient
 	const waitedSeconds = (attempts * delayMs) / 1000;
 	throw new Error(
 		serviceInstalled
-			? `Packed daemon did not become ready within ${waitedSeconds} seconds, but a supervised service is installed -- check it directly (e.g. systemctl --user status pi-packed.service) rather than auto-spawning a second one`
+			? `Packed daemon did not become ready within ${waitedSeconds} seconds, but a managed service is installed -- run packed doctor rather than auto-spawning a second one`
 			: `Packed daemon did not become ready within ${waitedSeconds} seconds`,
 	);
 }
@@ -259,7 +247,7 @@ export async function ensureClient(deps: EnsureClientDeps): Promise<PackedClient
 export async function ensurePackedClient(paths = resolvePackedClientPaths(), transport: FetchTransport = fetch): Promise<PackedClient> {
 	return ensureClient({
 		connect: () => connectPackedClient(paths, transport),
-		isServiceInstalled: () => isPackedServiceInstalled(paths.serviceDescriptor),
+		isServiceInstalled: () => isPackedServiceInstalled(),
 		spawn: () => {
 			const override = process.env.PI_PACKED_BIN;
 			const command = override ?? process.env.PI_PACKED_BUN ?? "bun";

package/service/src/public/protocol.ts

@@ -92,7 +92,6 @@ export type PackageResources = { source: string; name: string; scope: "global" |
 export interface ServiceSpecSummary {
 	name: string;
 	binPath: string;
-	descriptorPath: string;
 }
 
 /** Mirrors service/src/pi/pi-version.ts's CURRENT_PI_PACKAGE_NAME

package/service/src/security/security.ts

@@ -23,6 +23,7 @@ export const PACKAGE_OPERATIONS = [
 	"install",
 	"install_service",
 	"restart_service",
+	"reconcile_services",
 	"setup.apply",
 	"update",
 	"update.self",
@@ -70,6 +71,7 @@ const CLASSIFICATIONS: Record<PackageOperation, PackageOperationClassification>
 	install: "code-execution",
 	install_service: "code-execution",
 	restart_service: "code-execution",
+	reconcile_services: "code-execution",
 	"setup.apply": "code-execution",
 	update: "code-execution",
 	"update.self": "code-execution",

package/service/src/shared/constants.ts

@@ -52,6 +52,7 @@ export const INDEX_OPERATION_TIMEOUT_MS = 10 * 60_000;
 export const WATCH_INTERVAL_DEFAULT_MS = 30 * 60_000; // updates diff cadence
 export const CATALOG_INTERVAL_DEFAULT_MS = 6 * 3_600_000; // full mirror TTL
 export const INDEX_INTERVAL_DEFAULT_MS = 6 * 3_600_000; // static index regeneration TTL, same cadence as the catalog mirror it reads from
+export const RECONCILE_INTERVAL_DEFAULT_MS = 30 * 60_000; // Vehicle-service drift sweep cadence -- catches an out-of-band npm install/update a running daemon never picked up
 export const IDLE_BUDGET_DEFAULT_MS = 10 * 60_000; // on-demand self-exit
 export const WATCHDOG_TICK_MS = 15_000;
 
@@ -69,5 +70,6 @@ export const ENV = {
 	WATCH_SECS: "PI_PACKED_WATCH_SECS",
 	CATALOG_SECS: "PI_PACKED_CATALOG_SECS",
 	INDEX_SECS: "PI_PACKED_INDEX_SECS",
+	RECONCILE_SECS: "PI_PACKED_RECONCILE_SECS",
 	IDLE_SECS: "PI_PACKED_IDLE_SECS",
 } as const;

package/service/test/cli.test.ts

@@ -79,29 +79,48 @@ class FakeDaemonServiceInstaller {
 	restartGotSource = "";
 	restartApproved = false;
 	restartFail = false;
-	async install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	reconcileGotApproved: boolean | undefined;
+	reconcileGotProjectRoot: string | undefined;
+	reconcileFail = false;
+	async install(source: string, approved?: boolean) {
 		this.gotSource = source;
 		this.approved = approved === true;
 		if (this.fail) throw new Error("install-service failed");
 		return {
 			output: `installed a persistent service for ${source}`,
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
 		};
 	}
-	async restart(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async restart(source: string, approved?: boolean) {
 		this.restartGotSource = source;
 		this.restartApproved = approved === true;
 		if (this.restartFail) throw new Error("restart-service failed");
 		return {
 			output: `restarted the persistent service for ${source}`,
 			restarted: true,
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
+		};
+	}
+	async reconcileAll(approved?: boolean, projectRoot?: string) {
+		this.reconcileGotApproved = approved;
+		this.reconcileGotProjectRoot = projectRoot;
+		if (this.reconcileFail) throw new Error("reconcile-services failed");
+		return {
+			ok: true,
+			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			skipped: 0,
+			failed: [],
 		};
 	}
 }
@@ -454,67 +473,15 @@ describe("CLI", () => {
 	it("install runs with stable human and JSON output", async () => {
 		const d = deps();
 		expect((await cliRun(["install", "npm:foo"], d)).code).toBe(1);
-		// --no-service scopes this test to the base install output; service
-		// auto-registration composition has its own dedicated tests below.
-		const human = await cliRun(["install", "npm:foo", "--approve", "--no-service"], d);
+		const human = await cliRun(["install", "npm:foo", "--approve"], d);
 		expect(human.code).toBe(0);
 		expect(human.out).toContain("Installed npm:foo");
 		expect((d.inst as FakeInstaller).approved).toBe(true);
-		const json = await cliRun(["install", "npm:foo", "--approve", "--no-service", "--json"], d);
+		const json = await cliRun(["install", "npm:foo", "--approve", "--json"], d);
 		expect(json.code).toBe(0);
 		expect(JSON.parse(json.out)).toEqual({ ok: true, source: "npm:foo", output: "Installed npm:foo" });
 	});
 
-	it("install auto-registers a detected daemon service under the same approval, silently for a non-daemon package", async () => {
-		const d = deps();
-		const human = await cliRun(["install", "npm:foo", "--approve"], d);
-		expect(human.code).toBe(0);
-		expect(human.out).toContain("Installed npm:foo");
-		expect(human.out).toContain("installed a persistent service for npm:foo");
-		expect((d.daemonService as FakeDaemonServiceInstaller).approved).toBe(true);
-		const json = await cliRun(["install", "npm:foo", "--approve", "--json"], d);
-		expect(json.code).toBe(0);
-		expect(JSON.parse(json.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Installed npm:foo",
-			serviceInstall: { detected: true, ok: true, output: "installed a persistent service for npm:foo" },
-		});
-
-		// notADaemon: the overwhelmingly common case (an ordinary, non-daemon package) stays silent.
-		const notADaemon = deps();
-		(notADaemon.daemonService as FakeDaemonServiceInstaller).install = async () => {
-			throw Object.assign(
-				new Error("foo does not declare a packed.daemonService manifest and no Vehicle-shaped daemon dependency was detected"),
-				{ notADaemon: true },
-			);
-		};
-		const silent = await cliRun(["install", "npm:foo", "--approve", "--json"], notADaemon);
-		expect(JSON.parse(silent.out)).toEqual({ ok: true, source: "npm:foo", output: "Installed npm:foo" });
-
-		// A genuine failure (a daemon was detected but registration itself failed) is reported
-		// without failing the install, which already succeeded.
-		const realFailure = deps();
-		(realFailure.daemonService as FakeDaemonServiceInstaller).fail = true;
-		const failed = await cliRun(["install", "npm:foo", "--approve", "--json"], realFailure);
-		expect(failed.code).toBe(0);
-		expect(JSON.parse(failed.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Installed npm:foo",
-			serviceInstall: { detected: true, ok: false, output: "install-service failed" },
-		});
-
-		// --no-service skips the attempt entirely -- the daemonService fake is never called.
-		const skipped = deps();
-		await cliRun(["install", "npm:foo", "--approve", "--no-service"], skipped);
-		expect((skipped.daemonService as FakeDaemonServiceInstaller).gotSource).toBe("");
-
-		// A non-npm source never attempts service detection -- daemon-service resolution only supports npm: today.
-		const gitSource = deps();
-		await cliRun(["install", "git:github.com/u/r@v1", "--approve"], gitSource);
-		expect((gitSource.daemonService as FakeDaemonServiceInstaller).gotSource).toBe("");
-	});
 
 	it("install-service validates source", async () => {
 		const d = deps();
@@ -536,7 +503,12 @@ describe("CLI", () => {
 			ok: true,
 			source: "npm:foo",
 			output: "installed a persistent service for npm:foo",
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
 		});
 	});
 
@@ -555,33 +527,52 @@ describe("CLI", () => {
 		expect(out).toContain("requires a running packed daemon");
 	});
 
-	it("update delegates one configured source with stable output and approval", async () => {
+	it("reconcile-services requires approval, then sweeps every installed package with stable human and JSON output", async () => {
 		const d = deps();
-		expect((await cliRun(["update", "npm:foo"], d)).code).toBe(1);
-		// --no-service scopes this test to the base update output; service restart
-		// composition has its own dedicated test below, mirroring install's own split.
-		const human = await cliRun(["update", "npm:foo", "--approve", "--no-service"], d);
-		expect(human.out).toContain("Updated npm:foo");
-		expect((d.inst as FakeInstaller).updated).toBe("npm:foo");
-		expect((d.inst as FakeInstaller).approved).toBe(true);
-		const json = await cliRun(["update", "npm:foo", "--approve", "--no-service", "--json"], d);
+		expect((await cliRun(["reconcile-services"], d)).code).toBe(1);
+		const human = await cliRun(["reconcile-services", "--approve"], d);
+		expect(human.code).toBe(0);
+		expect(human.out).toContain("reconciled 1 Vehicle(s)");
+		expect((d.daemonService as FakeDaemonServiceInstaller).reconcileGotApproved).toBe(true);
+		const json = await cliRun(["reconcile-services", "--approve", "--json"], d);
+		expect(json.code).toBe(0);
 		expect(JSON.parse(json.out)).toEqual({
 			ok: true,
-			source: "npm:foo",
-			output: "Updated npm:foo",
-			reloadRequired: true,
-			alreadyUpToDate: false,
-			pinned: false,
+			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			skipped: 0,
+			failed: [],
 		});
 	});
 
-	it("update restarts a registered daemon service after a real change, silently for a non-daemon package", async () => {
+	it("reconcile-services threads --project through to the sweep", async () => {
+		const d = deps();
+		await cliRun(["reconcile-services", "--approve", "--project", "/repo"], d);
+		expect((d.daemonService as FakeDaemonServiceInstaller).reconcileGotProjectRoot).toBe("/repo");
+	});
+
+	it("reconcile-services reports a sweep failure in-band with exit code 1", async () => {
+		const d = deps();
+		(d.daemonService as FakeDaemonServiceInstaller).reconcileFail = true;
+		const { code, out } = await cliRun(["reconcile-services", "--approve"], d);
+		expect(code).toBe(1);
+		expect(out).toContain("reconcile-services failed");
+	});
+
+	it("reconcile-services fails closed without a running daemon", async () => {
+		const d = deps({ daemonService: undefined });
+		const { code, out } = await cliRun(["reconcile-services", "--approve"], d);
+		expect(code).toBe(1);
+		expect(out).toContain("requires a running packed daemon");
+	});
+
+	it("update delegates one configured source with stable output and approval", async () => {
 		const d = deps();
+		expect((await cliRun(["update", "npm:foo"], d)).code).toBe(1);
 		const human = await cliRun(["update", "npm:foo", "--approve"], d);
-		expect(human.code).toBe(0);
 		expect(human.out).toContain("Updated npm:foo");
-		expect(human.out).toContain("restarted the persistent service for npm:foo");
-		expect((d.daemonService as FakeDaemonServiceInstaller).restartApproved).toBe(true);
+		expect((d.inst as FakeInstaller).updated).toBe("npm:foo");
+		expect((d.inst as FakeInstaller).approved).toBe(true);
 		const json = await cliRun(["update", "npm:foo", "--approve", "--json"], d);
 		expect(JSON.parse(json.out)).toEqual({
 			ok: true,
@@ -590,47 +581,10 @@ describe("CLI", () => {
 			reloadRequired: true,
 			alreadyUpToDate: false,
 			pinned: false,
-			serviceRestart: { detected: true, ok: true, output: "restarted the persistent service for npm:foo" },
 		});
-
-		// notADaemon: the overwhelmingly common case (an ordinary, non-daemon package) stays silent.
-		const notADaemon = deps();
-		(notADaemon.daemonService as FakeDaemonServiceInstaller).restart = async () => {
-			throw Object.assign(
-				new Error("foo does not declare a packed.daemonService manifest and no Vehicle-shaped daemon dependency was detected"),
-				{ notADaemon: true },
-			);
-		};
-		const silent = await cliRun(["update", "npm:foo", "--approve", "--json"], notADaemon);
-		expect(JSON.parse(silent.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Updated npm:foo",
-			reloadRequired: true,
-			alreadyUpToDate: false,
-			pinned: false,
-		});
-
-		// A genuine failure (a daemon was detected but restarting it failed) is reported
-		// without failing the update, which already succeeded.
-		const realFailure = deps();
-		(realFailure.daemonService as FakeDaemonServiceInstaller).restartFail = true;
-		const failed = await cliRun(["update", "npm:foo", "--approve", "--json"], realFailure);
-		expect(failed.code).toBe(0);
-		const failedBody = JSON.parse(failed.out);
-		expect(failedBody.serviceRestart).toEqual({ detected: true, ok: false, output: "restart-service failed" });
-
-		// --no-service skips the attempt entirely -- the daemonService fake is never called.
-		const skipped = deps();
-		await cliRun(["update", "npm:foo", "--approve", "--no-service"], skipped);
-		expect((skipped.daemonService as FakeDaemonServiceInstaller).restartGotSource).toBe("");
-
-		// A non-npm source never attempts service detection -- daemon-service resolution only supports npm: today.
-		const gitSource = deps({ inst: new FakeInstaller() });
-		await cliRun(["update", "git:github.com/u/r@v1", "--approve"], gitSource);
-		expect((gitSource.daemonService as FakeDaemonServiceInstaller).restartGotSource).toBe("");
 	});
 
+
 	it("update --self requires approval under the guarded default, same as every other mutation", async () => {
 		const d = deps({
 			selfUpdater: {
@@ -851,19 +805,36 @@ describe("CLI", () => {
 			},
 			async installService(source) {
 				calls.push(`installService:${source}`);
-				return { output: source, spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" } };
+				return {
+					output: source,
+					spec: {
+						name: "probe",
+						version: "1.0.0",
+						binPath: "/opt/probe/cli.js",
+						handlePath: "/tmp/probe.handle.json",
+					},
+				};
 			},
 			async restartService(source) {
 				calls.push(`restartService:${source}`);
 				return {
 					output: source,
 					restarted: true,
-					spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+					spec: {
+						name: "probe",
+						version: "1.0.0",
+						binPath: "/opt/probe/cli.js",
+						handlePath: "/tmp/probe.handle.json",
+					},
 				};
 			},
 			async remove(name) {
 				return name;
 			},
+			async reconcileServices(approved, projectRoot) {
+				calls.push(`reconcileServices:${approved}:${projectRoot}`);
+				return { ok: true, output: "reconciled 0 Vehicle(s), skipped 0 non-daemon package(s)", reconciled: [], skipped: 0, failed: [] };
+			},
 			async update(source) {
 				return { output: source, reloadRequired: false, alreadyUpToDate: true, pinned: false };
 			},
@@ -1050,7 +1021,7 @@ describe("CLI", () => {
 			const d = deps({ piHome });
 
 			const clean = await cliRun(["doctor", "--json"], d);
-			expect(clean.code).toBe(0);
+			expect(clean.code, clean.out).toBe(0);
 			expect(JSON.parse(clean.out)).toMatchObject({ ok: true, conflicts: [] });
 
 			const withProject = await cliRun(["doctor", "--project", projectRoot, "--json"], d);
@@ -1105,16 +1076,27 @@ describe("daemon client", () => {
 			reg: new FakeRegistry([{ name: "pi-lsp", version: "0.3.0" }]),
 			inst: daemonInstaller,
 			daemonServiceInstaller: {
-				install: () => ({
-					ok: true,
-					result: { installed: true },
-					spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
-				}),
-				restart: () => ({
-					ok: true,
-					restarted: true,
-					spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
-				}),
+				async install() {
+					return {
+						ok: true,
+						result: { installed: true },
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
+				async remove() {
+					return {
+						ok: true,
+						result: { installed: true },
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
+				async restart() {
+					return {
+						ok: true,
+						restarted: true,
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
 			},
 			token: daemonToken,
 			stateDir: daemonDir,
@@ -1244,11 +1226,11 @@ describe("daemon client", () => {
 		expect((await client.setupApply(`${checkRoot}/pi-setup.json`, true)).ok).toBe(true);
 		expect(await client.security()).toEqual({ mutationApproval: "always" });
 		await expect(client.install("npm:pi-lsp")).rejects.toThrow("approval required");
-		expect(await client.install("npm:pi-lsp", true)).toBe("Installed npm:pi-lsp");
+		expect(await client.install("npm:pi-lsp", true)).toBe("Installed npm:pi-lsp\ninstalled persistent Vehicle pi-lsp");
 		await expect(client.installService("npm:pi-lsp")).rejects.toThrow("approval required");
 		expect(await client.installService("npm:pi-lsp", true)).toEqual({
 			output: "installed a persistent service for pi-lsp",
-			spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
+			spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js" },
 		});
 		expect(await client.remove("pi-lsp", true)).toBe("Removed npm:pi-lsp");
 		expect(await client.piStatus()).toEqual({ current: "0.82.1", latest: "0.83.0", upToDate: false });
@@ -1261,7 +1243,9 @@ describe("daemon client", () => {
 			currentVersion: undefined,
 		});
 		const installer = new PackageDaemonInstaller(client);
-		expect(await installer.install("npm:pi-lsp@1.0.0", { approved: true })).toBe("Installed npm:pi-lsp@1.0.0");
+		expect(await installer.install("npm:pi-lsp@1.0.0", { approved: true })).toBe(
+			"Installed npm:pi-lsp@1.0.0\ninstalled persistent Vehicle pi-lsp",
+		);
 		expect(await installer.remove("npm:pi-lsp", { approved: true })).toBe("Removed npm:pi-lsp");
 		expect((await installer.update("npm:pi-lsp", { approved: true })).output).toBe("Updated npm:pi-lsp");
 		expect(await client.setMutationApproval("never", true)).toEqual({ mutationApproval: "never" });

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

@@ -142,6 +142,7 @@ describe("daemon-kit migration", () => {
 			"package.install",
 			"package.install_service",
 			"package.restart_service",
+			"package.reconcile_services",
 			"package.remove",
 			"package.update",
 			"resources.list",