@xopcai/xopc 0.0.284 → 0.0.286

package/dist/src/gateway/side-chat/manager.js

@@ -46,9 +46,9 @@ var EphemeralSideChatManager = class {
 		this.sweepTimer?.unref();
 	}
 	async create(input) {
-		const parentSessionKey = input.parentSessionKey.trim();
+		const parentConversationId = input.parentConversationId.trim();
 		const clientInstanceId = input.clientInstanceId.trim();
-		if (!parentSessionKey || !clientInstanceId) throw new SideChatError("parentSessionKey and clientInstanceId are required", "INVALID_REQUEST");
+		if (!parentConversationId || !clientInstanceId) throw new SideChatError("parentConversationId and clientInstanceId are required", "INVALID_REQUEST");
 		await this.sweepExpired();
 		if (this.stopped || this.entries.size + [...this.reservations.values()].reduce((a, b) => a + b, 0) >= this.maxTotal) throw new SideChatError("The side chat capacity has been reached", "CAPACITY_REACHED");
 		if ([...this.entries.values()].filter((entry) => entry.clientInstanceId === clientInstanceId).length + (this.reservations.get(clientInstanceId) ?? 0) >= this.maxPerClient) throw new SideChatError(`A client can have at most ${this.maxPerClient} side chats`, "LIMIT_REACHED");
@@ -56,7 +56,7 @@ var EphemeralSideChatManager = class {
 		try {
 			return await this.createEntry({
 				...input,
-				parentSessionKey,
+				parentConversationId,
 				clientInstanceId
 			});
 		} finally {
@@ -66,10 +66,10 @@ var EphemeralSideChatManager = class {
 		}
 	}
 	async createEntry(input) {
-		const { parentSessionKey, clientInstanceId } = input;
-		const metadata = await this.options.getParentMetadata(parentSessionKey);
-		if (!metadata || !metadata.sessionId) throw new SideChatError("Parent session not found", "PARENT_NOT_FOUND");
-		const parentMessages = await this.options.loadParentMessages(parentSessionKey);
+		const { parentConversationId, clientInstanceId } = input;
+		const metadata = await this.options.getParentMetadata(parentConversationId);
+		if (!metadata || !metadata.transcriptId) throw new SideChatError("Parent session not found", "PARENT_NOT_FOUND");
+		const parentMessages = await this.options.loadParentMessages(parentConversationId);
 		if (this.stopped) throw new SideChatError("Gateway is stopping", "CAPACITY_REACHED");
 		let selections;
 		try {
@@ -81,7 +81,7 @@ var EphemeralSideChatManager = class {
 		const createdAt = new Date(now).toISOString();
 		const id = randomUUID();
 		const runtime = new InMemoryTranscriptRuntime({
-			runtimeId: `${parentSessionKey}:side-chat:${id}`,
+			runtimeId: `${parentConversationId}:side-chat:${id}`,
 			cwd: this.options.getWorkspacePath(metadata),
 			initialMessages: structuredClone(parentMessages)
 		});
@@ -89,12 +89,12 @@ var EphemeralSideChatManager = class {
 		if (selectionContext) runtime.openSessionManager(this.options.getWorkspacePath(metadata)).appendCustomMessageEntry("side-chat-selection", selectionContext, false);
 		runtime.captureBaseline();
 		const config = {
-			modelRef: normalizeOptionalString(input.config?.modelRef) || this.options.getDefaultModelRef(parentSessionKey),
-			thinkingLevel: input.config?.thinkingLevel ?? this.options.getDefaultThinkingLevel?.(parentSessionKey) ?? "medium"
+			modelRef: normalizeOptionalString(input.config?.modelRef) || this.options.getDefaultModelRef(parentConversationId),
+			thinkingLevel: input.config?.thinkingLevel ?? this.options.getDefaultThinkingLevel?.(parentConversationId) ?? "medium"
 		};
 		const entry = {
 			id,
-			parentSessionKey,
+			parentConversationId,
 			clientInstanceId,
 			status: "idle",
 			createdAt,
@@ -103,8 +103,8 @@ var EphemeralSideChatManager = class {
 			expiresAt: new Date(now + this.idleTtlMs).toISOString(),
 			messageCount: 0,
 			context: createSideChatContextSnapshot({
-				parentSessionKey,
-				parentSessionId: metadata.sessionId,
+				parentConversationId,
+				parentTranscriptId: metadata.transcriptId,
 				parentMessages,
 				selections,
 				createdAt

package/dist/src/gateway/side-chat/run-service.js

@@ -20,7 +20,7 @@ var SideChatRunService = class {
 		const run = {
 			sideChatId,
 			clientInstanceId,
-			executionSessionKey: this.options.manager.getRuntime(sideChatId, clientInstanceId).runtimeId,
+			executionConversationId: this.options.manager.getRuntime(sideChatId, clientInstanceId).runtimeId,
 			runId: randomUUID(),
 			abortController: new AbortController()
 		};
@@ -47,9 +47,9 @@ var SideChatRunService = class {
 		const active = this.activeBySideChat.get(sideChatId);
 		if (!active || active.clientInstanceId !== clientInstanceId || runId && active.runId !== runId) return false;
 		this.options.agentRunner.cancelClarificationForRun(active.runId);
-		this.options.agentRunner.unregisterExternalWebchatRun(active.executionSessionKey, active.runId);
+		this.options.agentRunner.unregisterExternalWebchatRun(active.executionConversationId, active.runId);
 		active.abortController.abort();
-		await abortEmbeddedRun(active.executionSessionKey).catch(() => false);
+		await abortEmbeddedRun(active.executionConversationId).catch(() => false);
 		return true;
 	}
 	async dispose(sideChatId, clientInstanceId) {
@@ -66,7 +66,7 @@ var SideChatRunService = class {
 		const topic = `run:${run.runId}`;
 		const mapper = new ChatStreamMapper({
 			runId: run.runId,
-			sessionKey: run.sideChatId,
+			conversationId: run.sideChatId,
 			channel: "side-chat"
 		});
 		const publish = (event) => {
@@ -91,7 +91,7 @@ var SideChatRunService = class {
 				media: input.attachments?.map(({ data: _data, ...attachment }) => attachment),
 				timestamp: Date.now()
 			});
-			this.options.agentRunner.registerExternalWebchatRun(run.executionSessionKey, run.runId, (event) => publishMapped(event), { beforeClarificationResponse: () => {
+			this.options.agentRunner.registerExternalWebchatRun(run.executionConversationId, run.runId, (event) => publishMapped(event), { beforeClarificationResponse: () => {
 				try {
 					this.options.manager.setStatus(run.sideChatId, run.clientInstanceId, "running");
 					return true;
@@ -100,8 +100,8 @@ var SideChatRunService = class {
 				}
 			} });
 			const result = await this.options.getAgentService().runEphemeralTurn({
-				executionSessionKey: run.executionSessionKey,
-				parentSessionKey: this.options.manager.get(run.sideChatId, run.clientInstanceId).parentSessionKey,
+				executionConversationId: run.executionConversationId,
+				parentConversationId: this.options.manager.get(run.sideChatId, run.clientInstanceId).parentConversationId,
 				runId: run.runId,
 				content: input.content,
 				attachments: input.attachments,
@@ -120,7 +120,7 @@ var SideChatRunService = class {
 			for (const event of mapper.error(message)) publish(event);
 			for (const event of mapper.end("error", message)) publish(event);
 		} finally {
-			this.options.agentRunner.unregisterExternalWebchatRun(run.executionSessionKey, run.runId);
+			this.options.agentRunner.unregisterExternalWebchatRun(run.executionConversationId, run.runId);
 			this.activeBySideChat.delete(run.sideChatId);
 			try {
 				this.options.manager.getMessages(run.sideChatId, run.clientInstanceId);

package/dist/src/gateway/side-chat/types.d.ts

@@ -30,8 +30,8 @@ export type SideChatSelection = {
     label?: string;
 };
 export interface SideChatContextSnapshot {
-    parentSessionKey: string;
-    parentSessionId: string;
+    parentConversationId: string;
+    parentTranscriptId: string;
     parentMessageCount: number;
     createdAt: string;
     selections: SideChatSelection[];
@@ -43,7 +43,7 @@ export interface SideChatConfig {
 }
 export interface SideChatView {
     id: string;
-    parentSessionKey: string;
+    parentConversationId: string;
     clientInstanceId: string;
     status: SideChatStatus;
     createdAt: string;
@@ -64,7 +64,7 @@ export interface SideChatView {
     config: SideChatConfig;
 }
 export interface CreateSideChatInput {
-    parentSessionKey: string;
+    parentConversationId: string;
     clientInstanceId: string;
     selections?: SideChatSelection[];
     config?: Partial<SideChatConfig>;

package/dist/src/heartbeat/wake.d.ts

@@ -1,7 +1,7 @@
 export interface WakeRequest {
     reason?: string;
     agentId?: string;
-    sessionKey?: string;
+    conversationId?: string;
     coalesceMs?: number;
 }
 /**

package/dist/src/history/ctx/exporter.js

@@ -10,7 +10,7 @@ function readSnapshot(db) {
 	db.exec("BEGIN");
 	try {
 		const transcripts = db.prepare(`SELECT
-         t.session_id,
+         t.transcript_id,
          t.status,
          t.created_at,
          t.archived_at,
@@ -18,36 +18,36 @@ function readSnapshot(db) {
          s.agent_id,
          s.session_type
        FROM transcripts t
-       JOIN sessions s ON s.session_key = t.session_key
+       JOIN sessions s ON s.conversation_id = t.conversation_id
        WHERE t.status = 'active' OR t.archive_reason IN ('reset', 'stale')
-       ORDER BY t.created_at ASC, t.session_id ASC`).all();
-		const entries = db.prepare(`SELECT e.entry_id, e.session_id, e.seq, e.payload_json, e.created_at
+       ORDER BY t.created_at ASC, t.transcript_id ASC`).all();
+		const entries = db.prepare(`SELECT e.entry_id, e.transcript_id, e.seq, e.payload_json, e.created_at
        FROM transcript_entries e
-       JOIN transcripts t ON t.session_id = e.session_id
-       JOIN sessions s ON s.session_key = t.session_key
+       JOIN transcripts t ON t.transcript_id = e.transcript_id
+       JOIN sessions s ON s.conversation_id = t.conversation_id
        WHERE t.status = 'active' OR t.archive_reason IN ('reset', 'stale')
-       ORDER BY t.created_at ASC, t.session_id ASC, e.seq ASC, e.entry_id ASC`).all();
+       ORDER BY t.created_at ASC, t.transcript_id ASC, e.seq ASC, e.entry_id ASC`).all();
 		db.exec("COMMIT");
 		const entriesBySession = /* @__PURE__ */ new Map();
 		for (const entry of entries) {
-			const bucket = entriesBySession.get(entry.session_id) ?? [];
+			const bucket = entriesBySession.get(entry.transcript_id) ?? [];
 			bucket.push({
 				entryId: entry.entry_id,
 				seq: entry.seq,
 				createdAt: entry.created_at,
 				payloadJson: entry.payload_json
 			});
-			entriesBySession.set(entry.session_id, bucket);
+			entriesBySession.set(entry.transcript_id, bucket);
 		}
 		return transcripts.map((transcript) => ({
-			sessionId: transcript.session_id,
+			transcriptId: transcript.transcript_id,
 			status: transcript.status,
 			createdAt: transcript.created_at,
 			archivedAt: transcript.archived_at,
 			cwd: transcript.cwd,
 			agentId: transcript.agent_id,
 			sessionType: transcript.session_type,
-			entries: entriesBySession.get(transcript.session_id) ?? []
+			entries: entriesBySession.get(transcript.transcript_id) ?? []
 		}));
 	} catch (error) {
 		try {

package/dist/src/history/ctx/format.d.ts

@@ -3,7 +3,7 @@ export declare const CTX_PROVIDER_KEY = "xopc";
 export declare const CTX_SOURCE_ID = "default";
 export declare const CTX_SOURCE_FORMAT = "xopc-session-history-v1";
 export interface XopcHistorySession {
-    sessionId: string;
+    transcriptId: string;
     status: string;
     createdAt: number;
     archivedAt: number | null;

package/dist/src/history/ctx/format.js

@@ -171,8 +171,8 @@ function splitTextByUtf8Bytes(text) {
 	}
 	return chunks;
 }
-function stableEventId(sessionId, entryId, eventOffset) {
-	return `xopc:${createHash("sha256").update(sessionId).update("\0").update(entryId).update("\0").update(String(eventOffset)).digest("hex")}`;
+function stableEventId(transcriptId, entryId, eventOffset) {
+	return `xopc:${createHash("sha256").update(transcriptId).update("\0").update(entryId).update("\0").update(String(eventOffset)).digest("hex")}`;
 }
 function serializeRecord(record) {
 	const line = JSON.stringify(record);
@@ -185,11 +185,11 @@ function sessionRecord(session) {
 	return {
 		record_type: "session",
 		source_id: CTX_SOURCE_ID,
-		provider_session_id: session.sessionId,
-		started_at: timestamp(session.createdAt, `session timestamp for ${session.sessionId}`),
+		provider_transcript_id: session.transcriptId,
+		started_at: timestamp(session.createdAt, `session timestamp for ${session.transcriptId}`),
 		external_agent_id: session.agentId,
 		cwd: session.cwd,
-		...session.archivedAt === null ? {} : { ended_at: timestamp(session.archivedAt, `session end timestamp for ${session.sessionId}`) },
+		...session.archivedAt === null ? {} : { ended_at: timestamp(session.archivedAt, `session end timestamp for ${session.transcriptId}`) },
 		status: active ? "active" : "completed",
 		agent_scope: session.sessionType === "workflow-subagent" ? "subagent" : "primary"
 	};
@@ -216,9 +216,9 @@ function entryRecords(session, entry) {
 			records.push({
 				record_type: "event",
 				source_id: CTX_SOURCE_ID,
-				provider_session_id: session.sessionId,
+				provider_transcript_id: session.transcriptId,
 				event_index: eventIndex,
-				event_id: stableEventId(session.sessionId, entry.entryId, offset),
+				event_id: stableEventId(session.transcriptId, entry.entryId, offset),
 				occurred_at: occurredAt,
 				event_type: event.eventType,
 				...event.role ? { role: event.role } : {},

package/dist/src/imports/contextImport.js

@@ -1,8 +1,9 @@
-import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { listKnowledgeItems, writeKnowledgeItem } from "../knowledge-memory/repository.js";
 import "../knowledge-memory/index.js";
 import { digest } from "./files.js";
 //#region src/imports/contextImport.ts
+init_transaction();
 /** Small source records fit the existing retrieval budget without injecting entire documents. */
 function importContextDocument(item, projectId) {
 	const content = item.content?.trim();

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;
+};