@nextclaw/kernel 0.1.2-beta.6 → 0.1.3

package/dist/index.js

@@ -1,4 +1,19 @@
 import { n as getUnsignedUpdateManifest, r as serializeUnsignedUpdateManifest, t as UpdateManifestReader } from "./update-manifest.types-C0qPrjGQ.js";
+import { AgentRouteResolver, CONTEXT_COMPACTION_METADATA_KEY, ChannelManager, ChannelManager as ChannelManager$1, CommandRegistry, ContextBuilder, ContextCompactionService, ContextWindowBudgetService, CronService, CronTool, DEFAULT_SESSION_SEARCH_LIMIT, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, LiteLLMProvider, MAX_SESSION_SEARCH_LIMIT, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderRegistry, ReadFileTool, RequestedSkillsMetadataReader, SessionManager, SessionRequestManager, SessionSearchManager, SessionsHistoryTool, SessionsListTool, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildCompressingCompactionCheckpoint, buildContextWindowSnapshot, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createToolExecutionContext, createTypingStopControlMessage, diffConfigPaths, ensureDir, expandHome, findEffectiveAgentProfile, getConfigPath, getDataDir, getSessionsPath, getWorkspacePath, loadConfig, parseAgentScopedSessionKey, parseThinkingLevel, readCompressedContextCompactionCheckpoint, readParentSessionId, readSessionProjectRoot, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, toDisposable } from "@nextclaw/core";
+import { EventBus, Ingress, createAppEventKey, createTypedKey, eventKeys } from "@nextclaw/shared";
+import { DefaultNcpAgentRuntime, LocalAssetStore, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool } from "@nextclaw/ncp-agent-runtime";
+import { NcpEventType, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, writeAssistantReasoningNormalizationModeToMetadata } from "@nextclaw/ncp";
+import { DefaultNcpAgentBackend, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { access, readFile } from "node:fs/promises";
+import { appendFileSync, constants, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { BUILTIN_PROVIDER_PLUGINS } from "@nextclaw/runtime";
+import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
+import { StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, probeStdioRuntime } from "@nextclaw/nextclaw-ncp-runtime-stdio-client";
+import { buildHermesAcpBridgeLaunchEnv, isHermesAcpRuntimeConfig } from "@nextclaw/nextclaw-hermes-acp-bridge";
+import { McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
+import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
+import { getPluginChannelBindings, getPluginUiMetadataFromRegistry, mergePluginConfigView, resolvePluginChannelMessageToolHints, toPluginConfigView } from "@nextclaw/openclaw-compat";
 //#region src/managers/agent.manager.ts
 var AgentManager = class {
 	listAgents = () => {
@@ -30,114 +45,3896 @@ var AgentManager = class {
 	};
 };
 //#endregion
-//#region src/managers/automation.manager.ts
-var AutomationManager = class {
-	listAutomations = () => {
-		throw new Error("AutomationManager.listAutomations is not implemented.");
+//#region src/features/narp-runtime/services/builtin-narp-runtime-registration.service.ts
+const NARP_API_MODE_HEADER = "x-nextclaw-narp-api-mode";
+const NARP_HTTP_RUNTIME_KIND = "narp-http";
+const NARP_STDIO_RUNTIME_KIND = "narp-stdio";
+const BUILTIN_PROVIDER_REGISTRY = new ProviderRegistry(BUILTIN_PROVIDER_PLUGINS);
+function readRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString$2(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function resolveEntryIcon(entry) {
+	return entry.icon ?? null;
+}
+function resolveRequestedModel(params) {
+	const { configuredModel, defaultModel, input, sessionMetadata } = params;
+	const runMetadata = readRecord$1(input.metadata);
+	return readString$2(runMetadata?.preferred_model) ?? readString$2(runMetadata?.preferredModel) ?? readString$2(runMetadata?.model) ?? readString$2(sessionMetadata.preferred_model) ?? readString$2(sessionMetadata.preferredModel) ?? readString$2(sessionMetadata.model) ?? configuredModel ?? defaultModel;
+}
+function resolveProviderApiMode(resolution) {
+	const wireApi = resolution.provider?.wireApi?.trim().toLowerCase();
+	if (wireApi === "responses") return "codex_responses";
+	if (wireApi === "chat") return "chat_completions";
+	const providerName = resolution.providerName?.trim().toLowerCase();
+	const apiBase = resolution.apiBase?.trim().toLowerCase() ?? "";
+	if (providerName === "anthropic" || apiBase.includes("anthropic.com")) return "anthropic_messages";
+	return "chat_completions";
+}
+function buildProviderRoute(params) {
+	const model = resolveRequestedModel(params);
+	if (!model) return;
+	const resolution = resolveProviderRuntime(params.config, model);
+	if (!resolution.provider) return;
+	const apiBase = resolution.apiBase ?? (resolution.providerName ? BUILTIN_PROVIDER_REGISTRY.findProviderByName(resolution.providerName)?.defaultApiBase ?? null : null);
+	return {
+		model: resolution.providerLocalModel,
+		apiKey: resolution.apiKey,
+		apiBase,
+		headers: {
+			...resolution.provider.extraHeaders ?? {},
+			[NARP_API_MODE_HEADER]: resolveProviderApiMode(resolution)
+		}
+	};
+}
+var BuiltinHttpRuntimeSessionTypeService = class {
+	pendingDescribeByMode = /* @__PURE__ */ new Map();
+	constructor(entry, defaultModel) {
+		this.entry = entry;
+		this.defaultModel = defaultModel;
+	}
+	describe = async (describeParams) => {
+		const describeMode = describeParams?.describeMode === "probe" ? "probe" : "observation";
+		const pending = this.pendingDescribeByMode.get(describeMode);
+		if (pending) return await pending;
+		const nextDescribe = this.describeInternal();
+		this.pendingDescribeByMode.set(describeMode, nextDescribe);
+		try {
+			return await nextDescribe;
+		} finally {
+			this.pendingDescribeByMode.delete(describeMode);
+		}
+	};
+	describeInternal = async () => {
+		const config = new HttpRuntimeConfigResolver(this.entry.config ?? {}).resolve({ defaultModel: this.defaultModel });
+		if (!config.baseUrl) return {
+			icon: resolveEntryIcon(this.entry),
+			ready: false,
+			reason: "base_url_missing",
+			reasonMessage: "Configure the runtime entry baseUrl before starting an HTTP runtime session.",
+			recommendedModel: config.recommendedModel ?? null,
+			cta: {
+				kind: "settings",
+				label: "Configure HTTP Runtime"
+			}
+		};
+		if (!((config.capabilityProbe ?? true) && Boolean(config.healthcheckUrl))) return {
+			icon: resolveEntryIcon(this.entry),
+			ready: true,
+			reason: null,
+			reasonMessage: null,
+			recommendedModel: config.recommendedModel ?? null,
+			...config.supportedModels ? { supportedModels: config.supportedModels } : {},
+			cta: null
+		};
+		const controller = new AbortController();
+		const timeoutMs = config.healthcheckTimeoutMs ?? 3e3;
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const response = await fetch(config.healthcheckUrl ?? "", {
+				method: "GET",
+				headers: config.headers,
+				signal: controller.signal
+			});
+			if (!response.ok) return {
+				icon: resolveEntryIcon(this.entry),
+				ready: false,
+				reason: "healthcheck_failed",
+				reasonMessage: `HTTP runtime healthcheck returned HTTP ${response.status}.`,
+				recommendedModel: config.recommendedModel ?? null,
+				...config.supportedModels ? { supportedModels: config.supportedModels } : {},
+				cta: null
+			};
+			return {
+				icon: resolveEntryIcon(this.entry),
+				ready: true,
+				reason: null,
+				reasonMessage: null,
+				recommendedModel: config.recommendedModel ?? null,
+				...config.supportedModels ? { supportedModels: config.supportedModels } : {},
+				cta: null
+			};
+		} catch (error) {
+			return {
+				icon: resolveEntryIcon(this.entry),
+				ready: false,
+				reason: "healthcheck_unreachable",
+				reasonMessage: error instanceof Error ? error.message : "Failed to reach the configured HTTP runtime healthcheck.",
+				recommendedModel: config.recommendedModel ?? null,
+				...config.supportedModels ? { supportedModels: config.supportedModels } : {},
+				cta: null
+			};
+		} finally {
+			clearTimeout(timeout);
+		}
+	};
+};
+var BuiltinStdioRuntimeSessionTypeService = class {
+	pendingDescribeByMode = /* @__PURE__ */ new Map();
+	constructor(entry) {
+		this.entry = entry;
+	}
+	describe = async (describeParams) => {
+		const describeMode = describeParams?.describeMode === "probe" ? "probe" : "observation";
+		const pending = this.pendingDescribeByMode.get(describeMode);
+		if (pending) return await pending;
+		const nextDescribe = this.describeInternal(describeMode);
+		this.pendingDescribeByMode.set(describeMode, nextDescribe);
+		try {
+			return await nextDescribe;
+		} finally {
+			this.pendingDescribeByMode.delete(describeMode);
+		}
+	};
+	describeInternal = async (describeMode) => {
+		const resolver = new StdioRuntimeConfigResolver(this.entry.config ?? {});
+		try {
+			const config = applyBuiltinStdioBridgeEnv(resolver.resolve(), { useProbeRoute: describeMode === "probe" });
+			if (!await resolveExecutablePath(config.command)) return {
+				icon: resolveEntryIcon(this.entry),
+				ready: false,
+				reason: "command_missing",
+				reasonMessage: `Configured stdio command "${config.command}" is not available. Update the runtime entry command or install the required launcher first.`,
+				cta: {
+					kind: "settings",
+					label: "Configure Stdio Runtime"
+				}
+			};
+			if (describeMode === "probe") try {
+				await probeStdioRuntime(config);
+			} catch (error) {
+				return {
+					icon: resolveEntryIcon(this.entry),
+					ready: false,
+					reason: "probe_failed",
+					reasonMessage: error instanceof Error ? error.message : "Configured stdio runtime could not complete the ACP probe.",
+					cta: {
+						kind: "settings",
+						label: "Repair Stdio Runtime"
+					}
+				};
+			}
+			return {
+				icon: resolveEntryIcon(this.entry),
+				ready: true,
+				reason: null,
+				reasonMessage: null,
+				cta: null
+			};
+		} catch (error) {
+			return {
+				icon: resolveEntryIcon(this.entry),
+				ready: false,
+				reason: "command_missing",
+				reasonMessage: error instanceof Error ? error.message : "Configure a stdio command before starting this runtime.",
+				cta: {
+					kind: "settings",
+					label: "Configure Stdio Runtime"
+				}
+			};
+		}
+	};
+};
+async function resolveExecutablePath(command) {
+	if (command.includes("/") || command.includes("\\")) return await isExecutable(command) ? command : null;
+	const searchPath = process.env.PATH ?? "";
+	for (const directory of searchPath.split(delimiter)) {
+		const trimmed = directory.trim();
+		if (!trimmed) continue;
+		const candidate = `${trimmed}/${command}`;
+		if (await isExecutable(candidate)) return candidate;
+	}
+	return null;
+}
+async function isExecutable(filePath) {
+	try {
+		await access(filePath, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+var BuiltinNarpRuntimeRegistrationService = class {
+	constructor(getConfig) {
+		this.getConfig = getConfig;
+	}
+	registerInto = (runtimeRegistry) => {
+		return [runtimeRegistry.register({
+			kind: NARP_HTTP_RUNTIME_KIND,
+			label: "NARP HTTP",
+			createRuntime: this.createUnavailableRuntime,
+			createRuntimeForEntry: ({ entry, runtimeParams }) => this.createHttpRuntime(entry, runtimeParams),
+			describeSessionTypeForEntry: ({ entry, describeParams }) => new BuiltinHttpRuntimeSessionTypeService(entry, this.getConfig().agents.defaults.model).describe(describeParams)
+		}), runtimeRegistry.register({
+			kind: NARP_STDIO_RUNTIME_KIND,
+			label: "NARP Stdio",
+			createRuntime: this.createUnavailableRuntime,
+			createRuntimeForEntry: ({ entry, runtimeParams }) => this.createStdioRuntime(entry, runtimeParams),
+			describeSessionTypeForEntry: ({ entry, describeParams }) => new BuiltinStdioRuntimeSessionTypeService(entry).describe(describeParams)
+		})];
+	};
+	createUnavailableRuntime = () => {
+		throw new Error("[narp] runtime entry is required before creating this runtime");
+	};
+	createHttpRuntime = (entry, runtimeParams) => {
+		const config = readRecord$1(entry.config) ?? {};
+		const resolver = new HttpRuntimeConfigResolver(config);
+		const resolvedConfig = resolver.resolve({ defaultModel: this.getConfig().agents.defaults.model });
+		return new HttpRuntimeNcpAgentRuntime({
+			baseUrl: resolver.requireBaseUrl(),
+			...resolvedConfig.basePath ? { basePath: resolvedConfig.basePath } : {},
+			...resolvedConfig.endpointId ? { endpointId: resolvedConfig.endpointId } : {},
+			...resolvedConfig.headers ? { headers: resolvedConfig.headers } : {},
+			stateManager: runtimeParams.stateManager,
+			resolveTools: runtimeParams.resolveTools,
+			resolveProviderRoute: (input) => buildProviderRoute({
+				config: this.getConfig(),
+				input,
+				sessionMetadata: runtimeParams.sessionMetadata,
+				defaultModel: this.getConfig().agents.defaults.model,
+				configuredModel: readString$2(config.model)
+			})
+		});
+	};
+	createStdioRuntime = (entry, runtimeParams) => {
+		const config = readRecord$1(entry.config) ?? {};
+		return new StdioRuntimeNcpAgentRuntime({
+			...applyBuiltinStdioBridgeEnv(new StdioRuntimeConfigResolver(config).resolve()),
+			sessionId: runtimeParams.sessionId,
+			stateManager: runtimeParams.stateManager,
+			resolveTools: runtimeParams.resolveTools,
+			resolveProviderRoute: (input) => buildProviderRoute({
+				config: this.getConfig(),
+				input,
+				sessionMetadata: runtimeParams.sessionMetadata,
+				defaultModel: this.getConfig().agents.defaults.model,
+				configuredModel: readString$2(config.model)
+			})
+		});
+	};
+};
+function applyBuiltinStdioBridgeEnv(config, params) {
+	if (!isHermesAcpRuntimeConfig(config)) return config;
+	return {
+		...config,
+		env: buildHermesAcpBridgeLaunchEnv({
+			command: config.command,
+			args: config.args,
+			baseEnv: config.env,
+			useProbeRoute: params?.useProbeRoute
+		})
+	};
+}
+//#endregion
+//#region src/features/runtime-registry/controllers/plugin-runtime-registration.controller.ts
+const RESERVED_BUILTIN_RUNTIME_KINDS = new Set([NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND]);
+function buildPluginRuntimeSnapshotKey(extensionRegistry) {
+	return (extensionRegistry?.ncpAgentRuntimes ?? []).map((registration) => [
+		registration.pluginId,
+		registration.kind,
+		registration.label,
+		registration.source
+	].join(":")).join("|");
+}
+var PluginRuntimeRegistrationController = class {
+	pluginRuntimeScopes = /* @__PURE__ */ new Map();
+	pluginRuntimeSnapshotKey = "";
+	constructor(runtimeRegistry, extensions) {
+		this.runtimeRegistry = runtimeRegistry;
+		this.extensions = extensions;
+	}
+	refreshPluginRuntimeRegistrations = () => {
+		this.syncPluginRuntimeRegistrations(this.resolveActiveExtensionRegistry());
+	};
+	dispose = () => {
+		for (const scope of this.pluginRuntimeScopes.values()) scope.dispose();
+		this.pluginRuntimeScopes.clear();
+		this.pluginRuntimeSnapshotKey = "";
+	};
+	syncPluginRuntimeRegistrations = (extensionRegistry) => {
+		const nextSnapshotKey = buildPluginRuntimeSnapshotKey(extensionRegistry);
+		if (nextSnapshotKey === this.pluginRuntimeSnapshotKey) return;
+		this.pluginRuntimeSnapshotKey = nextSnapshotKey;
+		for (const scope of this.pluginRuntimeScopes.values()) scope.dispose();
+		this.pluginRuntimeScopes.clear();
+		for (const registration of extensionRegistry?.ncpAgentRuntimes ?? []) {
+			if (RESERVED_BUILTIN_RUNTIME_KINDS.has(registration.kind.trim().toLowerCase())) continue;
+			const pluginId = registration.pluginId.trim() || registration.kind;
+			const scope = this.pluginRuntimeScopes.get(pluginId) ?? new DisposableStore();
+			this.pluginRuntimeScopes.set(pluginId, scope);
+			const createRuntimeForEntry = registration.createRuntimeForEntry;
+			scope.add(this.runtimeRegistry.register({
+				kind: registration.kind,
+				label: registration.label,
+				createRuntime: registration.createRuntime,
+				createRuntimeForEntry: createRuntimeForEntry ? ({ entry, runtimeParams }) => createRuntimeForEntry({
+					entry,
+					runtimeParams: {
+						...runtimeParams,
+						sessionMetadata: {
+							...runtimeParams.sessionMetadata,
+							runtime_type: entry.type
+						}
+					}
+				}) : void 0,
+				describeSessionType: registration.describeSessionType,
+				describeSessionTypeForEntry: registration.describeSessionTypeForEntry
+			}));
+		}
+	};
+	resolveActiveExtensionRegistry = () => this.extensions.getExtensionRegistry();
+};
+//#endregion
+//#region src/features/runtime-registry/services/agent-runtime-registry.service.ts
+const DEFAULT_AGENT_RUNTIME_ENTRY_ID = "native";
+function normalizeIdentifier(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim().toLowerCase();
+	return normalized.length > 0 ? normalized : null;
+}
+function cloneRuntimeEntry(entry) {
+	return {
+		id: entry.id,
+		label: entry.label,
+		...entry.icon ? { icon: { ...entry.icon } } : {},
+		type: entry.type,
+		enabled: entry.enabled !== false,
+		config: entry.config ? { ...entry.config } : {}
+	};
+}
+function normalizeAgentRuntimeSessionTypeIcon(value) {
+	if (typeof value === "string") {
+		const src = value.trim();
+		return src ? {
+			kind: "image",
+			src
+		} : null;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const iconRecord = value;
+	const src = typeof iconRecord.src === "string" ? iconRecord.src.trim() : "";
+	if (!src) return null;
+	const alt = typeof iconRecord.alt === "string" && iconRecord.alt.trim().length > 0 ? iconRecord.alt.trim() : null;
+	return {
+		kind: "image",
+		src,
+		...alt ? { alt } : {}
+	};
+}
+const BUILTIN_RUNTIME_PRESENTATION = { hermes: {
+	label: "Hermes",
+	icon: {
+		kind: "image",
+		src: "app://runtime-icons/hermes-agent.png",
+		alt: "Hermes"
+	}
+} };
+function readString$1(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function resolveBuiltinRuntimePresentation(value) {
+	const normalized = readString$1(value)?.toLowerCase();
+	if (!normalized) return null;
+	if (!(normalized in BUILTIN_RUNTIME_PRESENTATION)) return null;
+	return BUILTIN_RUNTIME_PRESENTATION[normalized] ?? null;
+}
+function buildNativeRuntimeEntry(config) {
+	const nativeRuntimeConfig = readRecord(config.ui?.ncp?.runtimes?.native) ?? {};
+	return {
+		id: DEFAULT_AGENT_RUNTIME_ENTRY_ID,
+		label: "Native",
+		type: DEFAULT_AGENT_RUNTIME_ENTRY_ID,
+		enabled: nativeRuntimeConfig.enabled !== false,
+		config: nativeRuntimeConfig
+	};
+}
+function resolveAgentRuntimeEntries(params) {
+	const entries = /* @__PURE__ */ new Map();
+	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$1(rawEntry.type)?.toLowerCase();
+		if (!id || !type) continue;
+		const explicitIcon = normalizeAgentRuntimeSessionTypeIcon(rawEntry.icon);
+		const builtinPresentation = resolveBuiltinRuntimePresentation(id) ?? resolveBuiltinRuntimePresentation(type);
+		entries.set(id, {
+			id,
+			label: readString$1(rawEntry.label) ?? builtinPresentation?.label ?? id,
+			...explicitIcon ?? builtinPresentation?.icon ? { icon: explicitIcon ?? builtinPresentation?.icon } : {},
+			type,
+			enabled: rawEntry.enabled !== false,
+			config: rawEntry.config ? { ...rawEntry.config } : {}
+		});
+	}
+	return {
+		defaultEntryId: entries.has("native") ? DEFAULT_AGENT_RUNTIME_ENTRY_ID : [...entries.keys()][0] ?? "native",
+		entries: [...entries.values()]
+	};
+}
+function readRequestedRuntimeEntryId(sessionMetadata) {
+	return normalizeIdentifier(sessionMetadata.runtime) ?? normalizeIdentifier(sessionMetadata.session_type) ?? normalizeIdentifier(sessionMetadata.sessionType) ?? null;
+}
+var AgentRuntimeRegistry = class {
+	providers = /* @__PURE__ */ new Map();
+	entries = /* @__PURE__ */ new Map();
+	defaultEntryId = DEFAULT_AGENT_RUNTIME_ENTRY_ID;
+	register = (registration) => {
+		const normalizedKind = normalizeIdentifier(registration.kind);
+		if (!normalizedKind) throw new Error("agent runtime kind must be a non-empty string");
+		const token = Symbol(normalizedKind);
+		this.providers.set(normalizedKind, {
+			...registration,
+			kind: normalizedKind,
+			token
+		});
+		return toDisposable(() => {
+			const current = this.providers.get(normalizedKind);
+			if (!current || current.token !== token) return;
+			this.providers.delete(normalizedKind);
+		});
+	};
+	applyEntries = (params) => {
+		const nextEntries = /* @__PURE__ */ new Map();
+		for (const rawEntry of params.entries) {
+			const id = normalizeIdentifier(rawEntry.id);
+			const type = normalizeIdentifier(rawEntry.type);
+			const label = rawEntry.label?.trim() ?? "";
+			if (!id || !type || !label) continue;
+			nextEntries.set(id, cloneRuntimeEntry({
+				...rawEntry,
+				id,
+				type,
+				label
+			}));
+		}
+		this.entries = nextEntries;
+		this.defaultEntryId = normalizeIdentifier(params.defaultEntryId) ?? (nextEntries.has("native") ? "native" : [...nextEntries.keys()][0] ?? "native");
+	};
+	listProviderKinds = () => {
+		return [...this.providers.keys()];
+	};
+	createRuntime = (params) => {
+		const requestedEntryId = readRequestedRuntimeEntryId(params.sessionMetadata) ?? this.defaultEntryId;
+		const entry = this.entries.get(requestedEntryId);
+		if (!entry || entry.enabled === false) throw new Error(`ncp runtime unavailable: ${requestedEntryId}`);
+		const provider = this.providers.get(entry.type);
+		if (!provider) throw new Error(`ncp runtime provider unavailable: ${entry.type}`);
+		const nextSessionMetadata = {
+			...params.sessionMetadata,
+			runtime: entry.id,
+			session_type: entry.id,
+			runtime_type: entry.type
+		};
+		params.setSessionMetadata(nextSessionMetadata);
+		if (provider.createRuntimeForEntry) return provider.createRuntimeForEntry({
+			entry: cloneRuntimeEntry(entry),
+			runtimeParams: {
+				...params,
+				sessionMetadata: nextSessionMetadata
+			}
+		});
+		return provider.createRuntime({
+			...params,
+			sessionMetadata: nextSessionMetadata
+		});
+	};
+	listSessionTypes = async (params) => {
+		const options = await Promise.all([...this.entries.values()].filter((entry) => entry.enabled !== false).map(async (entry) => {
+			const provider = this.providers.get(entry.type);
+			if (!provider) return {
+				value: entry.id,
+				label: entry.label,
+				icon: entry.icon ?? null,
+				ready: false,
+				reason: "runtime_provider_unavailable",
+				reasonMessage: `Runtime provider unavailable for type "${entry.type}".`,
+				recommendedModel: null,
+				cta: {
+					kind: "settings",
+					label: "Configure Runtime"
+				}
+			};
+			const descriptor = provider.describeSessionTypeForEntry ? await provider.describeSessionTypeForEntry({
+				entry: cloneRuntimeEntry(entry),
+				describeParams: params
+			}) : await provider.describeSessionType?.(params);
+			return {
+				value: entry.id,
+				label: entry.label,
+				icon: descriptor?.icon ?? entry.icon ?? null,
+				ready: descriptor?.ready ?? true,
+				reason: descriptor?.reason ?? null,
+				reasonMessage: descriptor?.reasonMessage ?? null,
+				recommendedModel: descriptor?.recommendedModel ?? null,
+				cta: descriptor?.cta ?? null,
+				...descriptor?.supportedModels ? { supportedModels: descriptor.supportedModels } : {}
+			};
+		}));
+		return {
+			defaultType: this.defaultEntryId,
+			options: options.sort((left, right) => {
+				if (left.value === this.defaultEntryId) return -1;
+				if (right.value === this.defaultEntryId) return 1;
+				return left.value.localeCompare(right.value);
+			})
+		};
+	};
+};
+//#endregion
+//#region src/features/ncp-dispatch/utils/agent-runtime-handle.utils.ts
+function createAgentRuntimeHandle(params) {
+	const { backend, runtimeRegistry, refreshPluginRuntimeRegistrations, refreshConfiguredRuntimeEntries, applyMcpConfig, dispose, assetStore } = params;
+	return {
+		basePath: "/api/ncp/agent",
+		agentClientEndpoint: createAgentClientFromServer(backend),
+		streamProvider: backend,
+		runApi: backend,
+		sessionApi: backend,
+		listSessionTypes: (describeParams) => {
+			refreshPluginRuntimeRegistrations();
+			refreshConfiguredRuntimeEntries();
+			return runtimeRegistry.listSessionTypes(describeParams);
+		},
+		assetApi: {
+			put: (input) => assetStore.putBytes({
+				fileName: input.fileName,
+				mimeType: input.mimeType,
+				bytes: input.bytes,
+				createdAt: input.createdAt
+			}),
+			stat: (uri) => assetStore.statRecord(uri),
+			resolveContentPath: (uri) => assetStore.resolveContentPath(uri)
+		},
+		applyMcpConfig,
+		dispose
+	};
+}
+//#endregion
+//#region src/utils/ncp-message-bridge.utils.ts
+function normalizeString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord$3(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneMetadata(value) {
+	return isRecord$3(value) ? structuredClone(value) : void 0;
+}
+function readStringArray(value) {
+	if (!Array.isArray(value)) return null;
+	const deduped = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		const normalized = normalizeString(item);
+		if (normalized) deduped.add(normalized);
+	}
+	return [...deduped];
+}
+function mergeSessionMetadata(currentMetadata, inputMetadata) {
+	if (!inputMetadata) return currentMetadata;
+	const nextMetadata = {
+		...currentMetadata,
+		...structuredClone(inputMetadata)
+	};
+	const model = normalizeString(inputMetadata.model) ?? normalizeString(inputMetadata.preferred_model) ?? normalizeString(inputMetadata.preferredModel);
+	if (model) {
+		nextMetadata.model = model;
+		nextMetadata.preferred_model = model;
+	}
+	const thinking = normalizeString(inputMetadata.thinking) ?? normalizeString(inputMetadata.preferred_thinking) ?? normalizeString(inputMetadata.thinking_level) ?? normalizeString(inputMetadata.thinkingLevel);
+	if (thinking) {
+		nextMetadata.thinking = thinking;
+		nextMetadata.preferred_thinking = thinking;
+	}
+	const sessionType = normalizeString(inputMetadata.session_type) ?? normalizeString(inputMetadata.sessionType);
+	if (sessionType) nextMetadata.session_type = sessionType;
+	const label = normalizeString(inputMetadata.label) ?? normalizeString(inputMetadata.session_label);
+	if (label) nextMetadata.label = label;
+	const requestedSkills = readStringArray(inputMetadata.requested_skills) ?? readStringArray(inputMetadata.requestedSkills);
+	if (requestedSkills) nextMetadata.requested_skills = requestedSkills;
+	return nextMetadata;
+}
+function extractMessageMetadata(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role !== "user") continue;
+		const metadata = cloneMetadata(message.metadata);
+		if (metadata) return metadata;
+	}
+}
+function ensureIsoTimestamp(value, fallback) {
+	if (typeof value !== "string") return fallback;
+	const timestamp = Date.parse(value);
+	if (!Number.isFinite(timestamp)) return fallback;
+	return new Date(timestamp).toISOString();
+}
+function serializeToolArgs(args) {
+	if (typeof args === "string") return args;
+	return JSON.stringify(args ?? {});
+}
+function serializeLegacyContent(parts) {
+	const text = parts.filter(isTextLikePart$1).map((part) => part.text).join("");
+	if (text.length > 0) return text;
+	if (parts.length === 0) return "";
+	return structuredClone(parts);
+}
+function extractTextFromNcpMessage(message) {
+	if (!message) return "";
+	return (message.role === "assistant" ? sanitizeAssistantReplyTags(message) : message).parts.filter(isTextLikePart$1).map((part) => part.text).join("");
+}
+function isTextLikePart$1(part) {
+	return part.type === "text" || part.type === "rich-text";
+}
+function buildLegacyUserContent(parts, options = {}) {
+	const content = buildNcpUserContent(parts, { assetStore: options.assetStore });
+	if (content === "") return serializeLegacyContent(parts);
+	return content;
+}
+function buildLegacyAssistantMessages(message, timestamp) {
+	const textContent = extractTextFromNcpMessage(message);
+	const reasoningParts = message.parts.filter((part) => part.type === "reasoning");
+	const reasoningContent = reasoningParts.map((part) => part.text).join("");
+	const toolInvocations = message.parts.filter((part) => part.type === "tool-invocation");
+	const assistantMessage = {
+		role: "assistant",
+		content: textContent,
+		timestamp,
+		ncp_message_id: message.id,
+		ncp_parts: structuredClone(message.parts)
+	};
+	if (typeof message.metadata?.reply_to === "string" && message.metadata.reply_to.trim().length > 0) assistantMessage.reply_to = message.metadata.reply_to.trim();
+	if (reasoningParts.length > 0) assistantMessage.reasoning_content = reasoningContent;
+	if (toolInvocations.length > 0) assistantMessage.tool_calls = toolInvocations.map((toolInvocation, index) => ({
+		id: toolInvocation.toolCallId ?? `${message.id}:tool:${index}`,
+		type: "function",
+		function: {
+			name: toolInvocation.toolName,
+			arguments: serializeToolArgs(toolInvocation.args)
+		}
+	}));
+	const messages = [assistantMessage];
+	for (const toolInvocation of toolInvocations) {
+		if (toolInvocation.state !== "result") continue;
+		messages.push({
+			role: "tool",
+			name: toolInvocation.toolName,
+			tool_call_id: toolInvocation.toolCallId,
+			content: typeof toolInvocation.result === "string" ? toolInvocation.result : JSON.stringify(toolInvocation.result ?? null),
+			...toolInvocation.resultContentItems ? { ncp_tool_result_content_items: structuredClone(toolInvocation.resultContentItems) } : {},
+			timestamp,
+			ncp_message_id: message.id
+		});
+	}
+	return messages;
+}
+function buildLegacyNonAssistantMessage(message, timestamp, options) {
+	return {
+		role: message.role === "service" && options.serviceRole === "system" ? "system" : message.role,
+		content: buildLegacyUserContent(message.parts, options),
+		timestamp,
+		ncp_message_id: message.id,
+		ncp_parts: structuredClone(message.parts),
+		...message.metadata ? { ncp_metadata: structuredClone(message.metadata) } : {}
+	};
+}
+function toLegacyMessages(messages, options = {}) {
+	const legacyMessages = [];
+	for (const rawMessage of messages) {
+		const message = rawMessage.role === "assistant" ? sanitizeAssistantReplyTags(rawMessage) : rawMessage;
+		const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+		if (message.role === "assistant") {
+			legacyMessages.push(...buildLegacyAssistantMessages(message, timestamp));
+			continue;
+		}
+		legacyMessages.push(buildLegacyNonAssistantMessage(message, timestamp, options));
+	}
+	return legacyMessages;
+}
+//#endregion
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-runner.utils.ts
+function normalizeOptionalString$2(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function resolveAttachmentName(attachment) {
+	const explicitName = normalizeOptionalString$2(attachment.name);
+	if (explicitName) return explicitName;
+	const explicitPath = normalizeOptionalString$2(attachment.path);
+	if (explicitPath) return basename(explicitPath);
+	const explicitUrl = normalizeOptionalString$2(attachment.url);
+	if (explicitUrl) try {
+		return basename(new URL(explicitUrl).pathname) || "asset.bin";
+	} catch {
+		return basename(explicitUrl) || "asset.bin";
+	}
+	return "asset.bin";
+}
+async function attachmentToPart(attachment, assetApi) {
+	const assetUri = normalizeOptionalString$2(attachment.assetUri);
+	if (assetUri) return createFilePartFromAssetUri(attachment, assetUri);
+	const remoteUrl = normalizeOptionalString$2(attachment.url);
+	const localPath = normalizeOptionalString$2(attachment.path);
+	if (localPath) return await createFilePartFromLocalPath(attachment, localPath, assetApi);
+	if (remoteUrl) return createFilePartFromRemoteUrl(attachment, remoteUrl);
+	throw new Error(`Unsupported attachment payload for "${resolveAttachmentName(attachment)}".`);
+}
+function createBaseFilePart(attachment) {
+	return {
+		...attachment.name ? { name: attachment.name } : {},
+		...attachment.mimeType ? { mimeType: attachment.mimeType } : {},
+		...typeof attachment.size === "number" ? { sizeBytes: attachment.size } : {}
+	};
+}
+function createFilePartFromAssetUri(attachment, assetUri) {
+	return {
+		type: "file",
+		assetUri,
+		...createBaseFilePart(attachment)
+	};
+}
+async function createFilePartFromLocalPath(attachment, localPath, assetApi) {
+	if (!assetApi) throw new Error("NCP asset api is unavailable for local attachments.");
+	const fileName = resolveAttachmentName(attachment);
+	const bytes = await readFile(localPath);
+	return {
+		type: "file",
+		assetUri: (await assetApi.put({
+			fileName,
+			mimeType: attachment.mimeType ?? null,
+			bytes
+		})).uri,
+		name: attachment.name ?? fileName,
+		...attachment.mimeType ? { mimeType: attachment.mimeType } : {},
+		...typeof attachment.size === "number" ? { sizeBytes: attachment.size } : {}
+	};
+}
+function createFilePartFromRemoteUrl(attachment, remoteUrl) {
+	return {
+		type: "file",
+		url: remoteUrl,
+		name: attachment.name ?? resolveAttachmentName(attachment),
+		...attachment.mimeType ? { mimeType: attachment.mimeType } : {},
+		...typeof attachment.size === "number" ? { sizeBytes: attachment.size } : {}
+	};
+}
+async function buildUserMessageParts(params) {
+	const { assetApi, attachments, content } = params;
+	const parts = [];
+	if (content.length > 0) parts.push({
+		type: "text",
+		text: content
+	});
+	for (const attachment of attachments ?? []) parts.push(await attachmentToPart(attachment, assetApi));
+	return parts;
+}
+async function buildNcpUserMessage(params) {
+	const { assetApi, attachments, content, metadata, sessionId } = params;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		id: `${sessionId}:user:${timestamp}`,
+		sessionId,
+		role: "user",
+		status: "final",
+		timestamp,
+		parts: await buildUserMessageParts({
+			content,
+			attachments,
+			assetApi
+		}),
+		metadata: structuredClone(metadata ?? {})
+	};
+}
+async function* streamPromptOverNcp(params) {
+	const { abortSignal, agent, attachments, content, metadata, onEvent, sessionId } = params;
+	const message = await buildNcpUserMessage({
+		sessionId,
+		content,
+		attachments,
+		metadata,
+		assetApi: agent.assetApi
+	});
+	for await (const event of agent.runApi.send({
+		sessionId,
+		message,
+		metadata
+	}, { ...abortSignal ? { signal: abortSignal } : {} })) {
+		onEvent?.(event);
+		yield event;
+	}
+}
+async function runPromptOverNcp(params) {
+	let completedMessage;
+	for await (const event of streamPromptOverNcp(params)) {
+		if (event.type === NcpEventType.MessageTextDelta) {
+			params.onAssistantDelta?.(event.payload.delta);
+			continue;
+		}
+		if (event.type === NcpEventType.MessageFailed) throw new Error(event.payload.error.message);
+		if (event.type === NcpEventType.RunError) throw new Error(event.payload.error ?? params.runErrorMessage ?? "NCP run failed.");
+		if (event.type === NcpEventType.MessageCompleted) completedMessage = event.payload.message;
+	}
+	if (!completedMessage) throw new Error(params.missingCompletedMessageError ?? "NCP run completed without a final assistant message.");
+	return {
+		text: extractTextFromNcpMessage(completedMessage),
+		completedMessage
+	};
+}
+//#endregion
+//#region src/features/ncp-dispatch/utils/channel-reply.utils.ts
+function readString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function isReplyCapableChannel(channel) {
+	return Boolean(channel) && typeof channel.consumeNcpReply === "function";
+}
+function resolveChannelReplyRoute(params) {
+	const { channel, message, route } = params;
+	if (!isReplyCapableChannel(channel)) return null;
+	const metadata = structuredClone(message.metadata ?? {});
+	const accountId = readString(route.accountId) ?? readString(metadata.accountId) ?? readString(metadata.account_id);
+	return {
+		target: {
+			conversationId: message.chatId,
+			...accountId ? { accountId } : {},
+			...Object.keys(metadata).length > 0 ? { metadata } : {}
+		},
+		channel
+	};
+}
+async function dispatchChannelReplyRoute(params) {
+	const { abortSignal, agent, attachments, content, metadata, onEvent, route, sessionId } = params;
+	const input = {
+		target: {
+			...route.target,
+			...agent.assetApi?.resolveContentPath ? { resolveAssetContentPath: agent.assetApi.resolveContentPath } : {}
+		},
+		eventStream: streamPromptOverNcp({
+			agent,
+			sessionId,
+			content,
+			attachments,
+			metadata,
+			abortSignal,
+			onEvent
+		})
+	};
+	await route.channel.consumeNcpReply(input);
+}
+//#endregion
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-dispatch.utils.ts
+function normalizeOptionalString$1(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function requireNcpAgent(resolveNcpAgent, purpose) {
+	const agent = resolveNcpAgent?.() ?? null;
+	if (!agent) throw new Error(`NCP agent is not ready for ${purpose}.`);
+	return agent;
+}
+function createDirectInboundMessage(params) {
+	const { attachments, channel, chatId, content, metadata } = params;
+	return {
+		channel: channel ?? "cli",
+		senderId: "user",
+		chatId: chatId ?? "direct",
+		content,
+		timestamp: /* @__PURE__ */ new Date(),
+		attachments: attachments ?? [],
+		metadata: structuredClone(metadata ?? {})
+	};
+}
+function buildRunMetadata(params) {
+	const { message, metadata, route } = params;
+	return {
+		...message.metadata ?? {},
+		...metadata ?? {},
+		channel: message.channel,
+		chatId: message.chatId,
+		chat_id: message.chatId,
+		accountId: route.accountId,
+		account_id: route.accountId,
+		agentId: route.agentId,
+		agent_id: route.agentId,
+		sessionKey: route.sessionKey,
+		session_key: route.sessionKey,
+		senderId: message.senderId,
+		sender_id: message.senderId
+	};
+}
+async function executeSlashCommandMaybe(params) {
+	const { channel, chatId, config, rawContent, sessionKey, sessionManager } = params;
+	if (!rawContent.trim().startsWith("/")) return null;
+	return (await new CommandRegistry(config, sessionManager).executeText(rawContent, {
+		channel,
+		chatId,
+		senderId: "user",
+		sessionKey
+	}))?.content ?? null;
+}
+function resolveDirectRoute(params) {
+	const { agentId, config, sessionKey } = params;
+	const message = createDirectInboundMessage(params);
+	const forcedAgentId = normalizeOptionalString$1(agentId) ?? parseAgentScopedSessionKey(sessionKey)?.agentId ?? void 0;
+	return {
+		message,
+		route: new AgentRouteResolver(config).resolveInbound({
+			message,
+			forcedAgentId,
+			sessionKeyOverride: sessionKey
+		})
+	};
+}
+function formatUserFacingError(error, maxChars = 320) {
+	const normalized = (error instanceof Error ? error.message || error.name || "Unknown error" : String(error ?? "Unknown error")).replace(/\s+/g, " ").trim();
+	if (!normalized) return "Unknown error";
+	if (normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+async function dispatchChannelReplyRouteMaybe(runtime, context) {
+	const { message, route, agent, runMetadata } = context;
+	if (message.channel === "system") return false;
+	const replyRoute = resolveChannelReplyRoute({
+		channel: runtime.kernel.channels.getChannel(message.channel),
+		message,
+		route
+	});
+	if (!replyRoute) return false;
+	await dispatchChannelReplyRoute({
+		agent,
+		route: replyRoute,
+		sessionId: route.sessionKey,
+		content: message.content,
+		attachments: message.attachments,
+		metadata: runMetadata
+	});
+	return true;
+}
+async function publishLegacyReply(runtime, context, result) {
+	const { message, route } = context;
+	if (message.channel === "system") {
+		runtime.appEventBus?.emit(eventKeys.sessionUpdated, { sessionKey: route.sessionKey }, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+		return;
+	}
+	if (!result.text.trim()) {
+		await runtime.messageBus.publishOutbound(createTypingStopControlMessage(message));
+		return;
+	}
+	await runtime.messageBus.publishOutbound({
+		channel: message.channel,
+		chatId: message.chatId,
+		content: result.text,
+		media: [],
+		metadata: buildRunMetadata({
+			message,
+			route,
+			metadata: result.completedMessage.metadata
+		})
+	});
+}
+async function dispatchPromptOverNcp(params) {
+	const { abortSignal, agentId, attachments, channel, chatId, config, content, metadata, onAssistantDelta, resolveNcpAgent, sessionKey, sessionManager } = params;
+	const { message, route } = resolveDirectRoute({
+		config,
+		content,
+		sessionKey,
+		channel,
+		chatId,
+		attachments,
+		metadata,
+		agentId
+	});
+	const commandResult = await executeSlashCommandMaybe({
+		config,
+		sessionManager,
+		rawContent: content,
+		channel: message.channel,
+		chatId: message.chatId,
+		sessionKey: route.sessionKey
+	});
+	if (commandResult) return commandResult;
+	return (await runPromptOverNcp({
+		agent: requireNcpAgent(resolveNcpAgent, "direct dispatch"),
+		sessionId: route.sessionKey,
+		content,
+		attachments,
+		metadata: buildRunMetadata({
+			message,
+			route
+		}),
+		abortSignal,
+		onAssistantDelta,
+		missingCompletedMessageError: `session "${route.sessionKey}" completed without a final assistant message`,
+		runErrorMessage: `session "${route.sessionKey}" failed`
+	})).text;
+}
+async function runGatewayInboundLoop(runtime) {
+	while (true) {
+		const message = await runtime.messageBus.consumeInbound();
+		let usedChannelReplyRoute = false;
+		try {
+			const explicitSessionKey = normalizeOptionalString$1(message.metadata.session_key_override);
+			const forcedAgentId = normalizeOptionalString$1(message.metadata.target_agent_id);
+			const route = new AgentRouteResolver(runtime.configManager.loadConfig()).resolveInbound({
+				message,
+				forcedAgentId,
+				sessionKeyOverride: explicitSessionKey
+			});
+			const agent = requireNcpAgent(() => runtime.liveAgentRuntime, "gateway dispatch");
+			const runMetadata = buildRunMetadata({
+				message,
+				route
+			});
+			const context = {
+				agent,
+				message,
+				route,
+				runMetadata
+			};
+			if (await dispatchChannelReplyRouteMaybe(runtime, context)) {
+				usedChannelReplyRoute = true;
+				continue;
+			}
+			if (message.channel !== "system") await runtime.messageBus.publishOutbound(createAssistantStreamResetControlMessage(message));
+			await publishLegacyReply(runtime, context, await runPromptOverNcp({
+				agent,
+				sessionId: route.sessionKey,
+				content: message.content,
+				attachments: message.attachments,
+				metadata: runMetadata,
+				onAssistantDelta: message.channel !== "system" ? (delta) => {
+					if (!delta) return;
+					runtime.messageBus.publishOutbound(createAssistantStreamDeltaControlMessage(message, delta));
+				} : void 0,
+				missingCompletedMessageError: `session "${route.sessionKey}" completed without a final assistant message`,
+				runErrorMessage: `session "${route.sessionKey}" failed`
+			}));
+		} catch (error) {
+			if (usedChannelReplyRoute) continue;
+			await runtime.messageBus.publishOutbound({
+				channel: message.channel,
+				chatId: message.chatId,
+				content: `Sorry, I encountered an error: ${formatUserFacingError(error)}`,
+				media: [],
+				metadata: {}
+			});
+		}
+	}
+}
+//#endregion
+//#region src/utils/ncp-session-message-adapter.utils.ts
+function tryParseJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function toTextPart(text) {
+	return text.length > 0 ? {
+		type: "text",
+		text
+	} : null;
+}
+function contentToParts(content) {
+	if (typeof content === "string") {
+		const textPart = toTextPart(content);
+		return textPart ? [textPart] : [];
+	}
+	if (Array.isArray(content)) return content.length > 0 ? [{
+		type: "extension",
+		extensionType: "nextclaw.legacy.content-array",
+		data: structuredClone(content)
+	}] : [];
+	if (content && typeof content === "object") return [{
+		type: "extension",
+		extensionType: "nextclaw.legacy.content-object",
+		data: structuredClone(content)
+	}];
+	return [];
+}
+function normalizeToolResultPayload(value) {
+	if (typeof value !== "string") return structuredClone(value);
+	const trimmed = value.trim();
+	if (!trimmed) return value;
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
+	return tryParseJson(trimmed);
+}
+function parseLegacyToolCalls(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+		const toolCall = entry;
+		const id = normalizeString(toolCall.id);
+		const rawFunction = toolCall.function;
+		if (!id || !rawFunction || typeof rawFunction !== "object" || Array.isArray(rawFunction)) return null;
+		const fn = rawFunction;
+		const name = normalizeString(fn.name);
+		const args = typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? {});
+		if (!name) return null;
+		return {
+			id,
+			type: "function",
+			function: {
+				name,
+				arguments: args
+			}
+		};
+	}).filter((entry) => entry !== null);
+}
+function createMessageId(sessionId, index, role, timestamp) {
+	return `${sessionId}:${role.trim().toLowerCase() || "message"}:${index}:${timestamp}`;
+}
+function resolveMessageId(params) {
+	const { index, message, role, sessionId, timestamp } = params;
+	return normalizeString(message.ncp_message_id) ?? createMessageId(sessionId, index, role, timestamp);
+}
+function isNcpMessagePart(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string";
+}
+function readStoredNcpParts(message) {
+	const rawParts = message.ncp_parts;
+	if (!Array.isArray(rawParts)) return null;
+	const parts = rawParts.filter((part) => isNcpMessagePart(part));
+	if (parts.length !== rawParts.length) return null;
+	return structuredClone(parts);
+}
+function readStoredNcpMetadata(message) {
+	const rawMetadata = message.ncp_metadata;
+	if (!rawMetadata || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) return;
+	return structuredClone(rawMetadata);
+}
+function buildAssistantMessage(params) {
+	const { index, message, sessionId } = params;
+	const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+	const replyTo = typeof message.reply_to === "string" && message.reply_to.trim().length > 0 ? message.reply_to.trim() : void 0;
+	const storedParts = readStoredNcpParts(message);
+	if (storedParts) return sanitizeAssistantReplyTags({
+		id: resolveMessageId({
+			index,
+			message,
+			role: "assistant",
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role: "assistant",
+		status: "final",
+		timestamp,
+		parts: storedParts,
+		metadata: replyTo ? { reply_to: replyTo } : void 0
+	});
+	const toolCalls = parseLegacyToolCalls(message.tool_calls);
+	const parts = [...contentToParts(message.content)];
+	if (typeof message.reasoning_content === "string") parts.push({
+		type: "reasoning",
+		text: message.reasoning_content
+	});
+	for (const toolCall of toolCalls) parts.push({
+		type: "tool-invocation",
+		toolCallId: toolCall.id,
+		toolName: toolCall.function.name,
+		state: "call",
+		args: tryParseJson(toolCall.function.arguments)
+	});
+	return sanitizeAssistantReplyTags({
+		id: resolveMessageId({
+			index,
+			message,
+			role: "assistant",
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role: "assistant",
+		status: "final",
+		timestamp,
+		parts,
+		metadata: replyTo ? { reply_to: replyTo } : void 0
+	});
+}
+function buildGenericMessage(params) {
+	const { index, message, role, sessionId } = params;
+	const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+	const storedParts = readStoredNcpParts(message);
+	const storedMetadata = readStoredNcpMetadata(message);
+	if (storedParts) return {
+		id: resolveMessageId({
+			index,
+			message,
+			role,
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role,
+		status: "final",
+		timestamp,
+		parts: storedParts,
+		...storedMetadata ? { metadata: storedMetadata } : {}
+	};
+	return {
+		id: resolveMessageId({
+			index,
+			message,
+			role,
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role,
+		status: "final",
+		timestamp,
+		parts: contentToParts(message.content),
+		...storedMetadata ? { metadata: storedMetadata } : {}
+	};
+}
+function attachToolResult(target, toolCallId, result, toolName, resultContentItems) {
+	const normalizedResult = normalizeToolResultPayload(result);
+	const normalizedContentItems = Array.isArray(resultContentItems) ? structuredClone(resultContentItems) : void 0;
+	return {
+		...target,
+		parts: target.parts.map((part) => {
+			if (part.type !== "tool-invocation" || part.toolCallId !== toolCallId) return part;
+			if (part.state === "result" && Object.prototype.hasOwnProperty.call(part, "result")) return {
+				...part,
+				...toolName ? { toolName } : {}
+			};
+			return {
+				...part,
+				toolName: toolName ?? part.toolName,
+				state: "result",
+				result: normalizedResult,
+				...normalizedContentItems ? { resultContentItems: normalizedContentItems } : {}
+			};
+		})
+	};
+}
+function toNcpMessages(sessionId, messages) {
+	const ncpMessages = [];
+	const assistantIndexByToolCallId = /* @__PURE__ */ new Map();
+	messages.forEach((message, index) => {
+		const role = normalizeString(message.role)?.toLowerCase() ?? "assistant";
+		if (role === "tool") {
+			const toolCallId = normalizeString(message.tool_call_id);
+			if (toolCallId) {
+				const assistantIndex = assistantIndexByToolCallId.get(toolCallId);
+				if (assistantIndex !== void 0) {
+					ncpMessages[assistantIndex] = attachToolResult(ncpMessages[assistantIndex], toolCallId, structuredClone(message.content), normalizeString(message.name) ?? void 0, message.ncp_tool_result_content_items);
+					return;
+				}
+			}
+			ncpMessages.push(buildGenericMessage({
+				sessionId,
+				index,
+				role: "tool",
+				message
+			}));
+			return;
+		}
+		if (role === "assistant") {
+			const assistant = buildAssistantMessage({
+				sessionId,
+				index,
+				message
+			});
+			const assistantPosition = ncpMessages.push(assistant) - 1;
+			for (const part of assistant.parts) if (part.type === "tool-invocation" && part.toolCallId) assistantIndexByToolCallId.set(part.toolCallId, assistantPosition);
+			return;
+		}
+		const normalizedRole = role === "system" || role === "user" || role === "service" ? role : "user";
+		ncpMessages.push(buildGenericMessage({
+			sessionId,
+			index,
+			role: normalizedRole,
+			message
+		}));
+	});
+	return ncpMessages;
+}
+function resolveLegacyEventType(message) {
+	const role = normalizeString(message.role)?.toLowerCase() ?? "";
+	if (role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) return "assistant.tool_call";
+	if (role === "tool") return "tool.result";
+	if (role === "assistant") return "message.assistant";
+	if (role === "user") return "message.user";
+	if (role === "system") return "message.system";
+	return `message.${role || "other"}`;
+}
+//#endregion
+//#region src/features/native-runtime/utils/context-compaction-timeline-message.utils.ts
+const NEXTCLAW_TIMELINE_KIND_METADATA_KEY = "nextclaw_timeline_kind";
+const CONTEXT_COMPACTION_TIMELINE_KIND = "context_compaction";
+function readTimelineMetadata(message) {
+	const rawMetadata = message?.ncp_metadata;
+	if (!rawMetadata || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) return null;
+	const metadata = rawMetadata;
+	if (metadata["nextclaw_timeline_kind"] !== "context_compaction") return null;
+	const checkpoint = metadata.checkpoint && typeof metadata.checkpoint === "object" && !Array.isArray(metadata.checkpoint) ? metadata.checkpoint : null;
+	if (!checkpoint) return null;
+	return {
+		[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+		checkpoint
+	};
+}
+function buildTimelineMessage(checkpoint) {
+	return {
+		role: "service",
+		content: checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩",
+		timestamp: checkpoint.updatedAt,
+		ncp_parts: [{
+			type: "text",
+			text: checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩"
+		}],
+		ncp_metadata: {
+			[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+			checkpoint
+		}
+	};
+}
+function buildContextCompactionTimelineNcpMessage(params) {
+	const { checkpoint, sessionId } = params;
+	const text = checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩";
+	return {
+		id: `${sessionId}:service:context-compaction:${checkpoint.id}`,
+		sessionId,
+		role: "service",
+		status: "final",
+		timestamp: checkpoint.updatedAt,
+		parts: [{
+			type: "text",
+			text
+		}],
+		metadata: {
+			[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+			checkpoint
+		}
+	};
+}
+function upsertContextCompactionTimelineMessage(params) {
+	const { checkpoint, insertBeforeMessageIds = [], session } = params;
+	const nextMessage = buildTimelineMessage(checkpoint);
+	for (let index = session.events.length - 1; index >= 0; index -= 1) {
+		const event = session.events[index];
+		const metadata = readTimelineMetadata(event?.data?.message && typeof event.data.message === "object" && !Array.isArray(event.data.message) ? event.data.message : null);
+		if (!metadata) continue;
+		event.timestamp = checkpoint.updatedAt;
+		event.data.message = nextMessage;
+		session.messages = session.messages.map((item) => {
+			return readTimelineMetadata(item)?.checkpoint.id === metadata.checkpoint.id ? nextMessage : item;
+		});
+		session.updatedAt = new Date(checkpoint.updatedAt);
+		return;
+	}
+	const event = {
+		seq: session.nextSeq,
+		type: "message.service",
+		timestamp: checkpoint.updatedAt,
+		data: { message: nextMessage }
+	};
+	session.nextSeq += 1;
+	const insertionIds = new Set(insertBeforeMessageIds);
+	const messageIndex = session.messages.findIndex((message) => typeof message.ncp_message_id === "string" && insertionIds.has(message.ncp_message_id));
+	if (messageIndex >= 0) session.messages.splice(messageIndex, 0, nextMessage);
+	else session.messages.push(nextMessage);
+	const eventIndex = session.events.findIndex((candidateEvent) => {
+		const message = candidateEvent?.data?.message && typeof candidateEvent.data.message === "object" && !Array.isArray(candidateEvent.data.message) ? candidateEvent.data.message : null;
+		return typeof message?.ncp_message_id === "string" && insertionIds.has(message.ncp_message_id);
+	});
+	if (eventIndex >= 0) session.events.splice(eventIndex, 0, event);
+	else session.events.push(event);
+	session.updatedAt = new Date(checkpoint.updatedAt);
+}
+function isContextCompactionTimelineMessage(message) {
+	return message?.metadata?.[NEXTCLAW_TIMELINE_KIND_METADATA_KEY] === CONTEXT_COMPACTION_TIMELINE_KIND;
+}
+//#endregion
+//#region src/features/native-runtime/utils/context-compaction-projection.utils.ts
+function readCompactionSummary(message) {
+	const metadata = message.metadata;
+	if (metadata?.["nextclaw_timeline_kind"] !== "context_compaction") return null;
+	return readCompressedContextCompactionCheckpoint(metadata.checkpoint)?.summary ?? null;
+}
+function projectNcpMessagesWithContextCompaction(params) {
+	const { sessionId, sessionMessages } = params;
+	let checkpointIndex = -1;
+	let summary = "";
+	for (let index = sessionMessages.length - 1; index >= 0; index -= 1) {
+		const candidateSummary = readCompactionSummary(sessionMessages[index]);
+		if (!candidateSummary) continue;
+		checkpointIndex = index;
+		summary = candidateSummary;
+		break;
+	}
+	if (checkpointIndex < 0) return sessionMessages.filter((message) => !readCompactionSummary(message)).map((message) => structuredClone(message));
+	return [{
+		id: `${sessionId}:context-compaction-summary:${sessionMessages[checkpointIndex]?.id ?? "latest"}`,
+		sessionId,
+		role: "user",
+		status: "final",
+		timestamp: sessionMessages[checkpointIndex]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+		parts: [{
+			type: "text",
+			text: summary
+		}]
+	}, ...sessionMessages.slice(checkpointIndex + 1).filter((message) => !readCompactionSummary(message)).map((message) => structuredClone(message))];
+}
+//#endregion
+//#region src/features/native-runtime/services/context-compaction-preflight.service.ts
+const SUMMARY_MAX_TOKENS = 4e3;
+const SUMMARY_SOURCE_MAX_CHARS = 12e4;
+function readRequestedAgentId$1(metadata) {
+	return normalizeString(metadata.agent_id)?.toLowerCase() ?? normalizeString(metadata.agentId)?.toLowerCase() ?? null;
+}
+function resolveCompactionProfile(params) {
+	const { config, requestMetadata, storedAgentId } = params;
+	const { defaults } = config.agents;
+	const defaultAgentId = resolveDefaultAgentProfileId(config);
+	const profile = findEffectiveAgentProfile(config, normalizeString(storedAgentId)?.toLowerCase() ?? readRequestedAgentId$1(requestMetadata) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
+	return {
+		contextTokens: profile?.contextTokens ?? defaults.contextTokens,
+		model: profile?.model ?? defaults.model,
+		reservedContextTokens: ContextWindowBudgetService.resolveReservedContextTokens({
+			contextTokens: profile?.contextTokens ?? defaults.contextTokens,
+			configuredReservedContextTokens: profile?.reservedContextTokens ?? defaults.reservedContextTokens
+		})
+	};
+}
+function mergeInputMessages(params) {
+	const messages = params.sessionMessages.map((message) => structuredClone(message));
+	const seen = new Set(messages.map((message) => message.id));
+	for (const message of params.inputMessages) {
+		if (seen.has(message.id)) continue;
+		messages.push(structuredClone(message));
+	}
+	return messages;
+}
+function stringifyCompactionSource(messages) {
+	const json = JSON.stringify(messages, null, 2);
+	if (json.length <= SUMMARY_SOURCE_MAX_CHARS) return json;
+	return `${json.slice(0, SUMMARY_SOURCE_MAX_CHARS).trimEnd()}\n[truncated_source]`;
+}
+function buildContextWindowSnapshotFromBudget(params) {
+	const { budget, checkpoint, totalContextTokens } = params;
+	return buildContextWindowSnapshot({
+		usedContextTokens: budget.estimatedTokens,
+		totalContextTokens,
+		prunedUsedContextTokens: budget.estimatedTokens,
+		droppedHistoryCount: budget.droppedHistoryCount,
+		truncatedToolResultCount: budget.truncatedToolResultCount,
+		truncatedSystemPrompt: budget.truncatedSystemPrompt,
+		truncatedUserMessage: budget.truncatedUserMessage,
+		checkpoint,
+		compactedUsedContextTokens: checkpoint ? budget.estimatedTokens : void 0
+	});
+}
+var ContextCompactionPreflightService = class {
+	compactionService = new ContextCompactionService();
+	contextWindowBudgetService = new ContextWindowBudgetService();
+	constructor(options) {
+		this.options = options;
+	}
+	run = async (params) => {
+		const beginResult = this.begin(params);
+		if (!beginResult) return null;
+		if (!beginResult.pendingCompaction) return beginResult;
+		return await this.finish(beginResult.pendingCompaction);
+	};
+	preview = (params) => {
+		const { contextWindowOwner, requestMetadata, sessionId, sessionMessages } = params;
+		if (contextWindowOwner === "runtime") return null;
+		const session = this.options.sessionManager.getIfExists(sessionId);
+		const metadata = session?.metadata ?? requestMetadata;
+		const profile = resolveCompactionProfile({
+			config: this.options.getConfig(),
+			requestMetadata,
+			storedAgentId: session?.agentId
+		});
+		const existingCheckpoint = readCompressedContextCompactionCheckpoint(metadata[CONTEXT_COMPACTION_METADATA_KEY]);
+		return this.buildContextWindowSnapshotForMessages({
+			checkpoint: existingCheckpoint,
+			contextTokens: profile.contextTokens,
+			reservedContextTokens: profile.reservedContextTokens,
+			sessionId,
+			sessionMessages
+		});
+	};
+	begin = (params) => {
+		const { contextWindowOwner, inputMessages, requestMetadata, sessionId, sessionMessages } = params;
+		if (contextWindowOwner === "runtime") return null;
+		const session = this.options.sessionManager.getOrCreate(sessionId);
+		const profile = resolveCompactionProfile({
+			config: this.options.getConfig(),
+			requestMetadata,
+			storedAgentId: session.agentId
+		});
+		const { contextTokens, reservedContextTokens } = profile;
+		const ncpMessages = mergeInputMessages({
+			inputMessages,
+			sessionMessages
+		});
+		const modelCandidateMessages = ncpMessages.filter((message) => !isContextCompactionTimelineMessage(message));
+		const existingCheckpoint = readCompressedContextCompactionCheckpoint(session.metadata[CONTEXT_COMPACTION_METADATA_KEY]);
+		const messages = toLegacyMessages(existingCheckpoint ? projectNcpMessagesWithContextCompaction({
+			sessionId,
+			sessionMessages: ncpMessages
+		}) : modelCandidateMessages);
+		const budget = this.contextWindowBudgetService.evaluate({
+			messages,
+			contextTokens,
+			reservedContextTokens
+		});
+		const plan = existingCheckpoint || !budget.shouldCompact ? null : this.compactionService.prepareForModelInput({
+			messages: budget.messages,
+			contextTokens,
+			compactionThresholdTokens: budget.triggerTokens
+		});
+		const checkpoint = plan ? {
+			...buildCompressingCompactionCheckpoint(session.metadata[CONTEXT_COMPACTION_METADATA_KEY]),
+			coveredMessageCount: plan.coveredMessages.length,
+			coveredSessionMessageCount: plan.coveredMessages.length,
+			originalEstimatedTokens: plan.originalEstimatedTokens,
+			projectedEstimatedTokens: budget.estimatedTokens
+		} : existingCheckpoint;
+		const contextWindow = buildContextWindowSnapshotFromBudget({
+			budget,
+			checkpoint,
+			totalContextTokens: contextTokens
+		});
+		if (plan && checkpoint) {
+			session.metadata[CONTEXT_COMPACTION_METADATA_KEY] = checkpoint;
+			upsertContextCompactionTimelineMessage({
+				session,
+				checkpoint,
+				insertBeforeMessageIds: inputMessages.map((message) => message.id)
+			});
+		}
+		this.options.sessionManager.save(session);
+		return {
+			contextWindow,
+			metadata: structuredClone(session.metadata),
+			sessionMessages: toNcpMessages(sessionId, session.messages),
+			timelineMessage: plan && checkpoint ? buildContextCompactionTimelineNcpMessage({
+				sessionId,
+				checkpoint
+			}) : null,
+			pendingCompaction: plan && checkpoint ? {
+				checkpoint,
+				contextTokens,
+				inputMessageIds: inputMessages.map((message) => message.id),
+				model: profile.model,
+				plan,
+				reservedContextTokens,
+				sessionId
+			} : null
+		};
+	};
+	buildContextWindowSnapshotForMessages = (params) => {
+		const { checkpoint, contextTokens, reservedContextTokens, sessionId, sessionMessages } = params;
+		const modelCandidateMessages = sessionMessages.filter((message) => !isContextCompactionTimelineMessage(message));
+		const messages = toLegacyMessages(checkpoint ? projectNcpMessagesWithContextCompaction({
+			sessionId,
+			sessionMessages
+		}) : modelCandidateMessages);
+		return buildContextWindowSnapshotFromBudget({
+			budget: this.contextWindowBudgetService.evaluate({
+				messages,
+				contextTokens,
+				reservedContextTokens
+			}),
+			checkpoint,
+			totalContextTokens: contextTokens
+		});
+	};
+	finish = async (pending) => {
+		const compacted = await this.compactionService.compactPreparedForModelInput({
+			contextTokens: pending.contextTokens,
+			plan: pending.plan,
+			generateSummary: async ({ messages }) => await this.generateSummary({
+				messages,
+				model: pending.model
+			})
+		});
+		const generatedCheckpoint = compacted.checkpoint;
+		if (!generatedCheckpoint) throw new Error("context compaction pending work did not produce a checkpoint");
+		const checkpoint = {
+			...generatedCheckpoint,
+			id: pending.checkpoint.id,
+			createdAt: pending.checkpoint.createdAt,
+			status: "compressed"
+		};
+		const contextWindow = buildContextWindowSnapshotFromBudget({
+			budget: this.contextWindowBudgetService.evaluate({
+				messages: compacted.messages,
+				contextTokens: pending.contextTokens,
+				reservedContextTokens: pending.reservedContextTokens
+			}),
+			checkpoint,
+			totalContextTokens: pending.contextTokens
+		});
+		const session = this.options.sessionManager.getOrCreate(pending.sessionId);
+		session.metadata[CONTEXT_COMPACTION_METADATA_KEY] = checkpoint;
+		upsertContextCompactionTimelineMessage({
+			session,
+			checkpoint,
+			insertBeforeMessageIds: pending.inputMessageIds
+		});
+		this.options.sessionManager.save(session);
+		return {
+			contextWindow,
+			metadata: structuredClone(session.metadata),
+			sessionMessages: toNcpMessages(pending.sessionId, session.messages),
+			timelineMessage: buildContextCompactionTimelineNcpMessage({
+				sessionId: pending.sessionId,
+				checkpoint
+			})
+		};
+	};
+	generateSummary = async (params) => {
+		if (!this.options.providerManager) throw new Error("context compaction summary generation requires a provider manager");
+		const { messages, model } = params;
+		const summary = (await this.options.providerManager.chat({
+			model,
+			maxTokens: SUMMARY_MAX_TOKENS,
+			messages: [{
+				role: "system",
+				content: [
+					"You are NextClaw's context compactor for a coding agent session.",
+					"Create a dense, structured summary that will replace earlier conversation history in a future model request.",
+					"Preserve user goals, explicit instructions, decisions, files touched or inspected, code changes, commands run, test results, failures, blockers, and exact next steps.",
+					"Do not invent facts. If something is uncertain, mark it as uncertain.",
+					"Return Markdown only. Start with '# Compressed Earlier Context'."
+				].join("\n")
+			}, {
+				role: "user",
+				content: [
+					"Compress these earlier runtime messages into a reusable checkpoint summary.",
+					"",
+					"Messages JSON:",
+					stringifyCompactionSource(messages)
+				].join("\n")
+			}]
+		})).content?.trim();
+		if (!summary) throw new Error("context compaction summary is empty");
+		return summary;
+	};
+};
+//#endregion
+//#region src/types/llm-usage.types.ts
+function createLlmUsageRecord(params) {
+	const { observedAt, source, model, usage: rawUsage } = params;
+	const usage = sanitizeLlmUsage(rawUsage);
+	return {
+		version: 1,
+		observedAt: observedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		model: normalizeLlmUsageModel(model),
+		usage,
+		summary: buildLlmUsageSummary(usage)
+	};
+}
+function sanitizeLlmUsage(usage) {
+	const next = {};
+	for (const [key, value] of Object.entries(usage)) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) continue;
+		next[key] = Math.floor(value);
+	}
+	return next;
+}
+function hasLlmUsageTelemetry(usage) {
+	return Object.keys(usage).length > 0;
+}
+function buildLlmUsageSummary(usage) {
+	const promptTokens = usage.prompt_tokens ?? usage.input_tokens ?? 0;
+	const completionTokens = usage.completion_tokens ?? usage.output_tokens ?? 0;
+	const totalTokens = usage.total_tokens ?? promptTokens + completionTokens;
+	const cacheMetricKeys = Object.keys(usage).filter((key) => key.endsWith("cached_tokens"));
+	const cachedTokens = cacheMetricKeys.reduce((max, key) => Math.max(max, usage[key] ?? 0), 0);
+	return {
+		promptTokens,
+		completionTokens,
+		totalTokens,
+		cachedTokens,
+		cacheHit: cachedTokens > 0,
+		cacheMetricKeys
+	};
+}
+function normalizeLlmUsageModel(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+//#endregion
+//#region src/stores/llm-usage.store.ts
+var LlmUsageStore = class {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	get snapshotPath() {
+		return this.options.snapshotPath ?? resolve(getDataDir(), "run", "llm-usage.json");
+	}
+	get historyPath() {
+		return this.options.historyPath ?? resolve(getDataDir(), "logs", "llm-usage.jsonl");
+	}
+	readSnapshot = () => {
+		if (!existsSync(this.snapshotPath)) return null;
+		try {
+			const raw = readFileSync(this.snapshotPath, "utf-8");
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	writeSnapshot = (snapshot) => {
+		mkdirSync(dirname(this.snapshotPath), { recursive: true });
+		writeFileSync(this.snapshotPath, JSON.stringify(snapshot, null, 2));
+	};
+	clearSnapshot = () => {
+		if (existsSync(this.snapshotPath)) rmSync(this.snapshotPath, { force: true });
+	};
+	listHistory = () => {
+		if (!existsSync(this.historyPath)) return [];
+		try {
+			return readFileSync(this.historyPath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0).flatMap((line) => {
+				try {
+					return [JSON.parse(line)];
+				} catch {
+					return [];
+				}
+			});
+		} catch {
+			return [];
+		}
+	};
+	appendHistory = (record) => {
+		mkdirSync(dirname(this.historyPath), { recursive: true });
+		appendFileSync(this.historyPath, `${JSON.stringify(record)}\n`);
+	};
+	clearHistory = () => {
+		if (existsSync(this.historyPath)) rmSync(this.historyPath, { force: true });
+	};
+};
+//#endregion
+//#region src/managers/llm-usage.manager.ts
+var ObservedLlmProviderRuntime = class {
+	constructor(delegate, manager, source) {
+		this.delegate = delegate;
+		this.manager = manager;
+		this.source = source;
+	}
+	get = (model) => {
+		return this.delegate.get(model);
+	};
+	chat = async (params) => {
+		const response = await this.delegate.chat(params);
+		this.manager.record({
+			source: this.source,
+			model: params.model ?? null,
+			usage: response.usage
+		});
+		return response;
+	};
+	chatStream = async function* (params) {
+		for await (const event of this.delegate.chatStream(params)) {
+			if (event.type === "done") this.manager.record({
+				source: this.source,
+				model: params.model ?? null,
+				usage: event.response.usage
+			});
+			yield event;
+		}
+	};
+};
+var LlmUsageManager = class {
+	store;
+	constructor(options = {}) {
+		this.store = options.store ?? new LlmUsageStore();
+	}
+	observeProviderManager = (providerManager, source) => {
+		return new ObservedLlmProviderRuntime(providerManager, this, source);
+	};
+	record = (params) => {
+		const record = createLlmUsageRecord(params);
+		if (!hasLlmUsageTelemetry(record.usage)) return null;
+		this.store.writeSnapshot(record);
+		this.store.appendHistory(record);
+		return record;
+	};
+};
+//#endregion
+//#region src/tools/session-search.tools.ts
+function isRecord$2(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalInteger(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.trunc(value);
+}
+function readOptionalBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+var SessionSearchTool = class {
+	name = "session_search";
+	description = "Search prior sessions by keyword and return structured hits with snippets. Use it to recall earlier discussions before creating new plans or summaries.";
+	parameters = {
+		type: "object",
+		properties: {
+			query: {
+				type: "string",
+				description: "Keyword search query for prior session text or labels."
+			},
+			limit: {
+				type: "integer",
+				minimum: 1,
+				maximum: MAX_SESSION_SEARCH_LIMIT,
+				description: `Optional max hit count. Defaults to ${DEFAULT_SESSION_SEARCH_LIMIT}.`
+			},
+			includeCurrentSession: {
+				type: "boolean",
+				description: "Set true to include the current session in results. Defaults to false."
+			}
+		},
+		required: ["query"],
+		additionalProperties: false
+	};
+	constructor(queryService, context) {
+		this.queryService = queryService;
+		this.context = context;
+	}
+	validateArgs = (args) => {
+		const issues = [];
+		const query = normalizeString(args.query);
+		const limit = readOptionalInteger(args.limit);
+		const includeCurrentSession = readOptionalBoolean(args.includeCurrentSession);
+		if (!query) issues.push("query must be a non-empty string.");
+		if (typeof args.limit !== "undefined" && typeof limit === "undefined") issues.push("limit must be a finite integer.");
+		if (typeof limit === "number" && (limit < 1 || limit > MAX_SESSION_SEARCH_LIMIT)) issues.push(`limit must be between 1 and ${MAX_SESSION_SEARCH_LIMIT}.`);
+		if (typeof args.includeCurrentSession !== "undefined" && typeof includeCurrentSession === "undefined") issues.push("includeCurrentSession must be a boolean.");
+		return issues;
+	};
+	execute = async (args) => {
+		if (!isRecord$2(args)) throw new Error("session_search requires an object argument.");
+		const issues = this.validateArgs(args);
+		if (issues.length > 0) throw new Error(issues.join(" "));
+		return this.queryService.search({
+			query: normalizeString(args.query) ?? "",
+			limit: readOptionalInteger(args.limit),
+			includeCurrentSession: readOptionalBoolean(args.includeCurrentSession),
+			currentSessionId: this.context.currentSessionId
+		});
+	};
+};
+//#endregion
+//#region src/features/native-runtime/tools/ncp-asset.tools.ts
+function readOptionalString$2(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function readOptionalBase64Bytes(value) {
+	const base64 = readOptionalString$2(value);
+	if (!base64) return null;
+	try {
+		return Buffer.from(base64, "base64");
+	} catch {
+		return null;
+	}
+}
+function toAssetPayload(record, contentBasePath) {
+	return {
+		uri: record.uri,
+		name: record.fileName,
+		mimeType: record.mimeType,
+		sizeBytes: record.sizeBytes,
+		createdAt: record.createdAt,
+		url: buildAssetContentPath({
+			basePath: contentBasePath,
+			assetUri: record.uri
+		})
+	};
+}
+var AssetPutTool = class {
+	name = "asset_put";
+	description = "Put a normal file path or base64 bytes into the managed asset store.";
+	parameters = {
+		type: "object",
+		properties: {
+			path: {
+				type: "string",
+				description: "Existing local file path to put into the asset store."
+			},
+			bytesBase64: {
+				type: "string",
+				description: "Base64 file bytes. Use together with fileName when no source path exists."
+			},
+			fileName: {
+				type: "string",
+				description: "Optional asset file name override. Required when using bytesBase64."
+			},
+			mimeType: {
+				type: "string",
+				description: "Optional mime type override."
+			}
+		},
+		additionalProperties: false
+	};
+	constructor(assetStore, contentBasePath) {
+		this.assetStore = assetStore;
+		this.contentBasePath = contentBasePath;
+	}
+	validateArgs = (args) => {
+		const path = readOptionalString$2(args.path);
+		const bytesBase64 = readOptionalString$2(args.bytesBase64);
+		const fileName = readOptionalString$2(args.fileName);
+		if (path && bytesBase64) return ["Provide either path, or bytesBase64 + fileName, not both."];
+		if (path) return [];
+		if (bytesBase64) return fileName ? [] : ["fileName is required when using bytesBase64."];
+		return ["Provide either path, or bytesBase64 + fileName."];
+	};
+	execute = async (args) => {
+		const path = readOptionalString$2(args?.path);
+		const fileName = readOptionalString$2(args?.fileName);
+		const mimeType = readOptionalString$2(args?.mimeType);
+		const bytes = readOptionalBase64Bytes(args?.bytesBase64);
+		if (path) return {
+			ok: true,
+			asset: toAssetPayload(await this.assetStore.putPath({
+				path,
+				fileName: fileName ?? void 0,
+				mimeType
+			}), this.contentBasePath)
+		};
+		if (bytes && fileName) return {
+			ok: true,
+			asset: toAssetPayload(await this.assetStore.putBytes({
+				fileName,
+				mimeType,
+				bytes
+			}), this.contentBasePath)
+		};
+		throw new Error("asset_put received invalid arguments after validation.");
+	};
+};
+var AssetExportTool = class {
+	name = "asset_export";
+	description = "Export a managed asset to a normal file path so it can be processed like any ordinary file.";
+	parameters = {
+		type: "object",
+		properties: {
+			assetUri: {
+				type: "string",
+				description: "Managed asset URI to export."
+			},
+			targetPath: {
+				type: "string",
+				description: "Destination file path."
+			}
+		},
+		required: ["assetUri", "targetPath"],
+		additionalProperties: false
+	};
+	constructor(assetStore) {
+		this.assetStore = assetStore;
+	}
+	execute = async (args) => {
+		const assetUri = readOptionalString$2(args?.assetUri);
+		const targetPath = readOptionalString$2(args?.targetPath);
+		if (!assetUri || !targetPath) throw new Error("asset_export requires assetUri and targetPath.");
+		return {
+			ok: true,
+			assetUri,
+			exportedPath: await this.assetStore.export({ uri: assetUri }, resolve(targetPath))
+		};
+	};
+};
+var AssetStatTool = class {
+	name = "asset_stat";
+	description = "Read managed asset metadata.";
+	parameters = {
+		type: "object",
+		properties: { assetUri: {
+			type: "string",
+			description: "Managed asset URI to inspect."
+		} },
+		required: ["assetUri"],
+		additionalProperties: false
+	};
+	constructor(assetStore, contentBasePath) {
+		this.assetStore = assetStore;
+		this.contentBasePath = contentBasePath;
+	}
+	execute = async (args) => {
+		const assetUri = readOptionalString$2(args?.assetUri);
+		if (!assetUri) throw new Error("asset_stat requires assetUri.");
+		const record = await this.assetStore.statRecord(assetUri);
+		if (!record) return {
+			ok: false,
+			error: {
+				code: "not_found",
+				message: `Asset not found: ${assetUri}`
+			}
+		};
+		return {
+			ok: true,
+			asset: toAssetPayload(record, this.contentBasePath)
+		};
+	};
+};
+function createAssetTools(params) {
+	const { assetStore } = params;
+	const contentBasePath = params.contentBasePath ?? "/api/ncp/assets/content";
+	return [
+		new AssetPutTool(assetStore, contentBasePath),
+		new AssetExportTool(assetStore),
+		new AssetStatTool(assetStore, contentBasePath)
+	];
+}
+//#endregion
+//#region src/features/native-runtime/utils/nextclaw-ncp-session-preferences.utils.ts
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readMetadataModel(metadata) {
+	const candidates = [
+		metadata.model,
+		metadata.llm_model,
+		metadata.agent_model,
+		metadata.session_model
+	];
+	for (const candidate of candidates) {
+		const normalized = normalizeOptionalString(candidate);
+		if (normalized) return normalized;
+	}
+	return null;
+}
+function readMetadataThinking(metadata) {
+	const candidates = [
+		metadata.thinking,
+		metadata.thinking_level,
+		metadata.thinkingLevel,
+		metadata.thinking_effort,
+		metadata.thinkingEffort
+	];
+	for (const candidate of candidates) {
+		if (typeof candidate !== "string") continue;
+		const normalized = candidate.trim().toLowerCase();
+		if (!normalized) continue;
+		if (normalized === "clear" || normalized === "reset" || normalized === "off!") return "__clear__";
+		const level = parseThinkingLevel(normalized);
+		if (level) return level;
+	}
+	return null;
+}
+function resolveEffectiveModel(params) {
+	const { fallbackModel, requestMetadata, session } = params;
+	const metadata = session.metadata;
+	if (requestMetadata.clear_model === true || requestMetadata.reset_model === true) delete metadata.preferred_model;
+	const inboundModel = readMetadataModel(requestMetadata);
+	if (inboundModel) metadata.preferred_model = inboundModel;
+	return normalizeOptionalString(metadata.preferred_model) ?? fallbackModel;
+}
+function syncSessionThinkingPreference(params) {
+	const { requestMetadata, session } = params;
+	const metadata = session.metadata;
+	if (requestMetadata.clear_thinking === true || requestMetadata.reset_thinking === true) delete metadata.preferred_thinking;
+	const inboundThinking = readMetadataThinking(requestMetadata);
+	if (inboundThinking === "__clear__") {
+		delete metadata.preferred_thinking;
+		return;
+	}
+	if (inboundThinking) metadata.preferred_thinking = inboundThinking;
+}
+function resolveSessionChannelContext(params) {
+	const { requestMetadata, session } = params;
+	const metadata = session.metadata;
+	const channel = normalizeOptionalString(requestMetadata.channel) ?? normalizeOptionalString(metadata.last_channel) ?? "ui";
+	const chatId = normalizeOptionalString(requestMetadata.chatId) ?? normalizeOptionalString(requestMetadata.chat_id) ?? normalizeOptionalString(metadata.last_to) ?? "web-ui";
+	metadata.last_channel = channel;
+	metadata.last_to = chatId;
+	return {
+		channel,
+		chatId
+	};
+}
+//#endregion
+//#region src/features/native-runtime/utils/nextclaw-ncp-current-turn.utils.ts
+function isTextLikePart(part) {
+	return part.type === "text" || part.type === "rich-text";
+}
+function collectTextPartIndexes(parts) {
+	return parts.map((part, index) => isTextLikePart(part) ? index : -1).filter((index) => index >= 0);
+}
+function replaceTextPartsWithSingleFormattedText(parts, textPartIndexes, formattedText) {
+	const nextParts = structuredClone(parts);
+	const firstTextIndex = textPartIndexes[0];
+	const firstTextPart = nextParts[firstTextIndex];
+	if (firstTextPart && isTextLikePart(firstTextPart)) firstTextPart.text = formattedText;
+	return nextParts.filter((part, index) => {
+		if (!isTextLikePart(part)) return true;
+		return index === firstTextIndex && part.text.length > 0;
+	});
+}
+function wrapTextPartsWithFormattedEdges(params) {
+	const { parts, prefix, suffix, textPartIndexes } = params;
+	const nextParts = structuredClone(parts);
+	const firstTextIndex = textPartIndexes[0];
+	const lastTextIndex = textPartIndexes[textPartIndexes.length - 1];
+	for (const index of textPartIndexes) {
+		const part = nextParts[index];
+		if (!part || !isTextLikePart(part)) continue;
+		if (index === firstTextIndex) part.text = `${prefix}${part.text}`;
+		if (index === lastTextIndex) part.text = `${part.text}${suffix}`;
+	}
+	return nextParts;
+}
+function buildFormattedCurrentParts(params) {
+	const { formattedText, message, originalText } = params;
+	const parts = message?.parts ?? [];
+	if (parts.length === 0) return formattedText.length > 0 ? [{
+		type: "text",
+		text: formattedText
+	}] : [];
+	const textPartIndexes = collectTextPartIndexes(parts);
+	if (textPartIndexes.length === 0) return formattedText.length > 0 ? [{
+		type: "text",
+		text: formattedText
+	}, ...structuredClone(parts)] : structuredClone(parts);
+	if (formattedText === originalText) return structuredClone(parts);
+	const originalTextIndex = formattedText.indexOf(originalText);
+	if (originalText.length === 0 || originalTextIndex < 0) return replaceTextPartsWithSingleFormattedText(parts, textPartIndexes, formattedText);
+	return wrapTextPartsWithFormattedEdges({
+		parts,
+		textPartIndexes,
+		prefix: formattedText.slice(0, originalTextIndex),
+		suffix: formattedText.slice(originalTextIndex + originalText.length)
+	});
+}
+function findLatestUserMessage(input) {
+	return input.messages.slice().reverse().find((message) => message.role === "user") ?? input.messages[input.messages.length - 1];
+}
+function buildCurrentTurnState(params) {
+	const { assetStore, currentModel, formatPrompt, input } = params;
+	const latestUserMessage = findLatestUserMessage(input);
+	const originalText = extractTextFromNcpMessage(latestUserMessage);
+	const currentParts = buildFormattedCurrentParts({
+		message: latestUserMessage,
+		formattedText: formatPrompt({
+			text: originalText,
+			timestamp: new Date(ensureIsoTimestamp(latestUserMessage?.timestamp, (/* @__PURE__ */ new Date()).toISOString()))
+		}),
+		originalText
+	});
+	return {
+		currentRole: latestUserMessage?.role === "system" ? "system" : "user",
+		currentUserContent: buildLegacyUserContent(currentParts, { assetStore }),
+		effectiveModel: currentModel
+	};
+}
+//#endregion
+//#region src/tools/session-request.tools.ts
+function readRequiredString$1(params, key) {
+	const value = params[key];
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${key} must be a non-empty string.`);
+	return value.trim();
+}
+function readOptionalString$1(params, key) {
+	const value = params[key];
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+var SessionRequestTool = class extends Tool {
+	sourceSessionId = "";
+	handoffDepth = 0;
+	constructor(manager) {
+		super();
+		this.manager = manager;
+	}
+	get name() {
+		return "sessions_request";
+	}
+	get description() {
+		return "Send one task to another session. Use notify to control whether this session should continue after the target session finishes.";
+	}
+	get parameters() {
+		return {
+			type: "object",
+			properties: {
+				target: {
+					type: "object",
+					description: "Target session reference. Pass an object like {\"session_id\":\"...\"}, not a bare string.",
+					properties: { session_id: {
+						type: "string",
+						description: "Existing target session id."
+					} },
+					required: ["session_id"]
+				},
+				task: {
+					type: "string",
+					description: "Task to send to the target session."
+				},
+				notify: {
+					type: "string",
+					enum: ["none", "final_reply"],
+					description: "Whether the current session should continue after the target session finishes. Use \"final_reply\" to continue after the target session reaches its final reply."
+				},
+				title: {
+					type: "string",
+					description: "Optional card title override."
+				}
+			},
+			required: [
+				"target",
+				"task",
+				"notify"
+			]
+		};
+	}
+	setContext = (params) => {
+		this.sourceSessionId = params.sourceSessionId;
+		this.handoffDepth = params.handoffDepth ?? 0;
+	};
+	execute = async (params, context) => {
+		const target = params.target;
+		if (!target || typeof target !== "object" || Array.isArray(target)) throw new Error("target must be an object.");
+		const task = readRequiredString$1(params, "task");
+		const notifyMode = readOptionalString$1(params, "notify")?.toLowerCase();
+		if (notifyMode !== "none" && notifyMode !== "final_reply") throw new Error("notify must be \"none\" or \"final_reply\".");
+		const { toolCallId, updateToolCallResult } = context;
+		return this.manager.requestSession({
+			sourceSessionId: this.sourceSessionId,
+			...toolCallId ? { sourceToolCallId: toolCallId } : {},
+			updateToolCallResult,
+			targetSessionId: readRequiredString$1(target, "session_id"),
+			task,
+			title: readOptionalString$1(params, "title"),
+			notify: notifyMode,
+			handoffDepth: this.handoffDepth
+		});
+	};
+};
+//#endregion
+//#region src/tools/session-spawn.tools.ts
+function readRequiredString(value, key) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${key} must be a non-empty string.`);
+	return value.trim();
+}
+function readOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readSpawnScope(value) {
+	const normalized = readOptionalString(value)?.toLowerCase();
+	if (!normalized || normalized === "standalone") return "standalone";
+	if (normalized === "child") return "child";
+	throw new Error("scope must be \"standalone\" or \"child\".");
+}
+function readSpawnRequestOptions(value) {
+	if (typeof value === "undefined") return;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("request must be an object.");
+	const notifyMode = readOptionalString(value.notify)?.toLowerCase();
+	if (notifyMode === "none" || notifyMode === "final_reply") return { notify: notifyMode };
+	throw new Error("request.notify must be \"none\" or \"final_reply\".");
+}
+var SessionSpawnTool = class extends Tool {
+	sourceSessionId = "";
+	sourceSessionMetadata = {};
+	handoffDepth = 0;
+	constructor(sessionManager, sessionRequestManager, onSessionUpdated) {
+		super();
+		this.sessionManager = sessionManager;
+		this.sessionRequestManager = sessionRequestManager;
+		this.onSessionUpdated = onSessionUpdated;
+	}
+	get name() {
+		return "sessions_spawn";
+	}
+	get description() {
+		return "Create a new session. Use scope=\"child\" to create a child session of the current flow, and add request.notify to control whether this session should continue after the new session finishes.";
+	}
+	get parameters() {
+		return {
+			type: "object",
+			properties: {
+				task: {
+					type: "string",
+					description: "Seed text used to title the new session. If request is provided, this same task is also sent as the first request to that new session."
+				},
+				scope: {
+					type: "string",
+					enum: ["standalone", "child"],
+					description: "Whether the new session should be a standalone thread or a child session of the current session."
+				},
+				title: {
+					type: "string",
+					description: "Optional explicit session title."
+				},
+				model: {
+					type: "string",
+					description: "Optional model override for the new session."
+				},
+				runtime: {
+					type: "string",
+					description: "Optional runtime override for the new session, for example native or codex."
+				},
+				agentId: {
+					type: "string",
+					description: "Optional target agent id for the new session. Omit to use the default agent."
+				},
+				request: {
+					type: "object",
+					description: "Optional initial request to run immediately inside the new session.",
+					properties: { notify: {
+						type: "string",
+						enum: ["none", "final_reply"],
+						description: "Whether the current session should continue after the new session finishes. Use \"final_reply\" to continue after the new session reaches its final reply."
+					} },
+					required: ["notify"]
+				}
+			},
+			required: ["task"]
+		};
+	}
+	setContext = (params) => {
+		this.sourceSessionId = params.sourceSessionId;
+		this.sourceSessionMetadata = structuredClone(params.sourceSessionMetadata);
+		this.handoffDepth = params.handoffDepth ?? 0;
+	};
+	execute = async (params, context) => {
+		const { agentId: rawAgentId, model: rawModel, request: rawRequest, runtime: rawRuntime, scope: rawScope, task: rawTask, title: rawTitle } = params;
+		const task = readRequiredString(rawTask, "task");
+		const scope = readSpawnScope(rawScope);
+		const request = readSpawnRequestOptions(rawRequest);
+		const parentSessionId = scope === "child" ? this.readParentSessionIdOrThrow() : void 0;
+		const { toolCallId, updateToolCallResult } = context;
+		if (request) return this.sessionRequestManager.spawnSessionAndRequest({
+			sourceSessionId: this.sourceSessionId,
+			...toolCallId ? { sourceToolCallId: toolCallId } : {},
+			updateToolCallResult,
+			sourceSessionMetadata: this.sourceSessionMetadata,
+			task,
+			title: readOptionalString(rawTitle),
+			agentId: readOptionalString(rawAgentId),
+			model: readOptionalString(rawModel),
+			runtime: readOptionalString(rawRuntime),
+			handoffDepth: this.handoffDepth,
+			...parentSessionId ? { parentSessionId } : {},
+			notify: request.notify
+		});
+		const session = this.sessionManager.createSession({
+			sourceSessionId: this.sourceSessionId,
+			task,
+			title: readOptionalString(rawTitle),
+			sourceSessionMetadata: this.sourceSessionMetadata,
+			agentId: readOptionalString(rawAgentId),
+			model: readOptionalString(rawModel),
+			runtime: readOptionalString(rawRuntime),
+			...parentSessionId ? { parentSessionId } : {}
+		});
+		this.onSessionUpdated?.(session.sessionId);
+		return {
+			kind: "nextclaw.session",
+			sessionId: session.sessionId,
+			...session.agentId ? { agentId: session.agentId } : {},
+			...session.parentSessionId ? { parentSessionId: session.parentSessionId } : {},
+			isChildSession: Boolean(session.parentSessionId),
+			lifecycle: session.lifecycle,
+			title: session.title,
+			sessionType: session.sessionType,
+			createdAt: session.createdAt
+		};
+	};
+	readParentSessionIdOrThrow = () => {
+		const sourceSessionId = this.sourceSessionId.trim();
+		if (!sourceSessionId) throw new Error("scope=\"child\" requires an active source session.");
+		return sourceSessionId;
+	};
+};
+//#endregion
+//#region src/features/native-runtime/services/nextclaw-ncp-tool-registry.service.ts
+function toToolParams(args) {
+	if (isRecord$3(args)) return args;
+	if (typeof args === "string") try {
+		const parsed = JSON.parse(args);
+		return isRecord$3(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+	return {};
+}
+function readMetadataAccountId(metadata, sessionMetadata) {
+	const candidates = [
+		metadata.accountId,
+		metadata.account_id,
+		sessionMetadata.last_account_id
+	];
+	for (const candidate of candidates) {
+		const normalized = normalizeString(candidate);
+		if (normalized) return normalized;
+	}
+}
+var CoreToolNcpAdapter = class {
+	constructor(tool, executeTool) {
+		this.tool = tool;
+		this.executeTool = executeTool;
+	}
+	get name() {
+		return this.tool.name;
+	}
+	get description() {
+		return this.tool.description;
+	}
+	get parameters() {
+		return this.tool.parameters;
+	}
+	execute = async (args) => {
+		return this.executeTool(this.tool.name, args);
+	};
+};
+var NextclawNcpToolRegistry = class {
+	registry = new ToolRegistry();
+	tools = /* @__PURE__ */ new Map();
+	currentExtensionToolContext = {};
+	constructor(options) {
+		this.options = options;
+	}
+	prepareForRun = (context) => {
+		const { channel, chatId, config, restrictToWorkspace, sessionId, workspace } = context;
+		this.currentExtensionToolContext = {
+			config,
+			workspaceDir: workspace,
+			sessionKey: sessionId,
+			channel,
+			chatId,
+			sandboxed: restrictToWorkspace
+		};
+		this.registry = new ToolRegistry();
+		this.tools.clear();
+		this.registerDefaultTools(context);
+		this.registerExtensionTools(context);
+		this.registerAdditionalTools(context);
+	};
+	listTools = () => {
+		return [...this.tools.values()].filter((tool) => this.isToolAvailable(tool.name));
 	};
-	getAutomation = (automationId) => {
-		throw new Error("AutomationManager.getAutomation is not implemented.");
+	getTool = (name) => {
+		if (!this.isToolAvailable(name)) return;
+		return this.tools.get(name);
 	};
-	requireAutomation = (automationId) => {
-		throw new Error("AutomationManager.requireAutomation is not implemented.");
+	getToolDefinitions = () => {
+		return this.listTools().map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}));
 	};
-	saveAutomation = (automation) => {
-		throw new Error("AutomationManager.saveAutomation is not implemented.");
+	execute = async (toolCallId, toolName, args) => {
+		if (this.registry.has(toolName)) return this.registry.executeRaw(toolName, toToolParams(args), this.buildToolExecutionContext(toolCallId));
+		return this.tools.get(toolName)?.execute(args);
 	};
-	enableAutomation = (automationId) => {
-		throw new Error("AutomationManager.enableAutomation is not implemented.");
+	buildToolExecutionContext = (toolCallId) => {
+		const sessionId = this.currentExtensionToolContext.sessionKey;
+		return createToolExecutionContext({
+			toolCallId,
+			updateToolCallResult: async (result) => {
+				if (!sessionId) return;
+				await this.options.updateToolCallResult({
+					sessionId,
+					toolCallId,
+					result
+				});
+			}
+		});
 	};
-	disableAutomation = (automationId) => {
-		throw new Error("AutomationManager.disableAutomation is not implemented.");
+	registerDefaultTools = (context) => {
+		const { channel, chatId, execTimeoutSeconds, handoffDepth, metadata, restrictToWorkspace, searchConfig, sessionId, workspace } = context;
+		const allowedDir = restrictToWorkspace ? workspace : void 0;
+		this.registerTool(new ReadFileTool(allowedDir));
+		this.registerTool(new WriteFileTool(allowedDir));
+		this.registerTool(new EditFileTool(allowedDir));
+		this.registerTool(new ListDirTool(allowedDir));
+		const execTool = new ExecTool({
+			workingDir: workspace,
+			timeout: execTimeoutSeconds,
+			restrictToWorkspace
+		});
+		execTool.setContext({
+			sessionKey: sessionId,
+			channel,
+			chatId
+		});
+		this.registerTool(execTool);
+		this.registerTool(new WebSearchTool(searchConfig));
+		this.registerTool(new WebFetchTool());
+		this.registerMessagingTools({
+			channel,
+			chatId,
+			metadata
+		});
+		const sessionsSpawnTool = new SessionSpawnTool(this.options.sessionManager, this.options.sessionRequestManager, this.options.onSessionUpdated);
+		sessionsSpawnTool.setContext({
+			sourceSessionId: sessionId,
+			sourceSessionMetadata: metadata,
+			handoffDepth
+		});
+		this.registerTool(sessionsSpawnTool);
+		const sessionsRequestTool = new SessionRequestTool(this.options.sessionRequestManager);
+		sessionsRequestTool.setContext({
+			sourceSessionId: sessionId,
+			handoffDepth
+		});
+		this.registerTool(sessionsRequestTool);
+		this.registerTool(new SessionsListTool(this.options.sessionManager));
+		this.registerTool(new SessionsHistoryTool(this.options.sessionManager));
+		this.registerTool(new MemorySearchTool(workspace));
+		this.registerTool(new MemoryGetTool(workspace));
+		const gatewayTool = new GatewayTool(this.options.gatewayController);
+		gatewayTool.setContext({ sessionKey: sessionId });
+		this.registerTool(gatewayTool);
 	};
-	deleteAutomation = (automationId) => {
-		throw new Error("AutomationManager.deleteAutomation is not implemented.");
+	registerMessagingTools = (context) => {
+		const { channel, chatId, metadata } = context;
+		const accountId = readMetadataAccountId(metadata, {});
+		const messageTool = new MessageTool((message) => this.options.bus.publishOutbound(message));
+		messageTool.setContext(channel, chatId, accountId ?? null);
+		this.registerTool(messageTool);
+		if (this.options.cronService) {
+			const cronTool = new CronTool(this.options.cronService);
+			cronTool.setContext(channel, chatId, accountId ?? null);
+			this.registerTool(cronTool);
+		}
+	};
+	registerExtensionTools = (context) => {
+		const extensionRegistry = this.options.getExtensionRegistry?.();
+		if (!extensionRegistry || extensionRegistry.tools.length === 0) return;
+		const seen = new Set(this.registry.toolNames);
+		for (const registration of extensionRegistry.tools) for (const alias of registration.names) {
+			if (seen.has(alias)) continue;
+			seen.add(alias);
+			this.registerTool(new ExtensionToolAdapter({
+				registration,
+				alias,
+				config: context.config,
+				workspaceDir: context.workspace,
+				contextProvider: () => this.currentExtensionToolContext,
+				diagnostics: extensionRegistry.diagnostics
+			}));
+		}
+	};
+	registerTool = (tool) => {
+		this.registry.register(tool);
+		this.tools.set(tool.name, new CoreToolNcpAdapter(tool, async (toolName, args) => this.registry.execute(toolName, toToolParams(args))));
+	};
+	registerAdditionalTools = (context) => {
+		const tools = this.options.getAdditionalTools?.(context) ?? [];
+		for (const tool of tools) {
+			if (this.tools.has(tool.name)) continue;
+			this.tools.set(tool.name, tool);
+		}
+	};
+	isToolAvailable = (name) => {
+		const coreTool = this.registry.get(name);
+		return coreTool ? coreTool.isAvailable() : true;
+	};
+};
+function resolveAgentHandoffDepth(metadata) {
+	const rawDepth = Number(metadata.agent_handoff_depth ?? 0);
+	if (!Number.isFinite(rawDepth) || rawDepth < 0) return 0;
+	return Math.trunc(rawDepth);
+}
+function readAccountIdForHints(metadata, sessionMetadata) {
+	return readMetadataAccountId(metadata, sessionMetadata);
+}
+//#endregion
+//#region src/features/native-runtime/services/nextclaw-ncp-context-builder.service.ts
+const TIME_HINT_TRIGGER_PATTERNS = [/\b(now|right now|current time|what time|today|tonight|tomorrow|yesterday|this morning|this afternoon|this evening|date)\b/i, /(现在|此刻|当前时间|现在几点|几点了|今天|今晚|今早|今晨|明天|昨天|日期)/];
+function isRecord$1(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeInputMetadata(input) {
+	const messageMetadata = input.messages.slice().reverse().find((message) => isRecord$1(message.metadata))?.metadata;
+	return {
+		...isRecord$1(messageMetadata) ? structuredClone(messageMetadata) : {},
+		...isRecord$1(input.metadata) ? structuredClone(input.metadata) : {}
+	};
+}
+const REQUESTED_SKILLS_METADATA_READER = new RequestedSkillsMetadataReader();
+function resolveRequestedToolNames(metadata) {
+	const rawValue = metadata.requested_tools ?? metadata.requestedTools;
+	if (!Array.isArray(rawValue)) return [];
+	return Array.from(new Set(rawValue.map((item) => normalizeString(item)).filter((item) => Boolean(item))));
+}
+function readRequestedAgentId(metadata) {
+	return normalizeString(metadata.agent_id)?.toLowerCase() ?? normalizeString(metadata.agentId)?.toLowerCase() ?? null;
+}
+function resolveAgentProfile(params) {
+	const { config, requestMetadata, storedAgentId } = params;
+	const { agents: { defaults }, search: searchConfig, tools: { restrictToWorkspace, exec: { timeout: execTimeoutSeconds } } } = config;
+	const defaultAgentId = resolveDefaultAgentProfileId(config);
+	const profile = findEffectiveAgentProfile(config, normalizeString(storedAgentId)?.toLowerCase() ?? readRequestedAgentId(requestMetadata) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
+	if (!profile) throw new Error(`default agent profile not found: ${defaultAgentId}`);
+	const contextTokens = profile.contextTokens ?? defaults.contextTokens;
+	return {
+		agentId: profile.id,
+		workspace: getWorkspacePath(profile.workspace ?? defaults.workspace),
+		model: profile.model ?? defaults.model,
+		contextTokens,
+		reservedContextTokens: ContextWindowBudgetService.resolveReservedContextTokens({
+			contextTokens,
+			configuredReservedContextTokens: profile.reservedContextTokens ?? defaults.reservedContextTokens
+		}),
+		restrictToWorkspace,
+		searchConfig,
+		execTimeoutSeconds
+	};
+}
+function shouldAppendTimeHint(content) {
+	const normalized = content.trim();
+	if (!normalized) return false;
+	return TIME_HINT_TRIGGER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function buildMinutePrecisionTimeHint(date) {
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	const hour = String(date.getHours()).padStart(2, "0");
+	const minute = String(date.getMinutes()).padStart(2, "0");
+	const offsetMinutes = -date.getTimezoneOffset();
+	const sign = offsetMinutes >= 0 ? "+" : "-";
+	const absMinutes = Math.abs(offsetMinutes);
+	return `${year}-${month}-${day} ${hour}:${minute} ${sign}${String(Math.floor(absMinutes / 60)).padStart(2, "0")}:${String(absMinutes % 60).padStart(2, "0")} (${Intl.DateTimeFormat().resolvedOptions().timeZone || "local"})`;
+}
+function appendTimeHintForPrompt(content, timestamp) {
+	if (!shouldAppendTimeHint(content)) return content;
+	return `${content}\n\n[time_hint_local_minute] ${buildMinutePrecisionTimeHint(Number.isNaN(timestamp.getTime()) ? /* @__PURE__ */ new Date() : timestamp)}`;
+}
+function prependRequestedSkills(content, requestedSkillSelectors) {
+	if (requestedSkillSelectors.length === 0) return content;
+	return `[Requested skills for this turn: ${requestedSkillSelectors.join(", ")}]\n\n${content}`;
+}
+function buildSessionOrchestrationSection() {
+	return [
+		"## Session Orchestration",
+		"- Before passing a non-default `runtime` to `sessions_spawn` or agent creation/update flows, inspect the installed runtime kinds with `nextclaw agents runtimes --json`.",
+		"- `sessions_spawn` is the unified session-creation tool. Omit `scope` or use `scope=\"standalone\"` for a regular session, and use `scope=\"child\"` when the new session should be a child session of the current flow.",
+		"- `sessions_spawn` only creates the session by default. Add `request: { notify: \"none\" | \"final_reply\" }` when the new session should start working immediately.",
+		"- When `sessions_spawn.scope=\"child\"` and `sessions_spawn.request.notify=\"final_reply\"`, the new child session starts right away and this session automatically continues after that child reaches its final reply.",
+		"- Use `sessions_spawn` without `request` when the user wants a separate thread created now but does not need it to start working yet.",
+		"- Use `sessions_request` to send one task to an existing session, including a session that was just created by `sessions_spawn` or a previously created child session.",
+		"- `sessions_request.target` must be an object shaped like `{ \"session_id\": \"<target-session-id>\" }`. Do not pass a bare string.",
+		"- Prefer `notify=\"final_reply\"` when the current session should continue after the target session produces its final reply. Use `notify=\"none\"` when you only want the target session to run independently."
+	].join("\n");
+}
+function buildRequestedOpenAiTools(toolDefinitions, requestedToolNames) {
+	const tools = toolDefinitions.map(buildOpenAiFunctionTool);
+	if (tools.length === 0) return;
+	if (requestedToolNames.length === 0) return tools;
+	const requested = new Set(requestedToolNames);
+	const filtered = tools.filter((tool) => requested.has(tool.function.name));
+	return filtered.length > 0 ? filtered : void 0;
+}
+var NextclawNcpContextBuilder = class {
+	inputBudgetPruner = new InputBudgetPruner();
+	constructor(options) {
+		this.options = options;
+	}
+	prepare = (input, _options) => {
+		const runContext = this.prepareRunContext(input);
+		const modelMessages = this.buildModelMessages(input, _options, runContext);
+		return {
+			messages: this.pruneModelMessages(runContext, modelMessages).messages,
+			tools: buildRequestedOpenAiTools(modelMessages.toolDefinitions, runContext.requestedToolNames),
+			model: runContext.effectiveModel,
+			thinkingLevel: runContext.runtimeThinking
+		};
+	};
+	prepareRunContext = (input) => {
+		const config = this.options.getConfig();
+		const requestMetadata = mergeInputMetadata(input);
+		const session = this.options.sessionManager.getOrCreate(input.sessionId);
+		const profile = resolveAgentProfile({
+			config,
+			storedAgentId: session.agentId,
+			requestMetadata
+		});
+		let effectiveModel = resolveEffectiveModel({
+			session,
+			requestMetadata,
+			fallbackModel: profile.model
+		});
+		const effectiveWorkspace = resolveSessionWorkspacePath({
+			sessionMetadata: session.metadata,
+			workspace: profile.workspace
+		});
+		syncSessionThinkingPreference({
+			session,
+			requestMetadata
+		});
+		const { channel, chatId } = resolveSessionChannelContext({
+			session,
+			requestMetadata
+		});
+		const requestedSkills = REQUESTED_SKILLS_METADATA_READER.readSelection(requestMetadata);
+		const currentTurn = buildCurrentTurnState({
+			input,
+			currentModel: effectiveModel,
+			formatPrompt: ({ text, timestamp }) => appendTimeHintForPrompt(prependRequestedSkills(text, requestedSkills.selectors), timestamp),
+			assetStore: this.options.assetStore
+		});
+		effectiveModel = currentTurn.effectiveModel;
+		const runtimeThinking = resolveThinkingLevel({
+			config,
+			agentId: profile.agentId,
+			model: effectiveModel,
+			sessionThinkingLevel: parseThinkingLevel(session.metadata.preferred_thinking) ?? null
+		});
+		this.options.toolRegistry.prepareForRun({
+			sessionId: input.sessionId,
+			channel,
+			chatId,
+			agentId: profile.agentId,
+			config,
+			contextTokens: profile.contextTokens,
+			execTimeoutSeconds: profile.execTimeoutSeconds,
+			handoffDepth: resolveAgentHandoffDepth(requestMetadata),
+			metadata: requestMetadata,
+			model: effectiveModel,
+			restrictToWorkspace: profile.restrictToWorkspace,
+			searchConfig: profile.searchConfig,
+			workspace: effectiveWorkspace
+		});
+		return {
+			accountId: readAccountIdForHints(requestMetadata, session.metadata),
+			channel,
+			chatId,
+			config,
+			currentTurn,
+			effectiveModel,
+			effectiveWorkspace,
+			profile,
+			requestMetadata,
+			requestedSkills,
+			requestedToolNames: resolveRequestedToolNames(requestMetadata),
+			runtimeThinking,
+			session,
+			sessionKey: input.sessionId
+		};
+	};
+	buildModelMessages = (input, _options, runContext) => {
+		const { accountId, channel, chatId, config, currentTurn, effectiveModel, effectiveWorkspace, profile, requestedSkills, runtimeThinking, session } = runContext;
+		const messageToolHints = this.options.resolveMessageToolHints?.({
+			sessionKey: input.sessionId,
+			channel,
+			chatId,
+			accountId: accountId ?? null
+		});
+		const toolDefinitions = this.options.toolRegistry.getToolDefinitions();
+		const additionalSystemSections = [buildSessionOrchestrationSection(), buildMinimalSystemExecutionPrompt(effectiveModel)].filter(Boolean);
+		const contextBuilder = new ContextBuilder(effectiveWorkspace, config.agents.context, {
+			hostWorkspace: profile.workspace,
+			sessionProjectRoot: readSessionProjectRoot(session.metadata)
+		});
+		const sessionMessages = projectNcpMessagesWithContextCompaction({
+			sessionId: input.sessionId,
+			sessionMessages: _options?.sessionMessages ?? []
+		});
+		const messages = contextBuilder.buildMessages({
+			history: toLegacyMessages([...sessionMessages], {
+				assetStore: this.options.assetStore,
+				serviceRole: "system"
+			}),
+			currentMessage: "",
+			channel,
+			chatId,
+			sessionKey: input.sessionId,
+			thinkingLevel: runtimeThinking,
+			skillNames: requestedSkills.selectors,
+			messageToolHints,
+			availableTools: buildToolCatalogEntries(toolDefinitions),
+			additionalSystemSections
+		});
+		messages[messages.length - 1] = {
+			role: currentTurn.currentRole,
+			content: currentTurn.currentUserContent
+		};
+		return {
+			messages,
+			toolDefinitions
+		};
+	};
+	pruneModelMessages = (runContext, modelMessages) => {
+		return this.inputBudgetPruner.prune({
+			messages: modelMessages.messages,
+			contextTokens: runContext.profile.contextTokens,
+			reserveTokensFloor: runContext.profile.reservedContextTokens,
+			softThresholdTokens: 0
+		});
 	};
 };
 //#endregion
-//#region src/managers/channel.manager.ts
-var ChannelManager = class {
-	listChannels = () => {
-		throw new Error("ChannelManager.listChannels is not implemented.");
+//#region src/features/native-runtime/services/provider-manager-ncp-llm-api.service.ts
+function normalizeModel(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeThinkingLevel(value) {
+	return parseThinkingLevel(value);
+}
+function normalizeFinishReason(value) {
+	if (typeof value !== "string") return "stop";
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : "stop";
+}
+function toToolCallDelta(toolCall, index) {
+	return {
+		index,
+		id: toolCall.id,
+		type: "function",
+		function: {
+			name: toolCall.name,
+			arguments: JSON.stringify(toolCall.arguments ?? {})
+		}
+	};
+}
+function toFinalChunk(response, options) {
+	const delta = {};
+	if (options.includeText && typeof response.content === "string" && response.content.length > 0) delta.content = response.content;
+	if (options.includeReasoning && typeof response.reasoningContent === "string" && response.reasoningContent.length > 0) delta.reasoning_content = response.reasoningContent;
+	if (options.includeToolCalls && response.toolCalls.length > 0) delta.tool_calls = response.toolCalls.map((toolCall, index) => toToolCallDelta(toolCall, index));
+	return {
+		choices: [{
+			delta,
+			finish_reason: normalizeFinishReason(response.finishReason)
+		}],
+		usage: response.usage
+	};
+}
+var ProviderManagerNcpLLMApi = class {
+	constructor(providerManager) {
+		this.providerManager = providerManager;
+	}
+	generate = async function* (input, options) {
+		const model = normalizeModel(input.model) ?? this.providerManager.get(null).getDefaultModel();
+		const thinkingLevel = normalizeThinkingLevel(input.thinkingLevel);
+		let sawTextDelta = false;
+		let sawReasoningDelta = false;
+		let sawToolCallDelta = false;
+		for await (const event of this.providerManager.chatStream({
+			messages: input.messages,
+			tools: input.tools,
+			model,
+			...thinkingLevel ? { thinkingLevel } : {},
+			maxTokens: input.max_tokens,
+			signal: options?.signal
+		})) {
+			if (event.type === "delta") {
+				sawTextDelta = true;
+				yield { choices: [{ delta: { content: event.delta } }] };
+				continue;
+			}
+			if (event.type === "reasoning_delta") {
+				sawReasoningDelta = true;
+				yield { choices: [{ delta: { reasoning_content: event.delta } }] };
+				continue;
+			}
+			if (event.type === "tool_call_delta") {
+				sawToolCallDelta = true;
+				yield { choices: [{ delta: { tool_calls: event.toolCalls } }] };
+				continue;
+			}
+			yield toFinalChunk(event.response, {
+				includeText: !sawTextDelta,
+				includeReasoning: !sawReasoningDelta,
+				includeToolCalls: !sawToolCallDelta
+			});
+		}
 	};
-	getChannel = (channelId) => {
-		throw new Error("ChannelManager.getChannel is not implemented.");
+};
+//#endregion
+//#region src/features/native-runtime/services/native-agent-runtime-factory.service.ts
+function createContextWindowUpdatedEvent(params) {
+	return {
+		type: NcpEventType.ContextWindowUpdated,
+		payload: {
+			sessionId: params.sessionId,
+			contextWindow: params.contextWindow
+		}
 	};
-	requireChannel = (channelId) => {
-		throw new Error("ChannelManager.requireChannel is not implemented.");
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveNativeReasoningNormalizationMode(params) {
+	const runtimeEntry = params.config.agents.runtimes.entries.native?.config ?? params.config.ui.ncp.runtimes.native;
+	const runtimeMetadata = isRecord(runtimeEntry) ? runtimeEntry : {};
+	return readAssistantReasoningNormalizationModeFromMetadata(params.sessionMetadata) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalizationMode) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization_mode) ?? "think-tags";
+}
+function createSessionSearchTools(params) {
+	const { currentSessionId, sessionSearch } = params;
+	return sessionSearch.isReady() ? [new SessionSearchTool({ search: sessionSearch.search }, { currentSessionId })] : [];
+}
+async function* publishPreflightResult(params) {
+	const { input, result, stateManager } = params;
+	const contextWindowEvent = createContextWindowUpdatedEvent({
+		contextWindow: result.contextWindow,
+		sessionId: input.sessionId
+	});
+	await stateManager.dispatch(contextWindowEvent);
+	yield contextWindowEvent;
+	if (!result.timelineMessage) return;
+	const activeRun = stateManager.getSnapshot().activeRun;
+	stateManager.hydrate({
+		sessionId: input.sessionId,
+		messages: result.sessionMessages,
+		activeRun,
+		contextWindow: result.contextWindow
+	});
+	const timelineEvent = {
+		type: NcpEventType.MessageSent,
+		payload: {
+			sessionId: input.sessionId,
+			message: result.timelineMessage
+		}
 	};
-	saveChannel = (channel) => {
-		throw new Error("ChannelManager.saveChannel is not implemented.");
+	await stateManager.dispatch(timelineEvent);
+	yield timelineEvent;
+}
+var NativeAgentRuntimeFactory = class {
+	observedProviderManager;
+	constructor(options) {
+		this.options = options;
+		this.observedProviderManager = options.llmUsage.observeProviderManager(options.providerManager, "ui-ncp");
+	}
+	create = ({ stateManager, sessionMetadata, setSessionMetadata }) => {
+		const reasoningNormalizationMode = resolveNativeReasoningNormalizationMode({
+			config: this.options.configManager.loadConfig(),
+			sessionMetadata
+		});
+		if (reasoningNormalizationMode !== "off" && readAssistantReasoningNormalizationModeFromMetadata(sessionMetadata) !== reasoningNormalizationMode) setSessionMetadata(writeAssistantReasoningNormalizationModeToMetadata(sessionMetadata, reasoningNormalizationMode));
+		const toolRegistry = this.createToolRegistry(this.observedProviderManager);
+		const runtime = new DefaultNcpAgentRuntime({
+			contextBuilder: new NextclawNcpContextBuilder({
+				sessionManager: this.options.sessions,
+				toolRegistry,
+				getConfig: this.options.configManager.loadConfig,
+				resolveMessageToolHints: ({ channel, accountId }) => this.options.extensions.resolveMessageToolHints({
+					channel,
+					config: this.options.configManager.loadConfig(),
+					accountId
+				}),
+				assetStore: this.options.assetStore
+			}),
+			llmApi: new ProviderManagerNcpLLMApi(this.observedProviderManager),
+			toolRegistry,
+			stateManager,
+			reasoningNormalizationMode
+		});
+		const contextCompactionPreflight = new ContextCompactionPreflightService({
+			getConfig: this.options.configManager.loadConfig,
+			providerManager: this.observedProviderManager,
+			sessionManager: this.options.sessions
+		});
+		const { onSessionUpdated } = this.options;
+		return { run: async function* (input, options) {
+			const beginResult = contextCompactionPreflight.begin({
+				contextWindowOwner: "nextclaw",
+				inputMessages: input.messages,
+				requestMetadata: input.metadata ?? {},
+				sessionId: input.sessionId,
+				sessionMessages: stateManager.getSnapshot().messages
+			});
+			if (beginResult) {
+				setSessionMetadata(beginResult.metadata);
+				onSessionUpdated(input.sessionId);
+				yield* publishPreflightResult({
+					input,
+					result: beginResult,
+					stateManager
+				});
+				if (beginResult.pendingCompaction) {
+					const finishResult = await contextCompactionPreflight.finish(beginResult.pendingCompaction);
+					setSessionMetadata(finishResult.metadata);
+					onSessionUpdated(input.sessionId);
+					yield* publishPreflightResult({
+						input,
+						result: finishResult,
+						stateManager
+					});
+				}
+			}
+			yield* runtime.run(input, options);
+		} };
 	};
-	enableChannel = (channelId) => {
-		throw new Error("ChannelManager.enableChannel is not implemented.");
+	resolveOpenAiToolsForRuntime = (input) => {
+		return new NextclawNcpContextBuilder({
+			sessionManager: this.options.sessions,
+			toolRegistry: this.createToolRegistry(this.options.providerManager),
+			getConfig: this.options.configManager.loadConfig,
+			resolveMessageToolHints: ({ channel, accountId }) => this.options.extensions.resolveMessageToolHints({
+				channel,
+				config: this.options.configManager.loadConfig(),
+				accountId
+			}),
+			assetStore: this.options.assetStore
+		}).prepare(input).tools;
 	};
-	disableChannel = (channelId) => {
-		throw new Error("ChannelManager.disableChannel is not implemented.");
+	createToolRegistry = (providerManager) => {
+		return new NextclawNcpToolRegistry({
+			bus: this.options.bus,
+			providerManager,
+			sessionManager: this.options.sessions,
+			cronService: this.options.cronService,
+			gatewayController: this.options.resolveGatewayController(),
+			getConfig: this.options.configManager.loadConfig,
+			getExtensionRegistry: this.options.extensions.getExtensionRegistry,
+			onSessionUpdated: this.options.onSessionUpdated,
+			sessionRequestManager: this.options.sessionRequests,
+			updateToolCallResult: this.options.updateToolCallResult,
+			getAdditionalTools: (context) => [
+				...createAssetTools({ assetStore: this.options.assetStore }),
+				...this.options.mcpToolRegistryAdapter.listToolsForRun({ agentId: context.agentId }),
+				...createSessionSearchTools({
+					sessionSearch: this.options.sessionSearch,
+					currentSessionId: context.sessionId
+				})
+			]
+		});
 	};
 };
 //#endregion
-//#region src/managers/context-builder.manager.ts
-var ContextBuilder = class {
-	constructor(sessions) {
-		this.sessions = sessions;
+//#region src/features/mcp-runtime-support/services/mcp-runtime-support.service.ts
+var McpRuntimeSupportOwner = class {
+	currentMcpConfig;
+	mcpLifecycleManager;
+	mcpRegistryService;
+	toolRegistryAdapter;
+	constructor(getConfig) {
+		this.currentMcpConfig = getConfig();
+		this.mcpLifecycleManager = new McpServerLifecycleManager({ getConfig: () => this.currentMcpConfig });
+		this.mcpRegistryService = new McpRegistryService({
+			getConfig: () => this.currentMcpConfig,
+			lifecycleManager: this.mcpLifecycleManager
+		});
+		this.toolRegistryAdapter = new McpNcpToolRegistryAdapter(this.mcpRegistryService);
 	}
-	build = (input) => {
-		this.sessions;
-		throw new Error("ContextBuilder.build is not implemented.");
+	applyMcpConfig = async (config) => {
+		const previousConfig = this.currentMcpConfig;
+		this.currentMcpConfig = config;
+		const reconcileResult = await this.mcpRegistryService.reconcileConfig({
+			prevConfig: previousConfig,
+			nextConfig: config
+		});
+		for (const warmResult of reconcileResult.warmed) if (!warmResult.ok) console.warn(`[mcp] Failed to warm ${warmResult.name}: ${warmResult.error}`);
+	};
+	prewarmEnabledServers = async () => await this.mcpRegistryService.prewarmEnabledServers();
+	dispose = async () => {
+		await this.mcpRegistryService.close();
 	};
 };
 //#endregion
-//#region src/managers/llm-provider.manager.ts
-var LlmProviderManager = class {
-	listProviders = () => {
-		throw new Error("LlmProviderManager.listProviders is not implemented.");
+//#region src/features/session-request/utils/agent-runtime-session-request-dispatcher.utils.ts
+const AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE = createTypedKey("agent-runtime.session-message.request");
+function extractSessionMessageText(message) {
+	const parts = message.parts.flatMap((part) => part.type === "text" || part.type === "rich-text" ? [part.text] : []).map((part) => part.trim()).filter((part) => part.length > 0);
+	return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function waitForAgentRuntimeSessionReply(input) {
+	let acceptedMessageId = null;
+	let unsubscribe = () => void 0;
+	const promise = new Promise((resolve, reject) => {
+		unsubscribe = input.eventBus.on(eventKeys.ncpEvent, (event) => {
+			switch (event.type) {
+				case NcpEventType.MessageAccepted:
+					if (event.payload.correlationId === input.requestId) {
+						acceptedMessageId = event.payload.messageId;
+						input.onAccepted(event.payload.messageId);
+					}
+					return;
+				case NcpEventType.MessageCompleted:
+					if (event.payload.correlationId === input.requestId || event.payload.message.id === acceptedMessageId) {
+						unsubscribe();
+						resolve(event.payload.message);
+					}
+					return;
+				case NcpEventType.MessageFailed:
+					if (event.payload.correlationId === input.requestId || event.payload.messageId === acceptedMessageId) {
+						unsubscribe();
+						reject(new Error(event.payload.error.message));
+					}
+					return;
+				case NcpEventType.RunError:
+					if (event.payload.messageId === acceptedMessageId) {
+						unsubscribe();
+						reject(new Error(event.payload.error ?? "Session request failed."));
+					}
+					return;
+			}
+		});
+	});
+	return {
+		dispose: unsubscribe,
+		promise
+	};
+}
+async function dispatchAgentRuntimeSessionRequest(input) {
+	await input.ingress.handle({
+		type: AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE,
+		payload: {
+			message: {
+				id: `${input.request.targetSessionId}:user:session-request:${input.request.requestId}`,
+				sessionId: input.request.targetSessionId,
+				role: "user",
+				status: "final",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				parts: [{
+					type: "text",
+					text: input.task
+				}],
+				metadata: { session_request_id: input.request.requestId }
+			},
+			requestId: input.request.requestId,
+			sessionId: input.request.targetSessionId
+		}
+	}, { source: "session-request" });
+}
+function createAgentRuntimeSessionRequestDispatcher(options) {
+	return { dispatch: async (input) => {
+		const reply = waitForAgentRuntimeSessionReply({
+			eventBus: options.eventBus,
+			onAccepted: input.onAccepted,
+			requestId: input.request.requestId
+		});
+		try {
+			await dispatchAgentRuntimeSessionRequest({
+				ingress: options.ingress,
+				request: input.request,
+				task: input.task
+			});
+			const message = await reply.promise;
+			return {
+				finalResponseMessageId: message.id,
+				finalResponseText: extractSessionMessageText(message)
+			};
+		} catch (error) {
+			reply.dispose();
+			throw error;
+		}
+	} };
+}
+//#endregion
+//#region src/managers/agent-runtime.manager.ts
+var AgentRuntimeManager = class {
+	runtimeRegistry = new AgentRuntimeRegistry();
+	mcpRuntimeSupport;
+	assetStore = new LocalAssetStore({ rootDir: join(getDataDir(), "assets") });
+	pluginRuntimeRegistrationController;
+	refreshConfiguredRuntimeEntries = () => {
+		this.runtimeRegistry.applyEntries(resolveAgentRuntimeEntries({
+			config: this.params.configManager.loadConfig(),
+			providerKinds: this.runtimeRegistry.listProviderKinds()
+		}));
+	};
+	backend = null;
+	handle = null;
+	builtinNarpRegistrations = [];
+	kernelBootstrapped = false;
+	warmupPromise = null;
+	unsubscribeNcpEvents = null;
+	unsubscribeAgentRuntimeRequestIngress = null;
+	gatewayController;
+	disposed = false;
+	constructor(params) {
+		this.params = params;
+		this.mcpRuntimeSupport = new McpRuntimeSupportOwner(params.configManager.loadConfig);
+		this.pluginRuntimeRegistrationController = new PluginRuntimeRegistrationController(this.runtimeRegistry, params.extensions);
+	}
+	get currentHandle() {
+		return this.handle;
+	}
+	connectGatewayController = (gatewayController) => {
+		this.assertNotDisposed();
+		this.gatewayController = gatewayController;
+	};
+	bootstrap = async () => {
+		this.assertNotDisposed();
+		if (this.handle) return this.handle;
+		const nativeRuntimeFactory = new NativeAgentRuntimeFactory({
+			bus: this.params.bus,
+			providerManager: this.params.providerManager,
+			sessions: this.params.sessions,
+			sessionRequests: this.params.sessionRequests,
+			sessionSearch: this.params.sessionSearch,
+			cronService: this.params.cronService,
+			configManager: this.params.configManager,
+			extensions: this.params.extensions,
+			llmUsage: this.params.llmUsage,
+			onSessionUpdated: this.params.onSessionUpdated,
+			resolveGatewayController: () => this.gatewayController,
+			mcpToolRegistryAdapter: this.mcpRuntimeSupport.toolRegistryAdapter,
+			assetStore: this.assetStore,
+			updateToolCallResult: this.updateToolCallResult
+		});
+		this.registerCoreRuntimes(nativeRuntimeFactory);
+		const contextWindowPreview = new ContextCompactionPreflightService({
+			getConfig: this.params.configManager.loadConfig,
+			sessionManager: this.params.sessions
+		});
+		this.backend = new DefaultNcpAgentBackend({
+			endpointId: "nextclaw-ui-agent",
+			sessionStore: this.params.ncpAgentSessionStore,
+			onSessionRunStatusChanged: this.publishSessionRunStatus,
+			resolveSessionContextWindow: ({ messages, metadata, sessionId }) => contextWindowPreview.preview({
+				contextWindowOwner: "nextclaw",
+				requestMetadata: metadata,
+				sessionId,
+				sessionMessages: messages
+			}),
+			createRuntime: (runtimeParams) => {
+				this.pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
+				this.refreshConfiguredRuntimeEntries();
+				return this.runtimeRegistry.createRuntime({
+					...runtimeParams,
+					resolveAssetContentPath: (assetUri) => this.assetStore.resolveContentPath(assetUri),
+					resolveTools: nativeRuntimeFactory.resolveOpenAiToolsForRuntime
+				});
+			}
+		});
+		this.unsubscribeAgentRuntimeRequestIngress = this.params.ingress.addHandler(AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, this.handleSessionMessageRequest);
+		this.unsubscribeNcpEvents = this.backend.subscribe(this.publishNcpEvent);
+		await this.backend.start();
+		this.handle = createAgentRuntimeHandle({
+			backend: this.backend,
+			runtimeRegistry: this.runtimeRegistry,
+			refreshPluginRuntimeRegistrations: this.pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations,
+			refreshConfiguredRuntimeEntries: this.refreshConfiguredRuntimeEntries,
+			applyMcpConfig: this.mcpRuntimeSupport.applyMcpConfig,
+			dispose: this.dispose,
+			assetStore: this.assetStore
+		});
+		return this.handle;
+	};
+	warmDerivedCapabilities = async () => {
+		this.assertNotDisposed();
+		this.warmupPromise ??= this.runDerivedCapabilityWarmup();
+		await this.warmupPromise;
+	};
+	dispose = async () => {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.warmupPromise?.catch(() => void 0);
+		this.unsubscribeAgentRuntimeRequestIngress?.();
+		this.unsubscribeAgentRuntimeRequestIngress = null;
+		this.unsubscribeNcpEvents?.();
+		this.unsubscribeNcpEvents = null;
+		for (const registration of this.builtinNarpRegistrations) registration.dispose();
+		this.pluginRuntimeRegistrationController.dispose();
+		await this.backend?.stop();
+		await this.mcpRuntimeSupport.dispose();
+	};
+	registerCoreRuntimes = (nativeRuntimeFactory) => {
+		if (this.kernelBootstrapped) return;
+		this.kernelBootstrapped = true;
+		this.runtimeRegistry.register({
+			kind: "native",
+			label: "Native",
+			createRuntime: nativeRuntimeFactory.create
+		});
+		this.builtinNarpRegistrations = new BuiltinNarpRuntimeRegistrationService(this.params.configManager.loadConfig).registerInto(this.runtimeRegistry);
+		this.pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
+		this.refreshConfiguredRuntimeEntries();
+	};
+	runDerivedCapabilityWarmup = async () => {
+		const mcpWarmResults = await this.mcpRuntimeSupport.prewarmEnabledServers();
+		for (const result of mcpWarmResults) if (!result.ok) console.warn(`[mcp] Failed to warm ${result.name}: ${result.error}`);
+	};
+	publishSessionRunStatus = (payload) => {
+		this.params.eventBus.emit(eventKeys.sessionRunStatus, payload, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+	};
+	publishNcpEvent = (event) => {
+		this.params.eventBus.emit(eventKeys.ncpEvent, event, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+		this.params.handleNcpEvent(event);
+	};
+	handleSessionMessageRequest = async (envelope) => {
+		const backend = this.backend;
+		if (!backend) throw new Error("NCP backend is not ready for agent runtime requests.");
+		const request = envelope.payload;
+		if (!request?.requestId || !request.sessionId || !request.message) throw new Error("Invalid agent runtime session message request.");
+		let terminalEventSeen = false;
+		for await (const event of backend.send({
+			sessionId: request.sessionId,
+			message: request.message,
+			correlationId: request.requestId
+		})) terminalEventSeen ||= event.type === NcpEventType.MessageCompleted || event.type === NcpEventType.MessageFailed || event.type === NcpEventType.RunError;
+		if (!terminalEventSeen) throw new Error("Session request completed without a final reply.");
+	};
+	updateToolCallResult = async ({ sessionId, toolCallId, result }) => {
+		const backend = this.backend;
+		if (!backend) throw new Error("NCP backend is not ready for tool result updates.");
+		await backend.updateToolCallResult(sessionId, toolCallId, result);
+	};
+	assertNotDisposed = () => {
+		if (this.disposed) throw new Error("Agent runtime has already been disposed.");
+	};
+};
+//#endregion
+//#region src/managers/automation.manager.ts
+var AutomationManager = class extends CronService {
+	constructor(options) {
+		super(options.storePath);
+	}
+};
+//#endregion
+//#region src/managers/config.manager.ts
+var ConfigManager = class {
+	configPath;
+	currentConfig;
+	hooks = {};
+	reloadTask = null;
+	providerReloadTask = null;
+	reloadTimer = null;
+	reloadRunning = false;
+	reloadPending = false;
+	constructor(options) {
+		this.options = options;
+		this.configPath = options.configPath ?? getConfigPath();
+		this.currentConfig = this.loadConfig();
+		this.options.providerManager.load(this.currentConfig);
+		this.options.channels.load({
+			channelConfig: this.resolveChannelConfig(this.currentConfig),
+			extensionChannels: this.resolveExtensionChannels()
+		});
+	}
+	get config() {
+		return this.currentConfig;
+	}
+	loadConfig = () => resolveConfigSecrets(loadConfig(this.configPath), { configPath: this.configPath });
+	installRuntimeHooks = (hooks) => {
+		this.hooks = hooks;
+	};
+	applyLiveConfigReload = async () => {
+		await this.applyReloadPlan(this.loadConfig());
+	};
+	applyReloadPlan = async (nextConfig) => {
+		const changedPaths = diffConfigPaths(this.currentConfig, nextConfig);
+		if (!changedPaths.length) return;
+		this.currentConfig = nextConfig;
+		const plan = buildReloadPlan(changedPaths);
+		let reloadPluginsResult = void 0;
+		if (plan.reloadPlugins) {
+			reloadPluginsResult = await this.reloadPlugins({
+				config: nextConfig,
+				changedPaths
+			});
+			console.log("Config reload: plugins reloaded.");
+		}
+		if (plan.reloadMcp) {
+			await this.reloadMcp({
+				config: nextConfig,
+				changedPaths
+			});
+			console.log("Config reload: MCP servers reloaded.");
+		}
+		if (plan.reloadCompanion) {
+			await this.reloadCompanion({
+				config: nextConfig,
+				changedPaths
+			});
+			console.log("Config reload: companion setting applied.");
+		}
+		if (plan.restartChannels || reloadPluginsResult?.restartChannels) {
+			await this.rebuildChannels(nextConfig, { start: true });
+			console.log("Config reload: channels restarted.");
+		}
+		if (plan.reloadProviders) {
+			await this.reloadProvider(nextConfig);
+			console.log("Config reload: provider settings applied.");
+		}
+		if (plan.reloadAgent) {
+			this.hooks.applyAgentRuntimeConfig?.(nextConfig);
+			console.log("Config reload: agent defaults applied.");
+		}
+		if (plan.restartRequired.length > 0) this.hooks.onRestartRequired?.(plan.restartRequired);
+	};
+	scheduleReload = (reason) => {
+		if (this.reloadTimer) clearTimeout(this.reloadTimer);
+		this.reloadTimer = setTimeout(() => {
+			this.runReload(reason);
+		}, 300);
+	};
+	runReload = async (reason) => {
+		if (this.reloadRunning) {
+			this.reloadPending = true;
+			return;
+		}
+		this.reloadRunning = true;
+		if (this.reloadTimer) {
+			clearTimeout(this.reloadTimer);
+			this.reloadTimer = null;
+		}
+		try {
+			await this.applyLiveConfigReload();
+		} catch (error) {
+			console.error(`Config reload failed (${reason}): ${String(error)}`);
+		} finally {
+			this.reloadRunning = false;
+			if (this.reloadPending) {
+				this.reloadPending = false;
+				this.scheduleReload("pending");
+			}
+		}
+	};
+	reloadConfig = async (reason) => {
+		await this.runReload(reason ?? "gateway tool");
+		return "Config reload triggered";
+	};
+	rebuildChannels = async (nextConfig, options = {}) => {
+		if (this.reloadTask) {
+			await this.reloadTask;
+			return;
+		}
+		this.reloadTask = (async () => {
+			await this.options.channels.reload({
+				channelConfig: this.resolveChannelConfig(nextConfig),
+				extensionChannels: this.resolveExtensionChannels(),
+				start: options.start ?? true
+			});
+		})();
+		try {
+			await this.reloadTask;
+		} finally {
+			this.reloadTask = null;
+		}
+	};
+	resolveChannelConfig = (config) => this.hooks.resolveChannelConfig?.(config) ?? config;
+	resolveExtensionChannels = () => this.hooks.getExtensionChannels?.() ?? [];
+	reloadProvider = async (nextConfig) => {
+		if (this.providerReloadTask) {
+			await this.providerReloadTask;
+			return;
+		}
+		this.providerReloadTask = (async () => {
+			this.options.providerManager.load(nextConfig);
+		})();
+		try {
+			await this.providerReloadTask;
+		} finally {
+			this.providerReloadTask = null;
+		}
+	};
+	reloadPlugins = async (params) => {
+		return await this.hooks.reloadPlugins?.(params);
+	};
+	reloadMcp = async (params) => {
+		await this.hooks.reloadMcp?.(params);
+	};
+	reloadCompanion = async (params) => {
+		await this.hooks.reloadCompanion?.(params);
+	};
+};
+//#endregion
+//#region src/managers/extension.manager.ts
+function createEmptyExtensionRegistry() {
+	return {
+		tools: [],
+		channels: [],
+		ncpAgentRuntimes: [],
+		diagnostics: []
+	};
+}
+var ExtensionManager = class {
+	pluginRegistry = null;
+	extensionRegistry = createEmptyExtensionRegistry();
+	channelBindings = [];
+	uiMetadata = [];
+	loadContributions = (contributions) => {
+		this.pluginRegistry = contributions.registry;
+		this.extensionRegistry = contributions.extensionRegistry;
+		this.channelBindings = contributions.channelBindings ?? getPluginChannelBindings(contributions.registry);
+		this.uiMetadata = contributions.uiMetadata ?? getPluginUiMetadataFromRegistry(contributions.registry);
+	};
+	loadExtensionRegistry = (extensionRegistry) => {
+		this.extensionRegistry = extensionRegistry;
 	};
-	getProvider = (providerId) => {
-		throw new Error("LlmProviderManager.getProvider is not implemented.");
+	getExtensionRegistry = () => this.extensionRegistry;
+	getChannelBindings = () => this.channelBindings;
+	getUiMetadata = () => this.uiMetadata;
+	toConfigView = (config) => toPluginConfigView(config, this.channelBindings);
+	mergeConfigView = (current, nextConfigView) => mergePluginConfigView(current, nextConfigView, this.channelBindings);
+	resolveMessageToolHints = (params) => {
+		if (!this.pluginRegistry) return [];
+		return resolvePluginChannelMessageToolHints({
+			registry: this.pluginRegistry,
+			channel: params.channel,
+			cfg: params.config,
+			accountId: params.accountId
+		});
 	};
-	requireProvider = (providerId) => {
-		throw new Error("LlmProviderManager.requireProvider is not implemented.");
+};
+//#endregion
+//#region src/configs/ncp-lifecycle-event.config.ts
+const agentRunStartedLifecycleEventKey = createAppEventKey("agent.run.started");
+const agentRunFinishedLifecycleEventKey = createAppEventKey("agent.run.finished");
+const agentMessageSentLifecycleEventKey = createAppEventKey("agent.message.sent");
+const agentSessionUpdatedLifecycleEventKey = createAppEventKey("agent.session.updated");
+//#endregion
+//#region src/configs/learning-loop.config.ts
+const LEARNING_LOOP_DISABLED_METADATA_KEY = "learning_loop_disabled";
+const LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY = "learning_loop_last_tool_call_count";
+const LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY = "learning_loop_last_requested_at";
+const LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY = "learning_loop_last_review_session_id";
+const LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY = "learning_loop_source_session_id";
+const LEARNING_LOOP_REQUESTED_SKILLS = ["skill-creator"];
+const DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD = 15;
+function readLearningLoopRuntimeConfig(config) {
+	return {
+		enabled: config.agents.learningLoop.enabled,
+		toolCallThreshold: config.agents.learningLoop.toolCallThreshold ?? 15
+	};
+}
+//#endregion
+//#region src/utils/learning-loop-prompt.utils.ts
+function pluralizeToolCalls(value) {
+	return value === 1 ? "1 tool call" : `${value} tool calls`;
+}
+function buildLearningLoopTask(params) {
+	return [
+		"Run a background learning-loop review for the parent session.",
+		`Parent session id: ${params.sessionId}.`,
+		`There have been ${pluralizeToolCalls(params.toolCallsSinceReview)} since the last learning-loop review (${params.currentToolCallCount} total so far).`,
+		"",
+		"Your job is to extract only the reusable lesson.",
+		"- Review the parent session history and, if helpful, use session_search to compare similar historical sessions.",
+		"- Decide exactly one outcome: no_skill_change, patch_existing_skill, or create_new_skill.",
+		"- Prefer patching an existing skill when the lesson extends an existing workflow.",
+		"- Only create a new skill when the lesson is clearly reusable, repeatable, and likely to recur.",
+		"- Do not create or patch a skill for one-off quirks, noisy transcripts, or narrow local accidents.",
+		"",
+		"If you decide to patch or create a skill:",
+		"- Use the available file tools.",
+		"- Keep the change minimal and maintainable.",
+		"- Write the skill into the current workspace/project skills directory under skills/<slug>/SKILL.md.",
+		"- Follow the built-in skill-creator guidance when it helps.",
+		"",
+		"If nothing reusable should be saved, stop without writing files."
+	].join("\n");
+}
+//#endregion
+//#region src/managers/learning-loop.manager.ts
+function countToolCallsFromMessage(message) {
+	if (Array.isArray(message.tool_calls)) return message.tool_calls.filter((toolCall) => Boolean(toolCall) && typeof toolCall === "object" && !Array.isArray(toolCall)).length;
+	if (!Array.isArray(message.ncp_parts)) return 0;
+	const seenIds = /* @__PURE__ */ new Set();
+	let anonymousCount = 0;
+	for (const part of message.ncp_parts) {
+		if (!part || typeof part !== "object" || Array.isArray(part)) continue;
+		const candidate = part;
+		if (candidate.type !== "tool-invocation") continue;
+		if (typeof candidate.toolCallId === "string" && candidate.toolCallId.trim()) {
+			seenIds.add(candidate.toolCallId.trim());
+			continue;
+		}
+		anonymousCount += 1;
+	}
+	return seenIds.size + anonymousCount;
+}
+function countSessionToolCalls(session) {
+	return session.messages.reduce((count, message) => count + countToolCallsFromMessage(message), 0);
+}
+function readSessionLabel(metadata) {
+	const label = metadata.label;
+	return typeof label === "string" && label.trim().length > 0 ? label.trim() : void 0;
+}
+function isLearningLoopDisabled(metadata) {
+	return metadata[LEARNING_LOOP_DISABLED_METADATA_KEY] === true;
+}
+function readLearningLoopLastToolCallCount(metadata) {
+	const value = metadata[LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY];
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+var LearningLoopManager = class {
+	sessionStore;
+	inFlightSessionIds = /* @__PURE__ */ new Set();
+	unsubscribe = null;
+	constructor(options) {
+		this.options = options;
+		this.sessionStore = options.sessionManager;
+	}
+	start = () => {
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.options.eventBus.on(agentRunFinishedLifecycleEventKey, this.handleRunFinished);
+	};
+	dispose = () => {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
 	};
-	saveProvider = (provider) => {
-		throw new Error("LlmProviderManager.saveProvider is not implemented.");
+	handleRunFinished = (event) => {
+		this.handleRunFinishedInBackground(event).catch((error) => {
+			console.warn(`[learning-loop] Failed for ${event.sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+		});
 	};
-	enableProvider = (providerId) => {
-		throw new Error("LlmProviderManager.enableProvider is not implemented.");
+	handleRunFinishedInBackground = async (event) => {
+		if (event.isChildSession || this.inFlightSessionIds.has(event.sessionId)) return;
+		const session = this.sessionStore.getIfExists(event.sessionId);
+		if (!session) return;
+		const runtimeConfig = this.readRuntimeConfig();
+		if (!runtimeConfig.enabled || isLearningLoopDisabled(session.metadata)) return;
+		const totalToolCalls = countSessionToolCalls(session);
+		const toolCallsSinceReview = totalToolCalls - readLearningLoopLastToolCallCount(session.metadata);
+		if (toolCallsSinceReview < runtimeConfig.toolCallThreshold) return;
+		this.inFlightSessionIds.add(event.sessionId);
+		try {
+			const reviewSession = await this.options.sessionRequester.spawnSessionAndRequest({
+				sourceSessionId: event.sessionId,
+				updateToolCallResult: async () => void 0,
+				sourceSessionMetadata: session.metadata,
+				metadataOverrides: {
+					requested_skills: LEARNING_LOOP_REQUESTED_SKILLS,
+					[LEARNING_LOOP_DISABLED_METADATA_KEY]: true,
+					[LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY]: event.sessionId
+				},
+				parentSessionId: event.sessionId,
+				notify: "none",
+				title: this.buildReviewTitle(session.metadata),
+				task: buildLearningLoopTask({
+					sessionId: event.sessionId,
+					toolCallsSinceReview,
+					currentToolCallCount: totalToolCalls
+				})
+			});
+			session.metadata = {
+				...session.metadata,
+				[LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY]: totalToolCalls,
+				[LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY]: (/* @__PURE__ */ new Date()).toISOString(),
+				[LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY]: reviewSession.sessionId
+			};
+			this.sessionStore.save(session);
+		} finally {
+			this.inFlightSessionIds.delete(event.sessionId);
+		}
 	};
-	disableProvider = (providerId) => {
-		throw new Error("LlmProviderManager.disableProvider is not implemented.");
+	readRuntimeConfig = () => {
+		return this.options.resolveLearningLoopConfig?.() ?? {
+			enabled: true,
+			toolCallThreshold: 15
+		};
 	};
-	selectProvider = (input) => {
-		throw new Error("LlmProviderManager.selectProvider is not implemented.");
+	buildReviewTitle = (metadata) => {
+		const label = readSessionLabel(metadata);
+		return label ? `Learning loop: ${label}` : "Learning loop";
 	};
 };
 //#endregion
-//#region src/managers/session.manager.ts
-var SessionManager = class {
-	listSessions = () => {
-		throw new Error("SessionManager.listSessions is not implemented.");
+//#region src/managers/llm-provider.manager.ts
+const normalizedModel = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+};
+const headersFingerprint = (headers) => {
+	if (!headers) return "";
+	const sortedEntries = Object.entries(headers).sort(([left], [right]) => left.localeCompare(right));
+	return JSON.stringify(sortedEntries);
+};
+var MissingKernelProvider = class extends LLMProvider {
+	constructor(defaultModel) {
+		super(null, null);
+		this.defaultModel = defaultModel;
+	}
+	setDefaultModel = (model) => {
+		this.defaultModel = model;
+	};
+	getDefaultModel = () => {
+		return this.defaultModel;
+	};
+	chat = async (_params) => {
+		throw new Error("No API key configured yet. Configure provider credentials in UI and retry.");
+	};
+};
+var LlmProviderManager = class {
+	providerRegistry;
+	providerPool = /* @__PURE__ */ new Map();
+	missingProvider = new MissingKernelProvider("gpt-4o");
+	config = null;
+	constructor() {
+		this.providerRegistry = new ProviderRegistry(BUILTIN_PROVIDER_PLUGINS);
+	}
+	load = (config) => {
+		this.config = config;
+		this.providerPool.clear();
+		this.missingProvider.setDefaultModel(config.agents.defaults.model);
 	};
-	getSession = (sessionId) => {
-		throw new Error("SessionManager.getSession is not implemented.");
+	get = (model) => {
+		const route = this.resolveRoute(model);
+		if (!route) return this.missingProvider;
+		return this.getOrCreateProvider(route);
 	};
-	requireSession = (sessionId) => {
-		throw new Error("SessionManager.requireSession is not implemented.");
+	chat = async (params) => {
+		return this.get(params.model ?? null).chat(params);
 	};
-	createSession = (input) => {
-		throw new Error("SessionManager.createSession is not implemented.");
+	chatStream = async function* (params) {
+		for await (const event of this.get(params.model ?? null).chatStream(params)) yield event;
 	};
-	saveSession = (session) => {
-		throw new Error("SessionManager.saveSession is not implemented.");
+	testConnection = async (input) => {
+		await this.createProvider({
+			providerName: input.providerName,
+			provider: {
+				enabled: true,
+				displayName: "",
+				apiKey: input.apiKey ?? "",
+				apiBase: input.apiBase ?? null,
+				extraHeaders: input.extraHeaders ?? null,
+				wireApi: input.wireApi ?? "auto",
+				models: [],
+				modelThinking: {}
+			},
+			apiBase: input.apiBase ?? null,
+			model: input.defaultModel
+		}).chat({
+			messages: input.messages,
+			model: input.defaultModel,
+			maxTokens: input.maxTokens,
+			signal: input.signal
+		});
 	};
-	appendMessage = (sessionId, message) => {
-		throw new Error("SessionManager.appendMessage is not implemented.");
+	resolveRoute = (model) => {
+		if (!this.config) return null;
+		const effectiveModel = normalizedModel(model) ?? this.config.agents.defaults.model;
+		const { provider, name } = this.resolveProvider(effectiveModel);
+		const providerSpec = name ? this.providerRegistry.findProviderByName(name) : void 0;
+		return {
+			model: effectiveModel,
+			providerName: name,
+			provider,
+			apiBase: provider?.apiBase ?? providerSpec?.defaultApiBase ?? null
+		};
+	};
+	resolveProvider = (model) => {
+		const providers = this.config?.providers;
+		if (!providers) return {
+			provider: null,
+			name: null
+		};
+		const specs = this.providerRegistry.listProviderSpecs();
+		const modelLower = model.toLowerCase();
+		const modelPrefix = modelLower.includes("/") ? modelLower.slice(0, modelLower.indexOf("/")) : "";
+		if (modelPrefix) {
+			const prefixed = this.matchPrefixedProvider(providers, modelPrefix);
+			if (prefixed) return prefixed;
+		}
+		const keywordMatches = specs.map((spec) => ({
+			name: spec.name,
+			provider: providers[spec.name],
+			spec
+		})).filter((entry) => entry.provider?.enabled !== false && Boolean(entry.provider?.apiKey)).filter((entry) => entry.spec.keywords.some((keyword) => modelLower.includes(keyword)));
+		if (keywordMatches.length === 1) {
+			const match = keywordMatches[0];
+			return {
+				provider: match.provider ?? null,
+				name: match.name
+			};
+		}
+		if (keywordMatches.length > 1) return {
+			provider: null,
+			name: null
+		};
+		const builtinNames = new Set(specs.map((spec) => spec.name));
+		const enabledProviders = Object.entries(providers).filter(([, provider]) => provider.enabled !== false && Boolean(provider.apiKey));
+		const enabledBuiltin = enabledProviders.filter(([name]) => builtinNames.has(name));
+		if (enabledBuiltin.length === 1) {
+			const [name, provider] = enabledBuiltin[0];
+			return {
+				provider,
+				name
+			};
+		}
+		const enabledCustom = enabledProviders.filter(([name]) => !builtinNames.has(name));
+		if (enabledCustom.length === 1) {
+			const [name, provider] = enabledCustom[0];
+			return {
+				provider,
+				name
+			};
+		}
+		return {
+			provider: null,
+			name: null
+		};
+	};
+	matchPrefixedProvider = (providers, modelPrefix) => {
+		for (const spec of this.providerRegistry.listProviderSpecs()) {
+			const provider = providers[spec.name];
+			const aliases = [spec.name, spec.modelPrefix ?? ""].map((value) => value.trim().toLowerCase()).filter(Boolean);
+			if (provider && aliases.includes(modelPrefix)) return provider.enabled !== false ? {
+				provider,
+				name: spec.name
+			} : {
+				provider: null,
+				name: null
+			};
+		}
+		const customProvider = Object.entries(providers).find(([name]) => name.toLowerCase() === modelPrefix);
+		if (!customProvider) return null;
+		const [name, provider] = customProvider;
+		return provider.enabled !== false ? {
+			provider,
+			name
+		} : {
+			provider: null,
+			name: null
+		};
 	};
-	attachTask = (sessionId, taskId) => {
-		throw new Error("SessionManager.attachTask is not implemented.");
+	getOrCreateProvider = (route) => {
+		if (!route.provider?.apiKey && !route.model.startsWith("bedrock/")) return this.missingProvider;
+		const cacheKey = this.buildCacheKey(route);
+		const cached = this.providerPool.get(cacheKey);
+		if (cached) return cached;
+		const created = this.createProvider(route);
+		this.providerPool.set(cacheKey, created);
+		return created;
 	};
-	closeSession = (sessionId) => {
-		throw new Error("SessionManager.closeSession is not implemented.");
+	createProvider = (route) => {
+		return new LiteLLMProvider({
+			apiKey: route.provider?.apiKey ?? null,
+			apiBase: route.apiBase,
+			defaultModel: route.model,
+			extraHeaders: route.provider?.extraHeaders ?? null,
+			providerName: route.providerName,
+			providerRegistry: this.providerRegistry,
+			wireApi: route.provider?.wireApi ?? null
+		});
+	};
+	buildCacheKey = (route) => {
+		const routeProvider = route.provider;
+		return [
+			route.providerName ?? "",
+			routeProvider?.apiKey ?? "",
+			route.apiBase ?? "",
+			routeProvider?.wireApi ?? "",
+			headersFingerprint(routeProvider?.extraHeaders ?? null)
+		].join("||");
 	};
 };
 //#endregion
@@ -166,37 +3963,6 @@ var SkillManager = class {
 	};
 };
 //#endregion
-//#region src/managers/task.manager.ts
-var TaskManager = class {
-	listTasks = () => {
-		throw new Error("TaskManager.listTasks is not implemented.");
-	};
-	getTask = (taskId) => {
-		throw new Error("TaskManager.getTask is not implemented.");
-	};
-	requireTask = (taskId) => {
-		throw new Error("TaskManager.requireTask is not implemented.");
-	};
-	createTask = (input) => {
-		throw new Error("TaskManager.createTask is not implemented.");
-	};
-	saveTask = (task) => {
-		throw new Error("TaskManager.saveTask is not implemented.");
-	};
-	updateTaskStatus = (taskId, status) => {
-		throw new Error("TaskManager.updateTaskStatus is not implemented.");
-	};
-	completeTask = (taskId, output) => {
-		throw new Error("TaskManager.completeTask is not implemented.");
-	};
-	failTask = (taskId, error) => {
-		throw new Error("TaskManager.failTask is not implemented.");
-	};
-	cancelTask = (taskId) => {
-		throw new Error("TaskManager.cancelTask is not implemented.");
-	};
-};
-//#endregion
 //#region src/managers/tool.manager.ts
 var ToolManager = class {
 	listTools = () => {
@@ -222,7 +3988,312 @@ var ToolManager = class {
 	};
 };
 //#endregion
+//#region src/services/ncp-lifecycle-event-bridge.service.ts
+function readSessionType(metadata) {
+	const sessionType = metadata?.session_type;
+	return typeof sessionType === "string" && sessionType.trim().length > 0 ? sessionType.trim() : void 0;
+}
+var NcpLifecycleEventBridge = class {
+	constructor(sessionManager, eventBus) {
+		this.sessionManager = sessionManager;
+		this.eventBus = eventBus;
+	}
+	publishSessionUpdated = (sessionId) => {
+		const context = this.buildSessionContext(sessionId);
+		if (!context) return;
+		const payload = { ...context };
+		this.eventBus.emit(agentSessionUpdatedLifecycleEventKey, payload);
+	};
+	handleEndpointEvent = (event) => {
+		switch (event.type) {
+			case NcpEventType.RunStarted:
+				this.publishRunStarted(event);
+				return;
+			case NcpEventType.RunFinished:
+				this.publishRunFinished(event);
+				return;
+			case NcpEventType.MessageSent:
+				this.publishMessageSent(event);
+				return;
+			default: return;
+		}
+	};
+	publishRunStarted = (event) => {
+		const sessionId = event.payload.sessionId?.trim();
+		if (!sessionId) return;
+		const context = this.buildSessionContext(sessionId);
+		if (!context) return;
+		const payload = {
+			...context,
+			...event.payload.runId ? { runId: event.payload.runId } : {},
+			...event.payload.messageId ? { messageId: event.payload.messageId } : {}
+		};
+		this.eventBus.emit(agentRunStartedLifecycleEventKey, payload);
+	};
+	publishRunFinished = (event) => {
+		const sessionId = event.payload.sessionId?.trim();
+		if (!sessionId) return;
+		const context = this.buildSessionContext(sessionId);
+		if (!context) return;
+		const payload = {
+			...context,
+			...event.payload.runId ? { runId: event.payload.runId } : {},
+			...event.payload.messageId ? { messageId: event.payload.messageId } : {}
+		};
+		this.eventBus.emit(agentRunFinishedLifecycleEventKey, payload);
+	};
+	publishMessageSent = (event) => {
+		const sessionId = event.payload.sessionId.trim();
+		const context = this.buildSessionContext(sessionId);
+		if (!context) return;
+		const payload = {
+			...context,
+			messageId: event.payload.message.id,
+			role: event.payload.message.role
+		};
+		this.eventBus.emit(agentMessageSentLifecycleEventKey, payload);
+	};
+	buildSessionContext = (sessionId) => {
+		const metadata = this.sessionManager.getIfExists(sessionId)?.metadata;
+		const sessionType = readSessionType(metadata);
+		const parentSessionId = metadata ? readParentSessionId(metadata) : void 0;
+		return {
+			sessionId,
+			...sessionType ? { sessionType } : {},
+			...parentSessionId ? { parentSessionId } : {},
+			isChildSession: Boolean(parentSessionId),
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	};
+};
+//#endregion
+//#region src/utils/ncp-session-summary.utils.ts
+function createNcpSessionSummary(params) {
+	const { sessionId, agentId, messages, updatedAt, status, metadata, contextWindow } = params;
+	return {
+		sessionId,
+		...agentId ? { agentId } : {},
+		messageCount: messages.length,
+		updatedAt,
+		...messages.length > 0 ? { lastMessageAt: messages[messages.length - 1]?.timestamp ?? updatedAt } : {},
+		status,
+		...metadata ? { metadata: structuredClone(metadata) } : {},
+		...contextWindow ? { contextWindow: structuredClone(contextWindow) } : {}
+	};
+}
+//#endregion
+//#region src/services/ncp-session-api.service.ts
+function applyLimit(items, limit) {
+	if (!Number.isFinite(limit) || typeof limit !== "number" || limit <= 0) return items;
+	return items.slice(0, Math.trunc(limit));
+}
+function formatBackgroundTaskError(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return String(error);
+}
+function buildUpdatedMetadata(params) {
+	const { existingMetadata, patch } = params;
+	if (patch.metadata === null) return {};
+	if (patch.metadata) return structuredClone(patch.metadata);
+	return structuredClone(existingMetadata ?? {});
+}
+function normalizeSessionId(sessionId) {
+	return sessionId.trim();
+}
+var NcpSessionApiService = class {
+	unsubscribeSessionUpdated = null;
+	contextWindowPreview;
+	constructor(options) {
+		this.options = options;
+		this.contextWindowPreview = new ContextCompactionPreflightService({
+			getConfig: options.getConfig,
+			sessionManager: options.sessionManager
+		});
+	}
+	start = () => {
+		if (this.unsubscribeSessionUpdated) return;
+		this.unsubscribeSessionUpdated = this.options.eventBus.on(eventKeys.sessionUpdated, ({ sessionKey }) => {
+			this.publishSessionChange(sessionKey).catch((error) => {
+				console.error(`[session-realtime] failed to publish session change for ${sessionKey}: ${formatBackgroundTaskError(error)}`);
+			});
+		});
+	};
+	dispose = () => {
+		this.unsubscribeSessionUpdated?.();
+		this.unsubscribeSessionUpdated = null;
+	};
+	publishSessionChange = async (sessionKey) => {
+		const normalizedSessionKey = normalizeSessionId(sessionKey);
+		if (!normalizedSessionKey) return;
+		const summary = await this.getSession(normalizedSessionKey);
+		if (summary) {
+			this.options.eventBus.emit(eventKeys.sessionSummaryUpsert, { summary });
+			return;
+		}
+		this.options.eventBus.emit(eventKeys.sessionSummaryDelete, { sessionKey: normalizedSessionKey });
+	};
+	listSessions = async (options) => {
+		const summaries = [];
+		for (const record of this.options.sessionManager.listSessions()) {
+			const sessionId = normalizeSessionId(record.key);
+			if (!sessionId) continue;
+			const session = this.options.sessionManager.getIfExists(sessionId);
+			if (!session) continue;
+			summaries.push(createNcpSessionSummary({
+				sessionId,
+				agentId: session.agentId,
+				messages: toNcpMessages(sessionId, session.messages),
+				updatedAt: session.updatedAt.toISOString(),
+				status: "idle",
+				metadata: session.metadata
+			}));
+		}
+		summaries.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+		return applyLimit(summaries, options?.limit);
+	};
+	listSessionMessages = async (sessionId, options) => {
+		const normalizedSessionId = normalizeSessionId(sessionId);
+		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
+		if (!session) return [];
+		return applyLimit(toNcpMessages(normalizedSessionId, session.messages).map((message) => structuredClone(message)), options?.limit);
+	};
+	getSession = async (sessionId) => {
+		const normalizedSessionId = normalizeSessionId(sessionId);
+		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
+		if (!session) return null;
+		const messages = toNcpMessages(normalizedSessionId, session.messages);
+		return createNcpSessionSummary({
+			sessionId: normalizedSessionId,
+			agentId: session.agentId,
+			messages,
+			updatedAt: session.updatedAt.toISOString(),
+			status: "idle",
+			metadata: session.metadata,
+			contextWindow: this.contextWindowPreview.preview({
+				contextWindowOwner: "nextclaw",
+				requestMetadata: session.metadata,
+				sessionId: normalizedSessionId,
+				sessionMessages: messages
+			})
+		});
+	};
+	updateSession = async (sessionId, patch) => {
+		const normalizedSessionId = normalizeSessionId(sessionId);
+		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
+		if (!session) return null;
+		session.metadata = buildUpdatedMetadata({
+			existingMetadata: session.metadata,
+			patch
+		});
+		session.updatedAt = /* @__PURE__ */ new Date();
+		this.options.sessionManager.save(session);
+		await this.publishSessionChange(normalizedSessionId);
+		return await this.getSession(normalizedSessionId);
+	};
+	deleteSession = async (sessionId) => {
+		const normalizedSessionId = normalizeSessionId(sessionId);
+		if (!normalizedSessionId) return;
+		this.options.sessionManager.delete(normalizedSessionId);
+		await this.publishSessionChange(normalizedSessionId);
+	};
+};
+//#endregion
+//#region src/utils/ncp-session-metadata.utils.ts
+function resolvePersistedSessionMetadata(params) {
+	const { currentMetadata, preserveExistingMetadata, sessionRecord } = params;
+	const messageMetadata = extractMessageMetadata(sessionRecord.messages);
+	return mergeSessionMetadata(preserveExistingMetadata ? mergeSessionMetadata(currentMetadata, messageMetadata) : mergeSessionMetadata({}, messageMetadata), cloneMetadata(sessionRecord.metadata));
+}
+//#endregion
+//#region src/services/ncp-agent-session-store-adapter.service.ts
+function readAgentIdFromMetadata(metadata) {
+	return normalizeString(metadata?.agent_id)?.toLowerCase() ?? normalizeString(metadata?.agentId)?.toLowerCase() ?? void 0;
+}
+function resolveSessionRecordAgentId(record) {
+	return normalizeString(record.agentId)?.toLowerCase() ?? readAgentIdFromMetadata(record.metadata);
+}
+var NcpAgentSessionStoreAdapter = class {
+	constructor(sessionManager, options = {}) {
+		this.sessionManager = sessionManager;
+		this.options = options;
+	}
+	getSession = async (sessionId) => {
+		const session = this.sessionManager.getIfExists(sessionId);
+		if (!session) return null;
+		return {
+			sessionId,
+			...session.agentId ? { agentId: session.agentId } : {},
+			messages: toNcpMessages(sessionId, session.messages),
+			updatedAt: session.updatedAt.toISOString(),
+			metadata: structuredClone(session.metadata)
+		};
+	};
+	listSessions = async () => {
+		const records = this.sessionManager.listSessions();
+		const sessions = [];
+		for (const record of records) {
+			const sessionId = normalizeString(record.key);
+			if (!sessionId) continue;
+			const session = this.sessionManager.getIfExists(sessionId);
+			if (!session) continue;
+			sessions.push({
+				sessionId,
+				...session.agentId ? { agentId: session.agentId } : {},
+				messages: toNcpMessages(sessionId, session.messages),
+				updatedAt: session.updatedAt.toISOString(),
+				metadata: structuredClone(session.metadata)
+			});
+		}
+		sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+		return sessions;
+	};
+	persistSession = async (sessionRecord, options) => {
+		if (this.options.writeMode === "runtime-owned") return;
+		const session = this.sessionManager.getIfExists(sessionRecord.sessionId) ?? this.sessionManager.getOrCreate(sessionRecord.sessionId);
+		const legacyMessages = toLegacyMessages(sessionRecord.messages);
+		const nextAgentId = resolveSessionRecordAgentId(sessionRecord);
+		if (nextAgentId) session.agentId = nextAgentId;
+		session.metadata = resolvePersistedSessionMetadata({
+			currentMetadata: session.metadata,
+			sessionRecord,
+			preserveExistingMetadata: options.preserveExistingMetadata
+		});
+		this.sessionManager.clear(session);
+		for (const message of legacyMessages) this.sessionManager.appendEvent(session, {
+			type: resolveLegacyEventType(message),
+			timestamp: ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString()),
+			data: { message }
+		});
+		if (legacyMessages.length === 0) session.updatedAt = new Date(ensureIsoTimestamp(sessionRecord.updatedAt, (/* @__PURE__ */ new Date()).toISOString()));
+		this.sessionManager.save(session);
+		this.options.onSessionUpdated?.(sessionRecord.sessionId);
+	};
+	saveSession = async (sessionRecord) => {
+		await this.persistSession(sessionRecord, { preserveExistingMetadata: true });
+	};
+	replaceSession = async (sessionRecord) => {
+		await this.persistSession(sessionRecord, { preserveExistingMetadata: false });
+	};
+	deleteSession = async (sessionId) => {
+		const existing = await this.getSession(sessionId);
+		if (!existing) return null;
+		this.sessionManager.delete(sessionId);
+		this.options.onSessionUpdated?.(sessionId);
+		return existing;
+	};
+};
+//#endregion
 //#region src/app/nextclaw-kernel.ts
+function resolveKernelSessionsDir(options) {
+	const homeDir = options.homeDir?.trim();
+	if (homeDir) return ensureDir(resolve(expandHome(homeDir), "sessions"));
+	return getSessionsPath();
+}
+function resolveKernelAutomationStorePath(options) {
+	const homeDir = options.homeDir?.trim();
+	if (homeDir) return resolve(expandHome(homeDir), "cron", "jobs.json");
+	return resolve(getDataDir(), "cron", "jobs.json");
+}
 var NextclawKernelControlManager = class {
 	runtimeControl = null;
 	installRuntimeControl = (runtimeControl) => {
@@ -234,136 +4305,117 @@ var NextclawKernelControlManager = class {
 	};
 };
 var NextclawKernel = class {
-	agents = new AgentManager();
-	tasks = new TaskManager();
-	sessions = new SessionManager();
-	contextBuilder = new ContextBuilder(this.sessions);
-	control = new NextclawKernelControlManager();
-	tools = new ToolManager();
-	skills = new SkillManager();
+	eventBus = new EventBus();
+	ingress = new Ingress();
+	messageBus = new MessageBus();
 	llmProviders = new LlmProviderManager();
-	automation = new AutomationManager();
-	channels = new ChannelManager();
-	run = (input) => {
-		throw new Error("NextclawKernel.run is not implemented.");
-	};
-};
-//#endregion
-//#region src/events/event-bus.service.ts
-var EventBus = class {
-	listeners = /* @__PURE__ */ new Map();
-	globalListeners = /* @__PURE__ */ new Set();
-	listenerCount = 0;
-	onFirstSubscriber;
-	onListenerError;
-	onNoSubscribers;
+	llmUsage = new LlmUsageManager();
+	configManager;
+	agents;
+	sessions;
+	control;
+	tools;
+	skills;
+	automation;
+	channels;
+	sessionRequests;
+	sessionSearch;
+	ncpSessionApi;
+	extensions;
+	agentRuntimeManager;
+	learningLoop;
+	sessionLifecycleEvents;
+	ncpAgentSessionStore;
+	startPromise = null;
 	constructor(options = {}) {
-		this.onFirstSubscriber = options.onFirstSubscriber;
-		this.onListenerError = options.onListenerError;
-		this.onNoSubscribers = options.onNoSubscribers;
-	}
-	emit = (key, payload, options = {}) => {
-		const envelope = {
-			type: key.id,
-			payload,
-			...options.emittedAt ? { emittedAt: options.emittedAt } : {},
-			...options.source ? { source: options.source } : {}
-		};
-		this.emitEnvelope(envelope);
-	};
-	emitEnvelope = (event) => {
-		const listeners = this.listeners.get(event.type);
-		if (listeners) for (const listener of listeners) this.safeInvokeListener(event, listener);
-		if (this.globalListeners.size === 0) return;
-		for (const listener of this.globalListeners) this.safeInvokeGlobalListener(event, listener);
-	};
-	on = (key, handler) => {
-		const listeners = this.listeners.get(key.id) ?? /* @__PURE__ */ new Set();
-		const typedHandler = handler;
-		const added = !listeners.has(typedHandler);
-		listeners.add(typedHandler);
-		this.listeners.set(key.id, listeners);
-		if (added) this.registerSubscriber();
-		return () => {
-			this.off(key, handler);
-		};
-	};
-	off = (key, handler) => {
-		const listeners = this.listeners.get(key.id);
-		if (!listeners) return;
-		const deleted = listeners.delete(handler);
-		if (listeners.size === 0) this.listeners.delete(key.id);
-		if (deleted) this.unregisterSubscriber();
-	};
-	once = (key, handler) => {
-		const wrappedHandler = (payload, envelope) => {
-			unsubscribe();
-			handler(payload, envelope);
-		};
-		const unsubscribe = this.on(key, wrappedHandler);
-		return unsubscribe;
-	};
-	subscribeAll = (handler) => {
-		const added = !this.globalListeners.has(handler);
-		this.globalListeners.add(handler);
-		if (added) this.registerSubscriber();
-		return () => {
-			if (this.globalListeners.delete(handler)) this.unregisterSubscriber();
-		};
-	};
-	registerSubscriber = () => {
-		this.listenerCount += 1;
-		if (this.listenerCount === 1) this.onFirstSubscriber?.();
-	};
-	unregisterSubscriber = () => {
-		this.listenerCount = Math.max(0, this.listenerCount - 1);
-		if (this.listenerCount === 0) this.onNoSubscribers?.();
-	};
-	safeInvokeListener = (event, listener) => {
-		try {
-			listener(event.payload, event);
-		} catch (error) {
-			this.onListenerError?.({
-				type: event.type,
-				payload: event.payload,
-				error
-			});
-		}
+		const sessionsDir = resolveKernelSessionsDir(options);
+		this.sessions = new SessionManager({ sessionsDir });
+		this.sessionLifecycleEvents = new NcpLifecycleEventBridge(this.sessions, this.eventBus);
+		this.sessionSearch = new SessionSearchManager({
+			databasePath: resolve(getDataDir(), "session-search.db"),
+			sessionsDir,
+			onSessionUpdated: this.publishSessionUpdated
+		});
+		this.ncpAgentSessionStore = new NcpAgentSessionStoreAdapter(this.sessions, { onSessionUpdated: this.sessionSearch.handleSessionUpdated });
+		this.sessionRequests = new SessionRequestManager({
+			sessions: this.sessions,
+			dispatcher: createAgentRuntimeSessionRequestDispatcher({
+				eventBus: this.eventBus,
+				ingress: this.ingress
+			}),
+			onSessionUpdated: this.sessionSearch.handleSessionUpdated
+		});
+		this.automation = new AutomationManager({ storePath: resolveKernelAutomationStorePath(options) });
+		this.agents = new AgentManager();
+		this.control = new NextclawKernelControlManager();
+		this.tools = new ToolManager();
+		this.skills = new SkillManager();
+		this.extensions = new ExtensionManager();
+		this.channels = new ChannelManager$1({
+			bus: this.messageBus,
+			sessionManager: this.sessions
+		});
+		this.configManager = new ConfigManager({
+			configPath: options.configPath,
+			channels: this.channels,
+			providerManager: this.llmProviders
+		});
+		this.ncpSessionApi = new NcpSessionApiService({
+			eventBus: this.eventBus,
+			getConfig: this.configManager.loadConfig,
+			sessionManager: this.sessions
+		});
+		this.agentRuntimeManager = new AgentRuntimeManager({
+			bus: this.messageBus,
+			providerManager: this.llmProviders,
+			sessions: this.sessions,
+			ingress: this.ingress,
+			sessionRequests: this.sessionRequests,
+			sessionSearch: this.sessionSearch,
+			ncpAgentSessionStore: this.ncpAgentSessionStore,
+			cronService: this.automation,
+			configManager: this.configManager,
+			extensions: this.extensions,
+			eventBus: this.eventBus,
+			handleNcpEvent: this.handleNcpEvent,
+			llmUsage: this.llmUsage,
+			onSessionUpdated: this.publishSessionUpdated
+		});
+		this.learningLoop = new LearningLoopManager({
+			eventBus: this.eventBus,
+			sessionManager: this.sessions,
+			sessionRequester: this.sessionRequests,
+			resolveLearningLoopConfig: () => readLearningLoopRuntimeConfig(this.configManager.loadConfig())
+		});
+	}
+	start = async () => {
+		this.startPromise ??= Promise.resolve().then(() => {
+			this.ncpSessionApi.start();
+		}).then(() => this.sessionSearch.start()).then(() => this.agentRuntimeManager.bootstrap()).then(() => {
+			this.learningLoop.start();
+		}).catch((error) => {
+			this.startPromise = null;
+			throw error;
+		});
+		return this.startPromise;
 	};
-	safeInvokeGlobalListener = (event, listener) => {
-		try {
-			listener(event);
-		} catch (error) {
-			this.onListenerError?.({
-				type: event.type,
-				payload: event.payload,
-				error
-			});
-		}
+	dispose = async () => {
+		this.learningLoop.dispose();
+		this.ncpSessionApi.dispose();
+		await this.agentRuntimeManager.dispose();
+		await this.sessionSearch.dispose();
+		this.startPromise = null;
+	};
+	publishSessionUpdated = (sessionKey) => {
+		this.sessionLifecycleEvents.publishSessionUpdated(sessionKey);
+		this.eventBus.emit(eventKeys.sessionUpdated, { sessionKey }, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+	};
+	handleNcpEvent = (event) => {
+		this.sessionLifecycleEvents.handleEndpointEvent(event);
 	};
 };
 //#endregion
-//#region src/app/nextclaw-app.service.ts
-const nextclaw = { eventBus: new EventBus() };
-//#endregion
-//#region src/events/event-keys.config.ts
-function createAppEventKey(id) {
-	return { id };
-}
-const eventKeys = {
-	configUpdated: createAppEventKey("config.updated"),
-	channelConfigApplyStatus: createAppEventKey("channel.config.apply-status"),
-	sessionUpdated: createAppEventKey("session.updated"),
-	sessionRunStatus: createAppEventKey("session.run-status"),
-	sessionSummaryUpsert: createAppEventKey("session.summary.upsert"),
-	sessionSummaryDelete: createAppEventKey("session.summary.delete"),
-	configReloadStarted: createAppEventKey("config.reload.started"),
-	configReloadFinished: createAppEventKey("config.reload.finished"),
-	error: createAppEventKey("error"),
-	connectionOpen: createAppEventKey("connection.open"),
-	connectionClose: createAppEventKey("connection.close"),
-	connectionError: createAppEventKey("connection.error"),
-	runtimeUpdateSnapshot: createAppEventKey("runtime.update.snapshot")
-};
-//#endregion
-export { AgentManager, AutomationManager, ChannelManager, ContextBuilder, EventBus, LlmProviderManager, NextclawKernel, SessionManager, SkillManager, TaskManager, ToolManager, UpdateManifestReader, createAppEventKey, eventKeys, getUnsignedUpdateManifest, nextclaw, serializeUnsignedUpdateManifest };
+export { AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, AgentManager, AgentRuntimeManager, AgentRuntimeRegistry, AutomationManager, BuiltinNarpRuntimeRegistrationService, ChannelManager, ConfigManager, ContextCompactionPreflightService, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD, ExtensionManager, LEARNING_LOOP_DISABLED_METADATA_KEY, LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY, LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY, LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY, LEARNING_LOOP_REQUESTED_SKILLS, LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY, LearningLoopManager, LlmProviderManager, LlmUsageManager, LlmUsageStore, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NativeAgentRuntimeFactory, NcpSessionApiService, NextclawKernel, NextclawNcpContextBuilder, NextclawNcpToolRegistry, PluginRuntimeRegistrationController, ProviderManagerNcpLLMApi, SkillManager, ToolManager, UpdateManifestReader, buildLearningLoopTask, buildLlmUsageSummary, buildNcpUserMessage, buildUserMessageParts, createAgentRuntimeHandle, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createLlmUsageRecord, createNcpSessionSummary, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isReplyCapableChannel, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, readAccountIdForHints, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, toNcpMessages, waitForAgentRuntimeSessionReply };