@xopcai/xopc 0.0.284 → 0.0.285

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,11 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
+import { proactiveChecksAllowed, proactivePreferences } from "../../proactive/policy/service.js";
+import { beginHeartbeatCheck, completeHeartbeatCheck, deliverHeartbeatChecks, recentHeartbeatChecks, recoverHeartbeatChecks } from "./check-store.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";
@@ -31,22 +33,41 @@ function heartbeatRunnerConfigFromConfig(cfg) {
 var HeartbeatService = class {
 	intervalId = null;
 	wake;
-	lastHeartbeatText = "";
-	lastHeartbeatAt = 0;
+	nextCheckAt = null;
+	deliveryTimer = null;
+	delivering = false;
+	recovered = false;
 	runnerConfig = null;
 	constructor(deps) {
 		this.deps = deps;
-		this.wake = createHeartbeatWake((reasons) => this.runHeartbeatOnce(reasons));
+		this.wake = createHeartbeatWake(async (reasons) => {
+			try {
+				await this.runHeartbeatOnce(reasons);
+			} catch (err) {
+				log.error({ err }, "Heartbeat check failed unexpectedly");
+			}
+		});
 	}
 	start(config) {
+		if (this.runnerConfig) this.stop();
 		if (!config.enabled) {
 			log.info("Heartbeat disabled");
 			this.runnerConfig = null;
 			return;
 		}
 		this.runnerConfig = config;
+		if (!this.recovered) {
+			recoverHeartbeatChecks(this.deps.getWorkspace());
+			this.recovered = true;
+		}
+		this.deliveryTimer = setInterval(() => {
+			this.drainDeliveries().catch((err) => log.warn({ err }, "Heartbeat delivery check failed"));
+		}, 1e4);
+		this.deliveryTimer.unref?.();
+		this.nextCheckAt = new Date(Date.now() + config.intervalMs).toISOString();
 		log.info({ intervalMs: config.intervalMs }, "Heartbeat timer started (interval wake)");
 		this.intervalId = setInterval(() => {
+			this.nextCheckAt = new Date(Date.now() + config.intervalMs).toISOString();
 			this.wake.request({ reason: "interval" });
 		}, config.intervalMs);
 		this.intervalId.unref?.();
@@ -56,6 +77,9 @@ var HeartbeatService = class {
 		this.wake.request({ reason: opts?.reason ?? "manual" });
 	}
 	stop() {
+		if (this.deliveryTimer) clearInterval(this.deliveryTimer);
+		this.deliveryTimer = null;
+		this.nextCheckAt = null;
 		if (this.intervalId) {
 			clearInterval(this.intervalId);
 			this.intervalId = null;
@@ -73,6 +97,24 @@ var HeartbeatService = class {
 	isRunning() {
 		return this.intervalId !== null;
 	}
+	status() {
+		const preferences = proactivePreferences(this.deps.getWorkspace());
+		return {
+			enabled: Boolean(this.runnerConfig?.enabled),
+			checksAllowed: proactiveChecksAllowed(preferences),
+			nextCheckAt: proactiveChecksAllowed(preferences) ? this.nextCheckAt : null,
+			recent: recentHeartbeatChecks(this.deps.getWorkspace())
+		};
+	}
+	async drainDeliveries() {
+		if (this.delivering || !this.runnerConfig?.enabled) return;
+		this.delivering = true;
+		try {
+			await deliverHeartbeatChecks(this.deps.getWorkspace(), this.deps.messageBus, this.runnerConfig.target?.trim(), this.runnerConfig.targetChatId?.trim());
+		} finally {
+			this.delivering = false;
+		}
+	}
 	async runHeartbeatOnce(reasons) {
 		const reasonSummary = [...new Set(reasons)].join(", ") || "unknown";
 		const cfg = this.runnerConfig;
@@ -80,36 +122,34 @@ var HeartbeatService = class {
 			log.debug({ reasons: reasonSummary }, "Heartbeat: skip (disabled)");
 			return;
 		}
+		if (!proactiveChecksAllowed(proactivePreferences(this.deps.getWorkspace()))) return;
 		if (cfg.activeHours && !isWithinActiveHours(cfg.activeHours)) {
 			log.debug({ reasons: reasonSummary }, "Heartbeat: skip (outside active hours)");
 			return;
 		}
+		const checkId = beginHeartbeatCheck(this.deps.getWorkspace());
 		const heartbeatPath = resolveHeartbeatMdPath(this.deps.getConfig());
 		if (!heartbeatPath) {
-			log.debug({ reasons: reasonSummary }, "Heartbeat: skip (no HEARTBEAT path)");
+			completeHeartbeatCheck(checkId, "blocked", "No workspace checklist path");
 			return;
 		}
 		let heartbeatContent;
 		try {
 			const raw = await readFile(heartbeatPath, "utf-8");
 			if (isHeartbeatContentEmpty(raw)) {
-				log.debug({
-					path: heartbeatPath,
-					reasons: reasonSummary
-				}, "Heartbeat: skip (HEARTBEAT.md empty)");
+				completeHeartbeatCheck(checkId, "empty_checklist");
 				return;
 			}
 			heartbeatContent = raw.trim();
 		} catch {
-			log.debug({
-				path: heartbeatPath,
-				reasons: reasonSummary
-			}, "Heartbeat: HEARTBEAT.md missing; continuing");
+			completeHeartbeatCheck(checkId, "blocked", "Checklist could not be read");
+			return;
 		}
 		const sessionKey = cfg.isolatedSession ? `heartbeat:isolated:${Date.now()}` : "heartbeat:main";
 		let basePrompt = (cfg.prompt?.trim() || DEFAULT_PROMPT).trim();
 		if (heartbeatContent) basePrompt = `${basePrompt}\n\n---\nHEARTBEAT.md:\n${heartbeatContent}\n---`;
 		basePrompt = appendCronEventLines(basePrompt, reasons);
+		basePrompt += "\nReturn notifications in your final response. Do not send messages, media or voice directly; delivery follows the user notification policy.";
 		const prompt = `${basePrompt}\n\nCurrent time: ${(/* @__PURE__ */ new Date()).toISOString()}`;
 		const ackMax = cfg.ackMaxChars ?? 300;
 		log.debug({
@@ -143,14 +183,21 @@ var HeartbeatService = class {
 				source: "heartbeat"
 			});
 		} catch (error) {
+			completeHeartbeatCheck(checkId, "failed", "Agent check failed; see gateway logs");
 			log.error({ err: error }, "Heartbeat: agent call failed");
 			return;
 		}
+		if (cfg !== this.runnerConfig || !proactiveChecksAllowed(proactivePreferences(this.deps.getWorkspace()))) {
+			completeHeartbeatCheck(checkId, "cancelled", "Checks paused or configuration changed");
+			return;
+		}
 		if (!reply?.trim()) {
+			completeHeartbeatCheck(checkId, "no_change");
 			log.debug({ reasons: reasonSummary }, "Heartbeat: skip (empty model reply)");
 			return;
 		}
 		if (shouldSilence(reply, ackMax)) {
+			completeHeartbeatCheck(checkId, "no_change");
 			log.info({
 				ackMax,
 				replyChars: reply.length,
@@ -159,38 +206,8 @@ var HeartbeatService = class {
 			return;
 		}
 		const { stripped } = stripHeartbeatToken(reply);
-		const finalText = stripped || reply.trim();
-		if (this.isDuplicate(finalText)) {
-			log.info({
-				finalTextChars: finalText.length,
-				reasons: reasonSummary
-			}, "Heartbeat: not sent — duplicate within 24h");
-			return;
-		}
-		const target = cfg.target?.trim();
-		const targetChatId = cfg.targetChatId?.trim();
-		if (Boolean(target && targetChatId)) {
-			await this.deps.messageBus.publishOutbound({
-				channel: target,
-				chat_id: targetChatId,
-				content: finalText,
-				type: "message"
-			});
-			log.info({
-				reasons: reasonSummary,
-				channel: target,
-				chatId: targetChatId,
-				contentChars: finalText.length
-			}, "Heartbeat: sent — outbound queued");
-		} else log.info({
-			reasons: reasonSummary,
-			finalTextChars: finalText.length
-		}, "Heartbeat: not sent — no delivery target (set gateway.heartbeat.target + targetChatId)");
-		this.lastHeartbeatText = finalText;
-		this.lastHeartbeatAt = Date.now();
-	}
-	isDuplicate(text) {
-		return text.trim() === this.lastHeartbeatText.trim() && Date.now() - this.lastHeartbeatAt < 1440 * 60 * 1e3;
+		completeHeartbeatCheck(checkId, "prepared", void 0, stripped || reply.trim(), cfg.target?.trim(), cfg.targetChatId?.trim());
+		await this.drainDeliveries();
 	}
 };
 //#endregion

package/dist/src/gateway/hono/routes/discussions.js

@@ -1,11 +1,11 @@
 import { DISCUSSION_STATUSES } from "../../../../packages/gateway-contract/src/discussions.js";
 import { hasGatewayScope } from "../../security/gateway-scopes.js";
 import { DiscussionServiceError } from "../../../discussions/errors.js";
-import { convertMeetingAction, meetingActionTasks } from "../../../discussions/action-tasks.js";
 import { MeetingEditSchema } from "../../../discussions/edits.js";
-import { exportDiscussion } from "../../../discussions/export.js";
 import "../../../discussions/index.js";
 import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import { convertMeetingAction, meetingActionTasks } from "../../../discussions/action-tasks.js";
+import { exportDiscussion } from "../../../discussions/export.js";
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
 import { Readable } from "node:stream";

package/dist/src/gateway/hono/routes/imports.js

@@ -1,12 +1,20 @@
 import { getGatewayPrincipal } from "../../security/gateway-principal.js";
 import { ImportError } from "../../../imports/types.js";
 import { isImportSource } from "../../../imports/sources.js";
+import { ImportSelectionRepository } from "../../../storage/sqlite/import-selection-repository.js";
+import { getLiveInventory, previewInventoryItem, publicInventory, scanProduct } from "../../../imports/inventory.js";
+import { importSelection, listImportSources } from "../../../imports/productImport.js";
 import { createRuntimeImportService } from "../../../imports/runtime.js";
-import { importProduct, listImportSources } from "../../../imports/productImport.js";
 import { z } from "zod";
 //#region src/gateway/hono/routes/imports.ts
-const requestSchema = z.object({ requestId: z.string().uuid() }).strict();
+const selectionSchema = z.object({
+	inventoryId: z.string().uuid(),
+	candidateIds: z.array(z.string().uuid()).min(1).max(5e3),
+	requestId: z.string().uuid(),
+	retryOf: z.string().uuid().optional()
+}).strict();
 function registerImportRoutes(app, deps) {
+	const service = () => createRuntimeImportService("gateway-owner", () => deps.service.agentService.refreshSkillsAfterDiskChange(), (root) => deps.service.agentService.getWorkspaceTrust(root).trusted);
 	const respond = async (c, run) => {
 		try {
 			if (getGatewayPrincipal(c).kind !== "owner") throw new ImportError("owner_required", "Only the Gateway owner can import local capabilities", 403);
@@ -28,17 +36,21 @@ function registerImportRoutes(app, deps) {
 			return c.json({
 				ok: false,
 				code: "import_failed",
-				error: "Import could not finish. Try again; existing content is preserved."
+				error: "Import could not finish. Existing content is preserved."
 			}, 400);
 		}
 	};
 	app.get("/api/imports/sources", (c) => respond(c, () => ({ sources: listImportSources("gateway-owner") })));
-	app.post("/api/imports/sources/:source/import", deps.strictRateLimitMiddleware, (c) => respond(c, async () => {
+	app.post("/api/imports/sources/:source/scan", deps.strictRateLimitMiddleware, (c) => respond(c, async () => {
 		const source = c.req.param("source");
 		if (!isImportSource(source)) throw new ImportError("unsupported_source", "Unsupported source");
-		const { requestId } = requestSchema.parse(await c.req.json());
-		return importProduct(createRuntimeImportService("gateway-owner", () => deps.service.agentService.refreshSkillsAfterDiskChange(), (root) => deps.service.agentService.getWorkspaceTrust(root).trusted), source, requestId);
+		z.object({}).strict().parse(await c.req.json());
+		return scanProduct(service(), source);
 	}));
+	app.get("/api/imports/inventories/:id", (c) => respond(c, () => publicInventory(getLiveInventory("gateway-owner", c.req.param("id")))));
+	app.get("/api/imports/inventories/:id/items/:itemId/preview", (c) => respond(c, () => previewInventoryItem(service(), "gateway-owner", c.req.param("id"), c.req.param("itemId"))));
+	app.post("/api/imports/runs", deps.strictRateLimitMiddleware, (c) => respond(c, async () => importSelection(service(), selectionSchema.parse(await c.req.json()))));
+	app.get("/api/imports/runs/:id", (c) => respond(c, () => new ImportSelectionRepository("gateway-owner").get("run", c.req.param("id"))));
 }
 //#endregion
 export { registerImportRoutes };

package/dist/src/gateway/hono/routes/proactive-control.js

@@ -33,7 +33,8 @@ function registerProactiveControlRoutes(app, deps) {
 	}));
 	app.get("/api/proactive/overview", (c) => c.json({
 		ok: true,
-		...delegationOverview(workspace())
+		...delegationOverview(workspace()),
+		heartbeat: deps.service.heartbeatStatus()
 	}));
 	app.post("/api/proactive/delegations", deps.strictRateLimitMiddleware, async (c) => c.json({
 		ok: true,

package/dist/src/gateway/run-loop.js

@@ -1,6 +1,6 @@
 import { loadConfig } from "../config/loader.js";
-import { isRestartEnabled } from "../config/commands.flags.js";
 import "../config/index.js";
+import { isRestartEnabled } from "../config/commands.flags.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { restartGatewayProcessWithFreshPid } from "./respawn.js";
 import { acquireGatewayLock } from "./lock.js";

package/dist/src/gateway/service.d.ts

@@ -124,6 +124,7 @@ export declare class GatewayService {
     private ensureHeartbeatService;
     private createTaskRunDispatcher;
     private createNotificationService;
+    private readonly taskRunDispatch;
     dispatchTaskRuns(): void;
     ensureTaskConversation(taskId: string, options?: {
         runId?: string;
@@ -255,6 +256,12 @@ export declare class GatewayService {
         manageable: boolean;
         order: number;
     }>;
+    heartbeatStatus(): {
+        enabled: boolean;
+        checksAllowed: boolean;
+        nextCheckAt: string;
+        recent: import("./heartbeat/check-store.js").HeartbeatCheck[];
+    };
     /**
      * Request an immediate heartbeat run (coalesced like interval/cron wakes).
      */

package/dist/src/gateway/service.js

@@ -63,23 +63,24 @@ import { ConnectionRecoveryService } from "../connectors/connection-recovery-ser
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
-import { DiscussionService } from "../discussions/service.js";
-import { DiscussionOrganizer } from "../discussions/organizer.js";
-import { DiscussionLiveWorker } from "../discussions/live-worker.js";
-import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
-import { DiscussionSealer } from "../discussions/sealer.js";
-import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
+import { createBackgroundTask } from "../infra/background-task.js";
 import { buildTaskAgentContext } from "../agent/source-context/task-context.js";
 import { deliverProactiveCard } from "../proactive/inbox/delivery.js";
 import { WorkDiscoveryService } from "../work-discovery/service.js";
 import { buildVoiceMemoryContext } from "../voice/realtime/memory-context.js";
 import { buildVoicePersonaContext } from "../voice/realtime/persona-context.js";
 import { voiceMemoryBudget, voicePersonaBudget } from "../voice/realtime/conversation-context.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionOrganizer } from "../discussions/organizer.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
+import { DiscussionSealer } from "../discussions/sealer.js";
+import "../discussions/index.js";
 import { NotesStore } from "../notes/store.js";
 import { buildNoteAgentContext } from "../notes/agent-context.js";
 import { NotesService } from "../notes/service.js";
@@ -665,7 +666,8 @@ var GatewayService = class {
 			agentService: this.ensureAgentService(),
 			messageBus: this.bus,
 			sessionStore: this.sessionIndex.getStore(),
-			getConfig: () => this.config
+			getConfig: () => this.config,
+			getWorkspace: () => this.workspacePath
 		});
 		return this.heartbeatService;
 	}
@@ -721,11 +723,21 @@ var GatewayService = class {
 		});
 		return this.notificationService;
 	}
-	dispatchTaskRuns() {
+	taskRunDispatch = createBackgroundTask(async () => {
 		new TaskSignalService().tick();
 		this.dispatchTaskEvents();
 		this.createTaskRunDispatcher().dispatch();
-		this.createWorkflowRunService().dispatchTaskRuns();
+		await this.createWorkflowRunService().dispatchTaskRuns();
+	}, (err) => {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		log.error({
+			err,
+			errorMessage,
+			phase: "task_run_dispatch"
+		}, `Task dispatch failed: ${errorMessage}`);
+	});
+	dispatchTaskRuns() {
+		this.taskRunDispatch();
 	}
 	async ensureTaskConversation(taskId, options = {}) {
 		const task = new TaskRepository().require(taskId);
@@ -1431,6 +1443,9 @@ var GatewayService = class {
 			return a.id.localeCompare(b.id);
 		});
 	}
+	heartbeatStatus() {
+		return this.heartbeatService?.status() ?? null;
+	}
 	/**
 	* Request an immediate heartbeat run (coalesced like interval/cron wakes).
 	*/

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

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

@@ -1,11 +1,12 @@
 import { type ScanInput } from './scanner.js';
-import { type ImportAction, type ImportJob, type ImportScan, type ImportTarget } from './types.js';
+import { type ImportAction, type ImportFile, type ImportJob, type ImportScan, type ImportTarget } from './types.js';
 export interface ImportServiceOptions {
     stateDir: string;
     owner: string;
     validateTarget?: (target: ImportTarget) => void;
-    isConnected?: (candidate: ImportScan['candidates'][number]) => boolean;
+    isConnected?: (candidate: ImportScan['candidates'][number], workspaceRoot?: string) => boolean;
     reservedNames?: (target: ImportTarget) => string[];
+    isWorkspaceTrusted?: (root: string) => boolean;
     refreshSkills?: () => void | Promise<void>;
 }
 export declare class ImportService {
@@ -13,20 +14,24 @@ export declare class ImportService {
     private readonly repo;
     private readonly root;
     constructor(options: ImportServiceOptions);
-    scan(input: ScanInput): ImportScan;
+    scan(input: ScanInput): Promise<ImportScan>;
     getScan(id: string): ImportScan;
-    private storeScan;
+    discardUnusedScan(id: string): void;
+    storeScan(scan: ImportScan, workspaceRoot?: string): ImportScan;
     plan(scanId: string, target: ImportTarget, choices: Array<Pick<ImportAction, 'candidateId' | 'operation'> & {
         name?: string;
     }>): import("./types.js").ImportPlan;
-    importSkills(scan: ImportScan, target: ImportTarget): Promise<{
-        imported: number;
-        skipped: number;
-        issues: Array<{
-            name: string;
-            reason: string;
-        }>;
-    }>;
+    describeSkills(scan: ImportScan, target: ImportTarget): {
+        candidate: import("./types.js").ImportCandidate;
+        status: import("./types.js").InventoryStatus;
+        reason: string;
+        targetName: string;
+    }[];
+    readSnapshot(scanId: string, candidateId: string): ImportFile[];
+    jobByKey(key: string): ImportJob;
+    validateTarget(target: ImportTarget): void;
+    reservedNames(target: ImportTarget): string[];
+    isWorkspaceTrusted(root: string): boolean;
     getPlan(id: string): import("./types.js").ImportPlan;
     apply(planId: string, key: string): ImportJob;
     private renameSkill;

package/dist/src/imports/importService.js

@@ -30,13 +30,23 @@ var ImportService = class {
 			mode: 448
 		});
 	}
-	scan(input) {
-		return this.storeScan(scanLocal(input));
+	async scan(input) {
+		return this.storeScan(await scanLocal(input), input.projectRoot);
 	}
 	getScan(id) {
 		return this.repo.get("scan", id);
 	}
-	storeScan(scan) {
+	discardUnusedScan(id) {
+		this.lock(() => {
+			if (this.repo.jobs(-1).some((job) => job.plan.scanId === id)) return;
+			rmSync(join(this.root, id), {
+				recursive: true,
+				force: true
+			});
+			this.repo.deleteScan(id);
+		});
+	}
+	storeScan(scan, workspaceRoot) {
 		const dir = join(this.root, scan.id);
 		mkdirSync(dir, { mode: 448 });
 		for (const item of scan.candidates) if (item.kind === "skill" && item.compatibility === "compatible") writeTextAtomicSync(join(dir, `${item.id}.json`), JSON.stringify(item.files));
@@ -44,7 +54,7 @@ var ImportService = class {
 			...scan,
 			candidates: scan.candidates.map((c) => ({
 				...c,
-				connected: this.options.isConnected?.(c) ?? false,
+				connected: this.options.isConnected?.(c, workspaceRoot) ?? false,
 				files: c.files.map((f) => ({
 					...f,
 					data: ""
@@ -60,84 +70,71 @@ var ImportService = class {
 		this.repo.save("plan", plan);
 		return plan;
 	}
-	async importSkills(scan, target) {
+	describeSkills(scan, target) {
 		const inventory = targetInventory(target.root);
 		const names = new Set([...this.options.reservedNames?.(target) ?? [], ...inventory.flatMap((i) => [i.directory, i.name])].map((n) => n.toLowerCase()));
-		const choices = [];
-		const result = {
-			imported: 0,
-			skipped: 0,
-			issues: []
-		};
 		const previous = /* @__PURE__ */ new Map();
 		for (const job of this.repo.jobs(-1)) {
 			if (job.plan.target.root !== canonicalTarget(target.root)) continue;
 			const origin = this.getScan(job.plan.scanId);
 			for (const item of job.items.filter((i) => i.status === "active")) {
 				const candidate = origin.candidates.find((c) => c.id === item.action.candidateId);
-				if (candidate?.source === scan.source && !previous.has(candidate.location)) previous.set(candidate.location, { name: item.action.name });
+				if (candidate?.source === scan.source && !previous.has(candidate.location)) previous.set(candidate.location, item.action.name);
 			}
 		}
-		for (const candidate of scan.candidates.filter((c) => c.kind === "skill")) {
-			if (candidate.connected) {
-				result.skipped++;
-				continue;
-			}
-			if (candidate.compatibility !== "compatible") {
-				result.issues.push({
-					name: candidate.name,
-					reason: candidate.findings.join("; ")
-				});
-				continue;
-			}
-			const prior = previous.get(candidate.location);
-			const priorTarget = prior && inventory.find((i) => i.directory === prior.name);
-			if (prior && priorTarget) {
-				const files = JSON.parse(readFileSync(join(this.root, scan.id, `${candidate.id}.json`), "utf8"));
-				if (fileHash(this.renameSkill(files, prior.name)) === priorTarget.hash) result.skipped++;
-				else result.issues.push({
-					name: candidate.name,
-					reason: "The previously imported skill has changed. Existing content was kept."
-				});
-				continue;
-			}
-			if (inventory.find((i) => i.name.toLowerCase() === candidate.name.toLowerCase())?.hash === candidate.hash) {
-				result.skipped++;
-				continue;
-			}
-			let name = candidate.name;
-			if (names.has(name.toLowerCase())) name = `${candidate.source}-${candidate.name}`.slice(0, 63);
-			const files = JSON.parse(readFileSync(join(this.root, scan.id, `${candidate.id}.json`), "utf8"));
-			const hash = fileHash(this.renameSkill(files, name));
-			if (inventory.some((i) => i.name === name && i.hash === hash)) {
-				result.skipped++;
-				continue;
-			}
-			if (names.has(name.toLowerCase())) {
-				result.issues.push({
-					name: candidate.name,
-					reason: "An existing skill was kept. Manage it in Skills to make changes."
-				});
-				continue;
+		return scan.candidates.filter((c) => c.kind === "skill").map((candidate) => {
+			let status = "ready";
+			let reason;
+			let targetName = candidate.name;
+			if (candidate.connected) status = "existing";
+			else if (candidate.compatibility !== "compatible") {
+				status = "blocked";
+				reason = candidate.findings.join("; ");
+			} else {
+				const prior = previous.get(candidate.location);
+				const priorTarget = prior && inventory.find((i) => i.directory === prior);
+				const files = this.readSnapshot(scan.id, candidate.id);
+				if (priorTarget) {
+					targetName = priorTarget.directory;
+					status = fileHash(this.renameSkill(files, targetName)) === priorTarget.hash ? "existing" : "blocked";
+					if (status === "blocked") reason = "Previously imported content has changed; existing edits will be kept.";
+				} else if (inventory.some((i) => i.name.toLowerCase() === candidate.name.toLowerCase() && i.hash === candidate.hash)) status = "existing";
+				else if (names.has(targetName.toLowerCase())) {
+					targetName = `${candidate.source}-${candidate.name}`.slice(0, 63);
+					if (inventory.some((i) => i.name === targetName && i.hash === fileHash(this.renameSkill(files, targetName)))) status = "existing";
+					else if (names.has(targetName.toLowerCase())) {
+						status = "blocked";
+						reason = "Both the original and product-prefixed names are in use.";
+					} else status = "conflict";
+				}
 			}
-			names.add(name.toLowerCase());
-			choices.push({
-				candidateId: candidate.id,
-				operation: name === candidate.name ? "create" : "rename",
-				name
-			});
-		}
-		if (!choices.length) return result;
-		const plan = this.plan(scan.id, target, choices);
-		const staged = this.apply(plan.id, plan.id);
-		const job = await this.activate(staged.id, staged.items.filter((i) => i.status === "staged").map((i) => i.action.candidateId));
-		for (const item of job.items) if (item.status === "active") result.imported++;
-		else if (item.status === "skipped") result.skipped++;
-		else result.issues.push({
-			name: item.action.name,
-			reason: item.error ?? "Could not import this skill. Try again."
+			if (status === "ready" || status === "conflict") names.add(targetName.toLowerCase());
+			return {
+				candidate,
+				status,
+				reason,
+				targetName
+			};
 		});
-		return result;
+	}
+	readSnapshot(scanId, candidateId) {
+		const candidate = this.getScan(scanId).candidates.find((c) => c.id === candidateId);
+		if (!candidate || candidate.kind !== "skill" || candidate.compatibility !== "compatible") throw new ImportError("not_found", "Snapshot not found", 404);
+		const files = JSON.parse(readFileSync(join(this.root, scanId, `${candidateId}.json`), "utf8"));
+		if (fileHash(files) !== candidate.hash) throw new ImportError("source_changed", "Snapshot changed", 409);
+		return files;
+	}
+	jobByKey(key) {
+		return this.repo.byKey(key);
+	}
+	validateTarget(target) {
+		this.options.validateTarget?.(target);
+	}
+	reservedNames(target) {
+		return this.options.reservedNames?.(target) ?? [];
+	}
+	isWorkspaceTrusted(root) {
+		return this.options.isWorkspaceTrusted?.(root) ?? false;
 	}
 	getPlan(id) {
 		return this.repo.get("plan", id);

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

@@ -0,0 +1,11 @@
+import type { ImportService } from './importService.js';
+import { type ImportSource, type ImportInventory, type StoredInventory, type ImportCandidate } from './types.js';
+export declare function contextKey(candidate: ImportCandidate): string;
+export declare function existingContext(candidate: ImportCandidate, projectId?: string): import("../knowledge-memory/domain.js").KnowledgeItem;
+export declare function publicInventory(inventory: StoredInventory): ImportInventory;
+export declare function getLiveInventory(owner: string, id: string): StoredInventory;
+export declare function scanProduct(service: ImportService, source: ImportSource, owner?: string): Promise<ImportInventory>;
+export declare function previewInventoryItem(service: ImportService, owner: string, inventoryId: string, itemId: string): {
+    text: string;
+    truncated: boolean;
+};