@danypops/pi-packed 0.21.15 → 0.22.0

package/service/test/module-freshness.test.ts

@@ -0,0 +1,146 @@
+/**
+ * module-freshness.test.ts — the "X is not a constructor" pattern this
+ * exists to catch: a long-running process's in-memory copy of a dependency
+ * going stale after an on-disk update, with the process itself none the
+ * wiser until restarted.
+ */
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	captureLoadedModule,
+	captureLoadedModules,
+	checkModuleFreshness,
+	checkModuleFreshnessAll,
+	ownRuntimeDependencyNames,
+} from "../src/adoption/module-freshness.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
+function writeDependency(nodeModulesDir: string, name: string, version: string): string {
+	const dir = join(nodeModulesDir, name);
+	mkdirSync(dir, { recursive: true });
+	const packageJsonPath = join(dir, "package.json");
+	writeFileSync(packageJsonPath, JSON.stringify({ name, version }));
+	return packageJsonPath;
+}
+
+function fromPackageDir(): string {
+	const dir = track(mkdtempSync(join(tmpdir(), "packed-module-freshness-")));
+	writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "consumer", version: "1.0.0" }));
+	return dir;
+}
+
+describe("captureLoadedModule / checkModuleFreshness", () => {
+	it("reports not stale immediately after capture -- nothing has changed yet", () => {
+		const fromDir = fromPackageDir();
+		writeDependency(join(fromDir, "node_modules"), "watched-dep", "1.0.0");
+
+		const snapshot = captureLoadedModule(fromDir, "watched-dep");
+		expect(snapshot).toBeDefined();
+		expect(snapshot!.version).toBe("1.0.0");
+
+		const diagnostic = checkModuleFreshness(snapshot!);
+		expect(diagnostic.stale).toBe(false);
+		expect(diagnostic.loadedVersion).toBe("1.0.0");
+		expect(diagnostic.currentVersion).toBe("1.0.0");
+	});
+
+	it("reports stale once the on-disk package.json is rewritten after the snapshot was taken -- the exact confirmed-live pattern", async () => {
+		const fromDir = fromPackageDir();
+		const packageJsonPath = writeDependency(join(fromDir, "node_modules"), "watched-dep", "1.0.0");
+		const snapshot = captureLoadedModule(fromDir, "watched-dep")!;
+
+		// Simulate a pkg_update landing a new build while this process (whose
+		// own snapshot was already taken) keeps running -- rewrite the file
+		// and force its mtime forward, since two writes in the same tick can
+		// otherwise land on an indistinguishable mtime on a fast filesystem.
+		writeFileSync(packageJsonPath, JSON.stringify({ name: "watched-dep", version: "2.0.0" }));
+		const future = new Date(Date.now() + 5_000);
+		utimesSync(packageJsonPath, future, future);
+
+		const diagnostic = checkModuleFreshness(snapshot);
+		expect(diagnostic.stale).toBe(true);
+		expect(diagnostic.loadedVersion).toBe("1.0.0");
+		expect(diagnostic.currentVersion).toBe("2.0.0");
+	});
+
+	it("never reports stale when either mtime is unknown -- never guesses from version alone", () => {
+		const fromDir = fromPackageDir();
+		const packageJsonPath = writeDependency(join(fromDir, "node_modules"), "watched-dep", "1.0.0");
+		const snapshot = { name: "watched-dep", packageJsonPath, version: "1.0.0", mtimeMs: undefined };
+
+		expect(checkModuleFreshness(snapshot).stale).toBe(false);
+	});
+
+	it("returns undefined (never throws) when the dependency isn't resolvable from here at all", () => {
+		const fromDir = fromPackageDir();
+		expect(captureLoadedModule(fromDir, "does-not-exist-anywhere")).toBeUndefined();
+	});
+});
+
+describe("captureLoadedModules / checkModuleFreshnessAll -- bulk, one unresolvable name never blocks the rest", () => {
+	it("captures every resolvable name and silently skips the rest", () => {
+		const fromDir = fromPackageDir();
+		writeDependency(join(fromDir, "node_modules"), "dep-a", "1.0.0");
+		writeDependency(join(fromDir, "node_modules"), "dep-b", "2.0.0");
+
+		const snapshots = captureLoadedModules(fromDir, ["dep-a", "dep-b", "dep-missing"]);
+
+		expect(snapshots.map((s) => s.name)).toEqual(["dep-a", "dep-b"]);
+	});
+
+	it("checks every captured snapshot and reports which ones went stale", () => {
+		const fromDir = fromPackageDir();
+		const staleDepPath = writeDependency(join(fromDir, "node_modules"), "dep-a", "1.0.0");
+		writeDependency(join(fromDir, "node_modules"), "dep-b", "2.0.0");
+		const snapshots = captureLoadedModules(fromDir, ["dep-a", "dep-b"]);
+
+		writeFileSync(staleDepPath, JSON.stringify({ name: "dep-a", version: "1.1.0" }));
+		const future = new Date(Date.now() + 5_000);
+		utimesSync(staleDepPath, future, future);
+
+		const diagnostics = checkModuleFreshnessAll(snapshots);
+		expect(diagnostics.find((d) => d.name === "dep-a")?.stale).toBe(true);
+		expect(diagnostics.find((d) => d.name === "dep-b")?.stale).toBe(false);
+	});
+});
+
+describe("ownRuntimeDependencyNames", () => {
+	it("returns exactly the dependencies field's keys, never devDependencies/peerDependencies", () => {
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-module-freshness-pkg-")));
+		const packageJsonPath = join(dir, "package.json");
+		writeFileSync(
+			packageJsonPath,
+			JSON.stringify({
+				name: "pkg",
+				dependencies: { "runtime-a": "^1.0.0", "runtime-b": "^2.0.0" },
+				devDependencies: { "dev-only": "^1.0.0" },
+				peerDependencies: { "peer-only": "*" },
+			}),
+		);
+
+		expect(ownRuntimeDependencyNames(packageJsonPath)).toEqual(["runtime-a", "runtime-b"]);
+	});
+
+	it("returns an empty array, never throws, for a missing or malformed package.json", () => {
+		expect(ownRuntimeDependencyNames("/nonexistent/package.json")).toEqual([]);
+	});
+
+	it("returns an empty array when dependencies is absent", () => {
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-module-freshness-pkg-")));
+		const packageJsonPath = join(dir, "package.json");
+		writeFileSync(packageJsonPath, JSON.stringify({ name: "pkg" }));
+
+		expect(ownRuntimeDependencyNames(packageJsonPath)).toEqual([]);
+	});
+});

package/service/test/resources.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
 import { createApp, type OperationInputs, type OperationName, type OperationOutputs } from "../src/daemon/service.ts";
 import type { Installer, PkgInfo, Registry, SearchPage } from "../src/packages/package.ts";
-import { listPackageResources, toggleResource } from "../src/packages/resources.ts";
+import { applyEntryFilters, captureEntryFilters, listPackageResources, toggleResource } from "../src/packages/resources.ts";
 
 const roots: string[] = [];
 afterEach(() => {
@@ -258,3 +258,68 @@ describe("toggleResource", () => {
 		expect(result.error).toContain("not found");
 	});
 });
+
+describe("captureEntryFilters / applyEntryFilters (preserving a pinned package's own filter overrides across a replace)", () => {
+	it("captures every filter field an object-form entry declares", () => {
+		const home = piHome([{ source: "npm:pi-demo@1.0.0", extensions: ["-extensions/one.ts"], skills: ["+skills/two.md"] }]);
+
+		const filters = captureEntryFilters(join(home, "settings.json"), "npm:pi-demo@1.0.0");
+
+		expect(filters).toEqual({ extensions: ["-extensions/one.ts"], skills: ["+skills/two.md"] });
+	});
+
+	it("returns undefined for a bare string entry -- nothing to preserve", () => {
+		const home = piHome(["npm:pi-demo@1.0.0"]);
+		expect(captureEntryFilters(join(home, "settings.json"), "npm:pi-demo@1.0.0")).toBeUndefined();
+	});
+
+	it("returns undefined when the source isn't found at all", () => {
+		const home = piHome(["npm:other"]);
+		expect(captureEntryFilters(join(home, "settings.json"), "npm:pi-demo@1.0.0")).toBeUndefined();
+	});
+
+	it("re-applies captured filters onto the new source's own freshly-installed bare-string entry", async () => {
+		const home = piHome(["npm:pi-demo@2.0.0"]);
+		const settingsPath = join(home, "settings.json");
+
+		const ok = await applyEntryFilters(settingsPath, "npm:pi-demo@2.0.0", { extensions: ["-extensions/one.ts"] });
+
+		expect(ok).toBe(true);
+		const written = JSON.parse(readFileSync(settingsPath, "utf8"));
+		expect(written.packages).toEqual([{ source: "npm:pi-demo@2.0.0", extensions: ["-extensions/one.ts"] }]);
+	});
+
+	it("is a no-op (still ok:true) when there are no filters to preserve", async () => {
+		const home = piHome(["npm:pi-demo@2.0.0"]);
+		const settingsPath = join(home, "settings.json");
+
+		expect(await applyEntryFilters(settingsPath, "npm:pi-demo@2.0.0", undefined)).toBe(true);
+		const written = JSON.parse(readFileSync(settingsPath, "utf8"));
+		expect(written.packages).toEqual(["npm:pi-demo@2.0.0"]);
+	});
+
+	it("reports failure (never throws) when the target entry doesn't exist yet -- e.g. install itself failed", async () => {
+		const home = piHome(["npm:unrelated"]);
+		const settingsPath = join(home, "settings.json");
+
+		const ok = await applyEntryFilters(settingsPath, "npm:pi-demo@2.0.0", { extensions: ["-extensions/one.ts"] });
+
+		expect(ok).toBe(false);
+	});
+
+	it("round-trips through a real capture-then-apply replace simulation", async () => {
+		const home = piHome([{ source: "npm:pi-demo@1.0.0", extensions: ["-extensions/one.ts"] }]);
+		const settingsPath = join(home, "settings.json");
+		const filters = captureEntryFilters(settingsPath, "npm:pi-demo@1.0.0");
+
+		// Simulate remove()+install(): the old entry is gone, a fresh bare-string
+		// entry exists for the new pinned version.
+		writeFileSync(settingsPath, JSON.stringify({ packages: ["npm:pi-demo@2.0.0"] }));
+
+		const ok = await applyEntryFilters(settingsPath, "npm:pi-demo@2.0.0", filters);
+
+		expect(ok).toBe(true);
+		const written = JSON.parse(readFileSync(settingsPath, "utf8"));
+		expect(written.packages).toEqual([{ source: "npm:pi-demo@2.0.0", extensions: ["-extensions/one.ts"] }]);
+	});
+});

package/service/test/service.test.ts

@@ -52,8 +52,10 @@ class FakeInstaller implements Installer {
 		return this.output;
 	}
 	updateOutcome: Partial<UpdateOutcome> = {};
-	async update(source: string): Promise<UpdateOutcome> {
+	gotTarget: string | undefined;
+	async update(source: string, options?: { target?: string }): Promise<UpdateOutcome> {
 		this.updated = source;
+		this.gotTarget = options?.target;
 		return { output: this.output, reloadRequired: true, alreadyUpToDate: false, pinned: false, ...this.updateOutcome };
 	}
 }
@@ -539,6 +541,71 @@ describe("service app", () => {
 		});
 	});
 
+	it("POST /update threads target through to the installer and validates it the same way as source", async () => {
+		const inst = new FakeInstaller();
+		const app = createApp(deps({ inst }));
+		const invalidTarget = await app.fetch(
+			new Request("http://x/update", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:@scope/pkg@1.0.0", target: "not a valid source!", approved: true }),
+			}),
+		);
+		expect(invalidTarget.status).toBe(400);
+		expect(inst.updated).toBe("");
+
+		const valid = await app.fetch(
+			new Request("http://x/update", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:@scope/pkg@1.0.0", target: "npm:@scope/pkg@2.0.0", approved: true }),
+			}),
+		);
+		expect(valid.status).toBe(200);
+		expect(inst.updated).toBe("npm:@scope/pkg@1.0.0");
+		expect(inst.gotTarget).toBe("npm:@scope/pkg@2.0.0");
+	});
+
+	it("POST /update reconciles the Vehicle under the NEW (target) source after a replace, not the removed one", async () => {
+		const svc = new FakeDaemonServiceInstaller();
+		const inst = new FakeInstaller();
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-update-vehicle-replace-")));
+		const app = createApp(deps({ inst, 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:@scope/pkg@1.0.0", target: "npm:@scope/pkg@2.0.0", approved: true }),
+			}),
+		);
+		expect(await response.json()).toMatchObject({ ok: true, serviceReconciled: true });
+		expect(svc.restartGotSource).toBe("npm:@scope/pkg@2.0.0");
+	});
+
+	it("POST /update surfaces pinnedSourceRequiresTarget/replaced/before/after/rollback through the wire response", async () => {
+		const inst = new FakeInstaller();
+		inst.updateOutcome = {
+			replaced: true,
+			before: { source: "npm:@scope/pkg@1.0.0", version: "1.0.0" },
+			after: { source: "npm:@scope/pkg@2.0.0", version: "2.0.0" },
+			rollback: { attempted: false, ok: true },
+		};
+		const app = createApp(deps({ inst }));
+		const response = await app.fetch(
+			new Request("http://x/update", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:@scope/pkg@1.0.0", target: "npm:@scope/pkg@2.0.0", approved: true }),
+			}),
+		);
+		expect(await response.json()).toMatchObject({
+			replaced: true,
+			before: { source: "npm:@scope/pkg@1.0.0", version: "1.0.0" },
+			after: { source: "npm:@scope/pkg@2.0.0", version: "2.0.0" },
+			rollback: { attempted: false, ok: true },
+		});
+	});
+
 	it("GET /updates serves the watcher snapshot", async () => {
 		const d = deps();
 		await saveUpdates(d.stateDir, {

package/service/test/smoke.test.ts

@@ -1,10 +1,10 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { checkPackage } from "../src/adoption/check.ts";
-import { runExtensionSmoke } from "../src/adoption/smoke.ts";
+import { resolveDependencyModulesDir, runExtensionSmoke } from "../src/adoption/smoke.ts";
 
 const roots: string[] = [];
 afterEach(() => {
@@ -47,6 +47,53 @@ function extension(source: string): { root: string; path: string } {
 	return { root, path };
 }
 
+/** A minimal fake dependency package.json -- no "exports" map, so a bare
+ * `require.resolve("<name>/package.json")` subpath is allowed by Node's
+ * default (no-exports-map) resolution rules without needing to replicate
+ * the real jiti package's own exports field. */
+function writeFakeDependency(nodeModulesDir: string, name: string): void {
+	const dir = join(nodeModulesDir, name);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "0.0.0-fixture" }));
+}
+
+describe("resolveDependencyModulesDir (packed doctor's real-layout dependency resolution)", () => {
+	it("resolves a dependency nested directly under the package's own node_modules", () => {
+		const root = mkdtempSync(join(tmpdir(), "packed-resolve-nested-"));
+		roots.push(root);
+		writeFileSync(join(root, "package.json"), JSON.stringify({ name: "pkg", version: "1.0.0" }));
+		writeFakeDependency(join(root, "node_modules"), "fake-loader");
+
+		const resolved = resolveDependencyModulesDir(root, "fake-loader");
+
+		expect(resolved).toBe(realpathSync(join(root, "node_modules", "fake-loader")));
+	});
+
+	it("resolves a dependency hoisted to a shared ancestor node_modules -- confirmed live bug: packed doctor --json crashed assuming a fixed nested-only path", () => {
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "packed-resolve-hoisted-"));
+		roots.push(workspaceRoot);
+		const packageDir = join(workspaceRoot, "node_modules", "@danypops", "pi-packed");
+		mkdirSync(packageDir, { recursive: true });
+		writeFileSync(join(packageDir, "package.json"), JSON.stringify({ name: "@danypops/pi-packed", version: "1.0.0" }));
+		// The dependency sits in the WORKSPACE's node_modules, never nested
+		// under the package's own -- exactly what npm's hoisting produces
+		// when another package in the tree also depends on it.
+		writeFakeDependency(join(workspaceRoot, "node_modules"), "fake-loader");
+
+		const resolved = resolveDependencyModulesDir(packageDir, "fake-loader");
+
+		expect(resolved).toBe(realpathSync(join(workspaceRoot, "node_modules", "fake-loader")));
+	});
+
+	it("returns undefined (never throws) when the dependency is genuinely unresolvable from here", () => {
+		const root = mkdtempSync(join(tmpdir(), "packed-resolve-missing-"));
+		roots.push(root);
+		writeFileSync(join(root, "package.json"), JSON.stringify({ name: "pkg", version: "1.0.0" }));
+
+		expect(resolveDependencyModulesDir(root, "does-not-exist-anywhere")).toBeUndefined();
+	});
+});
+
 describeIfSandboxed("isolated extension smoke runner", () => {
 	it("captures bounded registrations without a model", async () => {
 		const fixture = extension(`export default function (pi: any) {

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

@@ -70,14 +70,29 @@ async function invoke(app: { fetch(request: Request): Promise<Response> }, name:
 }
 
 describe("packed's daemon operation surface, through the real Vehicle wire protocol", () => {
-	it("GET /vehicle/manifest lists all 29 operations, authenticated the same as /api/v1/ops", async () => {
+	it("GET /vehicle/manifest lists all 29 operations plus the registry's own vehicle.approval.resolve, authenticated the same as /api/v1/ops", async () => {
 		const app = createApp(deps());
 		const unauthorized = await app.fetch(new Request("http://packed.internal/vehicle/manifest"));
 		expect(unauthorized.status).toBe(401);
 		const response = await app.fetch(new Request("http://packed.internal/vehicle/manifest", { headers: { authorization: "Bearer test-token" } }));
 		expect(response.status).toBe(200);
 		const body = (await response.json()) as { operations: Array<{ name: string }> };
-		expect(body.operations.map((o) => o.name).sort()).toEqual([...OPERATION_NAMES].sort());
+		expect(body.operations.map((o) => o.name).sort()).toEqual([...OPERATION_NAMES, "vehicle.approval.resolve"].sort());
+	});
+
+	it("a mutation's approvalRequired reflects security.ts's own per-operation classification, not a coarse effect default -- restart_service is gated despite sharing external-write with the never-gated catalog.sync", async () => {
+		const app = createApp(deps());
+		const response = await app.fetch(new Request("http://packed.internal/vehicle/manifest", { headers: { authorization: "Bearer test-token" } }));
+		const body = (await response.json()) as { operations: Array<{ name: string; approvalRequired?: boolean }> };
+		const byName = new Map(body.operations.map((o) => [o.name, o.approvalRequired]));
+		expect(byName.get("package.restart_service")).toBe(true);
+		expect(byName.get("package.reconcile_services")).toBe(true);
+		expect(byName.get("package.catalog.sync")).toBe(false);
+		expect(byName.get("package.index.build")).toBe(false);
+		expect(byName.get("resources.toggle")).toBe(true);
+		expect(byName.get("package.security.set")).toBe(true);
+		expect(byName.get("setup.export")).toBe(false);
+		expect(byName.get("setup.update")).toBe(false);
 	});
 
 	it("package.search round-trips through /vehicle/invoke, matching /api/v1/ops's own shape", async () => {
@@ -102,11 +117,88 @@ describe("packed's daemon operation surface, through the real Vehicle wire proto
 		expect(result.body.error?.category).toBe("authorization");
 	});
 
-	it("an approved mutation succeeds through /vehicle/invoke exactly like an approved /api/v1/ops call", async () => {
+	it("a genuinely approved mutation (through Vehicle's own request/resolve/capability dance) succeeds exactly like an approved /api/v1/ops call -- an approved:true field in the input body alone is no longer enough, since Vehicle's own gate never reads it", async () => {
 		const app = createApp(deps());
-		const result = await invoke(app, "package.remove", { name: "pi-lsp", approved: true });
+		const stillDenied = await invoke(app, "package.remove", { name: "pi-lsp", approved: true });
+		expect(stillDenied.status).toBe(403);
+
+		const denied = await invoke(app, "package.remove", { name: "pi-lsp" });
+		const requestId = (denied.body.error as unknown as { details?: { requestId?: string } }).details?.requestId;
+		expect(typeof requestId).toBe("string");
+		const resolveResponse = await app.fetch(
+			new Request("http://packed.internal/vehicle/invoke", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+				body: JSON.stringify({
+					name: "vehicle.approval.resolve",
+					version: 1,
+					input: { requestId, decision: "granted" },
+					permissions: ["vehicle:approvals:resolve"],
+				}),
+			}),
+		);
+		const resolved = {
+			status: resolveResponse.status,
+			body: (await resolveResponse.json()) as { output?: { capability?: string } },
+		};
+		expect(resolved.status).toBe(200);
+		const capability = (resolved.body.output as { capability?: string }).capability;
+		expect(typeof capability).toBe("string");
+
+		const response = await app.fetch(
+			new Request("http://packed.internal/vehicle/invoke", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+				body: JSON.stringify({
+					name: "package.remove",
+					version: 1,
+					input: { name: "pi-lsp" },
+					permissions: ["packed:read", "packed:write"],
+					approvalCapability: capability,
+				}),
+			}),
+		);
+		expect(response.status).toBe(200);
+		const body = (await response.json()) as { output: { ok: boolean } };
+		expect(body.output.ok).toBe(true);
+	});
+
+	it("mutationApproval: never disables the registry's own gate too, live, the instant /security POST changes it -- no daemon restart", async () => {
+		const app = createApp(deps());
+		const deniedFirst = await invoke(app, "package.remove", { name: "pi-lsp" });
+		expect(deniedFirst.status).toBe(403);
+
+		const securityPost = await app.fetch(
+			new Request("http://packed.internal/security", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+				body: JSON.stringify({ mutationApproval: "never", approved: true }),
+			}),
+		);
+		expect(securityPost.status).toBe(200);
+
+		const allowedNow = await invoke(app, "package.remove", { name: "pi-lsp" });
+		expect(allowedNow.status).toBe(200);
+		expect((allowedNow.body.output as { ok: boolean }).ok).toBe(true);
+	});
+
+	it("a daemon that boots with mutationApproval already never on disk starts with the gate already disabled, not just after the first /security POST", async () => {
+		const stateDir = temporaryRoot("packed-vehicle-never-");
+		const bootstrap = createApp(deps({ stateDir }));
+		const prep = await bootstrap.fetch(
+			new Request("http://packed.internal/security", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+				body: JSON.stringify({ mutationApproval: "never", approved: true }),
+			}),
+		);
+		expect(prep.status).toBe(200);
+
+		// A brand new app instance against the SAME on-disk state -- simulates a fresh daemon
+		// process starting up after the setting was already changed by a previous run.
+		const freshBoot = createApp(deps({ stateDir }));
+		const result = await invoke(freshBoot, "package.remove", { name: "pi-lsp" });
 		expect(result.status).toBe(200);
-		expect((result.body.output as { ok: boolean }).ok).toBe(true);
 	});
 
 	it("a handler-thrown validation error keeps its own real message, mapped to Vehicle's validation category (not a generic internal 500)", async () => {