@danypops/pi-packed 0.19.11 → 0.20.0

package/service/src/daemon/client.ts

@@ -25,6 +25,7 @@ import type { OperationInputs, OperationName, OperationOutputs } from "./service
 
 export type FetchTransport = (request: Request) => Promise<Response>;
 type RpcClient = AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>;
+type ServiceSummary = { name: string; binPath: string };
 
 export interface PackageDaemonPort {
 	search(query: string, limit: number, offline?: boolean): Promise<{ query: string; total: number; results: SearchPage["results"] }>;
@@ -46,14 +47,9 @@ export interface PackageDaemonPort {
 	security(): Promise<SecuritySettings>;
 	setMutationApproval(value: MutationApproval, approved?: boolean): Promise<SecuritySettings>;
 	install(source: string, approved?: boolean): Promise<string>;
-	installService(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }>;
-	restartService(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+	installService(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }>;
+	restartService(source: string, approved?: boolean): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }>;
+	reconcileServices(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]>;
 	remove(name: string, approved?: boolean): Promise<string>;
 	update(source: string, approved?: boolean): Promise<UpdateOutcome>;
 	piStatus(): Promise<PiVersionReport>;
@@ -230,10 +226,7 @@ export class PackageDaemonClient implements PackageDaemonPort {
 		return result.output;
 	}
 
-	async installService(
-		source: string,
-		approved = false,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async installService(source: string, approved = false): Promise<{ output: string; spec?: ServiceSummary }> {
 		const result = await this.call("package.install_service", { source, approved });
 		if (!result.ok)
 			throw new PackageDaemonError(
@@ -248,7 +241,7 @@ export class PackageDaemonClient implements PackageDaemonPort {
 	async restartService(
 		source: string,
 		approved = false,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }> {
 		const result = await this.call("package.restart_service", { source, approved });
 		if (!result.ok)
 			throw new PackageDaemonError(
@@ -260,6 +253,12 @@ export class PackageDaemonClient implements PackageDaemonPort {
 		return { output: result.output, restarted: result.restarted, spec: result.spec };
 	}
 
+	async reconcileServices(approved = false, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]> {
+		const result = await this.call("package.reconcile_services", { approved, projectRoot });
+		if (!result.ok) throw new PackageDaemonError(result.output || "failed to reconcile Vehicle services", "package.reconcile_services");
+		return result;
+	}
+
 	async remove(name: string, approved = false): Promise<string> {
 		const result = await this.call("package.remove", { name, approved });
 		if (!result.ok) throw new PackageDaemonError(result.output || `failed to remove ${name}`, "package.remove");
@@ -319,14 +318,9 @@ export class DaemonBackedInstaller implements Installer {
 }
 
 export interface DaemonServiceInstallerPort {
-	install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }>;
-	restart(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+	install(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }>;
+	restart(source: string, approved?: boolean): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }>;
+	reconcileAll(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]>;
 }
 
 export class DaemonBackedDaemonServiceInstaller implements DaemonServiceInstallerPort {
@@ -334,15 +328,15 @@ export class DaemonBackedDaemonServiceInstaller implements DaemonServiceInstalle
 	async restart(
 		source: string,
 		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }> {
 		return (await connectPackageDaemon(this.paths)).restartService(source, approved);
 	}
-	async install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async install(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }> {
 		return (await connectPackageDaemon(this.paths)).installService(source, approved);
 	}
+	async reconcileAll(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]> {
+		return (await connectPackageDaemon(this.paths)).reconcileServices(approved, projectRoot);
+	}
 }
 
 export class DaemonRegistry implements Registry {

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

@@ -26,25 +26,30 @@
  * on disk instead of asking for one more declaration.
  */
 import { readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { join } from "node:path";
+import { createVehicleRegistrar, type VehicleRegistrar } from "@danypops/armada";
 import { resolveDaemonPaths } from "@danypops/vehicle-server/paths";
 import {
-	createNodeServiceInstallDeps,
-	installUserService,
-	isServiceInstalled,
-	type ServiceInstallDeps,
+	isVehicleServiceRegistered,
+	registerVehicleService,
 	type ServiceInstallResult,
 	type ServiceSpec,
+	unregisterVehicleService,
 } from "@danypops/vehicle-server/service";
-import { npmPackageName } from "../packages/installed.ts";
+import { npmPackageName, readInstalledPackagesAcrossScopes } from "../packages/installed.ts";
 
 export interface DaemonServiceManifest {
 	/** Relative to the installed package's own root directory. */
 	binPath: string;
 	args?: string[];
-	/** Defaults to the bare npm package name (scope stripped). Used for the state-directory/unit name, matching each package's own service-install convention (e.g. web-spider.service). */
+	/** Defaults to the bare npm package name (scope stripped). */
 	name?: string;
 	displayName?: string;
+	/** Runtime handle filename inside the Vehicle's XDG runtime directory. */
+	handleFilename?: string;
+	workingDirectory?: string;
+	restartOnFailure?: boolean;
+	restartSec?: number;
 }
 
 export type ResolveDaemonServiceResult =
@@ -63,10 +68,16 @@ interface ResolvedDaemonEntrypoint {
 	args?: string[];
 	name: string;
 	displayName?: string;
+	handleFilename?: string;
+	workingDirectory?: string;
+	restartOnFailure?: boolean;
+	restartSec?: number;
+	version: string;
 }
 
 interface InstalledPackageJson {
 	name?: string;
+	version?: string;
 	bin?: string | Record<string, string>;
 	dependencies?: Record<string, string>;
 	packed?: { daemonService?: DaemonServiceManifest };
@@ -122,8 +133,8 @@ export function detectVehicleDaemonService(
 	if (!own) return undefined;
 
 	const ownBin = firstBinPath(own);
-	if (ownBin && dependsOnVehicle(own)) {
-		return { binPath: join(packageDir, ownBin), args: ["serve"], name: unscopedName(own.name ?? fallbackName) };
+	if (ownBin && dependsOnVehicle(own) && own.version) {
+		return { binPath: join(packageDir, ownBin), args: ["serve"], name: unscopedName(own.name ?? fallbackName), version: own.version };
 	}
 
 	for (const depName of Object.keys(own.dependencies ?? {})) {
@@ -135,8 +146,8 @@ export function detectVehicleDaemonService(
 			const dep = readPackageJson(depDir);
 			if (!dep) continue;
 			const depBin = firstBinPath(dep);
-			if (depBin && dependsOnVehicle(dep)) {
-				return { binPath: join(depDir, depBin), args: ["serve"], name: unscopedName(dep.name ?? depName) };
+			if (depBin && dependsOnVehicle(dep) && dep.version) {
+				return { binPath: join(depDir, depBin), args: ["serve"], name: unscopedName(dep.name ?? depName), version: dep.version };
 			}
 		}
 	}
@@ -146,20 +157,21 @@ export function detectVehicleDaemonService(
 function buildSpec(entry: ResolvedDaemonEntrypoint): ServiceSpec {
 	const paths = resolveDaemonPaths({
 		stateDirectoryName: entry.name,
-		// Only serviceDescriptor is used below; these three exist purely to
-		// satisfy resolveDaemonPaths()'s shared shape for a package this
-		// module never opens the db/token/handle of.
 		databaseFilename: "unused.db",
 		tokenFilename: "unused-token",
-		handleFilename: "unused-handle.json",
+		handleFilename: entry.handleFilename ?? "handle.json",
 		systemdUnitName: `${entry.name}.service`,
 	});
 	return {
 		name: entry.name,
 		displayName: entry.displayName,
+		version: entry.version,
 		binPath: entry.binPath,
 		args: entry.args,
-		descriptorPath: paths.serviceDescriptor,
+		handlePath: paths.handle,
+		workingDirectory: entry.workingDirectory,
+		...(entry.restartOnFailure === undefined ? {} : { restartOnFailure: entry.restartOnFailure }),
+		...(entry.restartSec === undefined ? {} : { restartSec: entry.restartSec }),
 	};
 }
 
@@ -187,6 +199,11 @@ export function resolveDaemonServiceSpec(piHome: string, source: string): Resolv
 				args: manifest.args,
 				name: manifest.name ?? unscopedName(packageName),
 				displayName: manifest.displayName,
+				handleFilename: manifest.handleFilename,
+				workingDirectory: manifest.workingDirectory,
+				restartOnFailure: manifest.restartOnFailure,
+				restartSec: manifest.restartSec,
+				version: pkg.version ?? "0.0.0",
 			}),
 		};
 	}
@@ -201,49 +218,122 @@ export function resolveDaemonServiceSpec(piHome: string, source: string): Resolv
 	};
 }
 
+export interface ReconcileAllResult {
+	reconciled: Array<{ packageName: string; vehicleName: string; installed: boolean; reason?: string }>;
+	skipped: number;
+	failed: Array<{ packageName: string; reason: string }>;
+}
+
+/** Matches readPackageDeclarations' own bound -- a reconcile-all sweep never processes an unbounded package list. */
+const MAX_RECONCILE_PACKAGES = 500;
+
+/**
+ * Sweeps every installed Packed package (global scope, plus a project's own
+ * pins when projectRoot is given), resolves each to a Vehicle-shaped daemon
+ * exactly as install()/restart() already do per-package, and upserts +
+ * reconciles it through Armada. This is what makes Armada authoritative for
+ * every Vehicle Packed knows about, not just the one source a single
+ * install/update call happened to touch -- it also self-heals a Vehicle
+ * whose daemon package version bumped as someone else's transitive
+ * dependency, and a Vehicle a prior Packed version never registered at all.
+ * Idempotent and safe to call unconditionally: a non-daemon package costs
+ * one or two file reads (see resolveDaemonServiceSpec) and never reaches
+ * Armada. Two packages that resolve to the same Vehicle (a Pi extension and
+ * its own daemon dependency, both separately Packed-tracked) reconcile it
+ * once, not twice.
+ */
+export async function reconcileAllDaemonServices(
+	piHome: string,
+	projectRoot: string | undefined,
+	installer: Pick<DaemonServiceInstaller, "install">,
+): Promise<ReconcileAllResult> {
+	const packages = readInstalledPackagesAcrossScopes(piHome, projectRoot).slice(0, MAX_RECONCILE_PACKAGES);
+	const reconciled: ReconcileAllResult["reconciled"] = [];
+	const failed: ReconcileAllResult["failed"] = [];
+	const seen = new Set<string>();
+	let skipped = 0;
+	for (const pkg of packages) {
+		const resolved = await installer.install(piHome, `npm:${pkg.name}`);
+		if (!resolved.ok) {
+			if (resolved.notADaemon) {
+				skipped++;
+				continue;
+			}
+			failed.push({ packageName: pkg.name, reason: resolved.reason });
+			continue;
+		}
+		if (seen.has(resolved.spec.name)) continue;
+		seen.add(resolved.spec.name);
+		reconciled.push({
+			packageName: pkg.name,
+			vehicleName: resolved.spec.name,
+			installed: resolved.result.installed,
+			...(resolved.result.installed ? {} : { reason: resolved.result.reason }),
+		});
+	}
+	return { reconciled, skipped, failed };
+}
+
 export interface DaemonServiceInstaller {
 	install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean };
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
+	remove(
+		piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
 	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 }>;
 }
 
+/**
+ * Calls Armada's own VehicleRegistrar directly (in-process), rather than
+ * shelling out to its CLI as a subprocess -- the same registration logic
+ * `@danypops/armada` exposes to any other library consumer, not a Packed-
+ * specific reimplementation. One registrar per instance so its manifest
+ * path/native controller are resolved once, not on every call.
+ */
 export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
-	install(
+	constructor(private readonly registrar: VehicleRegistrar = createVehicleRegistrar()) {}
+
+	async install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean } {
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
-		const result = installUserService(resolved.spec, createNodeServiceInstallDeps());
+		const result = await registerVehicleService(resolved.spec, this.registrar);
 		return { ok: true, result, spec: resolved.spec };
 	}
 
-	restart(
+	async remove(
+		piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		const resolved = resolveDaemonServiceSpec(piHome, source);
+		if (!resolved.ok) return resolved;
+		const result = await unregisterVehicleService(resolved.spec.name, this.registrar);
+		return { ok: true, result, spec: resolved.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 }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
-		const deps = createNodeServiceInstallDeps();
-		if (!isServiceInstalled(resolved.spec, deps)) {
+		if (!(await isVehicleServiceRegistered(resolved.spec.name, this.registrar))) {
 			return { ok: true, restarted: false, reason: `no persistent service is registered for ${resolved.spec.name}`, spec: resolved.spec };
 		}
-		const result = restartUserService(resolved.spec, deps);
-		return { ok: true, restarted: result.restarted, reason: result.reason, spec: resolved.spec };
+		const result = await registerVehicleService(resolved.spec, this.registrar);
+		return {
+			ok: true,
+			restarted: result.installed,
+			...(result.installed ? {} : { reason: result.reason }),
+			spec: resolved.spec,
+		};
 	}
 }
-
-/** Linux/systemd only, matching installUserService's platform coverage order -- macOS/Windows report unsupported rather than guessing at launchctl/reg.exe restart equivalents this module doesn't implement. */
-export function restartUserService(spec: ServiceSpec, deps: ServiceInstallDeps): { restarted: boolean; reason?: string } {
-	const platform = deps.platform ?? process.platform;
-	if (platform !== "linux")
-		return { restarted: false, reason: `restart is not supported on platform "${platform}" yet -- restart ${spec.name} manually` };
-	const result = deps.runCommand("systemctl", ["--user", "restart", basename(spec.descriptorPath)]);
-	if (!result.ok) return { restarted: false, reason: `systemctl --user restart failed: ${result.output}` };
-	return { restarted: true };
-}

package/service/src/daemon/daemon.ts

@@ -7,6 +7,7 @@ import {
 	startDaemon,
 } from "@danypops/vehicle-server/daemon";
 import { ensureAuthToken } from "@danypops/vehicle-server/paths";
+import { type DaemonServiceInstaller, RealDaemonServiceInstaller, reconcileAllDaemonServices } from "./daemon-service.ts";
 import { generateIndex, indexPath, indexStatus } from "../index/build-index.ts";
 import { catalogStatus, syncCatalog } from "../packages/catalog.ts";
 import { latestVersion, openDb } from "../packages/db.ts";
@@ -19,6 +20,7 @@ import {
 	ENV,
 	IDLE_BUDGET_DEFAULT_MS,
 	INDEX_INTERVAL_DEFAULT_MS,
+	RECONCILE_INTERVAL_DEFAULT_MS,
 	WATCH_INTERVAL_DEFAULT_MS,
 	WATCHDOG_TICK_MS,
 } from "../shared/constants.ts";
@@ -35,12 +37,13 @@ export interface StartPackedDaemonOptions {
 	reg?: Registry;
 	inst?: Installer;
 	piHome?: string;
+	daemonServiceInstaller?: DaemonServiceInstaller;
 	maintenanceTasks?: MaintenanceTask[];
 	idleBudgetMs?: number;
 	migrateLegacy?: boolean;
 }
 
-function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
+export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 	const paths = options.paths ?? resolvePackedPaths();
 	if (options.migrateLegacy ?? options.paths === undefined) migrateLegacyPackedState(paths, legacyPackedStateDirectory());
 	const token = ensureAuthToken(paths.token, "Packed");
@@ -48,6 +51,7 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 	const inst = options.inst ?? new ExecInstaller();
 	const piHome = options.piHome ?? defaultPiHome();
 	const database = openDb(paths.database);
+	const daemonServiceInstaller = options.daemonServiceInstaller ?? new RealDaemonServiceInstaller();
 	const configuredMaintenanceTasks = options.maintenanceTasks ?? [
 		{
 			name: "package-update-check",
@@ -75,6 +79,24 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 				if (indexStatus(indexPath(dataDirectory), ttlMs).stale) await generateIndex(reg, dataDirectory, indexPath(dataDirectory));
 			},
 		},
+		{
+			// Self-heals a Vehicle a running daemon never picked up -- an out-of-band
+			// npm install/update, or a transitive dependency bump that resolveDaemonServiceSpec
+			// would only otherwise re-check the next time /install or /restart-service ran
+			// for that exact package.
+			name: "vehicle-reconcile",
+			intervalMs: envMs(ENV.RECONCILE_SECS, RECONCILE_INTERVAL_DEFAULT_MS),
+			run: async () => {
+				const result = await reconcileAllDaemonServices(piHome, undefined, daemonServiceInstaller);
+				if (result.failed.length > 0) {
+					logger.warn("vehicle-reconcile completed with failures", {
+						reconciled: result.reconciled.length,
+						skipped: result.skipped,
+						failed: result.failed.length,
+					});
+				}
+			},
+		},
 	];
 	const maintenanceTasks = configuredMaintenanceTasks.filter((task) => task.intervalMs > 0);
 
@@ -93,7 +115,7 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 		maintenanceTasks,
 		idleBudgetMs: options.idleBudgetMs ?? envMs(ENV.IDLE_SECS, IDLE_BUDGET_DEFAULT_MS),
 		idleTickMs: WATCHDOG_TICK_MS,
-		buildApp: () => createApp({ reg, inst, token, stateDir: paths.stateDirectory, dataDir: dirname(paths.database), piHome }),
+		buildApp: () => createApp({ reg, inst, token, stateDir: paths.stateDirectory, dataDir: dirname(paths.database), piHome, daemonServiceInstaller }),
 		onShutdown: () => database.close(),
 	};
 }

package/service/src/daemon/service.ts

@@ -5,8 +5,11 @@
  */
 
 import { existsSync as fileExistsSync } from "node:fs";
+import { VehicleRegistry } from "@danypops/vehicle-server";
+import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
 import { errorResponse, healthResponse, jsonResponse, readyResponse, requireBearerToken } from "@danypops/vehicle-server/rpc-http";
 import type { ServiceSpec } from "@danypops/vehicle-server/service";
+import { registerPackedVehicleOperations } from "./vehicle-registration.ts";
 import { type AdvisoryReport, resolveInstalledVersions, scanInstalledPackages } from "../adoption/advisories.ts";
 import { type CheckReport, type PackageChecker, StaticPackageChecker } from "../adoption/check.ts";
 import { type DoctorReport, runDoctor } from "../adoption/doctor.ts";
@@ -42,7 +45,7 @@ import { SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT } from "../shared/constants.ts";
 import { createLogger } from "../shared/log.ts";
 import { VERSION } from "../shared/version.ts";
 import { formatCleanupSummary, runCleanup } from "./cleanup.ts";
-import { type DaemonServiceInstaller, RealDaemonServiceInstaller } from "./daemon-service.ts";
+import { type DaemonServiceInstaller, type ReconcileAllResult, reconcileAllDaemonServices, RealDaemonServiceInstaller } from "./daemon-service.ts";
 import { checkUpdates, loadUpdates } from "./watcher.ts";
 
 const log = createLogger("service");
@@ -90,6 +93,7 @@ export type OperationName =
 	| "package.install"
 	| "package.install_service"
 	| "package.restart_service"
+	| "package.reconcile_services"
 	| "package.remove"
 	| "package.update"
 	| "resources.list"
@@ -120,6 +124,7 @@ export interface OperationInputs {
 	"package.install": { source: string; approved?: boolean };
 	"package.install_service": { source: string; approved?: boolean };
 	"package.restart_service": { source: string; approved?: boolean };
+	"package.reconcile_services": { approved?: boolean; projectRoot?: string };
 	"package.remove": { name: string; approved?: boolean };
 	"package.update": { source: string; approved?: boolean };
 	"resources.list": { projectRoot?: string };
@@ -138,12 +143,13 @@ interface UpdateMutationResponse extends MutationResponse, Partial<Omit<UpdateOu
 interface InstallServiceResponse {
 	ok: boolean;
 	output: string;
-	spec?: Pick<ServiceSpec, "name" | "binPath" | "descriptorPath">;
+	spec?: Pick<ServiceSpec, "name" | "binPath">;
 	notADaemon?: boolean;
 }
 interface RestartServiceResponse extends InstallServiceResponse {
 	restarted?: boolean;
 }
+interface ReconcileServicesResponse extends MutationResponse, ReconcileAllResult {}
 
 export interface OperationOutputs {
 	"package.search": { query: string; total: number; results: SearchPage["results"]; offline?: boolean };
@@ -166,6 +172,7 @@ export interface OperationOutputs {
 	"package.install": MutationResponse;
 	"package.install_service": InstallServiceResponse;
 	"package.restart_service": RestartServiceResponse;
+	"package.reconcile_services": ReconcileServicesResponse;
 	"package.remove": MutationResponse;
 	"package.update": UpdateMutationResponse;
 	"resources.list": { global: PackageResources[]; project: PackageResources[] };
@@ -197,6 +204,7 @@ export const OPERATION_NAMES: readonly OperationName[] = [
 	"package.install",
 	"package.install_service",
 	"package.restart_service",
+	"package.reconcile_services",
 	"package.remove",
 	"package.update",
 	"resources.list",
@@ -227,8 +235,8 @@ function err(status: number, msg: string, details: Record<string, unknown> = {})
 	return jsonResponse({ error: msg, ...details }, { status });
 }
 
-function pickSpec(spec: ServiceSpec): Pick<ServiceSpec, "name" | "binPath" | "descriptorPath"> {
-	return { name: spec.name, binPath: spec.binPath, descriptorPath: spec.descriptorPath };
+function pickSpec(spec: ServiceSpec): Pick<ServiceSpec, "name" | "binPath"> {
+	return { name: spec.name, binPath: spec.binPath };
 }
 
 export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Response> } {
@@ -240,6 +248,13 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 	const daemonServiceInstaller = deps.daemonServiceInstaller ?? new RealDaemonServiceInstaller();
 	const piHomeForServiceInstall = deps.piHome ?? defaultPiHome();
 
+	// Additive, real Vehicle protocol surface for this daemon's full operation set -- served
+	// at /vehicle/* alongside (not replacing) /api/v1/ops below. Every operation delegates to
+	// the exact same executeOperation() this route's own /api/v1/ops handler calls.
+	const vehicleRegistry = new VehicleRegistry({ name: "packed", version: VERSION, description: "Pi package lifecycle daemon" });
+	registerPackedVehicleOperations(vehicleRegistry, executeOperation);
+	const vehicleApp = createVehicleHttpApp({ registry: vehicleRegistry, token: deps.token });
+
 	function authorize(operation: PackageOperation, approved: boolean): Response | undefined {
 		try {
 			assertPackagePermission(readSecuritySettings(deps.stateDir), operation, approved);
@@ -331,11 +346,21 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			// pi.cleanup is read and applied before delegating to pi remove --
 			// once pi remove finishes, an npm-sourced package's own directory
 			// (and its manifest) may already be gone.
-			const installedDir = resolveInstalledDir(deps.piHome ?? defaultPiHome(), `npm:${name}`);
+			const piHome = deps.piHome ?? defaultPiHome();
+			const installedDir = resolveInstalledDir(piHome, `npm:${name}`);
+			let serviceRemoved = false;
+			if (installedDir) {
+				const service = await daemonServiceInstaller.remove(piHome, `npm:${name}`);
+				if (!service.ok && !service.notADaemon) return json({ ok: false, name, output: service.reason });
+				if (service.ok) {
+					if (!service.result.installed) return json({ ok: false, name, output: service.result.reason });
+					serviceRemoved = true;
+				}
+			}
 			const cleanup = installedDir ? runCleanup(installedDir) : [];
 			try {
 				const output = await deps.inst.remove(`npm:${name}`, { approved });
-				return json({ ok: true, name, output: output + formatCleanupSummary(cleanup) });
+				return json({ ok: true, name, output: output + formatCleanupSummary(cleanup), serviceRemoved });
 			} catch (e) {
 				const message = e instanceof Error ? e.message : String(e);
 				return json({ ok: false, name, output: message + formatCleanupSummary(cleanup) });
@@ -359,7 +384,19 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			if (denied) return denied;
 			try {
 				const output = await deps.inst.install(source, { approved });
-				return json({ ok: true, source, output });
+				if (!source.startsWith("npm:")) return json({ ok: true, source, output });
+				const service = await daemonServiceInstaller.install(piHomeForServiceInstall, source);
+				if (!service.ok) {
+					if (service.notADaemon) return json({ ok: true, source, output });
+					return json({ ok: false, source, output: `${output}\n${service.reason}` });
+				}
+				if (!service.result.installed) return json({ ok: false, source, output: `${output}\n${service.result.reason}` });
+				return json({
+					ok: true,
+					source,
+					output: `${output}\ninstalled persistent Vehicle ${service.spec.name}`,
+					service: pickSpec(service.spec),
+				});
 			} catch (e) {
 				return json({ ok: false, source, output: e instanceof Error ? e.message : String(e) });
 			}
@@ -380,7 +417,7 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			}
 			const denied = authorize("install_service", approved);
 			if (denied) return denied;
-			const resolved = daemonServiceInstaller.install(piHomeForServiceInstall, source);
+			const resolved = await daemonServiceInstaller.install(piHomeForServiceInstall, source);
 			if (!resolved.ok) return json({ ok: false, output: resolved.reason, notADaemon: resolved.notADaemon });
 			if (!resolved.result.installed) return json({ ok: false, output: resolved.result.reason, spec: pickSpec(resolved.spec) });
 			return json({ ok: true, output: `installed a persistent service for ${resolved.spec.name}`, spec: pickSpec(resolved.spec) });
@@ -401,7 +438,7 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			}
 			const denied = authorize("restart_service", approved);
 			if (denied) return denied;
-			const resolved = daemonServiceInstaller.restart(piHomeForServiceInstall, source);
+			const resolved = await daemonServiceInstaller.restart(piHomeForServiceInstall, source);
 			if (!resolved.ok) return json({ ok: false, output: resolved.reason, notADaemon: resolved.notADaemon });
 			const output = resolved.restarted
 				? `restarted the persistent service for ${resolved.spec.name}`
@@ -409,6 +446,23 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			return json({ ok: true, output, restarted: resolved.restarted, spec: pickSpec(resolved.spec) });
 		}
 
+		if (path === "/reconcile-services" && req.method === "POST") {
+			let approved = false;
+			let projectRoot: string | undefined;
+			try {
+				const body = (await req.json()) as { approved?: unknown; projectRoot?: unknown };
+				approved = body.approved === true;
+				projectRoot = typeof body.projectRoot === "string" ? body.projectRoot : undefined;
+			} catch {
+				/* fall through -- approved stays false, projectRoot stays undefined */
+			}
+			const denied = authorize("reconcile_services", approved);
+			if (denied) return denied;
+			const result = await reconcileAllDaemonServices(piHomeForServiceInstall, projectRoot, daemonServiceInstaller);
+			const output = `reconciled ${result.reconciled.length} Vehicle(s), skipped ${result.skipped} non-daemon package(s)${result.failed.length > 0 ? `, ${result.failed.length} failure(s)` : ""}`;
+			return json({ ok: result.failed.length === 0, output, ...result });
+		}
+
 		if (path === "/update" && req.method === "POST") {
 			let source = "";
 			let approved = false;
@@ -426,7 +480,13 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			if (denied) return denied;
 			try {
 				const outcome = await deps.inst.update(source, { approved });
-				return json({ ok: true, source, ...outcome });
+				if (!source.startsWith("npm:") || outcome.alreadyUpToDate) return json({ ok: true, source, ...outcome });
+				const service = await daemonServiceInstaller.restart(piHomeForServiceInstall, source);
+				if (!service.ok) {
+					if (service.notADaemon) return json({ ok: true, source, ...outcome });
+					return json({ ok: false, source, ...outcome, output: `${outcome.output}\n${service.reason}` });
+				}
+				return json({ ok: true, source, ...outcome, serviceReconciled: service.restarted });
 			} catch (error) {
 				return json({ ok: false, source, output: error instanceof Error ? error.message : String(error), reloadRequired: false });
 			}
@@ -601,6 +661,10 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 				path = "/restart-service";
 				init = { method: "POST", body: JSON.stringify(input) };
 				break;
+			case "package.reconcile_services":
+				path = "/reconcile-services";
+				init = { method: "POST", body: JSON.stringify(input) };
+				break;
 			case "package.remove":
 				path = "/remove";
 				init = { method: "POST", body: JSON.stringify(input) };
@@ -626,8 +690,9 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 	return {
 		async fetch(req: Request): Promise<Response> {
 			const t0 = Date.now();
-			if (!requireBearerToken(req, deps.token)) return errorResponse("missing or invalid bearer token", 401);
 			const requestUrl = new URL(req.url);
+			if (requestUrl.pathname.startsWith("/vehicle/")) return vehicleApp.fetch(req);
+			if (!requireBearerToken(req, deps.token)) return errorResponse("missing or invalid bearer token", 401);
 			if (req.method === "GET" && requestUrl.pathname === "/api/v1/ops") return jsonResponse({ operations: OPERATION_NAMES });
 			if (req.method === "POST" && requestUrl.pathname === "/api/v1/ops") {
 				try {