@xopcai/xopc 0.0.241 → 0.0.243

package/dist/src/runtime-tools/manager.js

@@ -9,9 +9,9 @@ import { canFallbackRuntimeDownload, downloadVerifiedArchive } from "./downloade
 import { canFallbackPythonInstall, resolveRuntimeDownloadSource, runtimeGatewayPythonMirror } from "./download-source.js";
 import { withInstallLock } from "./install-lock.js";
 import { runtimeDownloadPath, runtimeLockPath, runtimeStagingDir, runtimeToolsRoot, runtimeVersionDir } from "./paths.js";
-import { readRuntimeManifest, writeRuntimeManifest } from "./manifest-store.js";
+import { readRuntimeManifests, writeRuntimeManifest } from "./manifest-store.js";
 import { bundledPythonArchiveName, resolveOfflineBundleArtifact } from "./offline-bundle.js";
-import { parseRuntimeVersion, probeSystemRuntime, versionSatisfies } from "./probe.js";
+import { normalizeRuntimeVersionRequest, parseRuntimeVersion, probeSystemRuntime, resolveInstallVersion, versionSatisfies } from "./probe.js";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
@@ -47,6 +47,16 @@ function uvExecutables(installDir) {
 		uvx: join(installDir, executableName("uvx"))
 	};
 }
+function isPathWithin(root, target) {
+	return target === root || target.startsWith(`${root}${process.platform === "win32" ? "\\" : "/"}`);
+}
+async function validateManagedExecutables(installDir, executables) {
+	for (const executable of Object.values(executables)) {
+		if (!executable) continue;
+		if (!isPathWithin(installDir, await realpath(executable))) return false;
+	}
+	return true;
+}
 function managedNodeProbeEnvironment(executables) {
 	const env = { ...process.env };
 	applyPathPrepend(env, [dirname(executables.node ?? executables.primary)]);
@@ -102,7 +112,9 @@ var ManagedRuntimeManager = class extends EventEmitter {
 	}
 	async resolve(request) {
 		const config = runtimeConfig(this.options, request.runtime);
-		const requestedVersion = request.version ?? this.defaultVersion(request.runtime);
+		const rawVersion = request.version ?? this.defaultVersion(request.runtime);
+		const requestedVersion = normalizeRuntimeVersionRequest(rawVersion);
+		if (!requestedVersion) throw new RuntimeError(`Invalid ${request.runtime} runtime version: ${rawVersion}`, "RUNTIME_VERSION_MISMATCH", request.runtime, "validate_version", false);
 		if (!this.options.config.enabled || !config.enabled) throw new RuntimeError(`${request.runtime} runtime is disabled`, "RUNTIME_DISABLED", request.runtime, "resolve", false);
 		const key = `${request.runtime}:${requestedVersion}:${request.allowProvision === true}`;
 		const existing = this.inFlight.get(key);
@@ -146,22 +158,21 @@ var ManagedRuntimeManager = class extends EventEmitter {
 		throw new RuntimeError(`${runtime} ${requestedVersion} is not available`, "RUNTIME_NOT_FOUND", runtime, "resolve", true, [`Run xopc runtime install ${runtime}`]);
 	}
 	async probeManaged(runtime, requestedVersion) {
-		const manifest = await readRuntimeManifest(this.options.stateDir, runtime);
-		if (!manifest || !versionSatisfies(manifest.version, requestedVersion)) return null;
-		try {
+		const manifests = (await readRuntimeManifests(this.options.stateDir, runtime)).filter((manifest) => versionSatisfies(manifest.version, requestedVersion));
+		for (const manifest of manifests) try {
 			const toolsRoot = await realpath(runtimeToolsRoot(this.options.stateDir));
 			const installDir = await realpath(manifest.installDir);
-			if (installDir !== toolsRoot && !installDir.startsWith(`${toolsRoot}${process.platform === "win32" ? "\\" : "/"}`)) return null;
-			await access(manifest.executables.primary);
+			if (!isPathWithin(toolsRoot, installDir)) continue;
+			if (!await validateManagedExecutables(installDir, manifest.executables)) continue;
 			const result = await runRuntimeCommand({
 				command: manifest.executables.primary,
 				args: ["--version"]
 			});
 			const version = parseRuntimeVersion(`${result.stdout}\n${result.stderr}`);
-			if (!result.ok || !version || !versionSatisfies(version, requestedVersion)) return null;
+			if (!result.ok || !version || !versionSatisfies(version, requestedVersion)) continue;
 			if (runtime === "node") {
 				const packageManagers = await probeNodePackageManagers(manifest.executables);
-				if (!packageManagers?.npm.ok || !packageManagers.npx.ok) return null;
+				if (!packageManagers?.npm.ok || !packageManagers.npx.ok) continue;
 			}
 			return {
 				runtime,
@@ -171,17 +182,18 @@ var ManagedRuntimeManager = class extends EventEmitter {
 				executables: manifest.executables,
 				installDir: manifest.installDir
 			};
-		} catch {
-			return null;
-		}
+		} catch {}
+		return null;
 	}
 	async install(runtime, version = this.defaultVersion(runtime), signal) {
 		const config = runtimeConfig(this.options, runtime);
 		if (!this.options.config.enabled || !config.enabled) throw new RuntimeError(`${runtime} runtime is disabled`, "RUNTIME_DISABLED", runtime, "install", false);
-		if (runtime === "python") return await this.installPython(version, signal);
-		return await this.installDistribution(runtime, version, signal);
+		const installVersion = resolveInstallVersion(version, DEFAULT_RUNTIME_VERSIONS[runtime]);
+		if (!installVersion) throw new RuntimeError(`Managed ${runtime} installation requires an exact version or a range containing catalog version ${DEFAULT_RUNTIME_VERSIONS[runtime]}`, "RUNTIME_VERSION_MISMATCH", runtime, "validate_version", false);
+		if (runtime === "python") return await this.installPython(installVersion, signal);
+		return await this.installDistribution(runtime, installVersion, signal);
 	}
-	async installDistribution(runtime, version, signal) {
+	async installDistribution(runtime, version, signal, alreadyLocked = false) {
 		const platform = detectRuntimePlatform();
 		if (!platform) throw new RuntimeError(`Managed ${runtime} is not supported on ${process.platform}-${process.arch}`, "RUNTIME_UNSUPPORTED", runtime, "resolve_asset", false);
 		const operationId = randomUUID();
@@ -191,11 +203,8 @@ var ManagedRuntimeManager = class extends EventEmitter {
 			platform
 		});
 		const installDir = runtimeVersionDir(this.options.stateDir, runtime, version);
-		return await withInstallLock(runtimeLockPath(this.options.stateDir, runtime, version), {
-			operationId,
-			runtime,
-			version
-		}, async () => {
+		const lockPath = runtimeLockPath(this.options.stateDir, runtime, version);
+		const performInstall = async () => {
 			const ready = await this.probeManaged(runtime, version);
 			if (ready) return ready;
 			this.progress({
@@ -225,22 +234,28 @@ var ManagedRuntimeManager = class extends EventEmitter {
 			let archivePath;
 			if (offline) archivePath = offline.archivePath;
 			else {
+				let lastDownloadProgressAt = 0;
 				const download = async () => await downloadVerifiedArchive({
 					runtime,
 					url: selectedDownload.url,
-					targetPath: runtimeDownloadPath(this.options.stateDir, asset.archiveFile),
+					targetPath: runtimeDownloadPath(this.options.stateDir, `${version}-${asset.archiveFile}`),
 					expectedSha256,
 					timeoutMs: this.options.config.download.timeoutMs,
 					proxy: this.options.config.download.proxy,
 					signal,
-					onProgress: (downloadedBytes, totalBytes) => this.progress({
-						operationId,
-						runtime,
-						phase: "download",
-						message: `Downloading ${runtime} ${version}`,
-						downloadedBytes,
-						totalBytes
-					})
+					onProgress: (downloadedBytes, totalBytes) => {
+						const now = Date.now();
+						if (downloadedBytes !== totalBytes && now - lastDownloadProgressAt < 100) return;
+						lastDownloadProgressAt = now;
+						this.progress({
+							operationId,
+							runtime,
+							phase: "download",
+							message: `Downloading ${runtime} ${version}`,
+							downloadedBytes,
+							totalBytes
+						});
+					}
 				});
 				try {
 					archivePath = await download();
@@ -345,16 +360,25 @@ var ManagedRuntimeManager = class extends EventEmitter {
 				executables,
 				installDir
 			};
-		});
+		};
+		return alreadyLocked ? await performInstall() : await withInstallLock(lockPath, {
+			operationId,
+			runtime,
+			version
+		}, performInstall, signal);
 	}
-	async installPython(version, signal) {
+	async installPython(version, signal, alreadyLocked = false) {
 		const operationId = randomUUID();
 		const installDir = runtimeVersionDir(this.options.stateDir, "python", version);
-		return await withInstallLock(runtimeLockPath(this.options.stateDir, "python", version), {
-			operationId,
-			runtime: "python",
-			version
-		}, async () => {
+		const lockPath = runtimeLockPath(this.options.stateDir, "python", version);
+		const ready = await this.probeManaged("python", version);
+		if (ready) return ready;
+		const uv = this.options.config.download.bundleDir ? null : await this.resolve({
+			runtime: "uv",
+			allowProvision: true,
+			signal
+		});
+		const performInstall = async () => {
 			const ready = await this.probeManaged("python", version);
 			if (ready) return ready;
 			if (this.options.config.download.bundleDir) return await this.installBundledPython({
@@ -363,11 +387,7 @@ var ManagedRuntimeManager = class extends EventEmitter {
 				installDir,
 				bundleDir: this.options.config.download.bundleDir
 			});
-			const uv = await this.resolve({
-				runtime: "uv",
-				allowProvision: true,
-				signal
-			});
+			if (!uv) throw new Error("uv runtime was not resolved");
 			await mkdir(dirname(installDir), { recursive: true });
 			const uvEnv = this.uvEnvironment(installDir);
 			this.progress({
@@ -457,7 +477,12 @@ var ManagedRuntimeManager = class extends EventEmitter {
 				executables,
 				installDir
 			};
-		});
+		};
+		return alreadyLocked ? await performInstall() : await withInstallLock(lockPath, {
+			operationId,
+			runtime: "python",
+			version
+		}, performInstall, signal);
 	}
 	async installBundledPython(params) {
 		const platform = detectRuntimePlatform();
@@ -596,7 +621,7 @@ var ManagedRuntimeManager = class extends EventEmitter {
 				repairable: false
 			};
 		} catch {}
-		if (await readRuntimeManifest(this.options.stateDir, runtime)) return {
+		if ((await readRuntimeManifests(this.options.stateDir, runtime)).filter((manifest) => versionSatisfies(manifest.version, requestedVersion)).length > 0) return {
 			runtime,
 			state: "corrupted",
 			requestedVersion,
@@ -618,32 +643,42 @@ var ManagedRuntimeManager = class extends EventEmitter {
 			"python"
 		].map((runtime) => this.status(runtime)));
 	}
-	async repair(runtime) {
-		const version = this.defaultVersion(runtime);
+	async repair(runtime, requestedVersion = this.defaultVersion(runtime)) {
+		const config = runtimeConfig(this.options, runtime);
+		if (!this.options.config.enabled || !config.enabled) throw new RuntimeError(`${runtime} runtime is disabled`, "RUNTIME_DISABLED", runtime, "repair", false);
+		const version = resolveInstallVersion(requestedVersion, DEFAULT_RUNTIME_VERSIONS[runtime]);
+		if (!version) throw new RuntimeError(`Managed ${runtime} repair requires an exact version or a range containing catalog version ${DEFAULT_RUNTIME_VERSIONS[runtime]}`, "RUNTIME_VERSION_MISMATCH", runtime, "validate_version", false);
 		const installDir = runtimeVersionDir(this.options.stateDir, runtime, version);
 		const backupDir = `${installDir}.repair-backup-${randomUUID()}`;
-		let hasBackup = false;
-		try {
-			await rename(installDir, backupDir);
-			hasBackup = true;
-		} catch {}
-		try {
-			const resolved = await this.install(runtime, version);
-			if (hasBackup) await rm(backupDir, {
-				recursive: true,
-				force: true
-			});
-			return resolved;
-		} catch (error) {
-			if (hasBackup) {
-				await rm(installDir, {
+		return await withInstallLock(runtimeLockPath(this.options.stateDir, runtime, version), {
+			operationId: randomUUID(),
+			runtime,
+			version,
+			action: "repair"
+		}, async () => {
+			let hasBackup = false;
+			try {
+				await rename(installDir, backupDir);
+				hasBackup = true;
+			} catch {}
+			try {
+				const resolved = runtime === "python" ? await this.installPython(version, void 0, true) : await this.installDistribution(runtime, version, void 0, true);
+				if (hasBackup) await rm(backupDir, {
 					recursive: true,
 					force: true
 				});
-				await rename(backupDir, installDir);
+				return resolved;
+			} catch (error) {
+				if (hasBackup) {
+					await rm(installDir, {
+						recursive: true,
+						force: true
+					});
+					await rename(backupDir, installDir);
+				}
+				throw error;
 			}
-			throw error;
-		}
+		});
 	}
 	progress(event) {
 		this.emit("progress", event);

package/dist/src/runtime-tools/manifest-store.d.ts

@@ -1,3 +1,5 @@
 import type { InstalledRuntimeManifest, RuntimeKind } from './types.js';
 export declare function readRuntimeManifest(stateDir: string, runtime: RuntimeKind): Promise<InstalledRuntimeManifest | null>;
+export declare function readRuntimeManifests(stateDir: string, runtime: RuntimeKind): Promise<InstalledRuntimeManifest[]>;
 export declare function writeRuntimeManifest(stateDir: string, manifest: InstalledRuntimeManifest): Promise<void>;
+export declare function removeRuntimeManifest(stateDir: string, runtime: RuntimeKind, version: string): Promise<void>;

package/dist/src/runtime-tools/manifest-store.js

@@ -1,26 +1,47 @@
-import { runtimeManifestPath } from "./paths.js";
-import { dirname } from "node:path";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { runtimeVersionManifestDir, runtimeVersionManifestPath } from "./paths.js";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 //#region src/runtime-tools/manifest-store.ts
 function isManifest(value, runtime) {
 	if (!value || typeof value !== "object") return false;
 	const item = value;
-	return item.schemaVersion === 1 && item.runtime === runtime && typeof item.version === "string" && typeof item.installDir === "string" && !!item.executables && typeof item.executables.primary === "string";
+	return item.schemaVersion === 1 && item.runtime === runtime && typeof item.version === "string" && typeof item.verifiedAt === "string" && typeof item.installDir === "string" && !!item.executables && typeof item.executables.primary === "string";
 }
 async function readRuntimeManifest(stateDir, runtime) {
+	return (await readRuntimeManifests(stateDir, runtime))[0] ?? null;
+}
+async function readManifestFile(path, runtime) {
 	try {
-		const parsed = JSON.parse(await readFile(runtimeManifestPath(stateDir, runtime), "utf8"));
+		const parsed = JSON.parse(await readFile(path, "utf8"));
 		return isManifest(parsed, runtime) ? parsed : null;
 	} catch {
 		return null;
 	}
 }
+async function readRuntimeManifests(stateDir, runtime) {
+	const manifests = [];
+	const versionRoot = runtimeVersionManifestDir(stateDir, runtime);
+	try {
+		const names = (await readdir(versionRoot)).filter((name) => name.endsWith(".json")).sort();
+		for (const name of names) {
+			const manifest = await readManifestFile(join(versionRoot, name), runtime);
+			if (manifest) manifests.push(manifest);
+		}
+	} catch {
+		return [];
+	}
+	return manifests.sort((a, b) => b.verifiedAt.localeCompare(a.verifiedAt));
+}
 async function writeRuntimeManifest(stateDir, manifest) {
-	const target = runtimeManifestPath(stateDir, manifest.runtime);
+	const target = runtimeVersionManifestPath(stateDir, manifest.runtime, manifest.version);
 	await mkdir(dirname(target), { recursive: true });
-	const temporary = `${target}.${process.pid}.tmp`;
+	const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
 	await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 384 });
 	await rename(temporary, target);
 }
+async function removeRuntimeManifest(stateDir, runtime, version) {
+	await rm(runtimeVersionManifestPath(stateDir, runtime, version), { force: true });
+}
 //#endregion
-export { readRuntimeManifest, writeRuntimeManifest };
+export { readRuntimeManifest, readRuntimeManifests, removeRuntimeManifest, writeRuntimeManifest };

package/dist/src/runtime-tools/paths.d.ts

@@ -1,7 +1,8 @@
 import type { RuntimeKind } from './types.js';
 export declare function runtimeToolsRoot(stateDir: string): string;
 export declare function runtimeVersionDir(stateDir: string, runtime: RuntimeKind, version: string): string;
-export declare function runtimeManifestPath(stateDir: string, runtime: RuntimeKind): string;
+export declare function runtimeVersionManifestDir(stateDir: string, runtime: RuntimeKind): string;
+export declare function runtimeVersionManifestPath(stateDir: string, runtime: RuntimeKind, version: string): string;
 export declare function runtimeLockPath(stateDir: string, runtime: RuntimeKind, version: string): string;
 export declare function runtimeDownloadPath(stateDir: string, archiveFile: string): string;
 export declare function runtimeStagingDir(stateDir: string, runtime: RuntimeKind, version: string, operationId: string): string;

package/dist/src/runtime-tools/paths.js

@@ -1,22 +1,33 @@
-import { join } from "node:path";
+import { join, relative, resolve } from "node:path";
 //#region src/runtime-tools/paths.ts
 function runtimeToolsRoot(stateDir) {
 	return join(stateDir, "tools");
 }
 function runtimeVersionDir(stateDir, runtime, version) {
-	return join(runtimeToolsRoot(stateDir), runtime, "versions", version);
+	return containedPath(join(runtimeToolsRoot(stateDir), runtime, "versions"), version, "runtime version");
 }
-function runtimeManifestPath(stateDir, runtime) {
-	return join(runtimeToolsRoot(stateDir), "manifests", `${runtime}.json`);
+function runtimeVersionManifestDir(stateDir, runtime) {
+	return join(runtimeToolsRoot(stateDir), "manifests", runtime);
+}
+function runtimeVersionManifestPath(stateDir, runtime, version) {
+	return containedPath(runtimeVersionManifestDir(stateDir, runtime), `${version}.json`, "runtime version");
 }
 function runtimeLockPath(stateDir, runtime, version) {
-	return join(runtimeToolsRoot(stateDir), "locks", `${runtime}-${version}.lock`);
+	return join(runtimeToolsRoot(stateDir), "locks", `${runtime}.lock`);
 }
 function runtimeDownloadPath(stateDir, archiveFile) {
-	return join(runtimeToolsRoot(stateDir), "downloads", `${archiveFile}.partial`);
+	return containedPath(join(runtimeToolsRoot(stateDir), "downloads"), `${archiveFile}.partial`, "archive file");
 }
 function runtimeStagingDir(stateDir, runtime, version, operationId) {
-	return join(runtimeToolsRoot(stateDir), "staging", `${runtime}-${version}-${operationId}`);
+	return containedPath(join(runtimeToolsRoot(stateDir), "staging"), `${runtime}-${version}-${operationId}`, "runtime staging directory");
+}
+function containedPath(root, child, label) {
+	if (child.includes("/") || child.includes("\\") || child.includes("\0")) throw new Error(`Invalid ${label}: ${child}`);
+	const absoluteRoot = resolve(root);
+	const target = resolve(absoluteRoot, child);
+	const rel = relative(absoluteRoot, target);
+	if (!rel || rel.startsWith("..") || rel.includes(`..${process.platform === "win32" ? "\\" : "/"}`)) throw new Error(`Invalid ${label}: ${child}`);
+	return target;
 }
 //#endregion
-export { runtimeDownloadPath, runtimeLockPath, runtimeManifestPath, runtimeStagingDir, runtimeToolsRoot, runtimeVersionDir };
+export { runtimeDownloadPath, runtimeLockPath, runtimeStagingDir, runtimeToolsRoot, runtimeVersionDir, runtimeVersionManifestDir, runtimeVersionManifestPath };

package/dist/src/runtime-tools/probe.d.ts

@@ -1,6 +1,8 @@
 import type { RuntimeExecutables, RuntimeKind } from './types.js';
 export declare function parseRuntimeVersion(output: string): string | null;
 export declare function versionSatisfies(actual: string, requested: string): boolean;
+export declare function normalizeRuntimeVersionRequest(requested: string): string | null;
+export declare function resolveInstallVersion(requested: string, catalogDefault: string): string | null;
 export declare function probeSystemRuntime(runtime: RuntimeKind, requestedVersion: string): Promise<{
     version: string;
     executables: RuntimeExecutables;

package/dist/src/runtime-tools/probe.js

@@ -14,6 +14,18 @@ function versionSatisfies(actual, requested) {
 	}
 	return semver.satisfies(normalized, requested) || normalized === requested;
 }
+function normalizeRuntimeVersionRequest(requested) {
+	const value = requested.trim();
+	if (!value || value.length > 128 || value.includes("/") || value.includes("\\") || value.includes("\0") || semver.validRange(value) === null) return null;
+	return value;
+}
+function resolveInstallVersion(requested, catalogDefault) {
+	const normalized = normalizeRuntimeVersionRequest(requested);
+	if (!normalized) return null;
+	const exact = semver.valid(normalized);
+	if (exact) return exact;
+	return versionSatisfies(catalogDefault, normalized) ? catalogDefault : null;
+}
 function commandNames(runtime) {
 	if (runtime === "node") return process.platform === "win32" ? ["node.exe", "node"] : ["node"];
 	if (runtime === "uv") return process.platform === "win32" ? ["uv.exe", "uv"] : ["uv"];
@@ -68,4 +80,4 @@ async function probeSystemRuntime(runtime, requestedVersion) {
 	return null;
 }
 //#endregion
-export { parseRuntimeVersion, probeSystemRuntime, versionSatisfies };
+export { normalizeRuntimeVersionRequest, parseRuntimeVersion, probeSystemRuntime, resolveInstallVersion, versionSatisfies };

package/dist/src/runtime-tools/prune.js

@@ -1,6 +1,9 @@
-import { runtimeToolsRoot } from "./paths.js";
-import { readRuntimeManifest } from "./manifest-store.js";
-import { join, resolve } from "node:path";
+import { DEFAULT_RUNTIME_VERSIONS } from "./catalog.js";
+import { withInstallLock } from "./install-lock.js";
+import { runtimeLockPath, runtimeToolsRoot } from "./paths.js";
+import { readRuntimeManifests, removeRuntimeManifest } from "./manifest-store.js";
+import { versionSatisfies } from "./probe.js";
+import { basename, join, resolve } from "node:path";
 import { lstat, readdir, rm, stat } from "node:fs/promises";
 //#region src/runtime-tools/prune.ts
 const RUNTIMES = [
@@ -9,6 +12,11 @@ const RUNTIMES = [
 	"python"
 ];
 const STALE_TEMP_MS = 1440 * 60 * 1e3;
+function configuredVersion(config, runtime) {
+	if (runtime === "node") return config.node.version ?? DEFAULT_RUNTIME_VERSIONS.node;
+	if (runtime === "python") return config.python.version ?? DEFAULT_RUNTIME_VERSIONS.python;
+	return config.uv.version ?? DEFAULT_RUNTIME_VERSIONS.uv;
+}
 async function pathSize(path) {
 	const details = await lstat(path);
 	if (details.isSymbolicLink()) return details.size;
@@ -36,9 +44,14 @@ async function pruneRuntimeTools(params) {
 	const removed = [];
 	let reclaimedBytes = 0;
 	const root = runtimeToolsRoot(params.stateDir);
-	for (const runtime of RUNTIMES) {
+	for (const runtime of RUNTIMES) await withInstallLock(runtimeLockPath(params.stateDir, runtime, "prune"), {
+		pid: process.pid,
+		runtime,
+		action: "prune"
+	}, async () => {
 		const entries = (await listEntries(join(root, runtime, "versions"))).sort((a, b) => b.mtimeMs - a.mtimeMs);
-		const manifest = await readRuntimeManifest(params.stateDir, runtime);
+		const manifests = await readRuntimeManifests(params.stateDir, runtime);
+		const manifest = manifests.find((item) => versionSatisfies(item.version, configuredVersion(params.config, runtime))) ?? manifests[0];
 		const entryPaths = new Set(entries.map((entry) => resolve(entry.path)));
 		const activePath = manifest && entryPaths.has(resolve(manifest.installDir)) ? resolve(manifest.installDir) : null;
 		const keep = /* @__PURE__ */ new Set();
@@ -53,10 +66,11 @@ async function pruneRuntimeTools(params) {
 				recursive: true,
 				force: true
 			});
+			await removeRuntimeManifest(params.stateDir, runtime, basename(entry.path));
 			removed.push(entry.path);
 			reclaimedBytes += entry.size;
 		}
-	}
+	});
 	const now = params.now ?? Date.now();
 	for (const entry of await listEntries(join(root, "staging"))) {
 		if (now - entry.mtimeMs < STALE_TEMP_MS) continue;
@@ -69,7 +83,7 @@ async function pruneRuntimeTools(params) {
 	}
 	const maxCacheBytes = params.config.retention.maxCacheBytes;
 	if (maxCacheBytes !== void 0) {
-		const cacheEntries = (await listEntries(join(root, "downloads"))).sort((a, b) => b.mtimeMs - a.mtimeMs);
+		const cacheEntries = (await listEntries(join(root, "downloads"))).filter((entry) => !entry.path.endsWith(".partial")).sort((a, b) => b.mtimeMs - a.mtimeMs);
 		let retained = 0;
 		for (const entry of cacheEntries) {
 			if (retained + entry.size <= maxCacheBytes) {

package/dist/src/session/client-history.js

@@ -267,6 +267,18 @@ function customRowToClientHistory(row) {
 	if (r.role !== "custom" && r.type !== "custom_message") return null;
 	const customType = optionalString(r.customType)?.trim();
 	if (!customType) return null;
+	if (customType === "voice_omni_transcript") {
+		const details = r.details;
+		if (details?.role !== "user" && details?.role !== "assistant") return null;
+		const content = typeof r.content === "string" ? r.content : "";
+		return {
+			role: details.role,
+			kind: "message",
+			content,
+			rawContent: content,
+			timestamp: parseTimestampValue(typeof r.timestamp === "string" || typeof r.timestamp === "number" ? r.timestamp : void 0)
+		};
+	}
 	const content = Array.isArray(r.content) || typeof r.content === "string" ? flattenMessageContent(r.content) : "";
 	const timestamp = parseTimestampValue(typeof r.timestamp === "string" || typeof r.timestamp === "number" ? r.timestamp : void 0);
 	return {

package/dist/src/session/manager.d.ts

@@ -149,6 +149,7 @@ export declare class SessionIndex extends EventEmitter {
         data?: unknown;
     }): Promise<void>;
     appendTranscriptCustomMessageEntry(key: string, entry: {
+        expectedSessionId?: string;
         customType: string;
         content?: string | unknown[];
         display?: boolean;

package/dist/src/session/session-context-for-llm.js

@@ -1,3 +1,4 @@
+import { voiceTranscriptMessage } from "./voice-transcript.js";
 import { isCompactionAudit, isCompactionHandover } from "./compaction-types.js";
 //#region src/session/session-context-for-llm.ts
 function isTranscriptContextEntry(x) {
@@ -245,6 +246,12 @@ function buildSessionContextForLlm(rows) {
 			continue;
 		}
 		if (isTranscriptCustomMessageEntry(r)) {
+			if (r.customType === "voice_call") continue;
+			if (r.customType === "voice_omni_transcript") {
+				const message = voiceTranscriptMessage(r);
+				if (message) out.push(message);
+				continue;
+			}
 			out.push(customMessageRowToLlmMessage(r));
 			continue;
 		}
@@ -257,6 +264,7 @@ function buildSessionDisplayMessages(rows) {
 	const out = [];
 	for (const r of rows) {
 		if (isTranscriptCustomMessageEntry(r)) {
+			if (r.customType === "voice_call") continue;
 			if (r.display === false) continue;
 			out.push(customMessageRowToLlmMessage(r));
 			continue;

package/dist/src/session/store.d.ts

@@ -124,6 +124,7 @@ export declare class SessionStore {
         data?: unknown;
     }): Promise<void>;
     appendTranscriptCustomMessageEntry(key: string, entry: {
+        expectedSessionId?: string;
         customType: string;
         content?: string | unknown[];
         display?: boolean;

package/dist/src/session/store.js

@@ -386,6 +386,7 @@ var SessionStore = class {
 	async appendTranscriptCustomMessageEntry(key, entry) {
 		return this.runStoreMutation(async () => {
 			requireXopcDatabase();
+			if (entry.expectedSessionId && getSessionMetadata(key)?.sessionId !== entry.expectedSessionId) throw new Error("Voice conversation session changed");
 			ensureSessionRecord(key, this.resolveWorkspaceCwd(key));
 			appendTranscriptEntry(key, {
 				role: "custom",

package/dist/src/session/stored-rows-to-file-entries.js

@@ -1,3 +1,4 @@
+import { voiceTranscriptMessage } from "./voice-transcript.js";
 import { isTranscriptContextEntry, isTranscriptCustomMessageEntry, isTranscriptCustomStateEntry } from "./session-context-for-llm.js";
 import { randomUUID } from "node:crypto";
 import { CURRENT_SESSION_VERSION } from "@earendil-works/pi-coding-agent";
@@ -100,7 +101,10 @@ function storedRowsToFileEntries(params) {
 			continue;
 		}
 		if (isTranscriptCustomMessageEntry(row)) {
-			const entry = customMessageRowToEntry(row, parentId, byId);
+			if (row.customType === "voice_call") continue;
+			const voiceMessage = row.customType === "voice_omni_transcript" ? voiceTranscriptMessage(row) : null;
+			if (row.customType === "voice_omni_transcript" && !voiceMessage) continue;
+			const entry = voiceMessage ? agentMessageToEntry(voiceMessage, parentId, byId) : customMessageRowToEntry(row, parentId, byId);
 			byId.add(entry.id);
 			entries.push(entry);
 			parentId = entry.id;

package/dist/src/session/voice-transcript.d.ts

@@ -0,0 +1,9 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+export declare const VOICE_CALL_TYPE = "voice_call";
+export declare const VOICE_TRANSCRIPT_TYPE = "voice_omni_transcript";
+/** One projection for both direct LLM loads and the embedded SessionManager. */
+export declare function voiceTranscriptMessage(row: {
+    content?: unknown;
+    details?: unknown;
+    timestamp?: string | number;
+}): AgentMessage | null;

package/dist/src/session/voice-transcript.js

@@ -0,0 +1,45 @@
+//#region src/session/voice-transcript.ts
+const VOICE_CALL_TYPE = "voice_call";
+const VOICE_TRANSCRIPT_TYPE = "voice_omni_transcript";
+/** One projection for both direct LLM loads and the embedded SessionManager. */
+function voiceTranscriptMessage(row) {
+	const details = row.details && typeof row.details === "object" ? row.details : {};
+	if (details.role !== "user" && details.role !== "assistant" || typeof row.content !== "string" || !row.content.trim()) return null;
+	const text = details.role === "assistant" && details.interrupted === true ? "[Voice reply was interrupted. Its generated text is omitted because the heard portion is unknown.]" : row.content;
+	const parsed = typeof row.timestamp === "number" ? row.timestamp : Date.parse(row.timestamp ?? "");
+	const timestamp = Number.isFinite(parsed) ? parsed : 0;
+	const content = [{
+		type: "text",
+		text
+	}];
+	if (details.role === "user") return {
+		role: "user",
+		content,
+		timestamp
+	};
+	return {
+		role: "assistant",
+		content,
+		timestamp,
+		api: "openai-completions",
+		provider: "xopc-voice",
+		model: "voice-transcript",
+		stopReason: "stop",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		}
+	};
+}
+//#endregion
+export { VOICE_CALL_TYPE, VOICE_TRANSCRIPT_TYPE, voiceTranscriptMessage };