@xopcai/xopc 0.0.284 → 0.0.285

package/dist/src/imports/inventory.js

@@ -0,0 +1,202 @@
+import { init_paths, resolveSkillsDir } from "../config/paths.js";
+import { listKnowledgeItems } from "../knowledge-memory/repository.js";
+import "../knowledge-memory/index.js";
+import { ProjectService } from "../projects/project-service.js";
+import { resolveWorkspaceSkillsDir } from "../agent/skills/workspace-skills-dir.js";
+import { ImportError } from "./types.js";
+import { digest } from "./files.js";
+import { canonicalTarget } from "./planner.js";
+import { detectImportSources } from "./sources.js";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
+import { basename, isAbsolute, parse } from "node:path";
+import { realpathSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
+//#region src/imports/inventory.ts
+init_paths();
+function contextKey(candidate) {
+	return `product-import:${candidate.source}:${digest(candidate.location)}`;
+}
+function existingContext(candidate, projectId) {
+	return listKnowledgeItems({
+		canonicalKey: contextKey(candidate),
+		scope: projectId ? {
+			type: "project",
+			id: projectId
+		} : { type: "global" },
+		statuses: [
+			"active",
+			"candidate",
+			"needs_review",
+			"stale",
+			"archived",
+			"rejected"
+		]
+	})[0];
+}
+function publicInventory(inventory) {
+	return {
+		id: inventory.id,
+		source: inventory.source,
+		createdAt: inventory.createdAt,
+		expiresAt: inventory.expiresAt,
+		complete: inventory.complete,
+		notices: inventory.notices,
+		candidates: inventory.candidates.map(({ id, kind, parentId, name, description, displayPath, scope, status, reason, suggested, targetName }) => ({
+			id,
+			kind,
+			parentId,
+			name,
+			description,
+			displayPath,
+			scope,
+			status,
+			reason,
+			suggested,
+			targetName
+		}))
+	};
+}
+function getLiveInventory(owner, id) {
+	const inventory = new ImportSelectionRepository(owner).get("inventory", id);
+	if (Date.now() > inventory.expiresAt) throw new ImportError("inventory_stale", "This list has expired. Refresh it before importing.", 409);
+	return inventory;
+}
+async function scanProduct(service, source, owner = "gateway-owner") {
+	if (!detectImportSources().some((s) => s.id === source && s.detected)) throw new ImportError("source_not_found", "App is unavailable on the xopc device", 404);
+	const inventory = {
+		id: randomUUID(),
+		source,
+		createdAt: Date.now(),
+		expiresAt: Date.now() + 15 * 6e4,
+		candidates: [],
+		notices: [],
+		complete: true,
+		scanIds: []
+	};
+	const budget = {
+		bytes: 0,
+		files: 0
+	};
+	const projects = new ProjectService();
+	const addScan = (scan, targetRoot, parent) => {
+		inventory.scanIds.push(scan.id);
+		inventory.notices.push(...scan.diagnostics);
+		if (scan.diagnostics.length) inventory.complete = false;
+		const relevant = {
+			...scan,
+			candidates: scan.candidates.filter((c) => c.scope === (parent ? "project" : "user"))
+		};
+		const skills = service.describeSkills(relevant, {
+			root: targetRoot,
+			projectId: parent?.projectId
+		});
+		for (const candidate of relevant.candidates) {
+			if (candidate.kind === "mcp") {
+				inventory.notices.push(`${candidate.name}: reconnect this tool in Connections.`);
+				continue;
+			}
+			const item = {
+				id: candidate.id,
+				kind: candidate.kind === "rule" ? "context" : "skill",
+				parentId: parent?.id,
+				name: candidate.name,
+				description: candidate.description,
+				displayPath: candidate.location,
+				location: candidate.location,
+				scope: candidate.scope,
+				status: candidate.compatibility === "compatible" ? "ready" : "blocked",
+				suggested: false,
+				reason: candidate.findings.join("; ") || void 0,
+				scanId: scan.id,
+				candidate,
+				targetRoot,
+				projectId: parent?.projectId
+			};
+			if (item.kind === "skill") {
+				const state = skills.find((s) => s.candidate.id === candidate.id);
+				item.status = state.status;
+				item.reason = state.reason;
+				item.targetName = state.targetName;
+				if (parent && !service.isWorkspaceTrusted(parent.location) && item.status !== "existing") {
+					item.status = "blocked";
+					item.reason = "Trust this project in Projects before importing its skills.";
+				}
+				item.suggested = item.status === "ready";
+			} else if (item.status === "ready") {
+				const existing = !parent || parent.projectId ? existingContext(candidate, parent?.projectId) : void 0;
+				if (existing) {
+					item.status = existing.source.hash === candidate.hash ? "existing" : "blocked";
+					item.reason = item.status === "blocked" ? "Previously imported context has changed; existing content will be kept." : void 0;
+				}
+			}
+			inventory.candidates.push(item);
+		}
+	};
+	const scan = await service.scan({
+		source,
+		budget
+	});
+	addScan(scan, canonicalTarget(resolveSkillsDir()));
+	const seen = /* @__PURE__ */ new Set();
+	const paths = scan.projectRoots ?? [];
+	const limit = 500;
+	if (paths.length > limit) {
+		inventory.complete = false;
+		inventory.notices.push(`${paths.length - limit} project directories were not scanned (limit: ${limit}).`);
+	}
+	for (const path of paths.slice(0, limit)) {
+		await setImmediate();
+		let parent;
+		try {
+			if (!isAbsolute(path) || parse(path).root === path || !statSync(path).isDirectory()) throw new Error("Unavailable project");
+			const location = realpathSync(path);
+			if (parse(location).root === location) throw new Error("Invalid project");
+			if (seen.has(location)) continue;
+			seen.add(location);
+			const existing = projects.findByWorkspaceRoot(location);
+			parent = {
+				id: randomUUID(),
+				kind: "project",
+				name: existing?.name ?? basename(location),
+				description: "",
+				displayPath: path,
+				location,
+				scope: "project",
+				status: existing ? "existing" : "ready",
+				suggested: false,
+				projectId: existing?.id
+			};
+			inventory.candidates.push(parent);
+			addScan(await service.scan({
+				source,
+				projectRoot: location,
+				projectOnly: true,
+				budget
+			}), canonicalTarget(resolveWorkspaceSkillsDir(location)), parent);
+		} catch {
+			inventory.complete = false;
+			inventory.notices.push(`${path}: some contents could not be scanned; only listed items can be imported.`);
+		}
+	}
+	const score = (item) => inventory.candidates.some((c) => c.parentId === item.id && ["ready", "conflict"].includes(c.status)) ? 0 : item.projectId ? 1 : 2;
+	const roots = inventory.candidates.filter((c) => c.kind === "project").sort((a, b) => score(a) - score(b) || a.name.localeCompare(b.name) || a.location.localeCompare(b.location));
+	inventory.candidates = [...inventory.candidates.filter((c) => c.scope === "user"), ...roots.flatMap((p) => [p, ...inventory.candidates.filter((c) => c.parentId === p.id)])];
+	new ImportSelectionRepository(owner).save("inventory", inventory);
+	return publicInventory(inventory);
+}
+function previewInventoryItem(service, owner, inventoryId, itemId) {
+	const item = getLiveInventory(owner, inventoryId).candidates.find((c) => c.id === itemId);
+	if (!item) throw new ImportError("not_found", "Item not found", 404);
+	if (item.status === "blocked") return {
+		text: item.reason ?? "",
+		truncated: false
+	};
+	const text = item.kind === "context" ? item.candidate?.content ?? "" : item.kind === "skill" ? Buffer.from(service.readSnapshot(item.scanId, item.id).find((f) => f.path === "SKILL.md").data, "base64").toString("utf8") : item.displayPath;
+	return {
+		text: text.slice(0, 2e4),
+		truncated: text.length > 2e4
+	};
+}
+//#endregion
+export { contextKey, existingContext, getLiveInventory, previewInventoryItem, publicInventory, scanProduct };

package/dist/src/imports/productImport.d.ts

@@ -1,10 +1,10 @@
 import type { ImportService } from './importService.js';
-import { type ImportSource, type ProductImportResult } from './types.js';
+import { type ImportSelection, type ProductImportResult } from './types.js';
 export declare function listImportSources(owner: string): {
     lastImport: ProductImportResult;
-    id: ImportSource;
+    id: import("./types.js").ImportSource;
     name: string;
     detected: boolean;
 }[];
-/** One product action. Destination services retain their existing scope and trust policies. */
-export declare function importProduct(service: ImportService, source: ImportSource, requestId?: string, owner?: string): Promise<ProductImportResult>;
+export declare function importSelection(service: ImportService, selection: ImportSelection, owner?: string): Promise<ProductImportResult>;
+export declare function recoverSelectionRuns(service: ImportService, owner: string): Promise<void>;

package/dist/src/imports/productImport.js

@@ -1,148 +1,241 @@
 import { resolveStateDir } from "../config/paths-state.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { init_paths } from "../config/paths.js";
 import { ProjectService } from "../projects/project-service.js";
 import { ImportError } from "./types.js";
+import { digest, fileHash, readRegularFile, readTree } from "./files.js";
 import { importContextDocument } from "./contextImport.js";
-import { ImportRepository } from "../storage/sqlite/import-repository.js";
+import { canonicalTarget, targetInventory } from "./planner.js";
 import { detectImportSources } from "./sources.js";
-import { resolveImportTarget } from "./runtime.js";
-import { isAbsolute, join, parse } from "node:path";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
+import { existingContext, getLiveInventory } from "./inventory.js";
+import { join } from "node:path";
 import { mkdirSync, realpathSync, statSync } from "node:fs";
-import { randomUUID } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
 import lockfile from "proper-lockfile";
 //#region src/imports/productImport.ts
 init_paths();
 function listImportSources(owner) {
-	const runs = new ImportRepository(owner).latestRuns();
+	const runs = new ImportSelectionRepository(owner).list("run");
 	return detectImportSources().map((source) => ({
 		...source,
 		lastImport: runs.find((r) => r.source === source.id)
 	}));
 }
-/** One product action. Destination services retain their existing scope and trust policies. */
-async function importProduct(service, source, requestId = randomUUID(), owner = "gateway-owner") {
-	const root = join(resolveStateDir(), "imports", "product-import");
-	mkdirSync(root, {
+function stale() {
+	throw new ImportError("inventory_stale", "Selected content or its destination changed. Refresh the list before importing.", 409);
+}
+function selectedItems(inventory, ids) {
+	if (!ids.length || new Set(ids).size !== ids.length) throw new ImportError("invalid_selection", "Select at least one item; duplicate selections are not allowed");
+	return ids.map((id) => {
+		const item = inventory.candidates.find((c) => c.id === id);
+		if (!item || item.status === "blocked" || item.status === "existing" && item.kind !== "project") throw new ImportError("invalid_selection", "Select available items from this list");
+		if (item.parentId && !ids.includes(item.parentId)) throw new ImportError("missing_parent", "Select the project entry along with its contents");
+		return item;
+	}).sort((a, b) => Number(b.kind === "project") - Number(a.kind === "project"));
+}
+async function preflight(service, inventory, items, retry) {
+	const projects = new ProjectService();
+	const names = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		await setImmediate();
+		try {
+			if (realpathSync(item.location) !== item.location) stale();
+			if (item.kind === "project") {
+				if (!statSync(item.location).isDirectory()) stale();
+				const existing = projects.findByWorkspaceRoot(item.location);
+				const expectedId = item.projectId ?? retry?.items.find((i) => i.candidateId === item.id)?.targetId;
+				if (existing?.id !== expectedId) stale();
+				continue;
+			}
+			const candidate = item.candidate;
+			const parent = item.parentId ? inventory.candidates.find((c) => c.id === item.parentId) : void 0;
+			if (item.kind === "context") {
+				if (digest(readRegularFile(item.location, 128 * 1024).toString("utf8").trim()) !== candidate.hash) stale();
+				const projectId = parent ? projects.findByWorkspaceRoot(parent.location)?.id : void 0;
+				if ((!parent || projectId) && existingContext(candidate, projectId)) stale();
+			} else {
+				if (parent && !service.isWorkspaceTrusted(parent.location)) stale();
+				if (fileHash(readTree(item.location)) !== candidate.hash) stale();
+				service.readSnapshot(item.scanId, candidate.id);
+				if (canonicalTarget(item.targetRoot) !== item.targetRoot) stale();
+				const key = `${item.targetRoot}:${item.targetName.toLowerCase()}`;
+				if (names.has(key)) stale();
+				names.add(key);
+				const existing = targetInventory(item.targetRoot);
+				const reserved = service.reservedNames({
+					root: item.targetRoot,
+					projectId: parent?.projectId
+				});
+				if ([...existing.flatMap((e) => [e.name, e.directory]), ...reserved].some((n) => n.toLowerCase() === item.targetName.toLowerCase())) stale();
+			}
+		} catch (error) {
+			if (error instanceof ImportError && error.code === "inventory_stale") throw error;
+			stale();
+		}
+	}
+}
+function summarize(run) {
+	run.skills = run.items.filter((i) => i.kind === "skill" && i.status === "imported").length;
+	run.context = run.items.filter((i) => i.kind === "context" && i.status === "imported").length;
+	run.projects = run.items.filter((i) => i.kind === "project" && i.status === "imported").length;
+	run.skipped = run.items.filter((i) => i.status === "existing").length;
+	run.issues = run.items.filter((i) => i.status === "failed").map((i) => ({
+		name: i.name,
+		reason: i.error
+	}));
+}
+async function execute(service, repo, inventory, run) {
+	const projects = new ProjectService();
+	const persist = () => {
+		summarize(run);
+		repo.save("run", run);
+	};
+	for (const entry of run.items.filter((i) => i.status === "pending")) {
+		await setImmediate();
+		const item = inventory.candidates.find((c) => c.id === entry.candidateId);
+		try {
+			if (Date.now() - run.createdAt > 720 * 60 * 6e4) throw new ImportError("expired", "Import recovery period expired. Scan again.");
+			const parent = item.parentId ? run.items.find((i) => i.candidateId === item.parentId) : void 0;
+			if (parent?.status === "failed") throw new ImportError("parent_failed", "The project could not be imported. Retry the project and its contents.");
+			if (item.kind === "project") {
+				if (realpathSync(item.location) !== item.location || !statSync(item.location).isDirectory()) stale();
+				runSqliteWriteTransaction(() => {
+					const existing = projects.findByWorkspaceRoot(item.location);
+					entry.targetId = (existing ?? projects.create({ workspaceRoot: item.location })).id;
+					entry.status = existing ? "existing" : "imported";
+					persist();
+				});
+			} else if (item.kind === "context") runSqliteWriteTransaction(() => {
+				if (parent && projects.get(parent.targetId)?.workspaceRoot !== inventory.candidates.find((c) => c.id === item.parentId).location) stale();
+				const status = importContextDocument(item.candidate, parent?.targetId);
+				if (status === "kept") throw new ImportError("conflict", "Existing context was kept. Refresh before importing.");
+				entry.targetId = existingContext(item.candidate, parent?.targetId)?.id;
+				entry.status = status === "created" ? "imported" : "existing";
+				persist();
+			});
+			else {
+				const key = `${run.id}:${item.id}`;
+				let job = service.jobByKey(key);
+				if (!job) {
+					const plan = service.plan(item.scanId, {
+						root: item.targetRoot,
+						projectId: parent?.targetId
+					}, [{
+						candidateId: item.id,
+						operation: item.targetName === item.candidate.name ? "create" : "rename",
+						name: item.targetName
+					}]);
+					job = service.apply(plan.id, key);
+				}
+				entry.jobId = job.id;
+				persist();
+				job = service.getJob(job.id);
+				const pending = job.items.filter((i) => ["staged", "failed"].includes(i.status));
+				if (pending.length) try {
+					job = await service.activate(job.id, pending.map((i) => i.action.candidateId));
+				} catch (error) {
+					job = service.getJob(job.id);
+					if (!job.items.every((i) => i.status === "active" || i.status === "skipped")) throw error;
+				}
+				const published = job.items[0];
+				if (!["active", "skipped"].includes(published.status)) throw new ImportError("publish_failed", published.error ?? "Could not publish the skill. Retry this item.");
+				entry.targetId = join(item.targetRoot, item.targetName);
+				entry.status = published.status === "active" ? "imported" : "existing";
+			}
+		} catch (error) {
+			entry.status = "failed";
+			delete entry.targetId;
+			entry.error = error instanceof ImportError ? error.message : "This item could not be imported. Check access and retry.";
+		}
+		persist();
+	}
+	run.status = run.items.some((i) => i.status === "failed") ? "partial" : "completed";
+	persist();
+	return run;
+}
+async function withImportLock(fn) {
+	const path = join(resolveStateDir(), "imports", "selection-lock");
+	mkdirSync(path, {
 		recursive: true,
 		mode: 448
 	});
-	const release = await lockfile.lock(root, {
+	const release = await lockfile.lock(path, {
 		realpath: false,
+		stale: 6e4,
 		retries: {
-			retries: 10,
+			retries: 15,
 			minTimeout: 100,
 			maxTimeout: 500
 		}
 	});
-	const repo = new ImportRepository(owner);
 	try {
+		return await fn();
+	} finally {
+		await release();
+	}
+}
+async function importSelection(service, selection, owner = "gateway-owner") {
+	return withImportLock(async () => {
+		const repo = new ImportSelectionRepository(owner);
+		const selectionHash = digest({
+			inventoryId: selection.inventoryId,
+			ids: [...selection.candidateIds].sort(),
+			retryOf: selection.retryOf
+		});
+		let previous;
 		try {
-			const previous = repo.get("run", requestId);
-			if (previous.source !== source) throw new ImportError("conflict", "Request belongs to another product", 409);
-			return previous;
+			previous = repo.get("run", selection.requestId);
 		} catch (error) {
 			if (!(error instanceof ImportError) || error.code !== "not_found") throw error;
 		}
-		if (!detectImportSources().some((s) => s.id === source && s.detected)) throw new ImportError("source_not_found", "This app is no longer available on the xopc device", 404);
-		const result = {
-			id: requestId,
-			source,
+		if (previous) {
+			if (previous.selectionHash !== selectionHash) throw new ImportError("conflict", "Request ID belongs to a different selection", 409);
+			return previous.status === "running" ? execute(service, repo, repo.get("inventory", previous.inventoryId), previous) : previous;
+		}
+		const inventory = getLiveInventory(owner, selection.inventoryId);
+		const items = selectedItems(inventory, selection.candidateIds);
+		const retry = selection.retryOf ? repo.get("run", selection.retryOf) : void 0;
+		if (retry) {
+			if (retry.status !== "partial" || retry.inventoryId !== inventory.id) throw new ImportError("invalid_selection", "Select failed items from the original import");
+			const failed = new Set(retry.items.filter((i) => i.status === "failed").map((i) => i.candidateId));
+			const parents = new Set(items.filter((i) => failed.has(i.id)).map((i) => i.parentId));
+			if (!items.some((i) => failed.has(i.id)) || items.some((i) => !failed.has(i.id) && !parents.has(i.id))) throw new ImportError("invalid_selection", "Retry can only include failed items and their project entries");
+		}
+		await preflight(service, inventory, items, retry);
+		const run = {
+			id: selection.requestId,
+			inventoryId: inventory.id,
+			selectionHash,
+			source: inventory.source,
 			createdAt: Date.now(),
+			status: "running",
 			skills: 0,
 			context: 0,
 			projects: 0,
 			skipped: 0,
-			issues: []
-		};
-		const budget = {
-			bytes: 0,
-			files: 0
-		};
-		const scan = service.scan({
-			source,
-			budget
-		});
-		const saveContext = (items, projectId) => {
-			for (const item of items.filter((c) => c.kind === "rule" && c.scope === (projectId ? "project" : "user"))) {
-				if (!item.content || item.compatibility !== "compatible") {
-					result.issues.push({
-						name: item.name,
-						reason: item.findings.join("; ")
-					});
-					continue;
-				}
-				try {
-					const status = importContextDocument(item, projectId);
-					if (status === "created") result.context++;
-					else if (status === "unchanged") result.skipped++;
-					else result.issues.push({
-						name: item.name,
-						reason: "Existing context was kept. The source document has changed."
-					});
-				} catch {
-					result.issues.push({
-						name: item.name,
-						reason: "Unable to save this context document. Try again."
-					});
-				}
-			}
-		};
-		const importScope = async (scopeScan, projectId) => {
-			const scoped = {
-				...scopeScan,
-				candidates: scopeScan.candidates.filter((c) => c.scope === (projectId ? "project" : "user"))
-			};
-			result.issues.push(...scopeScan.diagnostics.map((reason) => ({
-				name: source,
-				reason
-			})));
-			saveContext(scoped.candidates, projectId);
-			for (const item of scoped.candidates.filter((c) => c.kind === "mcp")) result.issues.push({
+			issues: [],
+			items: items.map((item) => ({
+				candidateId: item.id,
+				kind: item.kind,
 				name: item.name,
-				reason: "Reconnect this tool in Connections; credentials and executable settings are not transferred."
-			});
-			try {
-				const skills = await service.importSkills(scoped, resolveImportTarget(projectId));
-				result.skills += skills.imported;
-				result.skipped += skills.skipped;
-				result.issues.push(...skills.issues);
-			} catch (error) {
-				result.issues.push({
-					name: projectId ? "Project skills" : "Skills",
-					reason: error instanceof ImportError ? error.message : "Unable to import skills. Try again."
-				});
-			}
+				status: "pending"
+			}))
 		};
-		await importScope(scan);
-		const projects = new ProjectService();
-		const seen = /* @__PURE__ */ new Set();
-		for (const path of scan.projectRoots ?? []) try {
-			if (!isAbsolute(path) || parse(path).root === path || !statSync(path).isDirectory()) throw new Error("Invalid project");
-			const workspaceRoot = realpathSync(path);
-			if (seen.has(workspaceRoot)) continue;
-			seen.add(workspaceRoot);
-			let project = projects.findByWorkspaceRoot(workspaceRoot);
-			if (!project) {
-				project = projects.create({ workspaceRoot });
-				result.projects++;
-			} else result.skipped++;
-			await importScope(service.scan({
-				source,
-				projectRoot: workspaceRoot,
-				projectOnly: true,
-				budget
-			}), project.id);
-		} catch {
-			result.issues.push({
-				name: path,
-				reason: "Project unavailable; existing content was kept."
-			});
+		repo.save("run", run);
+		return execute(service, repo, inventory, run);
+	});
+}
+async function recoverSelectionRuns(service, owner) {
+	await withImportLock(async () => {
+		const repo = new ImportSelectionRepository(owner);
+		for (const run of repo.list("run").filter((r) => r.status === "running")) await execute(service, repo, repo.get("inventory", run.inventoryId), run);
+		const referenced = new Set(repo.list("run").map((r) => r.inventoryId));
+		for (const inventory of repo.list("inventory")) if (!referenced.has(inventory.id) && inventory.expiresAt < Date.now() || inventory.createdAt < Date.now() - 744 * 60 * 6e4) {
+			for (const scanId of inventory.scanIds) service.discardUnusedScan(scanId);
+			repo.deleteInventory(inventory.id);
 		}
-		repo.save("run", result);
-		return result;
-	} finally {
-		await release();
-	}
+	});
 }
 //#endregion
-export { importProduct, listImportSources };
+export { importSelection, listImportSources, recoverSelectionRuns };

package/dist/src/imports/runtime.js

@@ -8,6 +8,7 @@ import { ImportError } from "./types.js";
 import { ImportRepository } from "../storage/sqlite/import-repository.js";
 import { canonicalTarget } from "./planner.js";
 import { ImportService } from "./importService.js";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
 import { existsSync, realpathSync } from "node:fs";
 //#region src/imports/runtime.ts
 init_paths();
@@ -25,9 +26,11 @@ function createRuntimeImportService(owner, refreshSkills, checkTrust) {
 		owner,
 		stateDir: resolveStateDir(),
 		refreshSkills,
-		isConnected(candidate) {
+		isWorkspaceTrusted: (root) => checkTrust ? checkTrust(root) : new ProjectTrustStore().get(root) === true,
+		isConnected(candidate, sourceWorkspace) {
 			if (!candidate.shared) return false;
-			const workspaceDir = (candidate.scope === "project" ? new ProjectService().resolveForWorkspacePath(candidate.location)?.project : void 0)?.workspaceRoot;
+			const project = candidate.scope === "project" ? new ProjectService().resolveForWorkspacePath(candidate.location)?.project : void 0;
+			const workspaceDir = candidate.scope === "project" ? sourceWorkspace ?? project?.workspaceRoot : void 0;
 			return loadSkills({
 				workspaceDir,
 				workspaceTrust: workspaceDir && (checkTrust ? checkTrust(workspaceDir) : new ProjectTrustStore().get(workspaceDir) === true) ? "trusted" : "untrusted"
@@ -51,6 +54,8 @@ function createRuntimeImportService(owner, refreshSkills, checkTrust) {
 }
 async function recoverCapabilityImports() {
 	for (const owner of ImportRepository.owners()) await createRuntimeImportService(owner).recoverAndClean();
+	const { recoverSelectionRuns } = await import("./productImport.js");
+	for (const owner of ImportSelectionRepository.owners()) await recoverSelectionRuns(createRuntimeImportService(owner), owner);
 }
 //#endregion
 export { createRuntimeImportService, recoverCapabilityImports, resolveImportTarget };

package/dist/src/imports/scanner.d.ts

@@ -11,4 +11,4 @@ export interface ScanInput {
         files: number;
     };
 }
-export declare function scanLocal(input: ScanInput): ImportScan;
+export declare function scanLocal(input: ScanInput): Promise<ImportScan>;

package/dist/src/imports/scanner.js

@@ -6,6 +6,7 @@ import { IMPORT_SOURCES, sourceLayout } from "./sources.js";
 import { basename, join } from "node:path";
 import { existsSync, readdirSync, realpathSync } from "node:fs";
 import { randomUUID } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
 import { parse as parse$1 } from "smol-toml";
 //#region src/imports/scanner.ts
 function scanResult(source) {
@@ -31,7 +32,7 @@ function appendMcp(scan, raw, scope, location) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
 	for (const [name, config] of Object.entries(raw)) scan.candidates.push(inspectMcp(base(scan.source, scope, location), name, config));
 }
-function scanLocal(input) {
+async function scanLocal(input) {
 	const scan = scanResult(input.source);
 	const { home, root, layout } = sourceLayout(input.source, input.home, input.root);
 	const scopes = (input.projectOnly ? [] : layout.skills).map((s) => ({
@@ -64,6 +65,7 @@ function scanLocal(input) {
 			continue;
 		}
 		for (const entry of entries) {
+			await setImmediate();
 			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
 			const location = join(scope.path, entry.name);
 			if (!existsSync(join(location, "SKILL.md"))) continue;
@@ -96,9 +98,7 @@ function scanLocal(input) {
 			if (!input.projectOnly || config.scope === "project") appendMcp(scan, parsed[layout.config.mcpKey], config.scope, config.path);
 			const projects = parsed.projects;
 			if (config.scope === "user" && projects && typeof projects === "object" && !Array.isArray(projects)) {
-				const paths = Object.keys(projects);
-				scan.projectRoots = paths.slice(0, 100);
-				if (paths.length > 100) scan.diagnostics.push("Only the first 100 projects were imported.");
+				scan.projectRoots = Object.keys(projects);
 				if (input.projectRoot) {
 					const project = projects[input.projectRoot];
 					appendMcp(scan, project?.[layout.config.mcpKey], "project", config.path);