@nextclaw/kernel 0.12.3 → 0.13.0

package/dist/index.js

@@ -10,7 +10,7 @@ import { catchError, filter, from, lastValueFrom, tap } from "rxjs";
 import { DefaultNcpAgentConversationStateManager, insertMessageByTimeline, mergeToolExecutionTiming } from "@nextclaw/ncp-toolkit";
 import { accessSync, appendFileSync, chmodSync, constants, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import { access, appendFile, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { access, appendFile, chmod, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { AppHomeService, AppInstallationService, AppInstanceInventoryService, AppInstanceStorageService, AppManifestService, AppPlatformTargetService, AppRegistryService, AppServiceLaunchService, FileLockService, isAppComponentManifestBundle } from "@nextclaw/app-runtime";
 import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -19,7 +19,6 @@ import { McpRegistryService, McpServerLifecycleManager, normalizeMcpServerName }
 import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
 import { parse } from "yaml";
 import { createInterface } from "node:readline";
-import Database from "better-sqlite3";
 import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
 import { StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, probeStdioRuntime } from "@nextclaw/nextclaw-ncp-runtime-stdio-client";
 import { DefaultNcpAgentRuntime } from "@nextclaw/ncp-agent-runtime-next";
@@ -1394,7 +1393,7 @@ const SESSION_ACTIVITY_PREVIEW_STATUS_KINDS = new Set([
 	"run-failed",
 	"run-interrupted"
 ]);
-function isRecord$18(value) {
+function isRecord$19(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString$14(value) {
@@ -1403,7 +1402,7 @@ function readOptionalString$14(value) {
 	return trimmed.length > 0 ? trimmed : void 0;
 }
 function readSessionActivityPreviewMetadata(value) {
-	if (!isRecord$18(value)) return null;
+	if (!isRecord$19(value)) return null;
 	const state = value.state;
 	const timestamp = readOptionalString$14(value.timestamp);
 	if (!SESSION_ACTIVITY_PREVIEW_STATES.has(state) || !timestamp) return null;
@@ -1497,7 +1496,7 @@ var SessionActivityPreviewEventService = class {
 //#endregion
 //#region src/managers/agent-run-session-command.manager.ts
 const CONTINUATION_PROMPT = "Continue from where you stopped. Preserve completed work and avoid repeating it.";
-function isRecord$17(value) {
+function isRecord$18(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function hasSendableMessageContent(message) {
@@ -1505,7 +1504,7 @@ function hasSendableMessageContent(message) {
 }
 function readSessionActivityState(metadata) {
 	const preview = metadata?.[SESSION_ACTIVITY_PREVIEW_METADATA_KEY];
-	return isRecord$17(preview) && typeof preview.state === "string" ? preview.state : null;
+	return isRecord$18(preview) && typeof preview.state === "string" ? preview.state : null;
 }
 var AgentRunSessionCommandManager = class {
 	pendingCommands = /* @__PURE__ */ new Map();
@@ -2186,7 +2185,7 @@ var AgentRuntimeRunObserverService = class {
 };
 //#endregion
 //#region src/utils/agent-run-trigger.utils.ts
-function isRecord$16(value) {
+function isRecord$17(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString$12(value) {
@@ -2194,7 +2193,7 @@ function readOptionalString$12(value) {
 }
 function readSourceRunSpec(message) {
 	const value = message.metadata?.[AGENT_RUN_MESSAGE_RUN_SPEC_METADATA_KEY];
-	return isRecord$16(value) ? value : {};
+	return isRecord$17(value) ? value : {};
 }
 const SOURCE_CONTEXT_KEYS = [
 	"channel",
@@ -2699,7 +2698,7 @@ const BUILTIN_RUNTIME_PRESENTATION = {
 		}
 	}
 };
-function readString$9(value) {
+function readString$10(value) {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
 }
@@ -2708,7 +2707,7 @@ function readRecord$3(value) {
 	return value;
 }
 function resolveBuiltinRuntimePresentation(value) {
-	const normalized = readString$9(value)?.toLowerCase();
+	const normalized = readString$10(value)?.toLowerCase();
 	if (!normalized) return null;
 	if (!(normalized in BUILTIN_RUNTIME_PRESENTATION)) return null;
 	return BUILTIN_RUNTIME_PRESENTATION[normalized] ?? null;
@@ -2729,13 +2728,13 @@ function resolveAgentRuntimeEntries(params) {
 	entries.set(DEFAULT_AGENT_RUNTIME_ENTRY_ID, buildNativeRuntimeEntry(params.config));
 	for (const [rawId, rawEntry] of Object.entries(params.config.agents.runtimes.entries ?? {})) {
 		const id = rawId.trim().toLowerCase();
-		const type = readString$9(rawEntry.type)?.toLowerCase();
+		const type = readString$10(rawEntry.type)?.toLowerCase();
 		if (!id || !type) continue;
 		const explicitIcon = normalizeAgentRuntimeSessionTypeIcon(rawEntry.icon);
 		const builtinPresentation = resolveBuiltinRuntimePresentation(id) ?? resolveBuiltinRuntimePresentation(type);
 		entries.set(id, {
 			id,
-			label: readString$9(rawEntry.label) ?? builtinPresentation?.label ?? id,
+			label: readString$10(rawEntry.label) ?? builtinPresentation?.label ?? id,
 			...explicitIcon ?? builtinPresentation?.icon ? { icon: explicitIcon ?? builtinPresentation?.icon } : {},
 			type,
 			enabled: rawEntry.enabled !== false,
@@ -3535,6 +3534,570 @@ var AppPackageOperationManager = class {
 	isMissingFileError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 };
 //#endregion
+//#region src/types/app-package.types.ts
+var AppPackageError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "AppPackageError";
+	}
+};
+function isAppPackageError(error) {
+	return error instanceof AppPackageError;
+}
+//#endregion
+//#region src/utils/service-app-manifest.utils.ts
+const SERVICE_APP_ID_PATTERN$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SERVICE_ACTION_RISKS = new Set([
+	"read",
+	"write",
+	"external",
+	"dangerous"
+]);
+const SERVICE_APP_MANIFEST_FILE_NAME = "service-app.json";
+function getServiceAppManifestPath(dirPath) {
+	return join(dirPath, SERVICE_APP_MANIFEST_FILE_NAME);
+}
+async function readServiceAppManifest(dirPath, options) {
+	return parseServiceAppManifest(await readFile(getServiceAppManifestPath(dirPath), "utf8"), options);
+}
+function parseServiceAppManifest(raw, options = {}) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`service-app.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!isRecord$16(parsed)) throw new Error("service-app.json must contain an object.");
+	const id = readRequiredString$8(parsed, "id");
+	if (!SERVICE_APP_ID_PATTERN$1.test(id)) throw new Error("service app id must be kebab-case.");
+	const protocol = readOptionalString$11(parsed, "protocol") ?? "mcp";
+	if (protocol !== "mcp" && protocol !== "wasi-component") throw new Error("service app protocol must be mcp or wasi-component.");
+	const launch = protocol === "mcp" ? new AppServiceLaunchService(options.platformTargetService).resolve(parsed, options.target) : void 0;
+	const componentEntry = protocol === "wasi-component" ? readPortableComponentEntry(parsed) : void 0;
+	const lifecycle = readServiceAppLifecycle(parsed.lifecycle);
+	if (lifecycle.mode !== "action" && protocol !== "wasi-component") throw new Error(`${lifecycle.mode} service app lifecycle requires wasi-component protocol.`);
+	const provides = readServiceAppProvides(parsed.provides);
+	if (provides && lifecycle.mode !== "provider") throw new Error("service app provides requires provider lifecycle.");
+	return {
+		id,
+		title: readRequiredString$8(parsed, "title"),
+		description: readOptionalString$11(parsed, "description"),
+		enabled: readOptionalBoolean$2(parsed, "enabled") ?? true,
+		protocol,
+		command: launch?.command,
+		args: launch?.args,
+		componentEntry,
+		providerIds: readProviderIds(parsed.providers),
+		lifecycle,
+		requires: readServiceAppRequirements(parsed.requires),
+		provides,
+		actions: readManifestActions(parsed.actions)
+	};
+}
+function readServiceAppProvides(value) {
+	if (value === void 0) return void 0;
+	if (!isRecord$16(value)) throw new Error("service app provides must be an object.");
+	if (value.capabilities === void 0) return void 0;
+	if (!Array.isArray(value.capabilities)) throw new Error("service app provides.capabilities must be an array.");
+	const seen = /* @__PURE__ */ new Set();
+	const capabilities = value.capabilities.map((entry, index) => {
+		if (!isRecord$16(entry)) throw new Error(`service app provides.capabilities[${index}] must be an object.`);
+		const id = readRequirementIdentifier(entry, "id", `provides.capabilities[${index}].id`);
+		const version = readOptionalString$11(entry, "version");
+		if (!version) throw new Error(`service app provides.capabilities[${index}].version is required.`);
+		const key = `${id}@${version}`;
+		if (seen.has(key)) throw new Error(`service app provides.capabilities contains duplicate ${key}.`);
+		seen.add(key);
+		return {
+			id,
+			version,
+			resourceTypes: readCapabilityResourceTypes(entry.resourceTypes, index)
+		};
+	});
+	return capabilities.length > 0 ? { capabilities } : void 0;
+}
+function readCapabilityResourceTypes(value, index) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new Error(`service app provides.capabilities[${index}].resourceTypes must be an array.`);
+	const resourceTypes = value.map((entry, resourceIndex) => {
+		if (typeof entry !== "string" || !entry.trim()) throw new Error(`service app provides.capabilities[${index}].resourceTypes[${resourceIndex}] must be a lowercase identifier.`);
+		return entry.trim();
+	});
+	if (resourceTypes.some((entry) => !/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(entry))) throw new Error(`service app provides.capabilities[${index}].resourceTypes must contain lowercase identifiers.`);
+	return Array.from(new Set(resourceTypes));
+}
+function readServiceAppRequirements(value) {
+	if (value === void 0) return void 0;
+	if (!isRecord$16(value)) throw new Error("service app requires must be an object.");
+	const capabilities = readCapabilityRequirements(value.capabilities);
+	const resources = readResourceRequirements(value.resources);
+	return capabilities || resources ? {
+		capabilities,
+		resources
+	} : void 0;
+}
+function readCapabilityRequirements(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new Error("service app requires.capabilities must be an array.");
+	const seen = /* @__PURE__ */ new Set();
+	return value.map((entry, index) => {
+		if (!isRecord$16(entry)) throw new Error(`service app requires.capabilities[${index}] must be an object.`);
+		const id = readRequirementIdentifier(entry, "id", `requires.capabilities[${index}].id`);
+		const version = readOptionalString$11(entry, "version");
+		const key = `${id}@${version ?? "*"}`;
+		if (seen.has(key)) throw new Error(`service app requires.capabilities contains duplicate ${key}.`);
+		seen.add(key);
+		return {
+			id,
+			version,
+			title: readOptionalString$11(entry, "title"),
+			description: readOptionalString$11(entry, "description"),
+			remediation: readExternalRemediation(entry.remediation, `requires.capabilities[${index}]`)
+		};
+	});
+}
+function readResourceRequirements(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new Error("service app requires.resources must be an array.");
+	const seen = /* @__PURE__ */ new Set();
+	return value.map((entry, index) => {
+		if (!isRecord$16(entry)) throw new Error(`service app requires.resources[${index}] must be an object.`);
+		const binding = readRequirementIdentifier(entry, "binding", `requires.resources[${index}].binding`);
+		if (seen.has(binding)) throw new Error(`service app requires.resources contains duplicate binding ${binding}.`);
+		seen.add(binding);
+		return {
+			binding,
+			type: readRequirementIdentifier(entry, "type", `requires.resources[${index}].type`),
+			required: readOptionalBoolean$2(entry, "required") ?? true,
+			title: readOptionalString$11(entry, "title"),
+			description: readOptionalString$11(entry, "description"),
+			remediation: readExternalRemediation(entry.remediation, `requires.resources[${index}]`)
+		};
+	});
+}
+function readRequirementIdentifier(record, key, fieldName) {
+	const value = readOptionalString$11(record, key);
+	if (!value || !/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(value)) throw new Error(`service app ${fieldName} must be a lowercase identifier.`);
+	return value;
+}
+function readExternalRemediation(value, fieldPrefix) {
+	if (value === void 0) return void 0;
+	if (!isRecord$16(value) || value.kind !== "agent-setup") throw new Error(`service app ${fieldPrefix}.remediation.kind must be agent-setup.`);
+	const summary = readOptionalString$11(value, "summary");
+	if (!summary) throw new Error(`service app ${fieldPrefix}.remediation.summary is required.`);
+	return {
+		kind: "agent-setup",
+		summary,
+		requiresUserAction: readOptionalBoolean$2(value, "requiresUserAction")
+	};
+}
+function readServiceAppLifecycle(value) {
+	if (value === void 0) return { mode: "action" };
+	if (!isRecord$16(value)) throw new Error("service app lifecycle must be an object.");
+	const mode = readOptionalString$11(value, "mode") ?? "action";
+	if (mode === "action") return { mode };
+	if (mode === "provider") return { mode };
+	if (mode !== "resident") throw new Error("service app lifecycle.mode must be action, resident or provider.");
+	const eventIntervalMs = readOptionalNumber$1(value, "eventIntervalMs");
+	if (eventIntervalMs === void 0 || !Number.isInteger(eventIntervalMs) || eventIntervalMs < 250 || eventIntervalMs > 6e4) throw new Error("resident service app lifecycle.eventIntervalMs must be an integer between 250 and 60000.");
+	return {
+		mode,
+		eventIntervalMs
+	};
+}
+function readProviderIds(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error("service app providers must be an array.");
+	const providerIds = value.map((entry) => {
+		if (typeof entry !== "string" || !SERVICE_APP_ID_PATTERN$1.test(entry.trim())) throw new Error("service app providers must contain kebab-case service app ids.");
+		return entry.trim();
+	});
+	return Array.from(new Set(providerIds));
+}
+function readPortableComponentEntry(record) {
+	const component = record.component;
+	if (!isRecord$16(component)) throw new Error("service app component is required for wasi-component.");
+	const entry = readRequiredString$8(component, "entry").replace(/\\/g, "/");
+	if (path.isAbsolute(entry) || entry.includes("\0") || entry.split("/").includes("..")) throw new Error("service app component.entry must be a package-relative path.");
+	if (!entry.endsWith(".wasm")) throw new Error("service app component.entry must reference a .wasm file.");
+	return entry;
+}
+function readManifestActions(value) {
+	if (value === void 0) throw new Error("service app actions are required.");
+	if (!isRecord$16(value)) throw new Error("service app actions must be an object.");
+	if (Object.keys(value).length === 0) throw new Error("service app actions cannot be empty.");
+	const actions = {};
+	for (const [name, action] of Object.entries(value)) {
+		if (!name.trim()) throw new Error("service app action name cannot be empty.");
+		if (!isRecord$16(action)) throw new Error(`service app action ${name} must be an object.`);
+		const risk = readOptionalString$11(action, "risk");
+		if (risk !== void 0 && !SERVICE_ACTION_RISKS.has(risk)) throw new Error(`service app action ${name} has invalid risk.`);
+		const inputSchema = action.inputSchema;
+		if (inputSchema !== void 0 && !isRecord$16(inputSchema)) throw new Error(`service app action ${name} inputSchema must be an object.`);
+		const timeoutMs = readOptionalNumber$1(action, "timeoutMs");
+		if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 3e5)) throw new Error(`service app action ${name} timeoutMs must be an integer between 100 and 300000.`);
+		actions[name] = {
+			risk,
+			title: readOptionalString$11(action, "title"),
+			description: readOptionalString$11(action, "description"),
+			inputSchema,
+			timeoutMs
+		};
+	}
+	return actions;
+}
+function readRequiredString$8(record, key) {
+	const value = readOptionalString$11(record, key);
+	if (!value) throw new Error(`service app ${key} is required.`);
+	return value;
+}
+function readOptionalString$11(record, key) {
+	return typeof record[key] === "string" && record[key].trim() ? record[key].trim() : void 0;
+}
+function readOptionalBoolean$2(record, key) {
+	if (record[key] === void 0) return;
+	if (typeof record[key] !== "boolean") throw new Error(`service app ${key} must be boolean.`);
+	return record[key];
+}
+function readOptionalNumber$1(record, key) {
+	if (record[key] === void 0) return;
+	if (typeof record[key] !== "number") throw new Error(`service app ${key} must be number.`);
+	return record[key];
+}
+function isRecord$16(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/services/app-package-dependency.service.ts
+const STORE_FILE_NAME = "dependencies.json";
+const LOCK_FILE_NAME = ".dependencies.lock";
+const IDENTIFIER_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/;
+/**
+* Owns non-sensitive Consumer-to-Provider bindings. The Provider catalog stays
+* outside this service, so activation and runtime ownership remain unchanged.
+*/
+var AppPackageDependencyService = class {
+	fileLockService = new FileLockService();
+	inspect = async (params) => {
+		const [requirements, bindings] = await Promise.all([this.readRequirements(params.target.components), this.readBindings(params.target.storage)]);
+		return this.toView(requirements, bindings, params.providers);
+	};
+	resolveStoredProviderIds = async (target) => {
+		const [requirements, bindings] = await Promise.all([this.readRequirements(target.components), this.readBindings(target.storage)]);
+		const result = {};
+		for (const requirement of requirements) {
+			const binding = this.findBinding(bindings, requirement);
+			if (!binding) continue;
+			const providerIds = result[requirement.componentId] ?? [];
+			if (!providerIds.includes(binding.providerId)) providerIds.push(binding.providerId);
+			result[requirement.componentId] = providerIds;
+		}
+		return result;
+	};
+	listBindings = async (target) => await this.readBindings(target.storage);
+	setup = async (params) => await this.update(params, (requirements, bindings) => {
+		const updated = [...bindings];
+		for (const requirement of requirements) {
+			if (this.findBinding(updated, requirement)) continue;
+			const candidates = this.findCandidates(requirement, params.providers);
+			if (candidates.length === 1) updated.push(this.toBinding(requirement, candidates[0].providerId));
+		}
+		return updated;
+	});
+	bind = async (params) => await this.update(params, (requirements, bindings) => {
+		const requirement = this.requireRequirement(requirements, params.input);
+		const provider = params.providers.find((entry) => entry.providerId === params.input.providerId);
+		if (!provider || !this.providerMatches(requirement, provider)) throw new AppPackageError("APP_PACKAGE_NOT_READY", `Provider ${params.input.providerId} cannot satisfy ${this.requirementKey(requirement)}.`);
+		return [...bindings.filter((entry) => !this.isBindingForRequirement(entry, requirement)), this.toBinding(requirement, provider.providerId)];
+	});
+	unbind = async (params) => await this.update(params, (requirements, bindings) => {
+		const requirement = this.requireRequirement(requirements, params.input);
+		return bindings.filter((entry) => !this.isBindingForRequirement(entry, requirement));
+	});
+	update = async (params, mutate) => await this.fileLockService.withLock(this.lockPath(params.target.storage), async () => {
+		const [requirements, bindings] = await Promise.all([this.readRequirements(params.target.components), this.readBindings(params.target.storage)]);
+		const updated = this.normalizeBindings(mutate(requirements, bindings));
+		await this.writeBindings(params.target.storage, updated);
+		return this.toView(requirements, updated, params.providers);
+	});
+	readRequirements = async (components) => (await Promise.all(components.filter((component) => component.kind === "service").map(async (component) => this.readComponentRequirements(component)))).flat();
+	readComponentRequirements = async (component) => {
+		const manifest = await readServiceAppManifest(component.componentDirectory);
+		return this.toRequirements(component.id, manifest);
+	};
+	toRequirements = (componentId, manifest) => [...(manifest.requires?.capabilities ?? []).map((requirement) => ({
+		componentId,
+		kind: "capability",
+		id: requirement.version ? `${requirement.id}@${requirement.version}` : requirement.id,
+		title: requirement.title ?? requirement.id,
+		description: requirement.description,
+		remediation: requirement.remediation,
+		capabilityId: requirement.id,
+		capabilityVersion: requirement.version
+	})), ...(manifest.requires?.resources ?? []).filter((requirement) => requirement.required !== false).map((requirement) => ({
+		componentId,
+		kind: "resource",
+		id: requirement.binding,
+		title: requirement.title ?? requirement.type,
+		description: requirement.description,
+		remediation: requirement.remediation,
+		resourceType: requirement.type
+	}))];
+	toView = (requirements, bindings, providers) => {
+		const candidates = requirements.map((requirement) => ({
+			requirement: this.toReadinessRequirement(requirement),
+			providers: this.findCandidates(requirement, providers)
+		}));
+		const readinessRequirements = candidates.filter(({ requirement, providers: candidatesForRequirement }) => {
+			const source = this.toRequirement(requirement);
+			const binding = this.findBinding(bindings, source);
+			return !binding || !candidatesForRequirement.some((provider) => provider.providerId === binding.providerId);
+		}).map(({ requirement }) => requirement);
+		return {
+			readiness: this.toReadiness(readinessRequirements),
+			bindings,
+			candidates,
+			resolvedProviderIds: this.toResolvedProviderIds(requirements, bindings, providers)
+		};
+	};
+	toReadiness = (requirements) => ({
+		status: requirements.some((requirement) => requirement.kind === "capability") ? "needs-capability" : requirements.some((requirement) => requirement.kind === "configuration") ? "needs-configuration" : "ready",
+		requirements
+	});
+	toResolvedProviderIds = (requirements, bindings, providers) => {
+		const availableProviderIds = new Set(providers.map((provider) => provider.providerId));
+		const result = {};
+		for (const requirement of requirements) {
+			const binding = this.findBinding(bindings, requirement);
+			if (!binding || !availableProviderIds.has(binding.providerId)) continue;
+			const providerIds = result[requirement.componentId] ?? [];
+			if (!providerIds.includes(binding.providerId)) providerIds.push(binding.providerId);
+			result[requirement.componentId] = providerIds;
+		}
+		return result;
+	};
+	findCandidates = (requirement, providers) => providers.filter((provider) => this.providerMatches(requirement, provider));
+	providerMatches = (requirement, provider) => provider.capabilities.some((capability) => {
+		if (requirement.kind === "capability") return capability.id === requirement.capabilityId && (!requirement.capabilityVersion || capability.version === requirement.capabilityVersion);
+		return capability.resourceTypes?.includes(requirement.resourceType) ?? false;
+	});
+	requireRequirement = (requirements, input) => {
+		const requirement = requirements.find((entry) => entry.componentId === input.componentId && entry.kind === input.requirementKind && entry.id === input.requirementId);
+		if (!requirement) throw new AppPackageError("APP_PACKAGE_NOT_FOUND", `Dependency ${input.componentId}/${input.requirementKind}/${input.requirementId} was not declared by this App.`);
+		return requirement;
+	};
+	toBinding = (requirement, providerId) => ({
+		componentId: requirement.componentId,
+		requirementKind: requirement.kind,
+		requirementId: requirement.id,
+		providerId
+	});
+	findBinding = (bindings, requirement) => bindings.find((entry) => this.isBindingForRequirement(entry, requirement));
+	isBindingForRequirement = (binding, requirement) => binding.componentId === requirement.componentId && binding.requirementKind === requirement.kind && binding.requirementId === requirement.id;
+	requirementKey = (requirement) => `${requirement.componentId}/${requirement.kind}/${requirement.id}`;
+	toRequirement = (requirement) => ({
+		componentId: requirement.componentId,
+		kind: requirement.kind === "capability" ? "capability" : "resource",
+		id: requirement.id,
+		title: requirement.title,
+		description: requirement.description,
+		remediation: requirement.remediation
+	});
+	toReadinessRequirement = (requirement) => ({
+		componentId: requirement.componentId,
+		kind: requirement.kind === "capability" ? "capability" : "configuration",
+		id: requirement.id,
+		title: requirement.title,
+		description: requirement.description,
+		remediation: requirement.remediation
+	});
+	readBindings = async (storage) => {
+		try {
+			const parsed = JSON.parse(await readFile(this.storePath(storage), "utf8"));
+			if (!this.isStore(parsed)) throw new Error("schema");
+			return this.normalizeBindings(parsed.bindings);
+		} catch (error) {
+			if (this.isMissingFileError(error)) return [];
+			throw new AppPackageError("APP_PACKAGE_OPERATION_FAILED", `App dependency bindings are invalid: ${error instanceof Error ? error.message : String(error)}.`);
+		}
+	};
+	writeBindings = async (storage, bindings) => {
+		await mkdir(storage.configDirectory, {
+			recursive: true,
+			mode: 448
+		});
+		const filePath = this.storePath(storage);
+		const stagedPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+		await writeFile(stagedPath, `${JSON.stringify({
+			schemaVersion: 1,
+			bindings
+		}, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		await rename(stagedPath, filePath);
+		await chmod(filePath, 384);
+	};
+	normalizeBindings = (bindings) => {
+		const unique = /* @__PURE__ */ new Map();
+		for (const binding of bindings) {
+			if (!this.isBinding(binding)) throw new Error("invalid binding");
+			unique.set(`${binding.componentId}/${binding.requirementKind}/${binding.requirementId}`, binding);
+		}
+		return Array.from(unique.values()).sort((left, right) => this.bindingKey(left).localeCompare(this.bindingKey(right)));
+	};
+	bindingKey = (binding) => `${binding.componentId}/${binding.requirementKind}/${binding.requirementId}`;
+	isStore = (value) => Boolean(value) && typeof value === "object" && value.schemaVersion === 1 && Array.isArray(value.bindings);
+	isBinding = (value) => Boolean(value) && typeof value === "object" && IDENTIFIER_PATTERN.test(value.componentId) && (value.requirementKind === "capability" || value.requirementKind === "resource") && typeof value.requirementId === "string" && value.requirementId.length > 0 && IDENTIFIER_PATTERN.test(value.providerId);
+	storePath = (storage) => path.join(storage.configDirectory, STORE_FILE_NAME);
+	lockPath = (storage) => path.join(storage.configDirectory, LOCK_FILE_NAME);
+	isMissingFileError = (error) => typeof error === "object" && error !== null && error.code === "ENOENT";
+};
+//#endregion
+//#region src/services/app-package-dependency-coordinator.service.ts
+/**
+* Bridges the package lifecycle owner to dependency persistence. It keeps all
+* Provider queries and binding mutations on the one dependency service path.
+*/
+var AppPackageDependencyCoordinator = class {
+	dependencyService;
+	constructor(params) {
+		this.params = params;
+		this.dependencyService = params.dependencyService ?? new AppPackageDependencyService();
+	}
+	inspect = async (appId) => await this.inspectTarget(await this.getTarget(appId));
+	verify = async (appId) => await this.inspect(appId);
+	setup = async (appId) => await this.params.installationService.withAppOperation(appId, async () => {
+		const info = await this.getMutableTargetInfo(appId);
+		return await this.dependencyService.setup({
+			target: this.targetForInfo(info),
+			providers: await this.params.listCapabilityProviders()
+		});
+	});
+	bind = async (appId, input) => await this.params.installationService.withAppOperation(appId, async () => {
+		const info = await this.getMutableTargetInfo(appId);
+		return await this.dependencyService.bind({
+			target: this.targetForInfo(info),
+			providers: await this.params.listCapabilityProviders(),
+			input
+		});
+	});
+	unbind = async (appId, input) => await this.params.installationService.withAppOperation(appId, async () => {
+		const info = await this.getMutableTargetInfo(appId);
+		return await this.dependencyService.unbind({
+			target: this.targetForInfo(info),
+			providers: await this.params.listCapabilityProviders(),
+			input
+		});
+	});
+	inspectTarget = async (target, providers) => await this.dependencyService.inspect({
+		target,
+		providers: providers ?? await this.params.listCapabilityProviders()
+	});
+	resolveStoredProviderIds = async (target) => await this.dependencyService.resolveStoredProviderIds(target);
+	listBindings = async (target) => await this.dependencyService.listBindings(target);
+	listActiveComponentSourcesWithDiagnostics = async () => {
+		const records = await this.params.registryService.listApps();
+		const results = await Promise.all(records.filter((record) => record.enabled).map(async (record) => {
+			try {
+				await this.params.installationService.assertVersionIntegrity(record.appId, record.activeVersion);
+				const version = record.installedVersions[record.activeVersion];
+				if (!version || version.manifestSchemaVersion !== 2) return { sources: [] };
+				const target = this.target({
+					appId: record.appId,
+					storage: record.defaultInstance.storage,
+					components: version.components ?? []
+				});
+				const resolvedProviderIds = await this.resolveStoredProviderIds(target);
+				return { sources: (version.components ?? []).map((component) => ({
+					kind: component.kind,
+					id: component.id,
+					packageId: record.appId,
+					packageVersion: record.activeVersion,
+					sourcePath: component.componentDirectory,
+					manifestPath: component.manifestPath,
+					dataDirectory: record.dataDirectory,
+					instanceId: record.defaultInstance.id,
+					storage: record.defaultInstance.storage,
+					resolvedProviderIds: resolvedProviderIds[component.id],
+					...this.params.resolveSecurity(version, record.appId)
+				})) };
+			} catch (error) {
+				return {
+					sources: [],
+					unavailablePackage: {
+						appId: record.appId,
+						message: error instanceof Error ? error.message : String(error)
+					}
+				};
+			}
+		}));
+		return {
+			sources: results.flatMap((result) => result.sources),
+			unavailablePackages: results.flatMap((result) => result.unavailablePackage ?? [])
+		};
+	};
+	assertNoEnabledDependents = async (provider) => {
+		const providerIds = new Set(provider.components.filter((component) => component.kind === "service").map((component) => component.id));
+		if (providerIds.size === 0) return;
+		const records = await this.params.registryService.listApps();
+		const dependentAppIds = (await Promise.all(records.filter((record) => record.enabled && record.appId !== provider.id).map(async (record) => {
+			return (await this.listBindings(this.targetForInfo(await this.params.installationService.info(record.appId)))).some((binding) => providerIds.has(binding.providerId)) ? record.appId : void 0;
+		}))).filter((entry) => Boolean(entry));
+		if (dependentAppIds.length === 0) return;
+		throw new AppPackageError("APP_PACKAGE_CONFLICT", `App ${provider.id} is required by enabled App${dependentAppIds.length === 1 ? "" : "s"}: ${dependentAppIds.join(", ")}. Unbind or disable those Apps first.`);
+	};
+	targetForInfo = (info, selectedVersion = info.activeVersion) => {
+		const version = info.installedVersions.find((entry) => entry.version === selectedVersion);
+		if (!version) throw new AppPackageError("APP_PACKAGE_OPERATION_FAILED", `应用 ${info.appId} 缺少版本 ${selectedVersion}。`);
+		return this.target({
+			appId: info.appId,
+			storage: info.storage,
+			components: version.components ?? []
+		});
+	};
+	target = (params) => ({
+		appId: params.appId,
+		storage: params.storage,
+		components: params.components.map((component) => ({
+			id: component.id,
+			kind: component.kind,
+			componentDirectory: component.componentDirectory
+		}))
+	});
+	assertReadyToEnable = (app) => {
+		if (app.readiness.status === "ready") return;
+		const required = app.readiness.requirements.map((requirement) => requirement.title).join(", ");
+		const reason = app.readiness.status === "needs-capability" ? "an additional capability is required" : "external service setup is required";
+		throw new AppPackageError("APP_PACKAGE_NOT_READY", `App ${app.id} is not ready to enable: ${reason}${required ? ` (${required})` : ""}.`);
+	};
+	getTarget = async (appId) => this.targetForInfo(await this.params.installationService.info(appId));
+	getMutableTargetInfo = async (appId) => {
+		const info = await this.params.installationService.info(appId);
+		if (info.enabled) throw new AppPackageError("APP_PACKAGE_CONFLICT", `App ${appId} must be disabled before changing dependency bindings.`);
+		return info;
+	};
+};
+//#endregion
+//#region src/services/app-package-host-target.service.ts
+var AppPackageHostTargetService = class {
+	platformTargetService = new AppPlatformTargetService();
+	read = () => {
+		try {
+			const target = this.platformTargetService.readHostTarget();
+			return {
+				key: this.platformTargetService.toTargetKey(target),
+				operatingSystem: target.os,
+				architecture: target.arch,
+				...target.os === "darwin" ? {} : { abi: target.abi }
+			};
+		} catch {
+			return;
+		}
+	};
+};
+//#endregion
 //#region src/services/app-package-presentation.service.ts
 var AppPackagePresentationService = class {
 	readManifest = async (manifestPath) => {
@@ -3583,6 +4146,7 @@ var AppPackagePresentationService = class {
 //#endregion
 //#region src/services/app-package-runtime-activation.service.ts
 const EMPTY_APP_PACKAGE_RUNTIME_HOOKS = {
+	listCapabilityProviders: async () => [],
 	assertCanActivate: async () => void 0,
 	afterActivate: async () => void 0,
 	beforeDeactivate: async () => void 0,
@@ -3605,18 +4169,6 @@ var AppPackageRuntimeActivationService = class {
 	};
 };
 //#endregion
-//#region src/types/app-package.types.ts
-var AppPackageError = class extends Error {
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "AppPackageError";
-	}
-};
-function isAppPackageError(error) {
-	return error instanceof AppPackageError;
-}
-//#endregion
 //#region src/utils/app-engine-version.utils.ts
 function satisfiesAppEngineVersion(version, range) {
 	const parsedVersion = parseVersion(version);
@@ -3726,8 +4278,9 @@ var AppPackageManager = class {
 	installationService;
 	manifestService = new AppManifestService();
 	operationManager;
-	platformTargetService = new AppPlatformTargetService();
+	hostTargetService = new AppPackageHostTargetService();
 	presentationService = new AppPackagePresentationService();
+	dependencyCoordinator;
 	runtimeActivationService = new AppPackageRuntimeActivationService();
 	registryService;
 	runtimeHooks = EMPTY_APP_PACKAGE_RUNTIME_HOOKS;
@@ -3738,82 +4291,51 @@ var AppPackageManager = class {
 		this.appHomeService = new AppHomeService(params.appHomeDirectory);
 		this.installationService = new AppInstallationService(this.appHomeService);
 		this.registryService = new AppRegistryService(this.appHomeService);
+		this.dependencyCoordinator = new AppPackageDependencyCoordinator({
+			installationService: this.installationService,
+			registryService: this.registryService,
+			listCapabilityProviders: async () => await this.runtimeHooks.listCapabilityProviders(),
+			resolveSecurity: this.resolveSecurity
+		});
 		this.operationManager = new AppPackageOperationManager({
 			storePath: this.appHomeService.getOperationsPath(),
 			execute: this.executeOperation
 		});
 	}
 	installRuntimeHooks = (hooks) => {
-		this.runtimeHooks = hooks;
+		this.runtimeHooks = {
+			...EMPTY_APP_PACKAGE_RUNTIME_HOOKS,
+			...hooks
+		};
 	};
 	start = async () => await this.ensureBuiltInPackages();
 	listPackages = async (options = {}) => {
-		const records = await this.registryService.listApps();
+		const [records, providers] = await Promise.all([this.registryService.listApps(), this.runtimeHooks.listCapabilityProviders()]);
+		const entries = await Promise.all(records.map(async (record) => await this.toPackageView(await this.installationService.info(record.appId, { measureStorageUsage: options.includeStorageUsage !== false }), void 0, providers)));
 		return {
-			hostTarget: this.readHostTarget(),
-			entries: await Promise.all(records.map(async (record) => await this.toPackageView(await this.installationService.info(record.appId, { measureStorageUsage: options.includeStorageUsage !== false }))))
+			hostTarget: this.hostTargetService.read(),
+			entries
 		};
 	};
-	readHostTarget = () => {
-		try {
-			const target = this.platformTargetService.readHostTarget();
-			return {
-				key: this.platformTargetService.toTargetKey(target),
-				operatingSystem: target.os,
-				architecture: target.arch,
-				...target.os === "darwin" ? {} : { abi: target.abi }
-			};
-		} catch {
-			return;
-		}
-	};
 	listInstalledDataOwners = async () => (await this.registryService.listApps()).map((record) => ({
 		id: record.appId,
 		name: record.name
-	}));
-	getPackage = async (appId) => {
-		try {
-			return await this.toPackageView(await this.installationService.info(appId));
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("未找到已安装应用")) throw new AppPackageError("APP_PACKAGE_NOT_FOUND", error.message);
-			throw error;
-		}
-	};
-	listActiveComponentSources = async () => (await this.listActiveComponentSourcesWithDiagnostics()).sources;
-	listActiveComponentSourcesWithDiagnostics = async () => {
-		const records = await this.registryService.listApps();
-		const results = await Promise.all(records.filter((record) => record.enabled).map(async (record) => {
-			try {
-				await this.installationService.assertVersionIntegrity(record.appId, record.activeVersion);
-				const version = record.installedVersions[record.activeVersion];
-				if (!version || version.manifestSchemaVersion !== 2) return { sources: [] };
-				return { sources: (version.components ?? []).map((component) => ({
-					kind: component.kind,
-					id: component.id,
-					packageId: record.appId,
-					packageVersion: record.activeVersion,
-					sourcePath: component.componentDirectory,
-					manifestPath: component.manifestPath,
-					dataDirectory: record.dataDirectory,
-					instanceId: record.defaultInstance.id,
-					storage: record.defaultInstance.storage,
-					...this.resolveSecurity(version, record.appId)
-				})) };
-			} catch (error) {
-				return {
-					sources: [],
-					unavailablePackage: {
-						appId: record.appId,
-						message: error instanceof Error ? error.message : String(error)
-					}
-				};
-			}
-		}));
-		return {
-			sources: results.flatMap((result) => result.sources),
-			unavailablePackages: results.flatMap((result) => result.unavailablePackage ?? [])
-		};
+	}));
+	getPackage = async (appId) => {
+		try {
+			return await this.toPackageView(await this.installationService.info(appId));
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("未找到已安装应用")) throw new AppPackageError("APP_PACKAGE_NOT_FOUND", error.message);
+			throw error;
+		}
 	};
+	inspectDependencies = async (appId) => await this.dependencyCoordinator.inspect(appId);
+	verifyDependencies = async (appId) => await this.dependencyCoordinator.verify(appId);
+	setupDependencies = async (appId) => await this.dependencyCoordinator.setup(appId);
+	bindDependency = async (appId, input) => await this.dependencyCoordinator.bind(appId, input);
+	unbindDependency = async (appId, input) => await this.dependencyCoordinator.unbind(appId, input);
+	listActiveComponentSources = async () => (await this.listActiveComponentSourcesWithDiagnostics()).sources;
+	listActiveComponentSourcesWithDiagnostics = async () => await this.dependencyCoordinator.listActiveComponentSourcesWithDiagnostics();
 	listOperations = async () => await this.operationManager.list();
 	startOperation = async (input) => {
 		await this.ensureBuiltInPackages();
@@ -3832,6 +4354,7 @@ var AppPackageManager = class {
 			const app = await this.getPackage(appId);
 			await this.installationService.assertVersionIntegrity(appId, app.activeVersion);
 			if (app.enabled) return app;
+			this.dependencyCoordinator.assertReadyToEnable(app);
 			await this.assertEngineCompatibility(appId);
 			const sources = this.toComponentSources(app);
 			await this.runtimeHooks.assertCanActivate(sources);
@@ -3857,6 +4380,7 @@ var AppPackageManager = class {
 		return await this.installationService.withAppOperation(appId, async () => {
 			const app = await this.getPackage(appId);
 			if (!app.enabled) return app;
+			await this.dependencyCoordinator.assertNoEnabledDependents(app);
 			await this.runtimeHooks.beforeDeactivate(this.toComponentSources(app));
 			await this.installationService.setEnabled(appId, false);
 			return await this.getPackage(appId);
@@ -3873,12 +4397,14 @@ var AppPackageManager = class {
 				package: current,
 				result
 			};
+			await this.dependencyCoordinator.assertNoEnabledDependents(current);
 			let activated = false;
 			let deactivated = false;
 			try {
 				await this.assertEngineCompatibility(appId, result.version);
 				const candidate = await this.toPackageView(await this.installationService.info(appId), result.version);
 				if (current.enabled) {
+					this.dependencyCoordinator.assertReadyToEnable(candidate);
 					await this.runtimeHooks.beforeDeactivate(this.toComponentSources(current));
 					deactivated = true;
 					await this.runtimeHooks.assertCanActivate(this.toComponentSources(candidate));
@@ -3914,12 +4440,14 @@ var AppPackageManager = class {
 					rolledBack: false
 				}
 			};
+			await this.dependencyCoordinator.assertNoEnabledDependents(current);
 			await this.assertEngineCompatibility(appId, version);
 			const candidate = await this.toPackageView(await this.installationService.info(appId), version);
 			let deactivated = false;
 			let result;
 			try {
 				if (current.enabled) {
+					this.dependencyCoordinator.assertReadyToEnable(candidate);
 					await this.runtimeHooks.beforeDeactivate(this.toComponentSources(current));
 					deactivated = true;
 					await this.runtimeHooks.assertCanActivate(this.toComponentSources(candidate));
@@ -3945,6 +4473,7 @@ var AppPackageManager = class {
 	uninstall = async (appId, purgeData) => {
 		return await this.installationService.withAppOperation(appId, async () => {
 			const current = await this.getPackage(appId);
+			await this.dependencyCoordinator.assertNoEnabledDependents(current);
 			if (current.builtIn) await this.registryService.setBuiltInSuppressed(appId, true);
 			let rollbackRuntimeState;
 			try {
@@ -3985,7 +4514,7 @@ var AppPackageManager = class {
 			} });
 		}
 	};
-	toPackageView = async (info, selectedVersion = info.activeVersion) => {
+	toPackageView = async (info, selectedVersion = info.activeVersion, providers) => {
 		const activeVersion = info.installedVersions.find((version) => version.version === selectedVersion);
 		if (!activeVersion) throw new AppPackageError("APP_PACKAGE_OPERATION_FAILED", `应用 ${info.appId} 缺少版本 ${selectedVersion}。`);
 		const packagePresentation = await this.presentationService.readManifest(path.join(activeVersion.installDirectory, "manifest.json"));
@@ -3995,6 +4524,7 @@ var AppPackageManager = class {
 			isolation: manifestBundle.manifest.main.kind === "wasi-http-component" ? "host-mediated" : "sandboxed",
 			permissions: manifestBundle.manifest.permissions ?? {}
 		};
+		const dependencies = await this.dependencyCoordinator.inspectTarget(this.dependencyCoordinator.targetForInfo(info, selectedVersion), providers);
 		return {
 			id: info.appId,
 			name: info.name,
@@ -4020,6 +4550,7 @@ var AppPackageManager = class {
 				runtimeProfile: security.runtimeProfile,
 				isolation: security.isolation,
 				permissions: security.permissions,
+				resolvedProviderIds: dependencies.resolvedProviderIds[component.id],
 				...await this.presentationService.readManifest(component.manifestPath)
 			}))),
 			dataDirectory: info.dataDirectory,
@@ -4027,7 +4558,9 @@ var AppPackageManager = class {
 			storage: info.storage,
 			storageUsage: info.storageUsage,
 			runtimeProfile: security.runtimeProfile,
-			isolation: security.isolation
+			isolation: security.isolation,
+			readiness: dependencies.readiness,
+			dependencies
 		};
 	};
 	resolveSecurity = (version, appId) => {
@@ -4450,6 +4983,18 @@ function readExtensionProcessMemory(pid) {
 				pssBytes: toBytes(readMemoryKilobytes(rollup, "Pss"))
 			};
 		}
+		if (process.platform === "win32") {
+			const rssBytes = Number(execFileSync("powershell.exe", [
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				`(Get-Process -Id ${pid}).WorkingSet64`
+			], { encoding: "utf8" }).trim());
+			return {
+				rssBytes: Number.isFinite(rssBytes) ? rssBytes : null,
+				pssBytes: null
+			};
+		}
 		const rssKilobytes = Number(execFileSync("ps", [
 			"-o",
 			"rss=",
@@ -4975,18 +5520,18 @@ var ExtensionLifecycleService = class {
 };
 //#endregion
 //#region src/features/extension-runtime/utils/extension-runtime-payload.utils.ts
-function readString$8(value) {
+function readString$9(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function readRecord$2(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function readRequiredString$8(value, name) {
-	const trimmed = readString$8(value);
+function readRequiredString$7(value, name) {
+	const trimmed = readString$9(value);
 	if (!trimmed) throw new Error(`${name} is required`);
 	return trimmed;
 }
-function readOptionalNumber$1(value) {
+function readOptionalNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function readTextContent(value) {
@@ -4997,24 +5542,24 @@ function readTextContent(value) {
 function readInboundAttachments(value) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).map((entry) => ({
-		...readString$8(entry.id) ? { id: readString$8(entry.id) } : {},
-		...readString$8(entry.name) ? { name: readString$8(entry.name) } : {},
-		...readString$8(entry.path) ? { path: readString$8(entry.path) } : {},
-		...readString$8(entry.url) ? { url: readString$8(entry.url) } : {},
-		...readString$8(entry.assetUri) ? { assetUri: readString$8(entry.assetUri) } : {},
-		...readString$8(entry.mimeType) ? { mimeType: readString$8(entry.mimeType) } : {},
-		...readOptionalNumber$1(entry.size) !== void 0 ? { size: readOptionalNumber$1(entry.size) } : {},
-		...readString$8(entry.source) ? { source: readString$8(entry.source) } : {},
+		...readString$9(entry.id) ? { id: readString$9(entry.id) } : {},
+		...readString$9(entry.name) ? { name: readString$9(entry.name) } : {},
+		...readString$9(entry.path) ? { path: readString$9(entry.path) } : {},
+		...readString$9(entry.url) ? { url: readString$9(entry.url) } : {},
+		...readString$9(entry.assetUri) ? { assetUri: readString$9(entry.assetUri) } : {},
+		...readString$9(entry.mimeType) ? { mimeType: readString$9(entry.mimeType) } : {},
+		...readOptionalNumber(entry.size) !== void 0 ? { size: readOptionalNumber(entry.size) } : {},
+		...readString$9(entry.source) ? { source: readString$9(entry.source) } : {},
 		...entry.status === "ready" || entry.status === "remote-only" ? { status: entry.status } : {},
-		...readString$8(entry.errorCode) ? { errorCode: readString$8(entry.errorCode) } : {}
+		...readString$9(entry.errorCode) ? { errorCode: readString$9(entry.errorCode) } : {}
 	}));
 }
 function toInboundMessage(value) {
 	const payload = readRecord$2(value);
 	return {
-		channel: readRequiredString$8(payload.channelId, "channelId"),
-		chatId: readRequiredString$8(payload.conversationId, "conversationId"),
-		senderId: readRequiredString$8(payload.senderId, "senderId"),
+		channel: readRequiredString$7(payload.channelId, "channelId"),
+		chatId: readRequiredString$7(payload.conversationId, "conversationId"),
+		senderId: readRequiredString$7(payload.senderId, "senderId"),
 		content: readTextContent(payload.content),
 		timestamp: /* @__PURE__ */ new Date(),
 		attachments: readInboundAttachments(payload.attachments),
@@ -5036,10 +5581,10 @@ function normalizeAuthPollResult(value) {
 	if (!value) return null;
 	const record = readRecord$2(value);
 	return {
-		channel: readRequiredString$8(record.channel, "channel"),
+		channel: readRequiredString$7(record.channel, "channel"),
 		status: record.status,
-		message: readString$8(record.message),
-		nextPollMs: readOptionalNumber$1(record.nextPollMs),
+		message: readString$9(record.message),
+		nextPollMs: readOptionalNumber(record.nextPollMs),
 		accountId: typeof record.accountId === "string" ? record.accountId : null,
 		notes: Array.isArray(record.notes) ? record.notes.filter((note) => typeof note === "string") : [],
 		channelConfig: normalizeChannelConfigResult(record)
@@ -5068,16 +5613,16 @@ var ExtensionIngressDiagnosticsService = class {
 	recordExtensionEvent = (input, credential) => {
 		const payload = readRecord$2(input);
 		this.diagnostics.record({
-			domain: readRequiredString$8(payload.domain, "domain"),
-			event: readRequiredString$8(payload.event, "event"),
-			component: readRequiredString$8(payload.component, "component"),
-			outcome: readRequiredString$8(payload.outcome, "outcome"),
-			correlationId: readString$8(payload.correlationId),
-			parentCorrelationId: readString$8(payload.parentCorrelationId),
-			reasonCode: readString$8(payload.reasonCode),
-			providerCode: readString$8(payload.providerCode),
-			durationMs: readOptionalNumber$1(payload.durationMs),
-			attempt: readOptionalNumber$1(payload.attempt),
+			domain: readRequiredString$7(payload.domain, "domain"),
+			event: readRequiredString$7(payload.event, "event"),
+			component: readRequiredString$7(payload.component, "component"),
+			outcome: readRequiredString$7(payload.outcome, "outcome"),
+			correlationId: readString$9(payload.correlationId),
+			parentCorrelationId: readString$9(payload.parentCorrelationId),
+			reasonCode: readString$9(payload.reasonCode),
+			providerCode: readString$9(payload.providerCode),
+			durationMs: readOptionalNumber(payload.durationMs),
+			attempt: readOptionalNumber(payload.attempt),
 			facts: {
 				...readRecord$2(payload.facts),
 				extensionId: credential.extensionId,
@@ -5207,7 +5752,7 @@ var ExtensionAuthLeaseService = class {
 	}
 	updateAfterRequest = async (params, value, generation) => {
 		const { extensionId, kind, payload } = params;
-		const channelId = readRequiredString$8(payload.channelId, "channelId");
+		const channelId = readRequiredString$7(payload.channelId, "channelId");
 		if (kind === "channel.auth.start") {
 			await this.retainSession({
 				extensionId,
@@ -5217,14 +5762,14 @@ var ExtensionAuthLeaseService = class {
 			return;
 		}
 		if (kind === "channel.auth.poll") {
-			const sessionId = readRequiredString$8(payload.sessionId, "sessionId");
+			const sessionId = readRequiredString$7(payload.sessionId, "sessionId");
 			const result = value ? readRecord$2(value) : null;
-			const status = result ? readString$8(result.status) : null;
+			const status = result ? readString$9(result.status) : null;
 			if (status === "authorized") await this.retainHandoff(extensionId, channelId, generation);
 			if (!result || status === "authorized" || status === "expired" || status === "error") this.releaseSession(extensionId, sessionId);
 			return;
 		}
-		if (kind === "channel.auth.connect" && readString$8(readRecord$2(value).status) === "authorized") {
+		if (kind === "channel.auth.connect" && readString$9(readRecord$2(value).status) === "authorized") {
 			await this.retainHandoff(extensionId, channelId, generation);
 			return;
 		}
@@ -5253,8 +5798,8 @@ var ExtensionAuthLeaseService = class {
 	retainSession = async (params) => {
 		const { extensionId, generation } = params;
 		const result = readRecord$2(params.result);
-		const sessionId = readRequiredString$8(result.sessionId, "sessionId");
-		const expiresAt = readRequiredString$8(result.expiresAt, "expiresAt");
+		const sessionId = readRequiredString$7(result.sessionId, "sessionId");
+		const expiresAt = readRequiredString$7(result.expiresAt, "expiresAt");
 		const expiresAtMs = Date.parse(expiresAt);
 		if (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) throw new Error("Extension auth session has an invalid expiresAt");
 		const endpoint = this.requireEndpoint("auth start");
@@ -5343,7 +5888,7 @@ const BUILTIN_EXTENSION_PACKAGES = [
 	"@nextclaw/channel-extension-weixin"
 ];
 const runtimeRequire = createRequire(import.meta.url);
-function readString$7(value) {
+function readString$8(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function readStringArray$1(value) {
@@ -5392,16 +5937,16 @@ function toManifest(value, rootDir) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("extension manifest must be an object");
 	const record = value;
 	const server = readRecord$1(record.server);
-	const id = readString$7(record.id);
-	const command = readString$7(server.command);
+	const id = readString$8(record.id);
+	const command = readString$8(server.command);
 	if (!id) throw new Error("extension manifest id is required");
 	if (server.type !== "stdio") throw new Error("extension server.type must be stdio");
 	if (!command) throw new Error("extension server.command is required");
 	return {
 		id,
 		rootDir,
-		...readString$7(record.name) ? { name: readString$7(record.name) } : {},
-		...readString$7(record.version) ? { version: readString$7(record.version) } : {},
+		...readString$8(record.name) ? { name: readString$8(record.name) } : {},
+		...readString$8(record.version) ? { version: readString$8(record.version) } : {},
 		server: {
 			type: "stdio",
 			command,
@@ -5585,11 +6130,11 @@ var ExtensionObservationRuntimeService = class {
 	};
 	handleEvent = async (input) => {
 		const payload = readRecord$2(input.payload);
-		const subscriptionId = readRequiredString$8(payload.subscriptionId, "subscriptionId");
+		const subscriptionId = readRequiredString$7(payload.subscriptionId, "subscriptionId");
 		const event = readRecord$2(payload.event);
-		const eventId = readRequiredString$8(event.eventId, "event.eventId");
-		const eventType = readRequiredString$8(event.eventType, "event.eventType");
-		const occurredAt = readRequiredString$8(event.occurredAt, "event.occurredAt");
+		const eventId = readRequiredString$7(event.eventId, "event.eventId");
+		const eventType = readRequiredString$7(event.eventType, "event.eventType");
+		const occurredAt = readRequiredString$7(event.occurredAt, "event.occurredAt");
 		return await this.options.onEvent?.({
 			extensionId: input.extensionId,
 			subscriptionId,
@@ -5597,13 +6142,13 @@ var ExtensionObservationRuntimeService = class {
 				eventId,
 				eventType,
 				occurredAt,
-				observedAt: readString$8(event.observedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
-				...readString$8(event.cursor) ? { cursor: readString$8(event.cursor) } : {},
-				...readString$8(event.dedupeKey) ? { dedupeKey: readString$8(event.dedupeKey) } : {},
+				observedAt: readString$9(event.observedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+				...readString$9(event.cursor) ? { cursor: readString$9(event.cursor) } : {},
+				...readString$9(event.dedupeKey) ? { dedupeKey: readString$9(event.dedupeKey) } : {},
 				payload: event.payload,
 				...Array.isArray(event.sourceRefs) && event.sourceRefs.every((value) => typeof value === "string") ? { sourceRefs: event.sourceRefs } : {},
-				...readString$8(event.causationId) ? { causationId: readString$8(event.causationId) } : {},
-				...readString$8(event.correlationId) ? { correlationId: readString$8(event.correlationId) } : {}
+				...readString$9(event.causationId) ? { causationId: readString$9(event.causationId) } : {},
+				...readString$9(event.correlationId) ? { correlationId: readString$9(event.correlationId) } : {}
 			}
 		}) ?? { accepted: false };
 	};
@@ -5717,16 +6262,32 @@ const SERVICE_APP_ERROR_CODES = new Set([
 	"SERVICE_APP_MANAGED_SOURCE",
 	"SERVICE_APP_NOT_FOUND",
 	"SERVICE_APP_READ_FAILED",
-	"SERVICE_APP_RUNTIME_FAILED"
+	"SERVICE_APP_RUNTIME_FAILED",
+	"WASI_ABI_VERSION_MISMATCH",
+	"WASI_CAPABILITY_DENIED",
+	"WASI_COMPONENT_FAILED",
+	"WASI_COMPONENT_TRAP",
+	"WASI_GUEST_EXPORT_MISSING",
+	"WASI_INPUT_SCHEMA_MISMATCH"
 ]);
 var ServiceAppError = class extends Error {
-	constructor(code, message) {
+	constructor(code, message, details) {
 		super(message);
 		this.code = code;
+		this.details = details;
 		this.name = "ServiceAppError";
 	}
 };
 const isServiceAppError = (error) => error instanceof ServiceAppError || typeof error === "object" && error !== null && error.name === "ServiceAppError" && typeof error.message === "string" && SERVICE_APP_ERROR_CODES.has(error.code);
+const toServiceAppRuntimeError = (error, appId, actionName) => {
+	if (isPortableWasiError(error)) return new ServiceAppError(error.code, error.message, error.details);
+	return new ServiceAppError("SERVICE_APP_RUNTIME_FAILED", `Service App ${appId} action ${actionName} failed: ${error instanceof Error ? error.message : String(error)}`);
+};
+const isPortableWasiError = (error) => {
+	if (typeof error !== "object" || error === null) return false;
+	const candidate = error;
+	return candidate.name === "PortableServiceRunnerError" && typeof candidate.message === "string" && typeof candidate.code === "string" && candidate.code.startsWith("WASI_") && SERVICE_APP_ERROR_CODES.has(candidate.code);
+};
 //#endregion
 //#region src/utils/service-action.utils.ts
 const DEFAULT_SERVICE_ACTION_RISK = "dangerous";
@@ -6650,10 +7211,10 @@ var DesktopNodeReplService = class {
 	}
 	async handleWorkerMessage(key, worker, value) {
 		const message = asRecord$1(value);
-		const executionId = readString$6(message.executionId);
+		const executionId = readString$7(message.executionId);
 		if (!executionId || !worker.pending.has(executionId)) return;
 		if (message.type === "desktop.request") {
-			const requestId = readString$6(message.requestId);
+			const requestId = readString$7(message.requestId);
 			if (!requestId) return;
 			try {
 				const result = await this.invokeDesktop(worker.pending.get(executionId).caller, message.operation, message.args);
@@ -6684,7 +7245,7 @@ var DesktopNodeReplService = class {
 		}
 		if (message.type === "error") {
 			const error = asRecord$1(message.error);
-			this.reject(worker, executionId, replError(readString$6(error.code) ?? "repl_execution_failed", readString$6(error.message) ?? "node_repl execution failed."));
+			this.reject(worker, executionId, replError(readString$7(error.code) ?? "repl_execution_failed", readString$7(error.message) ?? "node_repl execution failed."));
 			return;
 		}
 		this.stopWorker(key, worker);
@@ -6830,7 +7391,7 @@ function readKeyboardModifiers(value) {
 	if (new Set(value).size !== value.length) throw replError("invalid_tool_arguments", "modifiers cannot contain duplicates.");
 	return value;
 }
-function readString$6(value) {
+function readString$7(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 function trimOutput(value) {
@@ -7298,12 +7859,12 @@ var ExtensionDesktopRuntimeService = class {
 		return await this.capabilities.invoke({
 			extensionId: credential.extensionId,
 			generation: credential.generation,
-			method: readRequiredString$8(payload.method, "method"),
+			method: readRequiredString$7(payload.method, "method"),
 			payload: readRecord$2(payload.payload),
 			caller: {
-				...readString$8(caller.sessionId) ? { sessionId: readString$8(caller.sessionId) } : {},
-				...readString$8(caller.agentRunId) ? { agentRunId: readString$8(caller.agentRunId) } : {},
-				...readString$8(caller.subscriptionId) ? { subscriptionId: readString$8(caller.subscriptionId) } : {}
+				...readString$9(caller.sessionId) ? { sessionId: readString$9(caller.sessionId) } : {},
+				...readString$9(caller.agentRunId) ? { agentRunId: readString$9(caller.agentRunId) } : {},
+				...readString$9(caller.subscriptionId) ? { subscriptionId: readString$9(caller.subscriptionId) } : {}
 			}
 		});
 	};
@@ -7444,7 +8005,7 @@ var ExtensionRuntimeService = class {
 		const desired = /* @__PURE__ */ new Map();
 		const channelConfig = readRecord$2(config.channels);
 		for (const manifest of this.manifests) for (const channel of manifest.contributes?.channels ?? []) {
-			const channelId = readString$8(channel.id);
+			const channelId = readString$9(channel.id);
 			if (!channelId || readRecord$2(channelConfig[channelId]).enabled !== true) continue;
 			desired.set(this.persistentLeaseKey(manifest.id, channelId), {
 				manifest,
@@ -7488,7 +8049,7 @@ var ExtensionRuntimeService = class {
 	};
 	handleChannelConfigGet = (envelope, context) => {
 		this.assertAuthorized(envelope, context);
-		const channelId = readRequiredString$8(readRecord$2(envelope.payload).channelId, "channelId");
+		const channelId = readRequiredString$7(readRecord$2(envelope.payload).channelId, "channelId");
 		return { config: this.options.getConfig().channels[channelId] ?? {} };
 	};
 	handleChannelMessageSubmit = async (envelope, context) => {
@@ -7510,9 +8071,9 @@ var ExtensionRuntimeService = class {
 	handleChannelCommandExecute = async (envelope, context) => {
 		this.assertAuthorized(envelope, context);
 		const payload = readRecord$2(envelope.payload);
-		const channel = readRequiredString$8(payload.channelId, "channelId");
-		const chatId = readRequiredString$8(payload.conversationId, "conversationId");
-		const senderId = readRequiredString$8(payload.senderId, "senderId");
+		const channel = readRequiredString$7(payload.channelId, "channelId");
+		const chatId = readRequiredString$7(payload.conversationId, "conversationId");
+		const senderId = readRequiredString$7(payload.senderId, "senderId");
 		const metadata = readRecord$2(payload.metadata);
 		const config = this.options.getConfig();
 		const registry = new CommandRegistry(config, this.options.sessionManager);
@@ -7521,15 +8082,15 @@ var ExtensionRuntimeService = class {
 				channel,
 				chatId,
 				senderId,
-				content: readString$8(payload.rawText) ?? readString$8(payload.commandName) ?? "",
+				content: readString$9(payload.rawText) ?? readString$9(payload.commandName) ?? "",
 				timestamp: /* @__PURE__ */ new Date(),
 				attachments: [],
 				metadata
 			},
-			forcedAgentId: readString$8(metadata.target_agent_id),
-			sessionKeyOverride: readString$8(metadata.session_key_override)
+			forcedAgentId: readString$9(metadata.target_agent_id),
+			sessionKeyOverride: readString$9(metadata.session_key_override)
 		});
-		const rawText = readString$8(payload.rawText);
+		const rawText = readString$9(payload.rawText);
 		if (rawText) return await registry.executeText(rawText, {
 			channel,
 			chatId,
@@ -7539,7 +8100,7 @@ var ExtensionRuntimeService = class {
 			content: "",
 			ephemeral: true
 		};
-		return await registry.execute(readRequiredString$8(payload.commandName, "commandName"), readRecord$2(payload.args), {
+		return await registry.execute(readRequiredString$7(payload.commandName, "commandName"), readRecord$2(payload.args), {
 			channel,
 			chatId,
 			senderId,
@@ -7556,13 +8117,13 @@ var ExtensionRuntimeService = class {
 	handleExtensionResponse = (envelope, context) => {
 		const credential = this.assertAuthorized(envelope, context);
 		const payload = readRecord$2(envelope.payload);
-		const requestId = readRequiredString$8(payload.requestId, "requestId");
+		const requestId = readRequiredString$7(payload.requestId, "requestId");
 		const pending = this.pendingRequests.get(requestId);
 		if (!pending || pending.extensionId !== credential.extensionId || pending.generation !== credential.generation) return { accepted: false };
 		this.pendingRequests.delete(requestId);
 		pending.cleanup();
 		if (payload.ok === false) {
-			const message = readString$8(readRecord$2(payload.error).message) ?? "Extension request failed";
+			const message = readString$9(readRecord$2(payload.error).message) ?? "Extension request failed";
 			pending.reject(new Error(message));
 			return { accepted: true };
 		}
@@ -7572,8 +8133,8 @@ var ExtensionRuntimeService = class {
 	handleRuntimeReady = async (envelope, context) => {
 		const credential = this.assertAuthorized(envelope, context);
 		const payload = readRecord$2(envelope.payload);
-		const generation = readRequiredString$8(payload.generation, "generation");
-		const pid = readOptionalNumber$1(payload.pid);
+		const generation = readRequiredString$7(payload.generation, "generation");
+		const pid = readOptionalNumber(payload.pid);
 		if (generation !== credential.generation || pid === void 0 || !Number.isInteger(pid) || pid <= 0) throw new Error("Invalid extension runtime ready payload");
 		this.lifecycle.markReady({
 			extensionId: credential.extensionId,
@@ -7591,12 +8152,12 @@ var ExtensionRuntimeService = class {
 		const endpoint = this.endpoint;
 		if (!endpoint) throw new Error("Extension runtime is not started");
 		if (kind === "channel.outbound.sendText") {
-			const channelId = readRequiredString$8(payload.channelId, "channelId");
+			const channelId = readRequiredString$7(payload.channelId, "channelId");
 			if (!this.isChannelEnabled(channelId)) throw new Error(`Channel is disabled: ${channelId}`);
 		}
 		const manifest = this.findManifest(extensionId);
 		const requestId = randomUUID();
-		const authSession = kind === "channel.auth.poll" ? this.authLeases.requireSession(extensionId, readRequiredString$8(payload.sessionId, "sessionId")) : null;
+		const authSession = kind === "channel.auth.poll" ? this.authLeases.requireSession(extensionId, readRequiredString$7(payload.sessionId, "sessionId")) : null;
 		const requestLease = await this.lifecycle.acquire(manifest, {
 			endpoint,
 			...authSession ? { expectedGeneration: authSession.generation } : {},
@@ -7673,9 +8234,9 @@ var ExtensionRuntimeService = class {
 	};
 	assertAuthorized = (envelope, context) => {
 		const credential = this.lifecycle.authenticateCredential({
-			extensionId: readString$8(envelope.extensionId) ?? null,
-			generation: readString$8(envelope.generation) ?? null,
-			token: readString$8(context.token) ?? null
+			extensionId: readString$9(envelope.extensionId) ?? null,
+			generation: readString$9(envelope.generation) ?? null,
+			token: readString$9(context.token) ?? null
 		});
 		if (!credential) throw new Error("Unauthorized ingress token");
 		return credential;
@@ -9147,16 +9708,16 @@ function parsePanelAppFolderManifest(raw) {
 		throw new Error(`panel-app.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	if (!isRecord$12(parsed)) throw new Error("panel-app.json must contain an object.");
-	const id = readOptionalString$11(parsed, "id");
+	const id = readOptionalString$10(parsed, "id");
 	if (id && !PANEL_APP_ID_PATTERN.test(id)) throw new Error("panel app id must be kebab-case.");
 	return {
 		id,
-		title: readRequiredString$7(parsed, "title"),
-		description: readOptionalString$11(parsed, "description"),
-		icon: readOptionalString$11(parsed, "icon"),
-		entry: readRequiredString$7(parsed, "entry"),
+		title: readRequiredString$6(parsed, "title"),
+		description: readOptionalString$10(parsed, "description"),
+		icon: readOptionalString$10(parsed, "icon"),
+		entry: readRequiredString$6(parsed, "entry"),
 		capabilities: readStringArray(parsed.capabilities, "capabilities"),
-		client: readOptionalBoolean$2(parsed, "client"),
+		client: readOptionalBoolean$1(parsed, "client"),
 		serviceActions: readStringArray(parsed.actions, "actions")
 	};
 }
@@ -9214,15 +9775,15 @@ function parseTokenList(content) {
 	if (!content) return [];
 	return [...new Set(content.split(/[,\s]+/).map((entry) => entry.trim()).filter(Boolean))];
 }
-function readRequiredString$7(record, key) {
-	const value = readOptionalString$11(record, key);
+function readRequiredString$6(record, key) {
+	const value = readOptionalString$10(record, key);
 	if (!value) throw new Error(`panel app ${key} is required.`);
 	return value;
 }
-function readOptionalString$11(record, key) {
+function readOptionalString$10(record, key) {
 	return typeof record[key] === "string" && record[key].trim() ? record[key].trim() : void 0;
 }
-function readOptionalBoolean$2(record, key) {
+function readOptionalBoolean$1(record, key) {
 	const value = record[key];
 	if (value === void 0) return false;
 	if (typeof value !== "boolean") throw new Error(`panel app ${key} must be a boolean.`);
@@ -11554,12 +12115,12 @@ function parseSkillFrontmatter(raw) {
 	const summaryI18n = readLocalizedTextMap(parsed, "summaryi18n", "summary_i18n");
 	const descriptionI18n = readLocalizedTextMap(parsed, "descriptioni18n", "description_i18n");
 	return {
-		name: readString$5(parsed, "name"),
-		summary: readString$5(parsed, "summary"),
-		summaryI18n: mergeLocalizedTextMap(summaryI18n, { zh: readString$5(parsed, "summaryzh", "summary_zh") }),
-		description: readString$5(parsed, "description"),
-		descriptionI18n: mergeLocalizedTextMap(descriptionI18n, { zh: readString$5(parsed, "descriptionzh", "description_zh") }),
-		author: readString$5(parsed, "author"),
+		name: readString$6(parsed, "name"),
+		summary: readString$6(parsed, "summary"),
+		summaryI18n: mergeLocalizedTextMap(summaryI18n, { zh: readString$6(parsed, "summaryzh", "summary_zh") }),
+		description: readString$6(parsed, "description"),
+		descriptionI18n: mergeLocalizedTextMap(descriptionI18n, { zh: readString$6(parsed, "descriptionzh", "description_zh") }),
+		author: readString$6(parsed, "author"),
 		tags: readTags(parsed)
 	};
 }
@@ -11586,7 +12147,7 @@ function parseYamlFrontmatter(raw) {
 		throw new Error(`Invalid SKILL.md frontmatter: ${message}`);
 	}
 }
-function readString$5(record, ...names) {
+function readString$6(record, ...names) {
 	const value = readValue(record, names);
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -11836,11 +12397,11 @@ function createAgentPeerSessionIdentity(params) {
 }
 function resolveAgentPeerScope(params) {
 	const metadata = params.metadata ?? {};
-	const explicitScope = readOptionalString$10(metadata["agent_peer_scope"]) ?? readOptionalString$10(metadata.agentPeerScope);
+	const explicitScope = readOptionalString$9(metadata["agent_peer_scope"]) ?? readOptionalString$9(metadata.agentPeerScope);
 	if (explicitScope) return explicitScope;
-	return `agent:${readOptionalString$10(params.agentId) ?? BUILTIN_MAIN_AGENT_ID}:${readOptionalString$10(params.channel) ?? readOptionalString$10(metadata.channel) ?? "agent-run"}:${readOptionalString$10(metadata.accountId) ?? readOptionalString$10(metadata.account_id) ?? "default"}`;
+	return `agent:${readOptionalString$9(params.agentId) ?? BUILTIN_MAIN_AGENT_ID}:${readOptionalString$9(params.channel) ?? readOptionalString$9(metadata.channel) ?? "agent-run"}:${readOptionalString$9(metadata.accountId) ?? readOptionalString$9(metadata.account_id) ?? "default"}`;
 }
-function readOptionalString$10(value) {
+function readOptionalString$9(value) {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
 }
@@ -12730,7 +13291,7 @@ function applyLimit(items, limit) {
 	if (!Number.isFinite(limit) || typeof limit !== "number" || limit <= 0) return items;
 	return items.slice(0, Math.trunc(limit));
 }
-function readOptionalString$9(value) {
+function readOptionalString$8(value) {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
@@ -12791,7 +13352,7 @@ function mergeMetadataOverrides(metadata, overrides) {
 }
 function resolveSessionType(params) {
 	const { metadata, runtime, sessionType } = params;
-	return readOptionalString$9(runtime) ?? readOptionalString$9(metadata.runtime) ?? readOptionalString$9(sessionType) ?? readOptionalString$9(metadata.session_type) ?? "native";
+	return readOptionalString$8(runtime) ?? readOptionalString$8(metadata.runtime) ?? readOptionalString$8(sessionType) ?? readOptionalString$8(metadata.session_type) ?? "native";
 }
 function applySessionOverrides(params) {
 	const { lifecycle, metadata, model, parentSessionId, projectRoot, requestId, sessionType, thinkingLevel, title } = params;
@@ -12801,15 +13362,15 @@ function applySessionOverrides(params) {
 	metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = lifecycle;
 	if (parentSessionId) metadata[CHILD_SESSION_PARENT_METADATA_KEY] = parentSessionId;
 	if (requestId) metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = requestId;
-	if (readOptionalString$9(model)) {
+	if (readOptionalString$8(model)) {
 		metadata.model = model?.trim();
 		metadata.preferred_model = model?.trim();
 	}
-	if (readOptionalString$9(thinkingLevel)) {
+	if (readOptionalString$8(thinkingLevel)) {
 		metadata.thinking = thinkingLevel?.trim();
 		metadata.preferred_thinking = thinkingLevel?.trim();
 	}
-	if (readOptionalString$9(projectRoot)) metadata.project_root = projectRoot?.trim();
+	if (readOptionalString$8(projectRoot)) metadata.project_root = projectRoot?.trim();
 }
 //#endregion
 //#region src/app/kernel-storage-paths.ts
@@ -13651,9 +14212,10 @@ var McpServiceAppRuntimeService = class {
 //#region src/services/portable-service-runner-client.service.ts
 const PORTABLE_RUNNER_PROTOCOL_VERSION = "0.1.0";
 var PortableServiceRunnerError = class extends Error {
-	constructor(code, message) {
+	constructor(code, message, details) {
 		super(message);
 		this.code = code;
+		this.details = details;
 		this.name = "PortableServiceRunnerError";
 	}
 };
@@ -13661,6 +14223,7 @@ var PortableServiceRunnerClientService = class {
 	child;
 	pending = /* @__PURE__ */ new Map();
 	stderrTail = [];
+	lastObservation;
 	constructor(params = {}) {
 		this.params = params;
 	}
@@ -13690,6 +14253,7 @@ var PortableServiceRunnerClientService = class {
 		input: event
 	}, 7e3);
 	stats = async () => this.request({ operation: "stats" }, 2e3);
+	getLastObservation = () => this.lastObservation;
 	stop = async (app) => {
 		await this.request({
 			operation: "stop",
@@ -13736,7 +14300,10 @@ var PortableServiceRunnerClientService = class {
 			this.pending.set(requestId, {
 				resolve: (value) => resolve(value),
 				reject,
-				timeout
+				timeout,
+				startedAt: Date.now(),
+				operation: request.operation,
+				appId: request.app?.id
 			});
 			child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
 				if (!error) return;
@@ -13799,11 +14366,23 @@ var PortableServiceRunnerClientService = class {
 		if (!pending) return;
 		clearTimeout(pending.timeout);
 		this.pending.delete(response.requestId);
+		const childPid = this.child?.pid ?? null;
+		this.lastObservation = {
+			operation: pending.operation,
+			appId: pending.appId,
+			durationMs: Date.now() - pending.startedAt,
+			runnerPid: childPid,
+			memory: childPid === null ? {
+				rssBytes: null,
+				pssBytes: null
+			} : readExtensionProcessMemory(childPid),
+			logs: [...this.stderrTail]
+		};
 		if (response.ok) {
 			pending.resolve(response.result);
 			return;
 		}
-		pending.reject(new PortableServiceRunnerError(response.error?.code ?? "PORTABLE_RUNTIME_FAILED", response.error?.message ?? "Portable runner request failed."));
+		pending.reject(new PortableServiceRunnerError(response.error?.code ?? "PORTABLE_RUNTIME_FAILED", response.error?.message ?? "Portable runner request failed.", this.stderrTail.length > 0 ? { logs: [...this.stderrTail] } : void 0));
 	};
 	handleChildFailure = (error) => {
 		this.failAll(error);
@@ -13855,13 +14434,14 @@ var PortableServiceAppRuntimeService = class {
 		});
 	}
 	getStatus = (appId) => this.states.get(appId) ?? { status: "idle" };
+	getLastObservation = () => this.runner.getLastObservation();
 	start = async ({ app, manifest }) => {
 		if (!app.enabled || !manifest.lifecycle || manifest.lifecycle.mode === "action") return;
 		this.persistentRegistrations.set(app.id, {
 			app,
 			manifest
 		});
-		const runnerApp = this.toRunnerApp(app, manifest.providerIds);
+		const runnerApp = this.toRunnerApp(app, app.providerIds);
 		this.apps.set(app.id, runnerApp);
 		if (manifest.lifecycle.mode === "provider") {
 			if (this.providers.has(app.id)) return;
@@ -13918,7 +14498,7 @@ var PortableServiceAppRuntimeService = class {
 	};
 	listActions = async ({ app, manifest }) => {
 		if (!app.enabled) return [];
-		const runnerApp = this.toRunnerApp(app, manifest.providerIds);
+		const runnerApp = this.toRunnerApp(app, app.providerIds);
 		this.apps.set(app.id, runnerApp);
 		const persistent = manifest.lifecycle?.mode === "resident" || manifest.lifecycle?.mode === "provider";
 		const lastStartedAt = persistent ? this.states.get(app.id)?.lastStartedAt ?? (/* @__PURE__ */ new Date()).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
@@ -13956,7 +14536,7 @@ var PortableServiceAppRuntimeService = class {
 			app,
 			manifest
 		});
-		const runnerApp = this.toRunnerApp(app, manifest.providerIds);
+		const runnerApp = this.toRunnerApp(app, app.providerIds);
 		this.apps.set(app.id, runnerApp);
 		if (manifest.lifecycle?.mode === "resident") try {
 			return await this.runner.invoke(runnerApp, actionName, input, manifest.actions[actionName]?.timeoutMs ?? 7e3);
@@ -14083,6 +14663,7 @@ var ServiceAppRuntimeService = class {
 	getStatus = (appId) => {
 		return this.protocols.get(appId) === "wasi-component" ? this.portable.getStatus(appId) : this.mcp.getStatus(appId);
 	};
+	getLastObservation = () => this.portable.getLastObservation();
 	start = async (call) => {
 		this.protocols.set(call.app.id, call.manifest.protocol);
 		if (call.manifest.protocol === "wasi-component") await this.portable.start(call);
@@ -14108,128 +14689,6 @@ var ServiceAppRuntimeService = class {
 	};
 };
 //#endregion
-//#region src/utils/service-app-manifest.utils.ts
-const SERVICE_APP_ID_PATTERN$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const SERVICE_ACTION_RISKS = new Set([
-	"read",
-	"write",
-	"external",
-	"dangerous"
-]);
-const SERVICE_APP_MANIFEST_FILE_NAME = "service-app.json";
-function getServiceAppManifestPath(dirPath) {
-	return join(dirPath, SERVICE_APP_MANIFEST_FILE_NAME);
-}
-async function readServiceAppManifest(dirPath, options) {
-	return parseServiceAppManifest(await readFile(getServiceAppManifestPath(dirPath), "utf8"), options);
-}
-function parseServiceAppManifest(raw, options = {}) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (error) {
-		throw new Error(`service-app.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord$7(parsed)) throw new Error("service-app.json must contain an object.");
-	const id = readRequiredString$6(parsed, "id");
-	if (!SERVICE_APP_ID_PATTERN$1.test(id)) throw new Error("service app id must be kebab-case.");
-	const protocol = readOptionalString$8(parsed, "protocol") ?? "mcp";
-	if (protocol !== "mcp" && protocol !== "wasi-component") throw new Error("service app protocol must be mcp or wasi-component.");
-	const launch = protocol === "mcp" ? new AppServiceLaunchService(options.platformTargetService).resolve(parsed, options.target) : void 0;
-	const componentEntry = protocol === "wasi-component" ? readPortableComponentEntry(parsed) : void 0;
-	const lifecycle = readServiceAppLifecycle(parsed.lifecycle);
-	if (lifecycle.mode !== "action" && protocol !== "wasi-component") throw new Error(`${lifecycle.mode} service app lifecycle requires wasi-component protocol.`);
-	return {
-		id,
-		title: readRequiredString$6(parsed, "title"),
-		description: readOptionalString$8(parsed, "description"),
-		enabled: readOptionalBoolean$1(parsed, "enabled") ?? true,
-		protocol,
-		command: launch?.command,
-		args: launch?.args,
-		componentEntry,
-		providerIds: readProviderIds(parsed.providers),
-		lifecycle,
-		actions: readManifestActions(parsed.actions)
-	};
-}
-function readServiceAppLifecycle(value) {
-	if (value === void 0) return { mode: "action" };
-	if (!isRecord$7(value)) throw new Error("service app lifecycle must be an object.");
-	const mode = readOptionalString$8(value, "mode") ?? "action";
-	if (mode === "action") return { mode };
-	if (mode === "provider") return { mode };
-	if (mode !== "resident") throw new Error("service app lifecycle.mode must be action, resident or provider.");
-	const eventIntervalMs = readOptionalNumber(value, "eventIntervalMs");
-	if (eventIntervalMs === void 0 || !Number.isInteger(eventIntervalMs) || eventIntervalMs < 250 || eventIntervalMs > 6e4) throw new Error("resident service app lifecycle.eventIntervalMs must be an integer between 250 and 60000.");
-	return {
-		mode,
-		eventIntervalMs
-	};
-}
-function readProviderIds(value) {
-	if (value === void 0) return [];
-	if (!Array.isArray(value)) throw new Error("service app providers must be an array.");
-	const providerIds = value.map((entry) => {
-		if (typeof entry !== "string" || !SERVICE_APP_ID_PATTERN$1.test(entry.trim())) throw new Error("service app providers must contain kebab-case service app ids.");
-		return entry.trim();
-	});
-	return Array.from(new Set(providerIds));
-}
-function readPortableComponentEntry(record) {
-	const component = record.component;
-	if (!isRecord$7(component)) throw new Error("service app component is required for wasi-component.");
-	const entry = readRequiredString$6(component, "entry").replace(/\\/g, "/");
-	if (path.isAbsolute(entry) || entry.includes("\0") || entry.split("/").includes("..")) throw new Error("service app component.entry must be a package-relative path.");
-	if (!entry.endsWith(".wasm")) throw new Error("service app component.entry must reference a .wasm file.");
-	return entry;
-}
-function readManifestActions(value) {
-	if (value === void 0) throw new Error("service app actions are required.");
-	if (!isRecord$7(value)) throw new Error("service app actions must be an object.");
-	if (Object.keys(value).length === 0) throw new Error("service app actions cannot be empty.");
-	const actions = {};
-	for (const [name, action] of Object.entries(value)) {
-		if (!name.trim()) throw new Error("service app action name cannot be empty.");
-		if (!isRecord$7(action)) throw new Error(`service app action ${name} must be an object.`);
-		const risk = readOptionalString$8(action, "risk");
-		if (risk !== void 0 && !SERVICE_ACTION_RISKS.has(risk)) throw new Error(`service app action ${name} has invalid risk.`);
-		const inputSchema = action.inputSchema;
-		if (inputSchema !== void 0 && !isRecord$7(inputSchema)) throw new Error(`service app action ${name} inputSchema must be an object.`);
-		const timeoutMs = readOptionalNumber(action, "timeoutMs");
-		if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 3e5)) throw new Error(`service app action ${name} timeoutMs must be an integer between 100 and 300000.`);
-		actions[name] = {
-			risk,
-			title: readOptionalString$8(action, "title"),
-			description: readOptionalString$8(action, "description"),
-			inputSchema,
-			timeoutMs
-		};
-	}
-	return actions;
-}
-function readRequiredString$6(record, key) {
-	const value = readOptionalString$8(record, key);
-	if (!value) throw new Error(`service app ${key} is required.`);
-	return value;
-}
-function readOptionalString$8(record, key) {
-	return typeof record[key] === "string" && record[key].trim() ? record[key].trim() : void 0;
-}
-function readOptionalBoolean$1(record, key) {
-	if (record[key] === void 0) return;
-	if (typeof record[key] !== "boolean") throw new Error(`service app ${key} must be boolean.`);
-	return record[key];
-}
-function readOptionalNumber(record, key) {
-	if (record[key] === void 0) return;
-	if (typeof record[key] !== "number") throw new Error(`service app ${key} must be number.`);
-	return record[key];
-}
-function isRecord$7(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-//#endregion
 //#region src/services/service-app-lifecycle.service.ts
 var ServiceAppLifecycleService = class {
 	constructor(params) {
@@ -14349,7 +14808,7 @@ var ServiceAppRecordService = class {
 			runtimeProfile: packageSource?.runtimeProfile ?? "native-process",
 			permissions: packageSource?.permissions ?? {},
 			componentPath: manifest.componentEntry ? join(dirPath, manifest.componentEntry) : void 0,
-			providerIds: manifest.providerIds,
+			providerIds: Array.from(new Set([...manifest.providerIds ?? [], ...packageSource?.resolvedProviderIds ?? []])),
 			lifecycle: manifest.lifecycle
 		};
 	};
@@ -14646,6 +15105,24 @@ var ServiceAppPackageRuntimeService = class {
 	};
 };
 //#endregion
+//#region src/services/service-app-capability-provider.service.ts
+function projectCapabilityProviders(entries) {
+	return entries.flatMap(({ manifest, record }) => {
+		if (manifest.lifecycle?.mode !== "provider" || !record.enabled || record.status !== "running") return [];
+		const capabilities = manifest.provides?.capabilities ?? [];
+		return capabilities.length === 0 ? [] : [{
+			providerId: record.id,
+			appId: record.packageId ?? record.id,
+			componentId: record.id,
+			capabilities: capabilities.map(({ id, version, resourceTypes }) => ({
+				id,
+				version,
+				resourceTypes
+			}))
+		}];
+	});
+}
+//#endregion
 //#region src/utils/service-app-runtime-action.utils.ts
 function listServiceAppManifestActions(record, manifest) {
 	if (!record.enabled) return [];
@@ -14736,6 +15213,7 @@ var ServiceAppManager = class {
 			entries: [...workspaceEntries, ...packageEntries].filter((entry) => Boolean(entry)).sort((left, right) => left.title.localeCompare(right.title))
 		};
 	};
+	listCapabilityProviders = async () => projectCapabilityProviders(await this.listValidServiceApps());
 	getServiceApp = async (appId) => {
 		const { record } = await this.requireServiceApp(appId);
 		return record;
@@ -14775,7 +15253,7 @@ var ServiceAppManager = class {
 				})
 			};
 		} catch (error) {
-			throw new ServiceAppError("SERVICE_APP_RUNTIME_FAILED", `Service App ${record.id} action ${actionName} failed: ${error instanceof Error ? error.message : String(error)}`);
+			throw toServiceAppRuntimeError(error, record.id, actionName);
 		}
 	};
 	grantServiceAction = async (actionId, request) => {
@@ -14995,7 +15473,7 @@ function hasToolCall(message, toolCallId) {
 	return message.parts.some((part) => part.type === "tool-invocation" && part.toolCallId === toolCallId);
 }
 function findContextInheritanceAnchor(params) {
-	const anchorToolCallId = readOptionalString$9(params.anchorToolCallId);
+	const anchorToolCallId = readOptionalString$8(params.anchorToolCallId);
 	if (!anchorToolCallId) return null;
 	const index = params.messages.findIndex((message) => hasToolCall(message, anchorToolCallId));
 	const message = index >= 0 ? params.messages[index] : void 0;
@@ -15035,7 +15513,7 @@ function createInheritedContextSnapshot(params) {
 			enabled: true,
 			sourceSessionId: sourceRecord.sessionId,
 			anchorKind: anchor ? "tool_call" : "latest_persisted",
-			anchorToolCallId: readOptionalString$9(anchorToolCallId),
+			anchorToolCallId: readOptionalString$8(anchorToolCallId),
 			anchorMessageId: anchor?.message.id,
 			inheritedMessageCount: messages.length
 		}
@@ -15323,7 +15801,7 @@ var SessionWorkingDirResolver = class {
 		return this.resolveContext(params).effectiveWorkspace;
 	};
 	resolveContext = (params) => {
-		const profile = this.agentManager.resolveAgentProfile(readOptionalString$9(params.agentId));
+		const profile = this.agentManager.resolveAgentProfile(readOptionalString$8(params.agentId));
 		return resolveSessionProjectContext({
 			sessionMetadata: params.metadata,
 			workspace: profile.workspace
@@ -15371,10 +15849,10 @@ var SessionManager = class {
 		const { agentId: requestedAgentId, contextInheritance, metadataOverrides, model, parentSessionId: rawParentSessionId, projectRoot, requestId: rawRequestId, runtime, sessionId: requestedSessionId, sessionType: requestedSessionType, sourceSessionId, sourceSessionMetadata, task, thinkingLevel, title: requestedTitle } = params;
 		const sourceRecord = sourceSessionId ? await this.getSessionRecord(sourceSessionId) : null;
 		const metadata = cloneInheritedMetadata(sourceSessionMetadata);
-		const title = readOptionalString$9(requestedTitle) ?? summarizeTask(task);
-		const parentSessionId = readOptionalString$9(rawParentSessionId);
+		const title = readOptionalString$8(requestedTitle) ?? summarizeTask(task);
+		const parentSessionId = readOptionalString$8(rawParentSessionId);
 		await assertCanCreateSessionFromLineage(parentSessionId, sourceRecord, metadataOverrides, this.getSessionRecord);
-		const requestId = readOptionalString$9(rawRequestId);
+		const requestId = readOptionalString$8(rawRequestId);
 		const sessionType = resolveSessionType({
 			runtime,
 			sessionType: requestedSessionType,
@@ -15400,8 +15878,8 @@ var SessionManager = class {
 			if (normalizedProjectRoot) nextMetadata.project_root = normalizedProjectRoot;
 			else delete nextMetadata.project_root;
 		}
-		const agentId = readOptionalString$9(requestedAgentId) ?? readOptionalString$9(sourceRecord?.agentId) ?? BUILTIN_MAIN_AGENT_ID;
-		const sessionId = readOptionalString$9(requestedSessionId) ?? buildSessionId();
+		const agentId = readOptionalString$8(requestedAgentId) ?? readOptionalString$8(sourceRecord?.agentId) ?? BUILTIN_MAIN_AGENT_ID;
+		const sessionId = readOptionalString$8(requestedSessionId) ?? buildSessionId();
 		const inheritedContext = createSessionContextInheritance({
 			childSessionId: sessionId,
 			contextInheritance,
@@ -15487,7 +15965,7 @@ var SessionManager = class {
 	listSessions = async (options) => {
 		const { limit, peerId: rawPeerId } = options ?? {};
 		const { journalStore } = this.options;
-		const peerId = readOptionalString$9(rawPeerId);
+		const peerId = readOptionalString$8(rawPeerId);
 		const summaryReadOptions = !peerId && limit !== void 0 ? { limit } : void 0;
 		return applyLimit((await journalStore.listSessionSummaries(summaryReadOptions)).filter((summary) => !peerId || summary.peerId === peerId).map(this.workingDirResolver.withWorkingDir), limit);
 	};
@@ -15546,9 +16024,9 @@ var SessionManager = class {
 	};
 	createAgentRunSession = async (params) => {
 		const { agentId, agentRuntimeId: requestedAgentRuntimeId, channel, contextInheritance, metadata, model, parentSessionId: rawParentSessionId, peerId: rawPeerId, projectRoot, sessionId, sourceSessionId: rawSourceSessionId, sourceSessionMetadata: requestedSourceSessionMetadata, task, thinkingEffort } = params;
-		const peerId = readOptionalString$9(rawPeerId);
-		const parentSessionId = readOptionalString$9(rawParentSessionId);
-		const sourceSessionId = readOptionalString$9(rawSourceSessionId);
+		const peerId = readOptionalString$8(rawPeerId);
+		const parentSessionId = readOptionalString$8(rawParentSessionId);
+		const sourceSessionId = readOptionalString$8(rawSourceSessionId);
 		const sourceRecord = sourceSessionId ? await this.getSessionRecord(sourceSessionId) : null;
 		const sourceSessionMetadata = requestedSourceSessionMetadata ?? sourceRecord?.metadata ?? {};
 		const agentRuntimeId = requestedAgentRuntimeId ?? readAgentRuntimeId(sourceSessionMetadata) ?? "native";
@@ -15558,7 +16036,7 @@ var SessionManager = class {
 			metadata,
 			peerId
 		}) : void 0;
-		const requestedSessionId = readOptionalString$9(sessionId);
+		const requestedSessionId = readOptionalString$8(sessionId);
 		const created = await this.createSession({
 			contextInheritance,
 			parentSessionId: parentSessionId ?? void 0,
@@ -17149,7 +17627,7 @@ function deduplicateNcpAgentSessionTailMessages(messages) {
 function isNcpAgentSessionMessageProjectionMeta(value, sessionId) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	const meta = value;
-	return meta.version === 7 && meta.sessionId === sessionId && Number.isSafeInteger(meta.total) && Number.isSafeInteger(meta.projectedJournalOffset) && Number.isSafeInteger(meta.dataBytes) && (meta.activeMessageId === null || typeof meta.activeMessageId === "string") && Array.isArray(meta.pendingCompactionMessageIds) && meta.pendingCompactionMessageIds.every((id) => typeof id === "string") && (meta.contextWindow === null || isRecord$6(meta.contextWindow));
+	return meta.version === 7 && meta.sessionId === sessionId && Number.isSafeInteger(meta.total) && Number.isSafeInteger(meta.projectedJournalOffset) && Number.isSafeInteger(meta.dataBytes) && (meta.activeMessageId === null || typeof meta.activeMessageId === "string") && Array.isArray(meta.pendingCompactionMessageIds) && meta.pendingCompactionMessageIds.every((id) => typeof id === "string") && (meta.contextWindow === null || isRecord$7(meta.contextWindow));
 }
 function readActiveAssistantMessageId(messages) {
 	for (let index = messages.length - 1; index >= 0; index -= 1) {
@@ -17172,12 +17650,12 @@ function mergePendingCompactionMessageIds(current, messages) {
 	}
 	return pending;
 }
-function isRecord$6(value) {
+function isRecord$7(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readCompactionStatus(message) {
 	const checkpoint = message.metadata?.checkpoint;
-	if (message.metadata?.nextclaw_timeline_kind !== "context_compaction" || !isRecord$6(checkpoint)) return null;
+	if (message.metadata?.nextclaw_timeline_kind !== "context_compaction" || !isRecord$7(checkpoint)) return null;
 	return typeof checkpoint.status === "string" ? checkpoint.status : null;
 }
 //#endregion
@@ -17685,6 +18163,151 @@ async function readLegacyRecords(journalDir, diagnostics) {
 	return /* @__PURE__ */ new Map();
 }
 //#endregion
+//#region src/stores/ncp-session-catalog-sqlite-driver.store.ts
+const require = createRequire(import.meta.url);
+const portableDatabases = /* @__PURE__ */ new Map();
+async function openSessionCatalogSqliteDatabase(databasePath) {
+	try {
+		return new (require("node:sqlite")).DatabaseSync(databasePath);
+	} catch (error) {
+		if (!isMissingNodeSqlite(error)) throw error;
+		return await openPortableDatabase(databasePath);
+	}
+}
+function runSessionCatalogSqliteTransaction(database, operation, mode = "DEFERRED") {
+	database.exec(`BEGIN ${mode}`);
+	try {
+		const result = operation();
+		database.exec("COMMIT");
+		return result;
+	} catch (error) {
+		database.exec("ROLLBACK");
+		throw error;
+	}
+}
+function isMissingNodeSqlite(error) {
+	const code = typeof error === "object" && error !== null ? error.code : void 0;
+	return code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND";
+}
+async function openPortableDatabase(databasePath) {
+	const existing = portableDatabases.get(databasePath);
+	if (existing) return (await existing).acquire();
+	const opening = createPortableDatabase(databasePath).catch((error) => {
+		portableDatabases.delete(databasePath);
+		throw error;
+	});
+	portableDatabases.set(databasePath, opening);
+	return (await opening).acquire();
+}
+async function createPortableDatabase(databasePath) {
+	const initialize = (await import("sql.js")).default;
+	const sqlite = await initialize({ locateFile: (file) => require.resolve(`sql.js/dist/${file}`) });
+	return new PortableSessionCatalogSqliteDatabase(databasePath, existsSync(databasePath) ? new sqlite.Database(readFileSync(databasePath)) : new sqlite.Database());
+}
+var PortableSessionCatalogSqliteDatabase = class {
+	inTransaction = false;
+	dirty = false;
+	leaseCount = 0;
+	constructor(databasePath, database) {
+		this.databasePath = databasePath;
+		this.database = database;
+	}
+	acquire = () => {
+		this.leaseCount += 1;
+		return new PortableSessionCatalogSqliteLease(this);
+	};
+	exec = (sql) => {
+		const command = sql.trim().toUpperCase();
+		this.database.run(sql);
+		if (command.startsWith("BEGIN")) {
+			this.inTransaction = true;
+			return;
+		}
+		if (command.startsWith("ROLLBACK")) {
+			this.inTransaction = false;
+			this.dirty = false;
+			return;
+		}
+		if (command.startsWith("COMMIT")) {
+			this.inTransaction = false;
+			this.persistIfDirty();
+			return;
+		}
+		if (!command.startsWith("PRAGMA")) this.markDirty();
+	};
+	prepare = (sql) => new PortableSessionCatalogSqliteStatement(this, sql);
+	release = () => {
+		this.leaseCount -= 1;
+		if (this.leaseCount > 0) return;
+		this.persistIfDirty();
+		this.database.close();
+		portableDatabases.delete(this.databasePath);
+	};
+	run = (sql, params) => {
+		this.database.run(sql, normalizeParams(params));
+		this.markDirty();
+	};
+	readRows = (sql, params) => {
+		const statement = this.database.prepare(sql);
+		try {
+			bindStatement(statement, params);
+			const rows = [];
+			while (statement.step()) rows.push(statement.getAsObject());
+			return rows;
+		} finally {
+			statement.free();
+		}
+	};
+	markDirty = () => {
+		this.dirty = true;
+		if (!this.inTransaction) this.persistIfDirty();
+	};
+	persistIfDirty = () => {
+		if (!this.dirty) return;
+		const temporaryPath = `${this.databasePath}.tmp`;
+		writeFileSync(temporaryPath, this.database.export());
+		renameSync(temporaryPath, this.databasePath);
+		this.dirty = false;
+	};
+};
+var PortableSessionCatalogSqliteLease = class {
+	closed = false;
+	constructor(owner) {
+		this.owner = owner;
+	}
+	close = () => {
+		if (this.closed) return;
+		this.closed = true;
+		this.owner.release();
+	};
+	exec = (sql) => this.owner.exec(sql);
+	prepare = (sql) => this.owner.prepare(sql);
+};
+var PortableSessionCatalogSqliteStatement = class {
+	constructor(database, sql) {
+		this.database = database;
+		this.sql = sql;
+	}
+	all = (...params) => this.database.readRows(this.sql, params);
+	get = (...params) => this.all(...params)[0];
+	run = (...params) => {
+		this.database.run(this.sql, params);
+		return {};
+	};
+};
+function bindStatement(statement, params) {
+	const normalized = normalizeParams(params);
+	if (Array.isArray(normalized) && normalized.length === 0) return;
+	statement.bind(normalized);
+}
+function normalizeParams(params) {
+	if (params.length !== 1 || !isRecord$6(params[0])) return params;
+	return Object.fromEntries(Object.entries(params[0]).map(([key, value]) => [`@${key}`, value]));
+}
+function isRecord$6(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region src/stores/ncp-agent-session-summary-index.store.ts
 const SQLITE_DATABASE_FILE = ".ncp-agent-session-catalog.sqlite";
 const CATALOG_SCHEMA_VERSION = 1;
@@ -17786,16 +18409,17 @@ var NcpAgentSessionSummaryIndexStore = class {
 	};
 	upsertForEvent = async (params) => {
 		await this.ensureReady();
-		const sessionId = normalizeNcpSessionId(params.sessionId);
+		const { sessionId: rawSessionId, event, updatedAt } = params;
+		const sessionId = normalizeNcpSessionId(rawSessionId);
 		const currentRow = this.db().prepare("SELECT * FROM sessions WHERE session_id = ? LIMIT 1").get(sessionId);
 		const row = summaryToRow({
 			...upsertNcpAgentSessionSummaryEvent({
 				current: currentRow && currentRow.deleted_at === null ? rowToSummary(currentRow) : void 0,
 				sessionId,
-				event: params.event,
-				updatedAt: params.updatedAt
+				event,
+				updatedAt
 			}),
-			messageCount: readEventMessage(params.event) ? 1 : 0
+			messageCount: readEventMessage(event) ? 1 : 0
 		});
 		this.db().prepare(`INSERT INTO sessions (
          session_id, peer_id, agent_id, created_at, updated_at,
@@ -17823,7 +18447,7 @@ var NcpAgentSessionSummaryIndexStore = class {
 		await this.ensureReady();
 		const normalizedSessionId = normalizeNcpSessionId(sessionId);
 		const deletedAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.db().transaction(() => {
+		runSessionCatalogSqliteTransaction(this.db(), () => {
 			if (this.db().prepare("SELECT session_id FROM sessions WHERE session_id = ? LIMIT 1").get(normalizedSessionId)) {
 				this.db().prepare("UPDATE sessions SET deleted_at = ? WHERE session_id = ?").run(deletedAt, normalizedSessionId);
 				return;
@@ -17832,7 +18456,7 @@ var NcpAgentSessionSummaryIndexStore = class {
            session_id, created_at, updated_at, message_count,
            status, metadata_json, deleted_at
          ) VALUES (?, ?, ?, 0, 'idle', '{}', ?)`).run(normalizedSessionId, deletedAt, deletedAt, deletedAt);
-		})();
+		}, "IMMEDIATE");
 	};
 	close = () => {
 		this.database?.close();
@@ -17848,10 +18472,13 @@ var NcpAgentSessionSummaryIndexStore = class {
 	};
 	initializeCatalog = async () => {
 		await mkdir(this.journalDir, { recursive: true });
-		this.database = new Database(resolve(this.journalDir, SQLITE_DATABASE_FILE), { timeout: 1e4 });
-		this.database.pragma("journal_mode = WAL");
-		this.database.pragma("synchronous = NORMAL");
-		this.database.pragma("foreign_keys = ON");
+		this.database = await openSessionCatalogSqliteDatabase(resolve(this.journalDir, SQLITE_DATABASE_FILE));
+		this.database.exec(`
+      PRAGMA busy_timeout = 10000;
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA foreign_keys = ON;
+    `);
 		this.database.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         session_id TEXT PRIMARY KEY,
@@ -17885,22 +18512,22 @@ var NcpAgentSessionSummaryIndexStore = class {
 			loadSession: (sessionId) => this.loadSession(sessionId),
 			loadSessionSummary: this.loadSessionSummary
 		});
-		this.db().transaction((result) => {
+		runSessionCatalogSqliteTransaction(this.db(), () => {
 			if (this.db().prepare("SELECT value FROM storage_meta WHERE key = ? LIMIT 1").get(MIGRATION_STATUS_KEY)?.value === MIGRATION_COMPLETE) {
-				this.reconcileRecords(result.records);
+				this.reconcileRecords(scan.records);
 				return;
 			}
-			for (const record of result.records) {
+			for (const record of scan.records) {
 				if (this.db().prepare("SELECT deleted_at FROM sessions WHERE session_id = ? LIMIT 1").get(record.sessionId)?.deleted_at) continue;
 				this.writeSummary(summaryToRow(record), false);
 			}
-			for (const diagnostic of result.diagnostics) this.db().prepare(`INSERT INTO migration_diagnostics (session_id, kind, detail_json, created_at)
+			for (const diagnostic of scan.diagnostics) this.db().prepare(`INSERT INTO migration_diagnostics (session_id, kind, detail_json, created_at)
            VALUES (?, ?, ?, ?)`).run(diagnostic.sessionId ?? null, diagnostic.kind, JSON.stringify(diagnostic.detail), (/* @__PURE__ */ new Date()).toISOString());
 			this.db().prepare(`INSERT INTO storage_meta (key, value) VALUES (?, ?)
          ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(MIGRATION_STATUS_KEY, MIGRATION_COMPLETE);
 			this.db().prepare(`INSERT INTO storage_meta (key, value) VALUES ('schema_version', ?)
          ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(CATALOG_SCHEMA_VERSION));
-		}).immediate(scan);
+		}, "IMMEDIATE");
 	};
 	reconcileRecords = (records) => {
 		for (const record of records) if (!this.db().prepare("SELECT deleted_at FROM sessions WHERE session_id = ? LIMIT 1").get(record.sessionId)?.deleted_at) this.writeSummary(summaryToRow(record), false);
@@ -18293,14 +18920,14 @@ function readRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
-function readString$4(value) {
+function readString$5(value) {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
 }
 function resolveRequestedModel(params) {
 	const { configuredModel, defaultModel, input, modelSelectionMode, sessionMetadata } = params;
 	if (modelSelectionMode === "runtime-default") return;
-	const requestedModel = readString$4(readRecord(input.metadata)?.preferred_model) ?? readString$4(readRecord(input.metadata)?.preferredModel) ?? readString$4(readRecord(input.metadata)?.model) ?? readString$4(sessionMetadata.preferred_model) ?? readString$4(sessionMetadata.preferredModel) ?? readString$4(sessionMetadata.model);
+	const requestedModel = readString$5(readRecord(input.metadata)?.preferred_model) ?? readString$5(readRecord(input.metadata)?.preferredModel) ?? readString$5(readRecord(input.metadata)?.model) ?? readString$5(sessionMetadata.preferred_model) ?? readString$5(sessionMetadata.preferredModel) ?? readString$5(sessionMetadata.model);
 	if (isRuntimeDefaultModelValue(requestedModel)) return;
 	return requestedModel ?? configuredModel ?? (modelSelectionMode === "optional" ? void 0 : defaultModel);
 }
@@ -18546,7 +19173,7 @@ var BuiltinNarpRuntimeProviderService = class {
 				input,
 				sessionMetadata: runtimeParams.sessionMetadata,
 				defaultModel: this.configManager.loadConfig().agents.defaults.model,
-				configuredModel: readString$4(config.model),
+				configuredModel: readString$5(config.model),
 				modelSelectionMode: normalizeRuntimeModelSelectionMode(config.modelSelectionMode)
 			})
 		});
@@ -18563,7 +19190,7 @@ var BuiltinNarpRuntimeProviderService = class {
 				input,
 				sessionMetadata: runtimeParams.sessionMetadata,
 				defaultModel: this.configManager.loadConfig().agents.defaults.model,
-				configuredModel: readString$4(config.model),
+				configuredModel: readString$5(config.model),
 				modelSelectionMode: normalizeRuntimeModelSelectionMode(config.modelSelectionMode)
 			})
 		});
@@ -19329,7 +19956,7 @@ const MAX_TOTAL_CONTEXT_CHARACTERS$1 = 96e3;
 function isRecord$5(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function readString$3(value) {
+function readString$4(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function escapeAttribute$1(value) {
@@ -19342,10 +19969,10 @@ function readConversationExcerpts(metadata) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const entry of entries) {
 		if (!isRecord$5(entry) || entry.kind !== CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) continue;
-		const key = readString$3(entry.key);
-		const messageId = readString$3(entry.messageId);
-		const label = readString$3(entry.label);
-		const excerpt = readString$3(entry.excerpt);
+		const key = readString$4(entry.key);
+		const messageId = readString$4(entry.messageId);
+		const label = readString$4(entry.label);
+		const excerpt = readString$4(entry.excerpt);
 		const role = entry.role;
 		if (!key || !messageId || !label || !excerpt || role !== "assistant" && role !== "user" || excerpt.length > MAX_EXCERPT_CHARACTERS$1 || seen.has(key)) continue;
 		seen.add(key);
@@ -20124,7 +20751,7 @@ var WorkspaceReferenceMaterializerService = class {
 function isRecord$2(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function readString$2(value) {
+function readString$3(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function readLine(value) {
@@ -20139,19 +20766,19 @@ function readWorkspaceReferences(metadata) {
 	for (const rawToken of rawTokens) {
 		if (!isRecord$2(rawToken)) continue;
 		const kind = rawToken.kind === CHAT_WORKSPACE_FILE_TOKEN_KIND ? CHAT_WORKSPACE_FILE_TOKEN_KIND : rawToken.kind === CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND ? CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND : rawToken.kind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND ? CHAT_WORKSPACE_EXCERPT_TOKEN_KIND : rawToken.kind === CHAT_PROJECT_TOKEN_KIND ? CHAT_PROJECT_TOKEN_KIND : null;
-		const key = readString$2(rawToken.key);
+		const key = readString$3(rawToken.key);
 		if (!kind || !key || seen.has(`${kind}:${key}`)) continue;
 		seen.add(`${kind}:${key}`);
 		if (kind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
-			const path = readString$2(rawToken.path);
-			const excerpt = readString$2(rawToken.excerpt);
+			const path = readString$3(rawToken.path);
+			const excerpt = readString$3(rawToken.excerpt);
 			if (!path || !excerpt) continue;
 			references.push({
 				kind,
 				key,
 				path,
 				excerpt,
-				label: readString$2(rawToken.label) ?? path,
+				label: readString$3(rawToken.label) ?? path,
 				startLine: readLine(rawToken.startLine),
 				endLine: readLine(rawToken.endLine)
 			});
@@ -20160,7 +20787,7 @@ function readWorkspaceReferences(metadata) {
 		references.push({
 			kind,
 			key,
-			label: readString$2(rawToken.label) ?? key
+			label: readString$3(rawToken.label) ?? key
 		});
 	}
 	return references;
@@ -20763,7 +21390,7 @@ function toInt(value, fallback) {
 	const parsed = typeof value === "number" || typeof value === "string" ? Number(value) : NaN;
 	return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : fallback;
 }
-function readString$1(value) {
+function readString$2(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function messageText(message) {
@@ -20791,7 +21418,7 @@ function capHistory(items) {
 	}];
 }
 function sessionLabel(summary) {
-	return readString$1(summary.metadata?.label) ?? readString$1(summary.metadata?.session_label);
+	return readString$2(summary.metadata?.label) ?? readString$2(summary.metadata?.session_label);
 }
 var SessionsListTool = class {
 	name = "sessions_list";
@@ -20820,7 +21447,7 @@ var SessionsListTool = class {
 	}
 	execute = async (args) => {
 		const { limit, messageLimit, sessionKey } = normalizeToolParams(args);
-		const exactSessionKey = readString$1(sessionKey);
+		const exactSessionKey = readString$2(sessionKey);
 		const summaries = exactSessionKey ? [await this.sessions.getSession(exactSessionKey)].filter((summary) => Boolean(summary)) : await this.sessions.listSessions();
 		const maxSessions = toInt(limit, DEFAULT_LIMIT);
 		const maxMessages = Math.min(toInt(messageLimit, 0), MAX_MESSAGE_LIMIT);
@@ -20869,7 +21496,7 @@ var SessionsHistoryTool = class {
 	}
 	execute = async (args) => {
 		const { includeTools, limit, sessionKey: rawSessionKey } = normalizeToolParams(args);
-		const sessionKey = readString$1(rawSessionKey);
+		const sessionKey = readString$2(rawSessionKey);
 		if (!sessionKey) return "Error: sessionKey is required";
 		const session = await this.resolveSession(sessionKey);
 		if (!session) return `Error: session '${sessionKey}' not found`;
@@ -22069,6 +22696,178 @@ function readInput(value) {
 	return value;
 }
 //#endregion
+//#region src/contributions/tool-provider/providers/app-package-dependency-tool.provider.ts
+const MUTATION_CONFIRMATION = {
+	type: "object",
+	properties: {
+		appId: {
+			type: "string",
+			description: "Installed App id."
+		},
+		confirm: {
+			type: "boolean",
+			description: "Set true only after the user approves this local configuration change."
+		}
+	},
+	required: ["appId"],
+	additionalProperties: false
+};
+var AppPackageDependencyToolProvider = class {
+	constructor(manager) {
+		this.manager = manager;
+	}
+	provide = (_request) => [
+		this.inspectTool(),
+		this.verifyTool(),
+		this.setupTool(),
+		this.bindTool(),
+		this.unbindTool()
+	];
+	inspectTool = () => ({
+		name: "app_dependencies_inspect",
+		description: "Inspect an installed App's declared dependencies, compatible trusted Providers, and non-sensitive bindings.",
+		parameters: {
+			type: "object",
+			properties: { appId: { type: "string" } },
+			required: ["appId"],
+			additionalProperties: false
+		},
+		execute: async (args) => JSON.stringify(await this.manager.inspectDependencies(readAppId(args)), null, 2)
+	});
+	verifyTool = () => ({
+		name: "app_dependencies_verify",
+		description: "Verify whether an installed App's current capability and resource dependencies are satisfied.",
+		parameters: {
+			type: "object",
+			properties: { appId: { type: "string" } },
+			required: ["appId"],
+			additionalProperties: false
+		},
+		execute: async (args) => JSON.stringify(await this.manager.verifyDependencies(readAppId(args)), null, 2)
+	});
+	setupTool = () => ({
+		name: "app_dependencies_setup",
+		description: "Set up dependency bindings only when each requirement has exactly one compatible trusted Provider. Run this only after the user has explicitly approved the local configuration change.",
+		parameters: MUTATION_CONFIRMATION,
+		execute: async (args) => await this.executeWithConfirmation(args, "setup", (appId) => this.manager.setupDependencies(appId))
+	});
+	bindTool = () => ({
+		name: "app_dependency_bind",
+		description: "Bind one declared dependency to an installed trusted Provider. Run this only after the user has explicitly approved the local configuration change.",
+		parameters: {
+			type: "object",
+			properties: {
+				appId: { type: "string" },
+				componentId: { type: "string" },
+				requirementKind: {
+					type: "string",
+					enum: ["capability", "resource"]
+				},
+				requirementId: { type: "string" },
+				providerId: { type: "string" },
+				confirm: { type: "boolean" }
+			},
+			required: [
+				"appId",
+				"componentId",
+				"requirementKind",
+				"requirementId",
+				"providerId"
+			],
+			additionalProperties: false
+		},
+		execute: async (args) => {
+			const input = readBinding(args);
+			if (!readConfirmation(args)) return confirmationResult("bind", input.appId);
+			return JSON.stringify(await this.manager.bindDependency(input.appId, input), null, 2);
+		}
+	});
+	unbindTool = () => ({
+		name: "app_dependency_unbind",
+		description: "Remove one local dependency binding. Run this only after the user has explicitly approved the local configuration change.",
+		parameters: {
+			type: "object",
+			properties: {
+				appId: { type: "string" },
+				componentId: { type: "string" },
+				requirementKind: {
+					type: "string",
+					enum: ["capability", "resource"]
+				},
+				requirementId: { type: "string" },
+				confirm: { type: "boolean" }
+			},
+			required: [
+				"appId",
+				"componentId",
+				"requirementKind",
+				"requirementId"
+			],
+			additionalProperties: false
+		},
+		execute: async (args) => {
+			const input = readUnbind(args);
+			if (!readConfirmation(args)) return confirmationResult("unbind", input.appId);
+			return JSON.stringify(await this.manager.unbindDependency(input.appId, input), null, 2);
+		}
+	});
+	executeWithConfirmation = async (args, action, execute) => {
+		const params = normalizeToolParams(args);
+		const appId = readAppId(params);
+		if (!readConfirmation(params)) return confirmationResult(action, appId);
+		return JSON.stringify(await execute(appId), null, 2);
+	};
+};
+function readAppId(value) {
+	const params = normalizeToolParams(value);
+	if (typeof params.appId !== "string" || !params.appId.trim()) throw new Error("appId must be a non-empty string.");
+	return params.appId.trim();
+}
+function readConfirmation(value) {
+	return normalizeToolParams(value).confirm === true;
+}
+function readBinding(value) {
+	const params = normalizeToolParams(value);
+	const appId = readAppId(params);
+	const componentId = readString$1(params.componentId, "componentId");
+	const requirementId = readString$1(params.requirementId, "requirementId");
+	const providerId = readString$1(params.providerId, "providerId");
+	if (params.requirementKind !== "capability" && params.requirementKind !== "resource") throw new Error("requirementKind must be capability or resource.");
+	return {
+		appId,
+		componentId,
+		requirementKind: params.requirementKind,
+		requirementId,
+		providerId,
+		confirm: params.confirm === true
+	};
+}
+function readUnbind(value) {
+	const binding = readBinding({
+		...normalizeToolParams(value),
+		providerId: "unused"
+	});
+	return {
+		appId: binding.appId,
+		componentId: binding.componentId,
+		requirementKind: binding.requirementKind,
+		requirementId: binding.requirementId,
+		confirm: binding.confirm
+	};
+}
+function readString$1(value, name) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${name} must be a non-empty string.`);
+	return value.trim();
+}
+function confirmationResult(action, appId) {
+	return JSON.stringify({
+		status: "requires_user_authorization",
+		action,
+		appId,
+		message: "This changes local dependency configuration. Confirm that the user has approved it, then retry with confirm=true."
+	}, null, 2);
+}
+//#endregion
 //#region src/contributions/tool-provider/services/tool-provider-run-context.service.ts
 var ToolProviderRunContextService = class {
 	constructor(sessionManager, agentManager, configManager) {
@@ -22126,6 +22925,7 @@ var ToolProviderContribution = class extends Contribution$1 {
 			new SessionToolProvider(runContextService, this.kernel.sessionManager, this.kernel.sessionRequests, this.kernel.sessionSearch),
 			new AssetToolProvider(this.kernel.assetStore),
 			new ServiceActionToolProvider(runContextService, this.kernel.serviceAppManager),
+			new AppPackageDependencyToolProvider(this.kernel.appPackageManager),
 			new McpToolProvider(runContextService, this.kernel.mcpManager)
 		];
 	};
@@ -22225,6 +23025,7 @@ function createKernelContributions(kernel) {
 function installKernelAppPackageRuntimeHooks(params) {
 	const { appPackageManager, panelAppManager, serviceAppManager } = params;
 	appPackageManager.installRuntimeHooks({
+		listCapabilityProviders: serviceAppManager.listCapabilityProviders,
 		assertCanActivate: async (sources) => {
 			await panelAppManager.assertCanActivatePackageComponents(sources);
 			await serviceAppManager.assertCanActivatePackageComponents(sources);