@openbkn/dsh-business-context 0.1.5-rc.1

package/lib/index.js

@@ -0,0 +1,1788 @@
+import Schema from "@deepseek-ai/schemastery";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import * as McpClient from "@deepseek-ai/dsh-mcp-client";
+import { createHash } from "node:crypto";
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+//#region src/config.ts
+/** Runtime schema and conservative defaults for the host plugin row. */
+const Config = Schema.object({
+	baseUrl: Schema.string().required(),
+	mcpUrl: Schema.string(),
+	businessDomain: Schema.string().pattern(/^[A-Za-z0-9_-]{1,64}$/),
+	cliPath: Schema.string().default("openbkn"),
+	requestTimeoutMs: Schema.natural().min(1).default(3e4),
+	maxResultBytes: Schema.natural().min(1).default(1e6),
+	maxGraphNodes: Schema.natural().min(1).default(200),
+	maxGraphEdges: Schema.natural().min(1).default(400),
+	allowInsecureTls: Schema.boolean().default(false)
+});
+//#endregion
+//#region src/business-network-catalog.ts
+/**
+* Convert one platform response into the bounded data shape consumed by the
+* network selector. The platform remains the authorization authority; this
+* function only removes unneeded fields and rejects malformed rows.
+*/
+function parseVisibleBusinessNetworks(value) {
+	const entries = entriesOf(value);
+	if (entries === void 0) throw new Error("OpenBKN returned an invalid network list.");
+	const seen = /* @__PURE__ */ new Set();
+	const networks = [];
+	for (const entry of entries) {
+		const network = networkOf(entry);
+		if (network === void 0 || seen.has(network.id)) continue;
+		seen.add(network.id);
+		networks.push(network);
+	}
+	return networks;
+}
+function entriesOf(value) {
+	if (!isRecord$3(value)) return void 0;
+	if (Array.isArray(value.entries)) return value.entries;
+	if (isRecord$3(value.result) && Array.isArray(value.result.entries)) return value.result.entries;
+}
+function networkOf(value) {
+	if (!isRecord$3(value) || typeof value.id !== "string" || typeof value.name !== "string") return void 0;
+	const id = value.id.trim();
+	const displayName = value.name.trim();
+	if (id.length === 0 || displayName.length === 0) return void 0;
+	const description = stringOrUndefined(value.description) ?? stringOrUndefined(value.comment);
+	return {
+		id,
+		displayName,
+		...description === void 0 ? {} : { description }
+	};
+}
+function stringOrUndefined(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/session-binding.ts
+/** Durable DSH event type for the business network selected by a session. */
+const BUSINESS_NETWORK_BOUND_EVENT = "openbkn/business-network-bound";
+/** A durable session already names a different OpenBKN network or platform. */
+var BusinessNetworkBindingConflictError = class extends Error {
+	existing;
+	requested;
+	constructor(existing, requested) {
+		super(`This DSH session is already bound to ${existing.platformBaseUrl}/${existing.knowledgeNetworkId}; cannot bind ${requested.platformBaseUrl}/${requested.knowledgeNetworkId}`);
+		this.existing = existing;
+		this.requested = requested;
+		this.name = "BusinessNetworkBindingConflictError";
+	}
+};
+/** Reconstruct the one permitted business-network binding from a DSH event log. */
+function readBusinessNetworkBinding(events) {
+	let binding;
+	for (const event of events) {
+		if (event.type !== "openbkn/business-network-bound") continue;
+		const next = parseBinding(event.data);
+		if (binding === void 0) {
+			binding = next;
+			continue;
+		}
+		if (!sameIdentity(binding, next)) throw new BusinessNetworkBindingConflictError(binding, next);
+	}
+	return binding;
+}
+/**
+* Decide whether selection emits the one durable event. The caller appends the
+* returned event through DSH's session log; no in-memory side store exists.
+*/
+function bindBusinessNetwork(events, requested) {
+	const next = normalizeBinding(requested);
+	const existing = readBusinessNetworkBinding(events);
+	if (existing === void 0) return {
+		kind: "bound",
+		event: {
+			type: BUSINESS_NETWORK_BOUND_EVENT,
+			data: next
+		}
+	};
+	if (!sameIdentity(existing, next)) throw new BusinessNetworkBindingConflictError(existing, next);
+	return {
+		kind: "already-bound",
+		binding: existing
+	};
+}
+function parseBinding(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("OpenBKN business-network binding event is malformed");
+	const candidate = value;
+	if (typeof candidate.platformBaseUrl !== "string" || typeof candidate.knowledgeNetworkId !== "string" || typeof candidate.displayName !== "string") throw new TypeError("OpenBKN business-network binding event is missing required fields");
+	return normalizeBinding({
+		platformBaseUrl: candidate.platformBaseUrl,
+		knowledgeNetworkId: candidate.knowledgeNetworkId,
+		displayName: candidate.displayName
+	});
+}
+function normalizeBinding(binding) {
+	const platformBaseUrl = binding.platformBaseUrl.replace(/\/+$/, "");
+	const knowledgeNetworkId = binding.knowledgeNetworkId.trim();
+	const displayName = binding.displayName.trim();
+	if (platformBaseUrl.length === 0 || knowledgeNetworkId.length === 0 || displayName.length === 0) throw new TypeError("OpenBKN business-network binding fields must not be empty");
+	return {
+		platformBaseUrl,
+		knowledgeNetworkId,
+		displayName
+	};
+}
+function sameIdentity(left, right) {
+	return left.platformBaseUrl === right.platformBaseUrl && left.knowledgeNetworkId === right.knowledgeNetworkId;
+}
+//#endregion
+//#region src/dsh-session-binding.ts
+/** Recover the binding directly from DSH's append-only session log. */
+function readDshSessionBusinessNetwork(session) {
+	return readBusinessNetworkBinding(session.snapshotEvents());
+}
+/**
+* Persist the selected business network as the one DSH session event. No
+* side-store is created; reselecting the same network is idempotent.
+*/
+function bindDshSessionBusinessNetwork(session, requested) {
+	const result = bindBusinessNetwork(session.snapshotEvents(), requested);
+	if (result.kind === "bound") session.append(result.event.type, result.event.data, { ignorable: true });
+	return result;
+}
+//#endregion
+//#region src/provenance-handle.ts
+const MAX_IDENTIFIERS = 32;
+/** Validate untrusted platform metadata before it becomes a Client-visible provenance reference. */
+function normalizeProvenanceHandle(value) {
+	if (!isRecord$2(value)) throw new TypeError("Provenance handle must be an object.");
+	if (value.schemaVersion !== 1) throw new TypeError("Unsupported provenance handle schema version.");
+	if (value.status !== "completed" && value.status !== "failed") throw new TypeError("Provenance handle must describe a completed turn.");
+	if (typeof value.partial !== "boolean") throw new TypeError("Provenance handle partial state is invalid.");
+	return {
+		schemaVersion: 1,
+		interactionId: identifier$2(value.interactionId, "interaction id"),
+		requestIds: identifiers(value.requestIds, "request ids"),
+		traceIds: identifiers(value.traceIds, "trace ids"),
+		receiptIds: identifiers(value.receiptIds, "receipt ids"),
+		status: value.status,
+		partial: value.partial
+	};
+}
+function identifiers(value, label) {
+	if (!Array.isArray(value)) throw new TypeError(`Provenance handle ${label} are invalid.`);
+	if (value.length > MAX_IDENTIFIERS) throw new RangeError(`Provenance handle ${label} exceed the limit.`);
+	return [...new Set(value.map((item) => identifier$2(item, label)))];
+}
+function identifier$2(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0 || value.length > 256) throw new TypeError(`Provenance handle ${label} is invalid.`);
+	return value.trim();
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/turn-provenance.ts
+/** Durable session event binding one finalized assistant message to one OpenBKN interaction. */
+const TURN_PROVENANCE_EVENT = "openbkn/turn-provenance";
+/** A completed message cannot be rewritten to point at a different interaction. */
+var TurnProvenanceConflictError = class extends Error {
+	messageId;
+	constructor(messageId) {
+		super(`Assistant message ${messageId} already has a different OpenBKN provenance handle.`);
+		this.messageId = messageId;
+		this.name = "TurnProvenanceConflictError";
+	}
+};
+/** Return the one append-only provenance event to write, or undefined if already recorded identically. */
+function appendTurnProvenance(events, messageId, handle) {
+	const normalizedMessageId = normalizeMessageId(messageId);
+	const normalizedHandle = normalizeProvenanceHandle(handle);
+	const existing = readTurnProvenance(events, normalizedMessageId);
+	if (existing === void 0) return {
+		type: TURN_PROVENANCE_EVENT,
+		data: {
+			messageId: normalizedMessageId,
+			handle: normalizedHandle
+		}
+	};
+	if (!sameHandle(existing, normalizedHandle)) throw new TurnProvenanceConflictError(normalizedMessageId);
+}
+/** Recover the committed handle for exactly one finalized assistant message. */
+function readTurnProvenance(events, messageId) {
+	const normalizedMessageId = normalizeMessageId(messageId);
+	let handle;
+	for (const event of events) {
+		if (event.type !== "openbkn/turn-provenance") continue;
+		const candidate = parseTurnProvenanceEvent(event.data);
+		if (candidate.messageId !== normalizedMessageId) continue;
+		if (handle === void 0) handle = candidate.handle;
+		else if (!sameHandle(handle, candidate.handle)) throw new TurnProvenanceConflictError(normalizedMessageId);
+	}
+	return handle;
+}
+function parseTurnProvenanceEvent(value) {
+	if (!isRecord$1(value)) throw new TypeError("OpenBKN turn provenance event is malformed.");
+	return {
+		messageId: normalizeMessageId(value.messageId),
+		handle: normalizeProvenanceHandle(value.handle)
+	};
+}
+function normalizeMessageId(value) {
+	if (typeof value !== "string") throw new TypeError("OpenBKN turn provenance message id is invalid.");
+	const normalized = value.trim();
+	if (normalized.length === 0 || normalized.length > 256) throw new TypeError("OpenBKN turn provenance message id is invalid.");
+	return normalized;
+}
+function sameHandle(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/dsh-session-provenance.ts
+/** Read one message's committed provenance directly from the append-only DSH log. */
+function readDshSessionTurnProvenance(session, messageId) {
+	return readTurnProvenance(session.snapshotEvents(), messageId);
+}
+/** Append a completed-turn handle once; identical retries are intentionally idempotent. */
+function appendDshSessionTurnProvenance(session, messageId, handle) {
+	const event = appendTurnProvenance(session.snapshotEvents(), messageId, handle);
+	if (event !== void 0) session.append(event.type, event.data, { ignorable: true });
+}
+//#endregion
+//#region src/native-mcp-provenance.ts
+const OPENBKN_FINISH_INTERACTION_TOOL = "mcp__openbkn__bkn_finish_interaction";
+/**
+* Recover provenance only from a completed interaction explicitly returned by
+* the OpenBKN MCP finish call in the same DSH turn. No model text, tool args,
+* or unrelated MCP output participates in this association.
+*/
+function findCompletedNativeMcpProvenance(events, turn) {
+	const calls = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.type !== "tool/call") continue;
+		const data = record$2(event.data);
+		if (data?.turn !== turn || typeof data.callId !== "string" || typeof data.name !== "string") continue;
+		calls.set(data.callId, data.name);
+	}
+	const completed = /* @__PURE__ */ new Map();
+	for (const [index, event] of events.entries()) {
+		if (event.type !== "tool/result") continue;
+		const data = record$2(event.data);
+		if (data?.turn !== turn) continue;
+		const message = record$2(data.message);
+		const source = message === void 0 ? void 0 : record$2(message.source);
+		const callId = source?.kind === "tool" && typeof source.callId === "string" ? source.callId : void 0;
+		if (callId === void 0 || calls.get(callId) !== OPENBKN_FINISH_INTERACTION_TOOL) continue;
+		const interactionId = completedInteractionId(message);
+		if (interactionId !== void 0) completed.set(callId, {
+			interactionId,
+			resultIndex: index
+		});
+	}
+	if (completed.size !== 1) return void 0;
+	const [, completedInteraction] = [...completed][0];
+	const answer = finalAssistantMessageAfter(events, turn, completedInteraction.resultIndex);
+	if (answer === void 0) return void 0;
+	return {
+		messageId: answer,
+		handle: {
+			schemaVersion: 1,
+			interactionId: completedInteraction.interactionId,
+			requestIds: [],
+			traceIds: [],
+			receiptIds: [],
+			status: "completed",
+			partial: true
+		}
+	};
+}
+function finalAssistantMessageAfter(events, turn, afterIndex) {
+	for (let index = events.length - 1; index > afterIndex; index -= 1) {
+		const event = events[index];
+		if (event?.type !== "assistant/message") continue;
+		const data = record$2(event.data);
+		if (data?.turn !== turn) continue;
+		const message = record$2(data.message);
+		if (message === void 0 || typeof message.id !== "string" || !Array.isArray(message.content)) continue;
+		if (!message.content.some((block) => record$2(block)?.type === "tool-call")) return message.id;
+	}
+}
+function completedInteractionId(message) {
+	if (message === void 0 || !Array.isArray(message.content)) return void 0;
+	for (const block of message.content) {
+		const toolResult = record$2(block);
+		if (toolResult?.type !== "tool-result" || !Array.isArray(toolResult.content)) continue;
+		for (const content of toolResult.content) {
+			const text = record$2(content);
+			if (text?.type !== "text" || typeof text.text !== "string") continue;
+			const parsed = jsonRecord(text.text);
+			if (parsed?.execution_status !== "completed") continue;
+			const interactionId = identifier$1(parsed.interaction_id);
+			if (interactionId !== void 0) return interactionId;
+		}
+	}
+}
+function jsonRecord(value) {
+	try {
+		return record$2(JSON.parse(value));
+	} catch {
+		return;
+	}
+}
+function identifier$1(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= 256 ? normalized : void 0;
+}
+function record$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
+//#region src/platform-reader.ts
+/** A bounded Host-side error. It never includes platform response bodies. */
+var PlatformReaderError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "PlatformReaderError";
+	}
+};
+const MAX_PLATFORM_RESPONSE_BYTES = 8388608;
+/**
+* A fixed-route Host reader for plugin control-plane data. It is deliberately
+* separate from the model path: agents use Context Loader MCP; this reader
+* only obtains the catalog, schema profile, and safe Trace projections.
+*/
+var OpenBknPlatformReader = class {
+	config;
+	fetcher;
+	constructor(config, fetcher = fetch) {
+		this.config = config;
+		this.fetcher = fetcher;
+	}
+	async listKnowledgeNetworks(signal, _cwd) {
+		return this.admit(await this.get("/api/bkn-backend/v1/knowledge-networks?limit=100", signal));
+	}
+	async getKnowledgeNetworkDetail(binding, signal, _cwd) {
+		if (normalizeBaseUrl$5(binding.platformBaseUrl) !== normalizeBaseUrl$5(this.config.baseUrl)) throw new PlatformReaderError("PLATFORM_MISMATCH", "The selected business network belongs to another OpenBKN platform.");
+		return this.admit(await this.post("/api/agent-retrieval/v1/kn/get_kn_detail", {
+			kn_id: binding.knowledgeNetworkId,
+			detail_level: "summary",
+			response_format: "json"
+		}, signal));
+	}
+	async getInteractionOperations(interactionId, signal, _cwd) {
+		const value = await this.get(`/api/agent-observability/v1/interactions/${encodeURIComponent(interactionId)}/operations`, signal, { licenseGated: true });
+		return this.admit(projectOperations$1(value));
+	}
+	async getInteractionBusinessGraph(interactionId, signal, _cwd) {
+		const value = await this.get(`/api/agent-observability/v1/interactions/${encodeURIComponent(interactionId)}/business-graph`, signal, { licenseGated: true });
+		return this.admit(projectBusinessGraph(value));
+	}
+	/** Resolve the deployment's license edition so license-gated failures can explain themselves. */
+	async getLicenseEdition(signal) {
+		const source = record$1(await this.get("/api/safe/v1/capabilities", signal));
+		const edition = string(source?.edition);
+		return {
+			...edition === void 0 ? {} : { edition },
+			...typeof source?.licensed === "boolean" ? { licensed: source.licensed } : {}
+		};
+	}
+	async get(path, signal, options) {
+		return await this.request(path, { method: "GET" }, signal, options);
+	}
+	async post(path, body, signal) {
+		return await this.request(path, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		}, signal);
+	}
+	async request(path, init, signal, options) {
+		if (signal.aborted) throw new PlatformReaderError("REQUEST_ABORTED", "OpenBKN context request was cancelled.");
+		const url = fixedUrl(this.config.baseUrl, path, this.config.allowInsecureTls);
+		const token = await this.config.resolveToken?.();
+		if (token === void 0 || token.trim().length === 0) throw new PlatformReaderError("AUTHENTICATION_REQUIRED", "OpenBKN authentication is required.");
+		const timeout = AbortSignal.timeout(this.config.requestTimeoutMs);
+		const requestSignal = AbortSignal.any([signal, timeout]);
+		let response;
+		try {
+			response = await this.fetcher(url, {
+				...init,
+				headers: {
+					...init.headers,
+					"x-business-domain": this.config.businessDomain?.trim() || "bd_public",
+					authorization: `Bearer ${token}`
+				},
+				redirect: "error",
+				signal: requestSignal
+			});
+		} catch (error) {
+			if (signal.aborted) throw new PlatformReaderError("REQUEST_ABORTED", "OpenBKN context request was cancelled.", { cause: error });
+			throw new PlatformReaderError("PLATFORM_UNAVAILABLE", "OpenBKN platform data is temporarily unavailable.", { cause: error });
+		}
+		if (response.status === 401) throw new PlatformReaderError("AUTHENTICATION_REQUIRED", "OpenBKN authentication is required.");
+		if (response.status === 403) {
+			if (options?.licenseGated === true) {
+				const body = await response.text().catch(() => "");
+				if (string(record$1(body.length <= 4096 ? record$1(safeParse(body))?.error : void 0)?.code) === "permission_denied") throw new PlatformReaderError("LICENSE_REQUIRED", "The requested OpenBKN capability requires an enterprise license for this business domain.");
+			}
+			throw new PlatformReaderError("AUTHENTICATION_REQUIRED", "OpenBKN authentication is required.");
+		}
+		if (!response.ok) throw new PlatformReaderError("PLATFORM_UNAVAILABLE", "OpenBKN platform data is temporarily unavailable.");
+		const contentLength = response.headers.get("content-length");
+		if (contentLength !== null && Number(contentLength) > MAX_PLATFORM_RESPONSE_BYTES) throw new PlatformReaderError("OUTPUT_OVERFLOW", "OpenBKN platform response exceeded the safe Host limit.");
+		let text;
+		try {
+			text = await readCappedBody(response, MAX_PLATFORM_RESPONSE_BYTES);
+		} catch (error) {
+			if (error instanceof PlatformReaderError) throw error;
+			throw new PlatformReaderError("PLATFORM_UNAVAILABLE", "OpenBKN platform data is temporarily unavailable.", { cause: error });
+		}
+		let value;
+		try {
+			value = JSON.parse(text);
+		} catch (error) {
+			throw new PlatformReaderError("INVALID_RESPONSE", "OpenBKN platform returned an invalid response.", { cause: error });
+		}
+		return value;
+	}
+	admit(value) {
+		if (new TextEncoder().encode(JSON.stringify(value)).byteLength > this.config.maxResultBytes) throw new PlatformReaderError("OUTPUT_OVERFLOW", "OpenBKN context result exceeded the configured size limit.");
+		return value;
+	}
+};
+function projectOperations$1(value) {
+	const source = record$1(value);
+	const entries = array(source?.entries ?? source?.operations).flatMap((entry) => {
+		const value = record$1(entry);
+		const operationId = string(value?.operation_id);
+		if (operationId === void 0) return [];
+		return [{
+			operation_id: operationId,
+			tool_name: string(value?.tool_name),
+			source_module: string(value?.source_module),
+			protocol: string(value?.protocol),
+			status: string(value?.status),
+			started_at: string(value?.started_at),
+			finished_at: string(value?.finished_at),
+			request_id: string(value?.request_id),
+			trace_id: string(value?.trace_id),
+			receipt_id: string(value?.receipt_id)
+		}];
+	});
+	return json({
+		entries,
+		total: number(source?.total) ?? entries.length
+	});
+}
+function projectBusinessGraph(value) {
+	const source = record$1(value);
+	const assembly = record$1(source?.assembly);
+	const projectRef = (candidate) => {
+		const ref = record$1(candidate);
+		const technical = record$1(ref?.technical_ref);
+		const display = record$1(ref?.display);
+		const id = string(technical?.ref_id);
+		const type = string(technical?.ref_type);
+		const name = string(display?.name);
+		return id === void 0 || type === void 0 || name === void 0 ? void 0 : {
+			technical_ref: {
+				ref_id: id,
+				ref_type: type,
+				visibility: string(technical?.visibility),
+				version_status: string(technical?.version_status)
+			},
+			display: {
+				name,
+				resolution_status: string(display?.resolution_status),
+				source_version: string(display?.source_version)
+			}
+		};
+	};
+	const refs = array(assembly?.business_refs).flatMap((candidate) => {
+		const projected = projectRef(candidate);
+		return projected === void 0 ? [] : [projected];
+	});
+	const edges = array(assembly?.operation_business_edges).flatMap((candidate) => {
+		const edge = record$1(candidate);
+		const operationId = string(edge?.operation_id);
+		const ref = projectRef(edge?.business_ref);
+		return operationId === void 0 || ref === void 0 ? [] : [{
+			operation_id: operationId,
+			role: string(edge?.role),
+			observed_at: string(edge?.observed_at),
+			business_ref: ref
+		}];
+	});
+	const events = array(source?.events).flatMap((candidate) => {
+		const event = record$1(candidate);
+		const eventId = string(event?.event_id);
+		const eventType = string(event?.event_type);
+		return eventId === void 0 || eventType === void 0 ? [] : [{
+			event_id: eventId,
+			event_type: eventType,
+			layer: string(event?.layer),
+			operation_id: string(event?.operation_id)
+		}];
+	});
+	return json({
+		interaction_id: string(source?.interaction_id),
+		conversation_id: string(source?.conversation_id),
+		execution_status: string(source?.execution_status),
+		evidence_status: string(source?.evidence_status),
+		assembly: {
+			business_refs: refs,
+			operation_business_edges: edges
+		},
+		events
+	});
+}
+/** Hosts for which plaintext http is tolerated regardless of the insecure switch. */
+function isLoopbackHost(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+/**
+* Scheme fence shared by every outbound OpenBKN path so the Bearer token can
+* never be configured onto a plaintext or unexpected endpoint: https is
+* required outside loopback unless plaintext was explicitly allowed.
+*/
+function assertHttpsEndpoint(url, allowPlaintext) {
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && (isLoopbackHost(url.hostname) || allowPlaintext))) throw new PlatformReaderError("PLATFORM_MISMATCH", "OpenBKN platform URL must use HTTPS outside loopback.");
+}
+function fixedUrl(baseUrl, path, allowInsecureTls) {
+	let url;
+	try {
+		url = new URL(path, `${normalizeBaseUrl$5(baseUrl)}/`);
+	} catch {
+		throw new PlatformReaderError("PLATFORM_MISMATCH", "OpenBKN platform URL is not configured.");
+	}
+	assertHttpsEndpoint(url, allowInsecureTls);
+	return url;
+}
+function normalizeBaseUrl$5(value) {
+	return value.trim().replace(/\/+$/, "");
+}
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function safeParse(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/** Read a response body as text, aborting the stream once the byte cap is exceeded. */
+async function readCappedBody(response, capBytes) {
+	if (response.body === null) return response.text();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let received = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done === true) break;
+		if (value === void 0) continue;
+		received += value.byteLength;
+		if (received > capBytes) {
+			await reader.cancel().catch(() => void 0);
+			throw new PlatformReaderError("OUTPUT_OVERFLOW", "OpenBKN platform response exceeded the safe Host limit.");
+		}
+		chunks.push(value);
+	}
+	const merged = new Uint8Array(received);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(merged);
+}
+function array(value) {
+	return Array.isArray(value) ? value : [];
+}
+function string(value) {
+	return typeof value === "string" && value.trim() ? value.trim().slice(0, 512) : void 0;
+}
+function number(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+/** Removes absent optional fields before the value crosses the Host boundary. */
+function json(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+//#endregion
+//#region src/auth.ts
+/** Thrown when the CLI cannot provide a trustworthy authentication status. */
+var OpenBknCliError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OpenBknCliError";
+	}
+};
+/**
+* Owns authentication lifecycle decisions. OpenBKN CLI remains the credential
+* store and refresh authority. Its token value is read only after an exact
+* platform fence and is returned only to Host-side credential synchronization.
+*/
+var AuthCoordinator = class {
+	cli;
+	baseUrl;
+	constructor(cli, baseUrl) {
+		this.cli = cli;
+		this.baseUrl = normalizeBaseUrl$4(baseUrl);
+	}
+	/** Read the active CLI session and fence it to this plugin's configured platform. */
+	async status(signal) {
+		const result = await this.cli.run([
+			"auth",
+			"status",
+			"--json"
+		], signal);
+		if (result.code !== 0) throw cliFailure("read authentication status", result);
+		const status = parseStatus(result.stdout);
+		const actualBaseUrl = normalizeBaseUrl$4(status.baseUrl);
+		if (actualBaseUrl !== this.baseUrl) return {
+			kind: "platform-mismatch",
+			expectedBaseUrl: this.baseUrl,
+			actualBaseUrl
+		};
+		if (!status.hasToken || status.expired) return {
+			kind: "authentication-required",
+			baseUrl: this.baseUrl
+		};
+		return {
+			kind: "authenticated",
+			baseUrl: this.baseUrl,
+			...status.userId === void 0 ? {} : { userId: status.userId },
+			...status.username === void 0 ? {} : { username: status.username }
+		};
+	}
+	/**
+	* Ask the CLI to initiate its normal local-browser OAuth flow. The plugin
+	* deliberately does not use `--no-browser`: that variant requires a human
+	* to paste an OAuth callback into stdin, while DSH's managed subprocess has
+	* no terminal input surface. Its human-facing output is not persisted here.
+	*/
+	async beginLogin() {
+		const result = await this.cli.run([
+			"auth",
+			"login",
+			this.baseUrl
+		]);
+		if (result.code !== 0) throw cliFailure("start login", result);
+	}
+	/**
+	* Read one refreshed token for the configured, authenticated platform.
+	* Callers must immediately write it to DSH credentials and must never expose
+	* this value through a Remote result, UI state, diagnostics, or logs.
+	*/
+	async readToken(signal) {
+		if ((await this.status(signal)).kind !== "authenticated") throw new OpenBknCliError("OpenBKN CLI is not authenticated for the configured platform");
+		const result = await this.cli.run(["auth", "token"], signal);
+		if (result.code !== 0) throw cliFailure("read authentication token", result);
+		const token = result.stdout.trim();
+		if (token.length === 0 || token.length > 16384 || /[\r\n]/.test(token)) throw new OpenBknCliError("OpenBKN CLI returned an invalid authentication token");
+		return token;
+	}
+};
+function parseStatus(stdout) {
+	let value;
+	try {
+		value = JSON.parse(stdout);
+	} catch {
+		throw new OpenBknCliError("OpenBKN CLI returned invalid JSON for auth status");
+	}
+	if (typeof value !== "object" || value === null) throw new OpenBknCliError("OpenBKN CLI returned an invalid auth status payload");
+	const candidate = value;
+	if (typeof candidate.baseUrl !== "string" || typeof candidate.hasToken !== "boolean" || typeof candidate.expired !== "boolean") throw new OpenBknCliError("OpenBKN CLI auth status is missing required fields");
+	if (candidate.userId !== void 0 && typeof candidate.userId !== "string") throw new OpenBknCliError("OpenBKN CLI auth status contains an invalid user id");
+	if (candidate.username !== void 0 && typeof candidate.username !== "string") throw new OpenBknCliError("OpenBKN CLI auth status contains an invalid username");
+	return {
+		baseUrl: candidate.baseUrl,
+		hasToken: candidate.hasToken,
+		expired: candidate.expired,
+		...candidate.userId === void 0 ? {} : { userId: candidate.userId },
+		...candidate.username === void 0 ? {} : { username: candidate.username }
+	};
+}
+function normalizeBaseUrl$4(value) {
+	return value.replace(/\/+$/, "");
+}
+function cliFailure(action, result) {
+	return new OpenBknCliError(`OpenBKN CLI could not ${action}: ${result.stderr.trim() || "no diagnostic output"}`);
+}
+//#endregion
+//#region src/openbkn-cli-subprocess.ts
+const OUTPUT_LIMIT = 65536;
+const GRACE_MS = 3e3;
+/** DSH-managed invocation of the OpenBKN CLI with a fixed authentication contract. */
+var OpenBknCliSubprocess = class {
+	subprocess;
+	cwd;
+	cliPath;
+	baseUrl;
+	constructor(subprocess, cwd, baseUrl, cliPath = "openbkn") {
+		this.subprocess = subprocess;
+		this.cwd = cwd;
+		this.cliPath = cliPath;
+		this.baseUrl = normalizeBaseUrl$3(baseUrl);
+	}
+	async run(args, signal) {
+		const argv = this.resolveArgv(args);
+		const child = this.subprocess.spawn({
+			argv,
+			cwd: this.cwd,
+			stdio: {
+				stdin: { data: "" },
+				stdout: { maxBytes: OUTPUT_LIMIT },
+				stderr: { maxBytes: OUTPUT_LIMIT }
+			},
+			graceMs: GRACE_MS,
+			...signal === void 0 ? {} : { signal }
+		});
+		const outcome = await child.done;
+		const stdout = child.collected.stdout?.readFrom(0);
+		const stderr = child.collected.stderr?.readFrom(0);
+		if (stdout?.lossy || stderr?.lossy) throw new Error("OpenBKN CLI output exceeded the safe size limit.");
+		return {
+			code: outcome.exitCode ?? 1,
+			stdout: stdout?.text ?? "",
+			stderr: stderr?.text ?? ""
+		};
+	}
+	resolveArgv(args) {
+		if (isAuthStatusCommand(args)) return [
+			this.cliPath,
+			"auth",
+			"status",
+			"--json"
+		];
+		if (isAuthTokenCommand(args)) return [
+			this.cliPath,
+			"auth",
+			"token"
+		];
+		if (isAuthLoginCommand(args, this.baseUrl)) return [
+			this.cliPath,
+			"auth",
+			"login",
+			this.baseUrl
+		];
+		throw new Error("OpenBKN CLI command is not allowed by this plugin.");
+	}
+};
+function isAuthStatusCommand(args) {
+	return args.length === 3 && args[0] === "auth" && args[1] === "status" && args[2] === "--json";
+}
+function isAuthTokenCommand(args) {
+	return args.length === 2 && args[0] === "auth" && args[1] === "token";
+}
+function isAuthLoginCommand(args, baseUrl) {
+	return args.length === 3 && args[0] === "auth" && args[1] === "login" && normalizeBaseUrl$3(args[2] ?? "") === baseUrl;
+}
+function normalizeBaseUrl$3(value) {
+	return value.trim().replace(/\/+$/, "");
+}
+//#endregion
+//#region src/openbkn-mcp-manager.ts
+const OPENBKN_MCP_TOKEN_REF = "OPENBKN_MCP_TOKEN";
+const REQUIRED_TOOL = "mcp__openbkn__bkn_start_interaction";
+/**
+* Mounts the standard DSH MCP client once the user has stored an OpenBKN
+* token. It resolves the credential immediately before mounting, and passes it
+* only to the in-memory standard MCP client configuration. An explicitly configured client with the same public tool
+* namespace is treated as the deployment-owned instance.
+*/
+var OpenBknMcpManager = class {
+	ctx;
+	config;
+	resolveToken;
+	starting;
+	fiber;
+	constructor(ctx, config, resolveToken) {
+		this.ctx = ctx;
+		this.config = config;
+		this.resolveToken = resolveToken;
+	}
+	reloading;
+	async ensure() {
+		if (this.reloading !== void 0) await this.reloading.catch(() => void 0);
+		await this.ensureMounted();
+	}
+	async ensureMounted() {
+		if (this.ctx.tools.get(REQUIRED_TOOL) !== void 0) return;
+		if (this.starting === void 0) this.starting = this.start().finally(() => {
+			this.starting = void 0;
+		});
+		await this.starting;
+	}
+	/** Reconnect the client after DSH rotates the managed credential. */
+	async refresh() {
+		await this.starting;
+		if (this.reloading !== void 0) return this.reloading;
+		this.reloading = (async () => {
+			const fiber = this.fiber;
+			this.fiber = void 0;
+			await fiber?.dispose();
+			await this.ensureMounted();
+		})().finally(() => {
+			this.reloading = void 0;
+		});
+		return this.reloading;
+	}
+	async start() {
+		const token = await this.resolveToken();
+		if (token === void 0 || token.length === 0) throw new Error("OpenBKN Context Loader MCP requires a configured token.");
+		const fiber = await this.ctx.plugin(McpClient, McpClient.Config({
+			transport: "streamable-http",
+			serverName: "openbkn",
+			url: resolveMcpUrl(this.config),
+			headers: { Authorization: `Bearer ${token}` },
+			toolCallTimeoutMs: 2e4,
+			failOnStartupError: true,
+			reconnect: {
+				enabled: true,
+				initialDelayMs: 500,
+				maxDelayMs: 3e4,
+				maxAttempts: 10
+			}
+		}));
+		this.fiber = fiber;
+		if (this.ctx.tools.get(REQUIRED_TOOL) === void 0) {
+			this.fiber = void 0;
+			await fiber.dispose();
+			throw new Error("OpenBKN Context Loader MCP did not publish its managed interaction tools.");
+		}
+	}
+};
+/**
+* Resolve the stable Context Loader endpoint from the deployment platform URL.
+* An explicitly configured mcpUrl gets the same scheme fence as the control
+* plane plus an origin fence: the Bearer token mounted on this client may
+* only ever be sent to the configured platform (or an explicitly allowed
+* plaintext loopback), never to an arbitrary host.
+*/
+function resolveMcpUrl(config) {
+	const base = new URL(config.baseUrl);
+	let url;
+	if (config.mcpUrl !== void 0 && config.mcpUrl.trim().length > 0) {
+		try {
+			url = new URL(config.mcpUrl);
+		} catch {
+			throw new Error("OpenBKN mcpUrl is not a valid URL.");
+		}
+		assertHttpsEndpoint(url, config.allowInsecureTls);
+		const sameOrigin = url.origin === base.origin;
+		const bothLoopback = isLoopbackHost(url.hostname) && isLoopbackHost(base.hostname);
+		if (!sameOrigin && !bothLoopback) throw new Error(`OpenBKN mcpUrl must stay on the configured platform (${base.origin}); refusing to send credentials to ${url.origin}.`);
+	} else url = new URL("/api/agent-retrieval/v1/mcp/", base);
+	return url.toString();
+}
+//#endregion
+//#region src/provenance-view.ts
+/**
+* Projects Community execution facts plus the exact EE-owned interaction
+* projection. It never derives BKN mappings from raw Core or MCP payloads.
+*/
+function buildProvenanceView(handle, operationsResponse, enterpriseProjection, limits) {
+	return {
+		interactionId: handle.interactionId,
+		execution: {
+			status: handle.status,
+			operations: projectOperations(operationRecords(operationsResponse))
+		},
+		business: projectBusiness(enterpriseProjection, operationsResponse, limits),
+		evidence: { kind: "unavailable" }
+	};
+}
+function projectOperations(value) {
+	return records(value).flatMap((entry) => {
+		const id = stringValue(entry.operation_id);
+		if (id === void 0) return [];
+		return [{
+			id,
+			label: stringValue(entry.tool_name) ?? stringValue(entry.source_module) ?? stringValue(entry.protocol) ?? "OpenBKN operation",
+			protocol: stringValue(entry.protocol),
+			status: stringValue(entry.call_status) ?? stringValue(entry.execution_status) ?? stringValue(entry.status),
+			startedAt: stringValue(entry.started_at),
+			finishedAt: stringValue(entry.finished_at),
+			requestId: stringValue(entry.request_id),
+			traceId: stringValue(entry.trace_id),
+			receiptId: stringValue(entry.receipt_id)
+		}];
+	});
+}
+function projectBusiness(value, operationsResponse, limits) {
+	const graph = record(value);
+	const assembly = graph === void 0 ? void 0 : record(graph.assembly);
+	if (assembly === void 0) return { kind: "unavailable" };
+	const elementsRemaining = { value: limits.maxGraphNodes };
+	const edgesRemaining = { value: limits.maxGraphEdges };
+	const coreLabels = new Map(projectOperations(operationRecords(operationsResponse)).map((operation) => [operation.id, operation.label]));
+	const byOperation = /* @__PURE__ */ new Map();
+	for (const edge of records(assembly.operation_business_edges)) {
+		if (edgesRemaining.value < 1) break;
+		const operationId = stringValue(edge.operation_id);
+		const element = projectTraceBusinessRef(record(edge.business_ref), elementsRemaining);
+		if (operationId === void 0 || element === void 0) continue;
+		edgesRemaining.value -= 1;
+		const existing = byOperation.get(operationId);
+		if (existing !== void 0) {
+			byOperation.set(operationId, {
+				...existing,
+				elements: [...existing.elements, element]
+			});
+			continue;
+		}
+		byOperation.set(operationId, {
+			id: operationId,
+			attempt: 0,
+			toolName: coreLabels.get(operationId) ?? "OpenBKN operation",
+			status: "resolved",
+			elements: [element],
+			missingFacts: []
+		});
+	}
+	return {
+		kind: "ready",
+		operations: [...byOperation.values()],
+		conversationContext: [],
+		contextRelations: [],
+		derivedFacts: []
+	};
+}
+function projectTraceBusinessRef(entry, remaining) {
+	if (entry === void 0 || remaining.value < 1) return void 0;
+	const technicalRef = record(entry.technical_ref);
+	const display = record(entry.display);
+	const id = technicalRef === void 0 ? void 0 : stringValue(technicalRef.ref_id);
+	const kind = technicalRef === void 0 ? void 0 : traceRefKind(technicalRef.ref_type);
+	const name = display === void 0 ? void 0 : stringValue(display.name);
+	if (id === void 0 || kind === void 0 || name === void 0) return void 0;
+	remaining.value -= 1;
+	return {
+		id,
+		kind,
+		name
+	};
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function records(value) {
+	return Array.isArray(value) ? value.flatMap((item) => record(item) === void 0 ? [] : [record(item)]) : [];
+}
+/** Community deployments expose either `entries` or the documented `operations` list. */
+function operationRecords(value) {
+	const response = record(value);
+	const candidates = response?.entries ?? response?.operations;
+	return Array.isArray(candidates) ? candidates : [];
+}
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value.trim().slice(0, 512) : void 0;
+}
+function traceRefKind(value) {
+	switch (value) {
+		case "object":
+		case "object_type":
+		case "object_instance":
+		case "knowledge_network": return "object";
+		case "relation":
+		case "relation_type": return "relation";
+		case "action":
+		case "action_type": return "action";
+		case "property":
+		case "property_type": return "property";
+		case "logic":
+		case "logic_property": return "logic";
+		case "metric": return "metric";
+		default: return;
+	}
+}
+//#endregion
+//#region src/network-capability-profile.ts
+const MAX_ENTRIES = 48;
+const MAX_IDENTIFIER_LENGTH = 160;
+/**
+* Project the platform summary into the small, non-instructional index the
+* managed-session policy may expose to an Agent. The original platform payload
+* is deliberately not retained.
+*/
+function buildNetworkCapabilityProfile(binding, payload) {
+	const detail = detailOf(payload);
+	const networkId = identifier(detail.id);
+	if (networkId === void 0 || networkId !== binding.knowledgeNetworkId) throw new Error("OpenBKN knowledge-network detail does not match the selected network.");
+	if (!Array.isArray(detail.object_types) || !Array.isArray(detail.concept_groups) || !Array.isArray(detail.relation_types)) throw new Error("OpenBKN knowledge-network detail is not a summary response.");
+	const profile = {
+		schemaVersion: 1,
+		knowledgeNetworkId: networkId,
+		conceptGroups: named(detail.concept_groups),
+		objectTypes: named(detail.object_types),
+		relationTypes: relations(detail.relation_types),
+		actionTypes: named(Array.isArray(detail.action_types) ? detail.action_types : [])
+	};
+	return {
+		...profile,
+		profileVersion: createHash("sha256").update(JSON.stringify(profile)).digest("hex").slice(0, 16)
+	};
+}
+function detailOf(payload) {
+	if (!isRecord(payload)) throw new Error("OpenBKN knowledge-network detail is not a summary response.");
+	return isRecord(payload.result) ? payload.result : payload;
+}
+function named(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		if (result.length === MAX_ENTRIES || !isRecord(value)) continue;
+		const id = identifier(value.id);
+		if (id === void 0 || seen.has(id)) continue;
+		seen.add(id);
+		const name = identifier(value.name);
+		result.push({
+			id,
+			...name === void 0 ? {} : { name }
+		});
+	}
+	return result;
+}
+function relations(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		if (result.length === MAX_ENTRIES || !isRecord(value)) continue;
+		const id = identifier(value.id) ?? identifier(value.relation_type_id);
+		const sourceObjectTypeId = identifier(value.source_object_type_id) ?? nestedId(value.source_object_type);
+		const targetObjectTypeId = identifier(value.target_object_type_id) ?? nestedId(value.target_object_type);
+		if (id === void 0 || sourceObjectTypeId === void 0 || targetObjectTypeId === void 0 || seen.has(id)) continue;
+		seen.add(id);
+		result.push({
+			id,
+			sourceObjectTypeId,
+			targetObjectTypeId
+		});
+	}
+	return result;
+}
+function nestedId(value) {
+	return isRecord(value) ? identifier(value.id) : void 0;
+}
+function identifier(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= MAX_IDENTIFIER_LENGTH ? normalized : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/managed-session-policy.ts
+/**
+* Stable lifecycle identity written by OpenBKN Trace for this plugin surface.
+* It is not a user, workspace, model, or knowledge-network identifier.
+*/
+const OPENBKN_DSH_INTERACTION_AGENT_NAME = "bkn-agent-dsh-business-context";
+/**
+* Produce the two scoped system-prompt sections for one bound network. The
+* fixed section renders the Host-verified identity as quoted data; the optional
+* profile remains a projection rather than a copy of platform metadata.
+*/
+function buildManagedSessionPolicy(binding, profile) {
+	return {
+		governance: [
+			"Bound OpenBKN knowledge network:",
+			`- kn_id: ${JSON.stringify(binding.knowledgeNetworkId)}`,
+			`- kn_name: ${JSON.stringify(binding.displayName)}`,
+			"The binding above is authoritative for this DSH session.",
+			`For every OpenBKN MCP tool that accepts \`kn_id\`, pass exactly ${JSON.stringify(binding.knowledgeNetworkId)}. Do not omit, discover, or infer \`kn_id\` from skills, schema results, or tool output.`,
+			"bkn_start_interaction manages only the conversation and interaction lifecycle; its response does not replace or unset the bound knowledge network.",
+			"bkn_start_interaction only accepts its documented lifecycle fields: conversation_mode, question, and agent_name; never pass kn_id or query to it.",
+			`For every bkn_start_interaction call, pass agent_name exactly ${JSON.stringify(OPENBKN_DSH_INTERACTION_AGENT_NAME)}. Keep this stable when continuing the Conversation.`,
+			"For the first question use conversation_mode \"new\" without a conversation_id. For later questions use conversation_mode \"continue\" with the conversation_id returned by the prior interaction.",
+			"For each user question, start exactly one mcp__openbkn__bkn_start_interaction before business retrieval and finish it with mcp__openbkn__bkn_finish_interaction using the final outcome.",
+			"Do not probe Bash or a tool list to test OpenBKN availability. Even if managed MCP tools are not listed in the initial tool catalog, directly call mcp__openbkn__bkn_start_interaction.",
+			"If bkn_start_interaction returns a retryable error, retry at most once. If that retry fails, do not retry again or perform business retrieval; report the platform condition briefly.",
+			"Use only mcp__openbkn__ tools for business data. Do not invent facts, identifiers, metrics, tool results, or provenance. State limits and missing data plainly.",
+			"Route a single fact to query_object_instance; a defined aggregate to query_metric; and BOM expansion, availability, substitution, common-material, reverse lookup, or delivery calculations to a matching published tool via search_tools then execute_tool. Pass only the documented business parameters.",
+			"Use search_schema then targeted get_object_types or get_relation_types when the needed schema is unknown. Schema fallback rule: if get_kn_detail returns a rendering, structured-output, or validation error, do not retry get_kn_detail with another format or detail_level. Preserve the bound kn_id. Use search_schema at most once, only when it can directly answer the requested schema question; do not use it to derive an exact exhaustive count or list. If it cannot directly answer, finish the Interaction as failed and state that the schema detail is unavailable.",
+			"Use run_code only as a read-only fallback for a business calculation when no matching published tool is available or its result cannot be obtained. Keep the bound kn_id and managed interaction context in every OpenBKN call made by the script. Do not use run_shell, run_sql, resources, or action execution unless the deployment explicitly enables them."
+		].join("\n"),
+		capabilities: profile === void 0 ? "" : capabilitySection(profile)
+	};
+}
+function capabilitySection(profile) {
+	const named = (values) => values.map((value) => value.name === void 0 ? value.id : `${value.id} (${value.name})`).join(", ") || "none declared";
+	const relations = profile.relationTypes.map((value) => `${value.id}: ${value.sourceObjectTypeId} → ${value.targetObjectTypeId}`).join(", ") || "none declared";
+	return [
+		`OpenBKN network capability index for ${profile.knowledgeNetworkId} (profile ${profile.profileVersion}; authoritative schema remains MCP):`,
+		`Concept groups: ${named(profile.conceptGroups)}.`,
+		`Object types: ${named(profile.objectTypes)}.`,
+		`Relations: ${relations}.`,
+		`Action types: ${named(profile.actionTypes)}.`,
+		"For a business function, search_tools first and obey the returned use_rule and input schema before execute_tool."
+	].join("\n");
+}
+//#endregion
+//#region src/scoped-business-context.ts
+const MANAGED_OPENBKN_TOOLS = [
+	"mcp__openbkn__bkn_start_interaction",
+	"mcp__openbkn__bkn_finish_interaction",
+	"mcp__openbkn__get_kn_detail",
+	"mcp__openbkn__search_schema",
+	"mcp__openbkn__get_object_types",
+	"mcp__openbkn__get_relation_types",
+	"mcp__openbkn__query_object_instance",
+	"mcp__openbkn__query_instance_subgraph",
+	"mcp__openbkn__explore_subgraph",
+	"mcp__openbkn__search_instance",
+	"mcp__openbkn__query_metric",
+	"mcp__openbkn__get_logic_properties_values",
+	"mcp__openbkn__run_code",
+	"mcp__openbkn__list_skills",
+	"mcp__openbkn__find_skills",
+	"mcp__openbkn__get_skill_content",
+	"mcp__openbkn__read_skill_file",
+	"mcp__openbkn__search_tools",
+	"mcp__openbkn__execute_tool"
+];
+/** Agent-scoped prompt rows: only mounted after the session has a compatible binding. */
+const scopedPolicyPlugin = (binding, profile) => ({
+	name: "openbkn-business-context-policy",
+	inject: ["systemPrompt", "tools"],
+	apply(ctx) {
+		if (binding === void 0) return;
+		const policy = buildManagedSessionPolicy(binding, profile);
+		const systemPrompt = ctx.systemPrompt;
+		ctx.tools.guard((execution) => MANAGED_OPENBKN_TOOLS.includes(execution.name) ? void 0 : "This OpenBKN business session only permits managed OpenBKN tools.");
+		systemPrompt.section({
+			name: "openbkn:managed-session",
+			order: 520,
+			text: policy.governance
+		});
+		if (policy.capabilities.length > 0) systemPrompt.section({
+			name: "openbkn:network-capabilities",
+			order: 521,
+			text: policy.capabilities
+		});
+	}
+});
+/**
+* Mount the model-visible OpenBKN tool in one Agent's Cordis scope. An
+* unbound or differently configured session gets no registration at all, so
+* native DSH conversations keep their original tool catalogue.
+*/
+function mountBoundBusinessNetworkTool(agent, config, profile) {
+	const binding = readDshSessionBusinessNetwork(agent.session);
+	if (binding === void 0 || normalizeBaseUrl$2(binding.platformBaseUrl) !== normalizeBaseUrl$2(config.baseUrl)) return false;
+	scopedPolicyPlugin(binding, profile).apply(agent.ctx);
+	return true;
+}
+function normalizeBaseUrl$2(value) {
+	return value.trim().replace(/\/+$/, "");
+}
+//#endregion
+//#region src/suggested-prompts.ts
+const MAX_NETWORK_NAME_LENGTH = 400;
+/** The only prompt shown before a bound business session has a completed answer. */
+function emptyBusinessSessionPrompt(displayName) {
+	const name = displayName.trim();
+	if (name.length === 0 || name.length > MAX_NETWORK_NAME_LENGTH || /[\u0000-\u001F\u007F]/.test(name)) throw new TypeError("OpenBKN business network name is invalid.");
+	return `了解「${name}」知识网络。`;
+}
+//#endregion
+//#region src/business-context-service.ts
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/**
+* Owns the only selection transition: append the immutable DSH session event,
+* then activate the model tool only inside that Agent scope. The browser UI
+* will call this service through its host bridge in the next slice.
+*/
+let OpenBknBusinessContextService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _remoteStatus_decorators;
+	let _remoteBeginLogin_decorators;
+	let _remoteConfigureToken_decorators;
+	let _remoteGetNetworkBinding_decorators;
+	let _remoteGetTurnProvenance_decorators;
+	let _remoteGetTurnProvenanceView_decorators;
+	let _remoteGetSessionSuggestions_decorators;
+	let _remoteListNetworks_decorators;
+	let _remoteBindNetworkWorkspace_decorators;
+	let _remoteBindNetwork_decorators;
+	return class OpenBknBusinessContextService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_remoteStatus_decorators = [Remote("status")];
+			_remoteBeginLogin_decorators = [Remote("beginLogin")];
+			_remoteConfigureToken_decorators = [Remote("configureToken")];
+			_remoteGetNetworkBinding_decorators = [Remote("getNetworkBinding")];
+			_remoteGetTurnProvenance_decorators = [Remote("getTurnProvenance")];
+			_remoteGetTurnProvenanceView_decorators = [Remote("getTurnProvenanceView")];
+			_remoteGetSessionSuggestions_decorators = [Remote("getSessionSuggestions")];
+			_remoteListNetworks_decorators = [Remote("listNetworks")];
+			_remoteBindNetworkWorkspace_decorators = [Remote("bindNetworkWorkspace")];
+			_remoteBindNetwork_decorators = [Remote("bindNetwork")];
+			__esDecorate(this, null, _remoteStatus_decorators, {
+				kind: "method",
+				name: "remoteStatus",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteStatus" in obj,
+					get: (obj) => obj.remoteStatus
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteBeginLogin_decorators, {
+				kind: "method",
+				name: "remoteBeginLogin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteBeginLogin" in obj,
+					get: (obj) => obj.remoteBeginLogin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteConfigureToken_decorators, {
+				kind: "method",
+				name: "remoteConfigureToken",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteConfigureToken" in obj,
+					get: (obj) => obj.remoteConfigureToken
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteGetNetworkBinding_decorators, {
+				kind: "method",
+				name: "remoteGetNetworkBinding",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteGetNetworkBinding" in obj,
+					get: (obj) => obj.remoteGetNetworkBinding
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteGetTurnProvenance_decorators, {
+				kind: "method",
+				name: "remoteGetTurnProvenance",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteGetTurnProvenance" in obj,
+					get: (obj) => obj.remoteGetTurnProvenance
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteGetTurnProvenanceView_decorators, {
+				kind: "method",
+				name: "remoteGetTurnProvenanceView",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteGetTurnProvenanceView" in obj,
+					get: (obj) => obj.remoteGetTurnProvenanceView
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteGetSessionSuggestions_decorators, {
+				kind: "method",
+				name: "remoteGetSessionSuggestions",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteGetSessionSuggestions" in obj,
+					get: (obj) => obj.remoteGetSessionSuggestions
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteListNetworks_decorators, {
+				kind: "method",
+				name: "remoteListNetworks",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteListNetworks" in obj,
+					get: (obj) => obj.remoteListNetworks
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteBindNetworkWorkspace_decorators, {
+				kind: "method",
+				name: "remoteBindNetworkWorkspace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteBindNetworkWorkspace" in obj,
+					get: (obj) => obj.remoteBindNetworkWorkspace
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteBindNetwork_decorators, {
+				kind: "method",
+				name: "remoteBindNetwork",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteBindNetwork" in obj,
+					get: (obj) => obj.remoteBindNetwork
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		config = __runInitializers(this, _instanceExtraInitializers);
+		static inject = [
+			"agents",
+			"credentials",
+			"subprocess",
+			"tools",
+			"openbknWorkspaceBindingRegistry"
+		];
+		static Config = Config;
+		mounted = /* @__PURE__ */ new WeakSet();
+		capabilityProfiles = /* @__PURE__ */ new WeakMap();
+		mcpManagerInstance;
+		constructor(ctx, config) {
+			super(ctx, "openbknBusinessContext");
+			this.config = config;
+			ctx.on("agent/created", ({ agent }) => {
+				this.bindWorkspaceNetworkIfUnique(agent);
+			});
+			ctx.on("agent/pre-step", async ({ agent, step, signal }, next) => await this.refreshManagedMcpAtTurnStart(agent, step, signal, next));
+			ctx.on("agent/turn-stopping", ({ agent, turn }) => {
+				this.captureTurnProvenance(agent, turn);
+			});
+			for (const agent of ctx.agents.list()) this.bindWorkspaceNetworkIfUnique(agent);
+		}
+		/**
+		* Return the CLI-authenticated state and synchronize its token into the
+		* DSH credential vault when needed. The token stays Host-only throughout.
+		* A pre-existing manually configured DSH credential remains a fallback for
+		* deployments without a usable CLI login.
+		*/
+		async remoteStatus(signal) {
+			if (signal.aborted) throw signal.reason;
+			try {
+				const auth = await this.authCoordinator().status(signal);
+				if (auth.kind === "authenticated") await this.synchronizeCliCredential(signal);
+				return auth;
+			} catch (error) {
+				if (!(await this.ctx.credentials.describe(credentialRef("OPENBKN_MCP_TOKEN"))).configured) throw error;
+				if (error instanceof OpenBknCliError) return {
+					kind: "authentication-required",
+					baseUrl: this.config.baseUrl
+				};
+				throw error;
+			}
+		}
+		/** Start the CLI's configured-platform browser login, then synchronize and verify it. */
+		async remoteBeginLogin(signal) {
+			if (signal.aborted) throw signal.reason;
+			await this.authCoordinator().beginLogin();
+			await this.synchronizeCliCredential(signal);
+			return await this.listNetworksAfterAuthentication(signal);
+		}
+		/**
+		* Save one user-entered token to DSH's credential provider, connect the
+		* standard MCP client by reference, then return only visible network DTOs.
+		*/
+		async remoteConfigureToken(token, signal) {
+			const value = token.trim();
+			if (value.length === 0) throw new Error("An OpenBKN token is required.");
+			await this.ctx.credentials.set(credentialRef(OPENBKN_MCP_TOKEN_REF), value);
+			try {
+				await this.refreshMcpConnection();
+			} catch (error) {
+				throw new RemoteError("openbkn/connection-failed", "The OpenBKN Context Loader MCP could not be connected.", {
+					baseUrl: this.config.baseUrl,
+					layer: "context-loader-mcp"
+				}, { cause: error });
+			}
+			return await this.listNetworksAfterAuthentication(signal);
+		}
+		/** Read the immutable network identity already recorded on one live DSH session. */
+		remoteGetNetworkBinding(sessionId) {
+			const agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) throw new Error("OpenBKN business-network binding target is not a live DSH session.");
+			return readDshSessionBusinessNetwork(agent.session);
+		}
+		/** Read only the provenance already committed for one finalized assistant message. */
+		remoteGetTurnProvenance(sessionId, messageId) {
+			const agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) throw new Error("OpenBKN turn provenance target is not a live DSH session.");
+			return readDshSessionTurnProvenance(agent.session, messageId);
+		}
+		/**
+		* Resolve the selected turn's provenance on demand through the fixed
+		* platform OSDK catalogue. The browser receives a bounded presentation DTO,
+		* never raw MCP output, OSDK routes, or credentials.
+		*/
+		async remoteGetTurnProvenanceView(sessionId, messageId, signal) {
+			const agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) throw new Error("OpenBKN turn provenance target is not a live DSH session.");
+			const handle = readDshSessionTurnProvenance(agent.session, messageId);
+			if (handle === void 0) return void 0;
+			const cwd = agent.session.header.cwd ?? ".";
+			const reader = this.platformReader();
+			const [core, graph] = await Promise.allSettled([reader.getInteractionOperations(handle.interactionId, signal, cwd), reader.getInteractionBusinessGraph(handle.interactionId, signal, cwd)]);
+			if (signal.aborted) throw signal.reason;
+			if (core.status === "rejected" && graph.status === "rejected") {
+				this.ctx.logger.warn("openbkn-business-context: provenance reads failed (core=%s, graph=%s)", safeRunnerFailureCode(core.reason), safeRunnerFailureCode(graph.reason));
+				if (safeRunnerFailureCode(core.reason) === "LICENSE_REQUIRED" || safeRunnerFailureCode(graph.reason) === "LICENSE_REQUIRED") {
+					const decision = provenanceLicenseDecision(await this.platformReader().getLicenseEdition(signal).then((value) => value, () => void 0));
+					if (decision.kind === "unavailable") throw new Error("OpenBKN provenance records are unavailable for this interaction.");
+					throw new RemoteError("openbkn/provenance-license-required", "Business provenance is an enterprise capability; the current deployment license does not include it.", { edition: decision.edition });
+				}
+				throw new Error("OpenBKN provenance records are unavailable for this interaction.");
+			}
+			return buildProvenanceView(handle, core.status === "fulfilled" ? core.value : void 0, graph.status === "fulfilled" ? graph.value : void 0, {
+				maxGraphNodes: this.config.maxGraphNodes,
+				maxGraphEdges: this.config.maxGraphEdges
+			});
+		}
+		/** Return the one optional, draft-only introduction for an empty bound session. */
+		remoteGetSessionSuggestions(sessionId) {
+			const agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) throw new Error("OpenBKN suggestion target is not a live DSH session.");
+			const binding = readDshSessionBusinessNetwork(agent.session);
+			if (binding === void 0) return [];
+			if (agent.session.snapshotEvents().some((event) => event.type === "assistant/message")) return [];
+			return [emptyBusinessSessionPrompt(binding.displayName)];
+		}
+		/** List only the business networks authorized by the managed OpenBKN token. */
+		async remoteListNetworks(signal) {
+			if ((await this.remoteStatus(signal)).kind !== "authenticated") throw new Error("OpenBKN authentication is required before listing business networks.");
+			await this.ensureMcpConnection();
+			return await this.listNetworksAfterAuthentication(signal);
+		}
+		/** A successful MCP initial handshake plus OSDK catalogue read is the connection test. */
+		async listNetworksAfterAuthentication(signal) {
+			let payload;
+			try {
+				payload = await this.platformReader().listKnowledgeNetworks(signal, ".");
+			} catch (error) {
+				if (error instanceof PlatformReaderError && error.code === "AUTHENTICATION_REQUIRED") throw new RemoteError("openbkn/authentication-required", "OpenBKN authentication is required.", { baseUrl: this.config.baseUrl });
+				if (error instanceof PlatformReaderError && error.code === "PLATFORM_UNAVAILABLE") throw new RemoteError("openbkn/platform-unavailable", "The OpenBKN platform knowledge-network catalogue is temporarily unavailable.", { baseUrl: this.config.baseUrl }, { cause: error });
+				throw new RemoteError("openbkn/connection-failed", "The OpenBKN platform API could not be queried.", {
+					baseUrl: this.config.baseUrl,
+					layer: "platform-api"
+				}, { cause: error });
+			}
+			return parseVisibleBusinessNetworks(payload).map((network) => {
+				const workspacePath = this.ctx.openbknWorkspaceBindingRegistry.get(this.config.baseUrl, network.id)?.workspacePath;
+				return workspacePath === void 0 ? network : {
+					...network,
+					workspacePath
+				};
+			});
+		}
+		/** Persist a selected local DSH workspace only after the network is authorized. */
+		async remoteBindNetworkWorkspace(networkId, workspacePath, signal) {
+			if ((await this.remoteStatus(signal)).kind !== "authenticated") throw new Error("OpenBKN authentication is required before selecting a workspace.");
+			const network = parseVisibleBusinessNetworks(await this.platformReader().listKnowledgeNetworks(signal, ".")).find((candidate) => candidate.id === networkId.trim());
+			if (network === void 0) throw new Error("The requested OpenBKN business network is not visible to the current identity.");
+			const canonicalPath = await canonicalDirectory(workspacePath);
+			await this.ctx.openbknWorkspaceBindingRegistry.put({
+				platformBaseUrl: this.config.baseUrl,
+				knowledgeNetworkId: network.id,
+				displayName: network.displayName,
+				workspacePath: canonicalPath
+			});
+			return {
+				...network,
+				workspacePath: canonicalPath
+			};
+		}
+		/**
+		* Bind this exact live Agent to one network already confirmed visible by the
+		* configured CLI identity. The Client provides only the opaque network id;
+		* display data and platform routing are re-derived on the Host.
+		*/
+		async remoteBindNetwork(sessionId, networkId, signal) {
+			if ((await this.remoteStatus(signal)).kind !== "authenticated") throw new Error("OpenBKN authentication is required before binding a business network.");
+			const network = parseVisibleBusinessNetworks(await this.platformReader().listKnowledgeNetworks(signal, ".")).find((candidate) => candidate.id === networkId.trim());
+			if (network === void 0) throw new Error("The requested OpenBKN business network is not visible to the current identity.");
+			const agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) throw new Error("OpenBKN business-network selection target is not a live DSH session.");
+			const binding = {
+				platformBaseUrl: this.config.baseUrl,
+				knowledgeNetworkId: network.id,
+				displayName: network.displayName
+			};
+			try {
+				this.capabilityProfiles.set(agent, buildNetworkCapabilityProfile(binding, await this.platformReader().getKnowledgeNetworkDetail(binding, signal, agent.session.header.cwd ?? ".")));
+			} catch (error) {
+				this.ctx.logger.warn("openbkn-business-context: capability profile unavailable; continuing with the verified network binding and fixed managed-session policy (code=%s)", safeCapabilityProfileFailureCode(error));
+			}
+			const result = this.bind(agent, binding);
+			return result.kind === "bound" ? result.event.data : result.binding;
+		}
+		/** Persist one network selection, reject conflicts, then scope the capability to this Agent. */
+		bind(agent, requested) {
+			if (this.ctx.agents.get(agent.id) !== agent) throw new Error("OpenBKN business-network selection target is not a live DSH agent.");
+			if (normalizeBaseUrl$1(requested.platformBaseUrl) !== normalizeBaseUrl$1(this.config.baseUrl)) throw new Error("OpenBKN business-network selection must use the configured OpenBKN platform.");
+			const result = bindDshSessionBusinessNetwork(agent.session, requested);
+			this.mountIfBound(agent);
+			return result;
+		}
+		mountIfBound(agent) {
+			if (this.mounted.has(agent)) return;
+			if (!mountBoundBusinessNetworkTool(agent, this.config, this.capabilityProfiles.get(agent))) return;
+			this.mounted.add(agent);
+		}
+		/**
+		* Project one user-approved workspace association into a newly live native
+		* DSH session. A missing or ambiguous association deliberately leaves the
+		* native session untouched.
+		*/
+		bindWorkspaceNetworkIfUnique(agent) {
+			if (readDshSessionBusinessNetwork(agent.session) !== void 0) {
+				this.mountIfBound(agent);
+				return;
+			}
+			const workspacePath = agent.session.header.cwd;
+			if (workspacePath === void 0) {
+				this.mountIfBound(agent);
+				return;
+			}
+			const record = this.ctx.openbknWorkspaceBindingRegistry.findUniqueByWorkspace(this.config.baseUrl, workspacePath);
+			if (record === void 0) {
+				this.mountIfBound(agent);
+				return;
+			}
+			this.bind(agent, {
+				platformBaseUrl: this.config.baseUrl,
+				knowledgeNetworkId: record.knowledgeNetworkId,
+				displayName: record.displayName ?? record.knowledgeNetworkId
+			});
+		}
+		/**
+		* Reconcile the CLI-owned credential before a bound business turn reaches
+		* its first model step. This is the only per-turn lifecycle point: later
+		* tool-planning steps retain the same connection and do not re-authenticate.
+		*/
+		async refreshManagedMcpAtTurnStart(agent, step, signal, next) {
+			if (step === 1 && readDshSessionBusinessNetwork(agent.session) !== void 0) await this.remoteStatus(signal);
+			return await next();
+		}
+		/** Persist only an explicitly completed OpenBKN interaction when its turn ends. */
+		captureTurnProvenance(agent, turn) {
+			if (readDshSessionBusinessNetwork(agent.session) === void 0) return;
+			const provenance = findCompletedNativeMcpProvenance(agent.session.snapshotEvents(), turn);
+			if (provenance === void 0) return;
+			appendDshSessionTurnProvenance(agent.session, provenance.messageId, provenance.handle);
+		}
+		async ensureMcpConnection() {
+			if (this.ctx.tools === void 0) return;
+			await this.mcpManager().ensure();
+		}
+		async refreshMcpConnection() {
+			if (this.ctx.tools === void 0) return;
+			await this.mcpManager().refresh();
+		}
+		mcpManager() {
+			return this.mcpManagerInstance ??= new OpenBknMcpManager(this.ctx, this.config, () => this.resolveOpenBknToken());
+		}
+		authCoordinator() {
+			return new AuthCoordinator(new OpenBknCliSubprocess(this.ctx.subprocess, ".", this.config.baseUrl, this.config.cliPath), this.config.baseUrl);
+		}
+		/** Synchronize exactly one configured-platform CLI token into DSH credentials. */
+		async synchronizeCliCredential(signal) {
+			const token = await this.authCoordinator().readToken(signal);
+			await this.ctx.credentials.set(credentialRef(OPENBKN_MCP_TOKEN_REF), token);
+			await this.refreshMcpConnection();
+		}
+		/** Historical private seam retained for unit fixtures; it now returns the Host HTTP reader, never a Python OSDK process. */
+		platformReader() {
+			return new OpenBknPlatformReader({
+				...this.config,
+				resolveToken: () => this.resolveOpenBknToken()
+			});
+		}
+		/** Resolve only the DSH-managed token; legacy environment variables are not silently migrated. */
+		async resolveOpenBknToken() {
+			const ref = credentialRef(OPENBKN_MCP_TOKEN_REF);
+			return (await this.ctx.credentials.resolve(ref))?.value;
+		}
+	};
+})();
+/**
+* A permission_denied gate is only a license statement when the deployment is
+* verifiably unlicensed; an enterprise deployment that still denies the read
+* has a domain-authorization problem instead, and must not be told to upgrade.
+* Capabilities being unreachable leaves the cause undetermined: report the
+* generic unavailable failure rather than guessing an upgrade path.
+*/
+function provenanceLicenseDecision(license) {
+	if (license === void 0 || license.licensed !== false) return { kind: "unavailable" };
+	return {
+		kind: "license-required",
+		edition: license.edition ?? ""
+	};
+}
+function safeRunnerFailureCode(error) {
+	return error instanceof PlatformReaderError ? error.code : "UNCLASSIFIED";
+}
+function safeCapabilityProfileFailureCode(error) {
+	return error instanceof PlatformReaderError ? error.code : "PROFILE_UNAVAILABLE";
+}
+function normalizeBaseUrl$1(value) {
+	return value.trim().replace(/\/+$/, "");
+}
+async function canonicalDirectory(path) {
+	const canonicalPath = await realpath(path);
+	if (!(await stat(canonicalPath)).isDirectory()) throw new Error("OpenBKN workspace must be an existing local directory.");
+	return canonicalPath;
+}
+//#endregion
+//#region src/workspace-binding-registry.ts
+/** A local DSH workspace chosen for one OpenBKN business knowledge network. */
+const workspaceBindingRecord = z.object({
+	platformBaseUrl: z.string().url(),
+	knowledgeNetworkId: z.string().trim().min(1),
+	/** Optional only for records written before business display metadata existed. */
+	displayName: z.string().trim().min(1).max(512).optional(),
+	workspacePath: z.string().trim().refine(isAbsolute, "workspacePath must be absolute"),
+	updatedAt: z.string().datetime()
+});
+const workspaceBindingDomain = defineDomain({
+	name: "openbkn_workspace_bindings",
+	version: 1,
+	tables: { bindings: domainTable(workspaceBindingRecord) }
+});
+/** Stable storage key: one configurable OpenBKN platform and network identity. */
+function workspaceBindingKey(platformBaseUrl, knowledgeNetworkId) {
+	return `${normalizeBaseUrl(platformBaseUrl)}::${knowledgeNetworkId.trim()}`;
+}
+/**
+* Host-owned durable index for the small, non-secret network-to-workspace
+* association. It deliberately stores a path rather than a DSH workspace id:
+* DSH resolves a registered workspace id from the path at each Client run.
+*/
+var OpenBknWorkspaceBindingRegistry = class extends Service {
+	static inject = ["storageDomain"];
+	table;
+	constructor(ctx) {
+		super(ctx, "openbknWorkspaceBindingRegistry");
+	}
+	async [Service.init]() {
+		const domain = await this.ctx.storageDomain.open(workspaceBindingDomain);
+		this.ctx.effect(() => () => domain.close(), "openbknWorkspaceBindingRegistry.domainClose");
+		this.table = domain.table("bindings");
+	}
+	get(platformBaseUrl, knowledgeNetworkId) {
+		return this.requireTable().get(workspaceBindingKey(platformBaseUrl, knowledgeNetworkId));
+	}
+	/**
+	* Return the one network associated with a native DSH workspace. Ambiguous
+	* workspace associations deliberately produce no result so a session is
+	* never bound to a network by guesswork.
+	*/
+	findUniqueByWorkspace(platformBaseUrl, workspacePath) {
+		const expectedPlatform = normalizeBaseUrl(platformBaseUrl);
+		const expectedPath = normalizeWorkspacePath(workspacePath);
+		let match;
+		for (const [, candidate] of this.requireTable().entries()) {
+			if (normalizeBaseUrl(candidate.platformBaseUrl) !== expectedPlatform) continue;
+			if (normalizeWorkspacePath(candidate.workspacePath) !== expectedPath) continue;
+			if (match !== void 0) return void 0;
+			match = candidate;
+		}
+		return match;
+	}
+	async put(input) {
+		const record = workspaceBindingRecord.parse({
+			...input,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		for (const [, candidate] of this.requireTable().entries()) {
+			if (normalizeBaseUrl(candidate.platformBaseUrl) !== normalizeBaseUrl(record.platformBaseUrl)) continue;
+			if (normalizeWorkspacePath(candidate.workspacePath) !== normalizeWorkspacePath(record.workspacePath)) continue;
+			if (candidate.knowledgeNetworkId !== record.knowledgeNetworkId) throw new Error("This local DSH workspace is already associated with another OpenBKN knowledge network.");
+		}
+		await this.requireTable().put(workspaceBindingKey(record.platformBaseUrl, record.knowledgeNetworkId), record);
+		return record;
+	}
+	requireTable() {
+		if (this.table === void 0) throw new Error("OpenBKN workspace binding registry is not ready.");
+		return this.table;
+	}
+};
+function normalizeBaseUrl(value) {
+	return value.trim().replace(/\/+$/, "");
+}
+function normalizeWorkspacePath(value) {
+	return resolve(value);
+}
+//#endregion
+//#region src/index.ts
+/** Cordis identity used by the bundle's Host row. */
+const name = "openbkn-business-context";
+const inject = [
+	"agents",
+	"subprocess",
+	"storageDomain"
+];
+/** Register the host service; it contributes no model-visible tool globally. */
+async function apply(ctx, config) {
+	await ctx.plugin(OpenBknWorkspaceBindingRegistry);
+	await ctx.plugin(OpenBknBusinessContextService, config);
+}
+//#endregion
+export { AuthCoordinator, BUSINESS_NETWORK_BOUND_EVENT, BusinessNetworkBindingConflictError, Config, OPENBKN_DSH_INTERACTION_AGENT_NAME, OpenBknBusinessContextService, OpenBknCliError, OpenBknPlatformReader, OpenBknWorkspaceBindingRegistry, PlatformReaderError, TURN_PROVENANCE_EVENT, TurnProvenanceConflictError, appendDshSessionTurnProvenance, appendTurnProvenance, apply, bindBusinessNetwork, bindDshSessionBusinessNetwork, buildManagedSessionPolicy, buildNetworkCapabilityProfile, emptyBusinessSessionPrompt, inject, mountBoundBusinessNetworkTool, name, normalizeProvenanceHandle, readBusinessNetworkBinding, readDshSessionBusinessNetwork, readDshSessionTurnProvenance, readTurnProvenance, workspaceBindingKey, workspaceBindingRecord };