nextclaw 0.17.10 → 0.17.12

package/dist/cli/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import * as NextclawCore from "@nextclaw/core";
-import { APP_NAME, APP_TAGLINE, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, ChannelManager, CommandRegistry, ConfigSchema, ContextBuilder, CronService, CronTool, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, FileLogSink, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderManager, ReadFileTool, SessionManager, SessionsHistoryTool, SessionsListTool, SkillsLoader, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildConfigSchema, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAgentProfile, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createExternalCommandEnv, createTypingStopControlMessage, diffConfigPaths, expandHome, findEffectiveAgentProfile, getAppLogger, getConfigPath, getDataDir, getLoggingRuntime, getLogsPath, getPackageVersion, getWorkspacePath, hasSecretRef, loadConfig, normalizeInlineSecretRefs, parseAgentScopedSessionKey, parseThinkingLevel, readSessionProjectRoot, redactConfigObject, removeAgentProfile, resolveAppLogPath, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveEffectiveAgentProfiles, resolveLocalUiBaseUrl, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, toDisposable, updateAgentProfile } from "@nextclaw/core";
+import { APP_NAME, APP_TAGLINE, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, ChannelManager, CommandRegistry, ConfigSchema, ContextBuilder, CronService, CronTool, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, FileLogSink, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderManager, ReadFileTool, RequestedSkillsMetadataReader, SessionManager, SessionsHistoryTool, SessionsListTool, SkillsLoader, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildConfigSchema, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAgentProfile, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createExternalCommandEnv, createGlobalTypedEventBus, createTypedEventKey, createTypingStopControlMessage, diffConfigPaths, expandHome, findEffectiveAgentProfile, getAppLogger, getConfigPath, getDataDir, getLoggingRuntime, getLogsPath, getPackageVersion, getWorkspacePath, hasSecretRef, loadConfig, normalizeInlineSecretRefs, parseAgentScopedSessionKey, parseThinkingLevel, readSessionProjectRoot, redactConfigObject, removeAgentProfile, resolveAppLogPath, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveEffectiveAgentProfiles, resolveLocalUiBaseUrl, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, toDisposable, updateAgentProfile } from "@nextclaw/core";
 import { Command } from "commander";
-import fs, { appendFileSync, closeSync, cpSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import fs, { appendFileSync, closeSync, constants, cpSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import path, { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { hostname, platform } from "node:os";
 import { ensureUiBridgeSecret, startUiServer } from "@nextclaw/server";
 import { addPluginLoadPath, buildPluginStatusReport, disablePluginInConfig, discoverPluginStatusReport, enablePluginInConfig, getPackageManifestExtensions, getPluginChannelBindings, getPluginUiMetadataFromRegistry, installPluginFromNpmSpec, installPluginFromPath, loadOpenClawPlugins, loadOpenClawPluginsProgressively, loadPluginManifest, mergePluginConfigView, recordPluginInstall, resolvePluginChannelMessageToolHints, resolveUninstallDirectoryTargets, setPluginRuntimeBridge, startPluginChannelGateways, stopPluginChannelGateways, toPluginConfigView, toPluginConfigView as toPluginConfigView$1, uninstallPlugin } from "@nextclaw/openclaw-compat";
@@ -15,6 +15,9 @@ import { createInterface } from "node:readline";
 import { createServer, isIP } from "node:net";
 import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds, listBuiltinProviders } from "@nextclaw/runtime";
 import { McpDoctorFacade, McpMutationService, McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
+import { access, readFile } from "node:fs/promises";
+import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
+import { StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, probeStdioRuntime } from "@nextclaw/nextclaw-ncp-runtime-stdio-client";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
 import { setImmediate as setImmediate$1, setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -24,7 +27,7 @@ import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
 import { NCP_INTERNAL_VISIBILITY_METADATA_KEY, NcpEventType, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, writeAssistantReasoningNormalizationModeToMetadata } from "@nextclaw/ncp";
 import { DefaultNcpAgentBackend, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
 import { createHash, randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { DatabaseSync } from "node:sqlite";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -4711,17 +4714,24 @@ var LlmUsageQueryService = class {
 		let totalTokens = 0;
 		let totalCachedTokens = 0;
 		let cacheHitRecords = 0;
+		let usageRecordCount = 0;
+		let promptTokenRecordCount = 0;
 		for (const record of records) {
+			if (Object.keys(record.usage).length > 0) usageRecordCount += 1;
 			totalPromptTokens += record.summary.promptTokens;
 			totalCompletionTokens += record.summary.completionTokens;
 			totalTokens += record.summary.totalTokens;
 			totalCachedTokens += record.summary.cachedTokens;
+			if (record.summary.promptTokens > 0) promptTokenRecordCount += 1;
 			if (record.summary.cacheHit) cacheHitRecords += 1;
 			this.bumpCounter(sources, record.source);
 			this.bumpCounter(models, record.model ?? "unknown");
 		}
 		return {
 			totalRecords: records.length,
+			usageRecordCount,
+			emptyUsageRecordCount: records.length - usageRecordCount,
+			promptTokenRecordCount,
 			oldestObservedAt: records[0]?.observedAt ?? null,
 			latestObservedAt: records.at(-1)?.observedAt ?? null,
 			totalPromptTokens,
@@ -4729,7 +4739,8 @@ var LlmUsageQueryService = class {
 			totalTokens,
 			totalCachedTokens,
 			cacheHitRecords,
-			cacheHitRate: records.length > 0 ? cacheHitRecords / records.length : 0,
+			cacheHitRate: promptTokenRecordCount > 0 ? cacheHitRecords / promptTokenRecordCount : 0,
+			tokenCacheRate: totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens : 0,
 			sources: this.toSortedCounts(sources),
 			models: this.toSortedCounts(models)
 		};
@@ -4892,13 +4903,17 @@ var LlmUsageCommands = class {
 			"LLM usage history stats",
 			`History path: ${this.queryService.historyPath}`,
 			`Records: ${stats.totalRecords}`,
+			`Usage records: ${stats.usageRecordCount}`,
+			`Empty usage records: ${stats.emptyUsageRecordCount}`,
+			`Prompt-bearing records: ${stats.promptTokenRecordCount}`,
 			`Oldest observed at: ${stats.oldestObservedAt ?? "n/a"}`,
 			`Latest observed at: ${stats.latestObservedAt ?? "n/a"}`,
 			`Prompt tokens: ${stats.totalPromptTokens}`,
 			`Completion tokens: ${stats.totalCompletionTokens}`,
 			`Total tokens: ${stats.totalTokens}`,
 			`Cached tokens: ${stats.totalCachedTokens}`,
-			`Cache hits: ${stats.cacheHitRecords}/${stats.totalRecords} (${this.toPercent(stats.cacheHitRate)})`
+			`Cache hit records: ${stats.cacheHitRecords}/${stats.promptTokenRecordCount} (${this.toPercent(stats.cacheHitRate)})`,
+			`Cache token rate: ${this.toPercent(stats.tokenCacheRate)}`
 		];
 		if (stats.sources.length > 0) lines.push(`Sources: ${stats.sources.map((item) => `${item.value}=${item.count}`).join(", ")}`);
 		if (stats.models.length > 0) lines.push(`Models: ${stats.models.map((item) => `${item.value}=${item.count}`).join(", ")}`);
@@ -5145,7 +5160,7 @@ function parseSkillFrontmatter(raw) {
 		const message = error instanceof Error ? error.message : String(error);
 		throw new Error(`Invalid SKILL.md frontmatter: ${message}`);
 	}
-	if (!isRecord$5(parsed)) return {};
+	if (!isRecord$6(parsed)) return {};
 	const summaryI18n = readLocalizedTextMapField(parsed, [["summaryi18n"], ["summary_i18n"]]);
 	const descriptionI18n = readLocalizedTextMapField(parsed, [["descriptioni18n"], ["description_i18n"]]);
 	const summaryZh = readFrontmatterStringField(parsed, [["summaryzh"], ["summary_zh"]]);
@@ -5176,7 +5191,7 @@ function readMarketplaceMetadataFile(skillDir, explicitMetaFile) {
 		const message = error instanceof Error ? error.message : String(error);
 		throw new Error(`Invalid marketplace metadata file: ${metadataPath} (${message})`);
 	}
-	if (!isRecord$5(parsed)) throw new Error(`Invalid marketplace metadata file: ${metadataPath} (root must be an object)`);
+	if (!isRecord$6(parsed)) throw new Error(`Invalid marketplace metadata file: ${metadataPath} (root must be an object)`);
 	return {
 		slug: readMetadataString(parsed, "slug"),
 		name: readMetadataString(parsed, "name"),
@@ -5224,7 +5239,7 @@ function readMetadataStringArray(record, fieldName) {
 function readMetadataLocalizedTextMap(record, fieldName) {
 	const value = record[fieldName];
 	if (value == null) return;
-	if (!isRecord$5(value)) throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an object`);
+	if (!isRecord$6(value)) throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an object`);
 	const localized = {};
 	for (const [locale, text] of Object.entries(value)) {
 		if (typeof text !== "string") throw new Error(`Invalid marketplace metadata field: ${fieldName}.${locale} must be a string`);
@@ -5245,7 +5260,7 @@ function readFrontmatterStringField(record, keyPaths) {
 function readLocalizedTextMapField(record, keyPaths) {
 	for (const keyPath of keyPaths) {
 		const value = readNestedFrontmatterValue(record, keyPath);
-		if (!isRecord$5(value)) continue;
+		if (!isRecord$6(value)) continue;
 		const normalized = {};
 		for (const [locale, text] of Object.entries(value)) {
 			if (typeof text !== "string") continue;
@@ -5269,7 +5284,7 @@ function readFrontmatterTags(record) {
 function readNestedFrontmatterValue(record, keyPath) {
 	let current = record;
 	for (const rawKey of keyPath) {
-		if (!isRecord$5(current)) return;
+		if (!isRecord$6(current)) return;
 		const normalizedKey = normalizeFrontmatterKey(rawKey);
 		const matchingKey = Object.keys(current).find((candidate) => normalizeFrontmatterKey(candidate) === normalizedKey);
 		if (!matchingKey) return;
@@ -5283,7 +5298,7 @@ function normalizeFrontmatterKey(raw) {
 function normalizeLocaleTag(raw) {
 	return raw.trim().toLowerCase();
 }
-function isRecord$5(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -5503,11 +5518,17 @@ function openBrowser(url) {
 		command = "xdg-open";
 		args = [url];
 	}
-	spawn(command, args, {
-		stdio: "ignore",
-		detached: true,
-		env: createExternalCommandEnv(process.env)
-	}).unref();
+	if (!which(command)) return false;
+	try {
+		spawn(command, args, {
+			stdio: "ignore",
+			detached: true,
+			env: createExternalCommandEnv(process.env)
+		}).unref();
+		return true;
+	} catch {
+		return false;
+	}
 }
 function normalizePathEntries(rawPath, platform) {
 	const delimiter = platform === "win32" ? ";" : ":";
@@ -5558,9 +5579,9 @@ function resolveVersionFromPackageTree(startDir, expectedName) {
 		if (existsSync(pkgPath)) try {
 			const raw = readFileSync(pkgPath, "utf-8");
 			const parsed = JSON.parse(raw);
-			if (typeof parsed.version === "string") {
-				if (!expectedName || parsed.name === expectedName) return parsed.version;
-			}
+			const version = typeof parsed.version === "string" ? parsed.version : null;
+			const matchesExpectedName = !expectedName || parsed.name === expectedName;
+			if (version && matchesExpectedName) return version;
 		} catch {}
 		const parent = resolve(current, "..");
 		if (parent === current) break;
@@ -5642,6 +5663,71 @@ function persistPlatformToken(params) {
 	saveConfig(config, configPath);
 }
 var PlatformAuthCommands = class {
+	shouldUseBrowserLogin = (opts) => {
+		const email = typeof opts.email === "string" ? opts.email.trim() : "";
+		const password = typeof opts.password === "string" ? opts.password : "";
+		return !email && !password;
+	};
+	waitFor = async (delayMs) => {
+		await new Promise((resolve) => setTimeout(resolve, delayMs));
+	};
+	formatLoginDeadline = (expiresAt) => {
+		const value = Date.parse(expiresAt);
+		return Number.isNaN(value) ? expiresAt : new Date(value).toLocaleString();
+	};
+	printLoginSuccess = (result) => {
+		console.log(`✓ Logged in to NextClaw platform (${result.platformBase})`);
+		console.log(`✓ Account: ${result.email} (${result.role})`);
+		console.log("✓ Token saved into providers.nextclaw.apiKey");
+	};
+	printBrowserLoginIntro = (params) => {
+		const { expiresAt, open, openedBrowser, verificationUri } = params;
+		const expiresText = this.formatLoginDeadline(expiresAt);
+		console.log("NextClaw browser sign-in");
+		console.log(`Open this link to continue: ${verificationUri}`);
+		if (open) if (openedBrowser) console.log("✓ Opened the default browser. Finish sign-in there and this terminal will complete automatically.");
+		else console.log("Browser did not open automatically. Open the link above in any browser to continue.");
+		else console.log("Automatic browser opening is disabled. Open the link above in any browser to continue.");
+		console.log("This link can be opened on this machine or on another device if your CLI is running remotely.");
+		console.log(`Waiting for authorization until ${expiresText}...`);
+	};
+	waitForBrowserLoginResult = async (params) => {
+		while (true) {
+			const result = await this.pollBrowserAuth({
+				apiBase: params.apiBase,
+				sessionId: params.sessionId
+			});
+			if (result.status === "pending") {
+				await this.waitFor(result.nextPollMs);
+				continue;
+			}
+			if (result.status === "expired") throw new Error(`${result.message} Run \`nextclaw login\` again to generate a new sign-in link.`);
+			return {
+				token: result.token,
+				role: result.role,
+				email: result.email,
+				platformBase: result.platformBase,
+				v1Base: result.v1Base
+			};
+		}
+	};
+	loginWithBrowserResult = async (opts = {}) => {
+		const startResult = await this.startBrowserAuth({ apiBase: opts.apiBase });
+		const shouldOpenBrowser = opts.open !== false;
+		const openedBrowser = shouldOpenBrowser ? openBrowser(startResult.verificationUri) : false;
+		this.printBrowserLoginIntro({
+			verificationUri: startResult.verificationUri,
+			expiresAt: startResult.expiresAt,
+			open: shouldOpenBrowser,
+			openedBrowser
+		});
+		const result = await this.waitForBrowserLoginResult({
+			apiBase: opts.apiBase,
+			sessionId: startResult.sessionId
+		});
+		console.log("✓ Browser authorization completed.");
+		return result;
+	};
 	readStoredToken = (params = {}) => {
 		const resolved = resolveProviderConfig({ apiBase: params.apiBase });
 		const token = resolved.nextclawProvider.apiKey?.trim() ?? "";
@@ -5732,10 +5818,8 @@ var PlatformAuthCommands = class {
 		};
 	};
 	login = async (opts = {}) => {
-		const result = await this.loginResult(opts);
-		console.log(`✓ Logged in to NextClaw platform (${result.platformBase})`);
-		console.log(`✓ Account: ${result.email} (${result.role})`);
-		console.log(`✓ Token saved into providers.nextclaw.apiKey`);
+		const result = this.shouldUseBrowserLogin(opts) ? await this.loginWithBrowserResult(opts) : await this.loginResult(opts);
+		this.printLoginSuccess(result);
 	};
 	me = async (params = {}) => {
 		const { platformBase, v1Base, inputApiBase, token } = this.readStoredToken(params);
@@ -5852,9 +5936,9 @@ async function fetchMarketplaceSkillFiles(apiBase, slug) {
 			const message = payload.error?.message || `marketplace skill file fetch failed: ${response.status}`;
 			throw new Error(message);
 		}
-		if (!isRecord$4(payload.data) || !Array.isArray(payload.data.files)) throw new Error("Invalid marketplace skill file manifest response");
+		if (!isRecord$5(payload.data) || !Array.isArray(payload.data.files)) throw new Error("Invalid marketplace skill file manifest response");
 		return { files: payload.data.files.map((entry, index) => {
-			if (!isRecord$4(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) throw new Error(`Invalid marketplace skill file manifest at index ${index}`);
+			if (!isRecord$5(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) throw new Error(`Invalid marketplace skill file manifest at index ${index}`);
 			const normalized = { path: entry.path.trim() };
 			if (typeof entry.downloadPath === "string" && entry.downloadPath.trim().length > 0) normalized.downloadPath = entry.downloadPath.trim();
 			if (typeof entry.contentBase64 === "string" && entry.contentBase64.trim().length > 0) normalized.contentBase64 = entry.contentBase64.trim();
@@ -5881,7 +5965,7 @@ async function readMarketplaceEnvelope(response) {
 	} catch {
 		throw new Error(`Invalid marketplace response: ${response.status}`);
 	}
-	if (!isRecord$4(payload) || typeof payload.ok !== "boolean") throw new Error(`Invalid marketplace response shape: ${response.status}`);
+	if (!isRecord$5(payload) || typeof payload.ok !== "boolean") throw new Error(`Invalid marketplace response shape: ${response.status}`);
 	return payload;
 }
 function resolveSkillFileDownloadUrl(apiBase, slug, file) {
@@ -5896,7 +5980,7 @@ function extractMarketplaceErrorMessage(raw, fallbackStatus) {
 		return raw || `Request failed (${fallbackStatus})`;
 	}
 }
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -6433,10 +6517,14 @@ const readJsonFile = (filePath) => {
 		return null;
 	}
 };
-const readString = (value) => {
+const readString$3 = (value) => {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
 };
+const normalizeInstallRecordPath = (value) => {
+	const filePath = readString$3(value);
+	return filePath ? path.resolve(filePath) : void 0;
+};
 const resolveDevFirstPartyPluginDir = (explicitDir, moduleDir = path.dirname(fileURLToPath(import.meta.url))) => {
 	const configured = explicitDir?.trim();
 	if (configured) return configured;
@@ -6478,7 +6566,7 @@ const readWorkspacePluginPackages = (workspaceExtensionsDir) => {
 		const packageDir = path.join(workspaceExtensionsDir, entry.name);
 		const pkg = readJsonFile(path.join(packageDir, "package.json"));
 		if (!pkg || !hasOpenClawExtensions(pkg)) continue;
-		const packageName = readString(pkg.name);
+		const packageName = readString$3(pkg.name);
 		if (!packageName?.startsWith("@nextclaw/")) continue;
 		packages.push({
 			packageName,
@@ -6493,14 +6581,22 @@ const mergeLoadPaths$1 = (existingLoadPaths, devLoadPaths) => {
 	for (const entry of existingLoadPaths) if (!mergedLoadPaths.includes(entry)) mergedLoadPaths.push(entry);
 	return mergedLoadPaths;
 };
+const findWorkspacePackageForInstallRecord = (installRecord, workspacePackages, packageByName) => {
+	const packageName = normalizePackageSpec(readString$3(installRecord.spec) ?? "");
+	if (packageName) {
+		const matchedByPackageName = packageByName.get(packageName);
+		if (matchedByPackageName) return matchedByPackageName;
+	}
+	const installPathCandidates = new Set([installRecord.sourcePath, installRecord.installPath].map(normalizeInstallRecordPath).filter((entry) => Boolean(entry)));
+	if (installPathCandidates.size === 0) return;
+	return workspacePackages.find((workspacePackage) => installPathCandidates.has(path.resolve(workspacePackage.dir)));
+};
 const buildDevelopmentSourceEntryDefaults = (config, workspacePackages) => {
 	const packageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
 	const nextEntries = { ...config.plugins.entries ?? {} };
 	let didDefaultDevelopmentSource = false;
 	for (const [pluginId, installRecord] of Object.entries(config.plugins.installs ?? {})) {
-		const packageName = normalizePackageSpec(installRecord.spec ?? "");
-		if (!packageName) continue;
-		if (!packageByName.get(packageName)?.supportsDevelopmentSource) continue;
+		if (!findWorkspacePackageForInstallRecord(installRecord, workspacePackages, packageByName)?.supportsDevelopmentSource) continue;
 		const existingEntry = nextEntries[pluginId];
 		if (existingEntry?.source) continue;
 		nextEntries[pluginId] = {
@@ -6520,12 +6616,12 @@ const resolveDevFirstPartyPluginLoadPaths = (config, workspaceExtensionsDir) =>
 	const workspacePackages = readWorkspacePluginPackages(rootDir);
 	if (workspacePackages.length === 0) return [];
 	const packageDirByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry.dir]));
+	const packageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
 	const loadPaths = [];
 	const installs = config.plugins.installs ?? {};
 	for (const installRecord of Object.values(installs)) {
-		const packageName = normalizePackageSpec(installRecord.spec ?? "");
-		if (!packageName) continue;
-		const packageDir = packageDirByName.get(packageName);
+		const matchedWorkspacePackage = findWorkspacePackageForInstallRecord(installRecord, workspacePackages, packageByName);
+		const packageDir = matchedWorkspacePackage ? matchedWorkspacePackage.dir : packageDirByName.get(normalizePackageSpec(readString$3(installRecord.spec) ?? "") ?? "");
 		if (!packageDir || loadPaths.includes(packageDir)) continue;
 		loadPaths.push(packageDir);
 	}
@@ -6537,12 +6633,15 @@ const resolveDevFirstPartyPluginInstallRoots = (config, workspaceExtensionsDir)
 	const workspacePackages = readWorkspacePluginPackages(rootDir);
 	if (workspacePackages.length === 0) return [];
 	const packageNames = new Set(workspacePackages.map((entry) => entry.packageName));
+	const packageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
 	const installRoots = [];
 	for (const installRecord of Object.values(config.plugins.installs ?? {})) {
-		const packageName = normalizePackageSpec(installRecord.spec ?? "");
-		if (!packageName || !packageNames.has(packageName)) continue;
-		const installPath = readString(installRecord.installPath);
+		const workspacePackage = findWorkspacePackageForInstallRecord(installRecord, workspacePackages, packageByName);
+		const packageName = normalizePackageSpec(readString$3(installRecord.spec) ?? "");
+		if (!workspacePackage && (!packageName || !packageNames.has(packageName))) continue;
+		const installPath = readString$3(installRecord.installPath);
 		if (!installPath || installRoots.includes(installPath)) continue;
+		if (workspacePackage && path.resolve(installPath) === path.resolve(workspacePackage.dir)) continue;
 		installRoots.push(installPath);
 	}
 	return installRoots;
@@ -6571,7 +6670,7 @@ const applyDevFirstPartyPluginLoadPaths = (config, workspaceExtensionsDir) => {
 //#endregion
 //#region src/cli/commands/plugin/development-source/dev-plugin-overrides.utils.ts
 const DEV_PLUGIN_OVERRIDES_ENV = "NEXTCLAW_DEV_PLUGIN_OVERRIDES";
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString$6(value) {
@@ -6600,7 +6699,7 @@ function assertOverridePluginReadable(override) {
 	}
 }
 function readOverrideRecord(value, index) {
-	if (!isRecord$3(value)) throw new Error(`[dev-plugin-override] override[${index}] must be an object`);
+	if (!isRecord$4(value)) throw new Error(`[dev-plugin-override] override[${index}] must be an object`);
 	const pluginId = readOptionalString$6(value.pluginId);
 	const pluginPath = readOptionalString$6(value.pluginPath);
 	const source = value.source === "development" ? "development" : "production";
@@ -6851,7 +6950,9 @@ function toExtensionRegistry(pluginRegistry) {
 			kind: runtime.kind,
 			label: runtime.label,
 			createRuntime: runtime.createRuntime,
+			createRuntimeForEntry: runtime.createRuntimeForEntry,
 			describeSessionType: runtime.describeSessionType,
+			describeSessionTypeForEntry: runtime.describeSessionTypeForEntry,
 			source: runtime.source
 		})),
 		diagnostics: pluginRegistry.diagnostics.map((diag) => ({
@@ -8369,55 +8470,110 @@ var CronCommands = class {
 };
 //#endregion
 //#region src/cli/commands/ncp/ui-ncp-runtime-registry.ts
-const DEFAULT_UI_NCP_RUNTIME_KIND = "native";
-function normalizeRuntimeKind(value) {
+const DEFAULT_UI_NCP_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 readRequestedRuntimeKind(sessionMetadata) {
-	return normalizeRuntimeKind(sessionMetadata.runtime) ?? normalizeRuntimeKind(sessionMetadata.session_type) ?? normalizeRuntimeKind(sessionMetadata.sessionType) ?? null;
+function cloneRuntimeEntry(entry) {
+	return {
+		id: entry.id,
+		label: entry.label,
+		type: entry.type,
+		enabled: entry.enabled !== false,
+		config: entry.config ? { ...entry.config } : {}
+	};
+}
+function readRequestedRuntimeEntryId(sessionMetadata) {
+	return normalizeIdentifier(sessionMetadata.runtime) ?? normalizeIdentifier(sessionMetadata.session_type) ?? normalizeIdentifier(sessionMetadata.sessionType) ?? null;
 }
 var UiNcpRuntimeRegistry = class {
-	registrations = /* @__PURE__ */ new Map();
-	constructor(defaultKind = DEFAULT_UI_NCP_RUNTIME_KIND) {
-		this.defaultKind = defaultKind;
-	}
+	providers = /* @__PURE__ */ new Map();
+	entries = /* @__PURE__ */ new Map();
+	defaultEntryId = DEFAULT_UI_NCP_RUNTIME_ENTRY_ID;
 	register(registration) {
-		const normalizedKind = normalizeRuntimeKind(registration.kind);
+		const normalizedKind = normalizeIdentifier(registration.kind);
 		if (!normalizedKind) throw new Error("ui ncp runtime kind must be a non-empty string");
 		const token = Symbol(normalizedKind);
-		this.registrations.set(normalizedKind, {
+		this.providers.set(normalizedKind, {
 			...registration,
 			kind: normalizedKind,
 			token
 		});
 		return toDisposable(() => {
-			const current = this.registrations.get(normalizedKind);
+			const current = this.providers.get(normalizedKind);
 			if (!current || current.token !== token) return;
-			this.registrations.delete(normalizedKind);
+			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 requestedKind = readRequestedRuntimeKind(params.sessionMetadata) ?? this.defaultKind;
-		const registration = this.registrations.get(requestedKind);
-		if (!registration) throw new Error(`ncp runtime unavailable: ${requestedKind}`);
+		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,
-			session_type: registration.kind
+			runtime: entry.id,
+			session_type: entry.id,
+			runtime_type: entry.type
 		};
 		params.setSessionMetadata(nextSessionMetadata);
-		return registration.createRuntime({
+		if (provider.createRuntimeForEntry) return provider.createRuntimeForEntry({
+			entry: cloneRuntimeEntry(entry),
+			runtimeParams: {
+				...params,
+				sessionMetadata: nextSessionMetadata
+			}
+		});
+		return provider.createRuntime({
 			...params,
 			sessionMetadata: nextSessionMetadata
 		});
 	}
 	async listSessionTypes(params) {
-		const options = await Promise.all([...this.registrations.values()].map(async (registration) => {
-			const descriptor = await registration.describeSessionType?.(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,
+				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: registration.kind,
-				label: registration.label,
+				value: entry.id,
+				label: entry.label,
 				ready: descriptor?.ready ?? true,
 				reason: descriptor?.reason ?? null,
 				reasonMessage: descriptor?.reasonMessage ?? null,
@@ -8427,16 +8583,328 @@ var UiNcpRuntimeRegistry = class {
 			};
 		}));
 		return {
-			defaultType: this.defaultKind,
+			defaultType: this.defaultEntryId,
 			options: options.sort((left, right) => {
-				if (left.value === this.defaultKind) return -1;
-				if (right.value === this.defaultKind) return 1;
+				if (left.value === this.defaultEntryId) return -1;
+				if (right.value === this.defaultEntryId) return 1;
 				return left.value.localeCompare(right.value);
 			})
 		};
 	}
 };
 //#endregion
+//#region src/cli/commands/ncp/ui-ncp-runtime-entry-resolver.ts
+function readString$2(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function buildNativeRuntimeEntry(config) {
+	const nativeRuntimeConfig = readRecord$1(config.ui?.ncp?.runtimes?.native) ?? {};
+	return {
+		id: "native",
+		label: "Native",
+		type: "native",
+		enabled: nativeRuntimeConfig.enabled !== false,
+		config: nativeRuntimeConfig
+	};
+}
+function buildBuiltinRuntimeEntry(kind, label) {
+	return {
+		id: kind,
+		label,
+		type: kind,
+		enabled: true,
+		config: {}
+	};
+}
+function resolveUiNcpRuntimeEntries(params) {
+	const providerKindSet = new Set(params.providerKinds.map((kind) => kind.trim().toLowerCase()).filter(Boolean));
+	const entries = /* @__PURE__ */ new Map();
+	entries.set("native", buildNativeRuntimeEntry(params.config));
+	if (providerKindSet.has("codex")) entries.set("codex", buildBuiltinRuntimeEntry("codex", "Codex"));
+	if (providerKindSet.has("claude")) entries.set("claude", buildBuiltinRuntimeEntry("claude", "Claude"));
+	for (const [rawId, rawEntry] of Object.entries(params.config.agents.runtimes.entries ?? {})) {
+		const id = rawId.trim().toLowerCase();
+		const type = readString$2(rawEntry.type)?.toLowerCase();
+		if (!id || !type) continue;
+		entries.set(id, {
+			id,
+			label: readString$2(rawEntry.label) ?? id,
+			type,
+			enabled: rawEntry.enabled !== false,
+			config: rawEntry.config ? { ...rawEntry.config } : {}
+		});
+	}
+	return {
+		defaultEntryId: entries.has("native") ? "native" : [...entries.keys()][0] ?? "native",
+		entries: [...entries.values()]
+	};
+}
+//#endregion
+//#region src/cli/commands/ncp/builtin-narp-runtime-types.ts
+const NARP_HTTP_RUNTIME_KIND = "narp-http";
+const NARP_STDIO_RUNTIME_KIND = "narp-stdio";
+//#endregion
+//#region src/cli/commands/ncp/builtin-narp-runtime-registration.service.ts
+const NARP_API_MODE_HEADER = "x-nextclaw-narp-api-mode";
+function readRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString$1(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function resolveRequestedModel(params) {
+	const runMetadata = readRecord(params.input.metadata);
+	return readString$1(runMetadata?.preferred_model) ?? readString$1(runMetadata?.preferredModel) ?? readString$1(runMetadata?.model) ?? readString$1(params.sessionMetadata.preferred_model) ?? readString$1(params.sessionMetadata.preferredModel) ?? readString$1(params.sessionMetadata.model) ?? params.configuredModel ?? params.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;
+	return {
+		model: resolution.providerLocalModel,
+		apiKey: resolution.apiKey,
+		apiBase: resolution.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 {
+			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 {
+			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 {
+				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 {
+				ready: true,
+				reason: null,
+				reasonMessage: null,
+				recommendedModel: config.recommendedModel ?? null,
+				...config.supportedModels ? { supportedModels: config.supportedModels } : {},
+				cta: null
+			};
+		} catch (error) {
+			return {
+				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 = resolver.resolve();
+			if (!await resolveExecutablePath(config.command)) return {
+				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 {
+					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 {
+				ready: true,
+				reason: null,
+				reasonMessage: null,
+				cta: null
+			};
+		} catch (error) {
+			return {
+				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(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$1(config.model)
+			})
+		});
+	};
+	createStdioRuntime = (entry, runtimeParams) => {
+		const config = readRecord(entry.config) ?? {};
+		return new StdioRuntimeNcpAgentRuntime({
+			...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$1(config.model)
+			})
+		});
+	};
+};
+//#endregion
 //#region src/cli/commands/agent/agent-runtime.ts
 function createUnusedRuntime(_params) {
 	throw new Error("runtime creation is not available during runtime listing");
@@ -8463,15 +8931,21 @@ async function listAvailableAgentRuntimes(params) {
 	const pluginRegistry = loadRuntimeOnlyPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace));
 	logPluginDiagnostics(pluginRegistry);
 	const extensionRegistry = toExtensionRegistry(pluginRegistry);
-	const runtimeRegistry = new UiNcpRuntimeRegistry(DEFAULT_UI_NCP_RUNTIME_KIND);
+	const runtimeRegistry = new UiNcpRuntimeRegistry();
 	const runtimeSourceByKind = /* @__PURE__ */ new Map();
+	const runtimeSourceByEntryId = /* @__PURE__ */ new Map();
 	runtimeRegistry.register({
-		kind: DEFAULT_UI_NCP_RUNTIME_KIND,
+		kind: DEFAULT_UI_NCP_RUNTIME_ENTRY_ID,
 		label: "Native",
 		createRuntime: createUnusedRuntime
 	});
-	runtimeSourceByKind.set(DEFAULT_UI_NCP_RUNTIME_KIND, { source: "builtin" });
+	runtimeSourceByKind.set(DEFAULT_UI_NCP_RUNTIME_ENTRY_ID, { source: "builtin" });
+	new BuiltinNarpRuntimeRegistrationService(() => config).registerInto(runtimeRegistry);
+	runtimeSourceByKind.set("narp-http", { source: "builtin" });
+	runtimeSourceByKind.set("narp-stdio", { source: "builtin" });
 	for (const registration of extensionRegistry.ncpAgentRuntimes) {
+		const normalizedKind = registration.kind.trim().toLowerCase();
+		if (normalizedKind === "narp-http" || normalizedKind === "narp-stdio") continue;
 		runtimeRegistry.register({
 			kind: registration.kind,
 			label: registration.label,
@@ -8483,11 +8957,20 @@ async function listAvailableAgentRuntimes(params) {
 			pluginId: registration.pluginId
 		});
 	}
+	const resolvedEntries = resolveUiNcpRuntimeEntries({
+		config,
+		providerKinds: runtimeRegistry.listProviderKinds()
+	});
+	runtimeRegistry.applyEntries(resolvedEntries);
+	for (const entry of resolvedEntries.entries) {
+		const source = runtimeSourceByKind.get(entry.type);
+		runtimeSourceByEntryId.set(entry.id, source ?? { source: entry.id === "native" ? "builtin" : "plugin" });
+	}
 	const listed = await runtimeRegistry.listSessionTypes(params);
 	return {
 		defaultRuntime: listed.defaultType,
 		runtimes: listed.options.map((runtime) => {
-			const source = runtimeSourceByKind.get(runtime.value);
+			const source = runtimeSourceByEntryId.get(runtime.value);
 			return {
 				...runtime,
 				default: runtime.value === listed.defaultType,
@@ -10343,7 +10826,7 @@ var RemoteAccessHost = class {
 	};
 };
 //#endregion
-//#region src/cli/commands/service-support/runtime/service-remote-access.ts
+//#region src/cli/commands/service-support/ui/service-remote-access.service.ts
 function requestManagedServiceRestart(requestRestart, options = {}) {
 	const uiPort = typeof options.uiPort === "number" && Number.isFinite(options.uiPort) ? Math.floor(options.uiPort) : void 0;
 	return requestRestart({
@@ -10355,27 +10838,122 @@ function requestManagedServiceRestart(requestRestart, options = {}) {
 	});
 }
 function createRemoteAccessHost(params) {
-	const currentLocalOrigin = `http://127.0.0.1:${params.uiConfig.port}`;
+	const { remoteModule, requestRestart, serviceCommands, uiConfig } = params;
 	return new RemoteAccessHost({
-		serviceCommands: params.serviceCommands,
-		requestManagedServiceRestart: (options) => requestManagedServiceRestart(params.requestRestart, options),
-		remoteCommands: new RemoteCommands({ currentLocalOrigin }),
+		serviceCommands,
+		requestManagedServiceRestart: (options) => requestManagedServiceRestart(requestRestart, options),
+		remoteCommands: new RemoteCommands({ currentLocalOrigin: `http://127.0.0.1:${uiConfig.port}` }),
 		platformAuthCommands: new PlatformAuthCommands(),
-		currentUi: params.uiConfig,
-		remoteRuntimeController: params.remoteModule ? {
+		currentUi: uiConfig,
+		remoteRuntimeController: remoteModule ? {
 			start: async () => {
-				params.remoteModule?.start();
+				remoteModule?.start();
 			},
 			stop: async () => {
-				await params.remoteModule?.stop();
+				await remoteModule?.stop();
 			},
 			restart: async () => {
-				await params.remoteModule?.restart();
+				await remoteModule?.restart();
 			}
 		} : null
 	});
 }
 //#endregion
+//#region src/cli/commands/service-support/ui/runtime-control-host.service.ts
+const MANAGED_SERVICE_OWNER_LABEL = "Managed local service";
+const DESKTOP_APP_ONLY_REASON = "App restart is only available in the desktop shell.";
+const RUNNING_PAGE_START_REASON = "This page is already hosted by the running local service.";
+var RuntimeControlHost = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	getControl = () => {
+		const service = resolveRemoteServiceView(this.deps.uiConfig);
+		const serviceRunning = service.running;
+		return {
+			environment: "managed-local-service",
+			lifecycle: serviceRunning ? "healthy" : "unavailable",
+			serviceState: serviceRunning ? "running" : "stopped",
+			canStartService: {
+				available: !serviceRunning,
+				requiresConfirmation: false,
+				impact: "brief-ui-disconnect",
+				...serviceRunning ? { reasonIfUnavailable: RUNNING_PAGE_START_REASON } : {}
+			},
+			canRestartService: {
+				available: serviceRunning,
+				requiresConfirmation: false,
+				impact: "brief-ui-disconnect",
+				...!serviceRunning ? { reasonIfUnavailable: "The local service is not running." } : {}
+			},
+			canStopService: {
+				available: serviceRunning,
+				requiresConfirmation: true,
+				impact: "brief-ui-disconnect",
+				...!serviceRunning ? { reasonIfUnavailable: "The local service is already stopped." } : {}
+			},
+			canRestartApp: {
+				available: false,
+				requiresConfirmation: true,
+				impact: "full-app-relaunch",
+				reasonIfUnavailable: DESKTOP_APP_ONLY_REASON
+			},
+			ownerLabel: MANAGED_SERVICE_OWNER_LABEL,
+			managementHint: service.currentProcess ? "This page is served by the running local service. Closing the browser does not stop it." : "Manage the local NextClaw service from this page without tying service lifecycle to the browser tab.",
+			message: "Use this page to manage the local NextClaw service. Closing the browser does not stop the service."
+		};
+	};
+	startService = async () => {
+		const result = await controlRemoteService("start", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "start-service",
+			lifecycle: "starting-service",
+			message: result.message
+		};
+	};
+	restartService = async () => {
+		const result = await controlRemoteService("restart", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "restart-service",
+			lifecycle: "restarting-service",
+			message: result.message
+		};
+	};
+	stopService = async () => {
+		const result = await controlRemoteService("stop", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "stop-service",
+			lifecycle: "stopping-service",
+			message: result.message
+		};
+	};
+	createServiceControlDeps = () => {
+		return {
+			serviceCommands: this.deps.serviceCommands,
+			requestManagedServiceRestart: () => requestManagedServiceRestart(this.deps.requestRestart, { uiPort: this.deps.uiConfig.port }),
+			currentUi: this.deps.uiConfig
+		};
+	};
+};
+function createRuntimeControlHost(params) {
+	return new RuntimeControlHost(params);
+}
+//#endregion
+//#region src/cli/commands/service-support/ui/service-ui-hosts.service.ts
+function createServiceUiHosts(params) {
+	return {
+		remoteAccess: createRemoteAccessHost(params),
+		runtimeControl: createRuntimeControlHost({
+			serviceCommands: params.serviceCommands,
+			requestRestart: params.requestRestart,
+			uiConfig: params.uiConfig
+		})
+	};
+}
+//#endregion
 //#region src/cli/commands/ncp/runtime/ncp-asset-tools.ts
 function readOptionalString$5(value) {
 	if (typeof value !== "string") return null;
@@ -10547,11 +11125,11 @@ function normalizeString(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function cloneMetadata(value) {
-	return isRecord$2(value) ? structuredClone(value) : void 0;
+	return isRecord$3(value) ? structuredClone(value) : void 0;
 }
 function readStringArray(value) {
 	if (!Array.isArray(value)) return null;
@@ -11030,10 +11608,10 @@ var SessionSpawnTool = class extends Tool {
 //#endregion
 //#region src/cli/commands/ncp/nextclaw-ncp-tool-registry.ts
 function toToolParams(args) {
-	if (isRecord$2(args)) return args;
+	if (isRecord$3(args)) return args;
 	if (typeof args === "string") try {
 		const parsed = JSON.parse(args);
-		return isRecord$2(parsed) ? parsed : {};
+		return isRecord$3(parsed) ? parsed : {};
 	} catch {
 		return {};
 	}
@@ -11076,13 +11654,14 @@ var NextclawNcpToolRegistry = class {
 		this.options = options;
 	}
 	prepareForRun = (context) => {
+		const { channel, chatId, config, restrictToWorkspace, sessionId, workspace } = context;
 		this.currentExtensionToolContext = {
-			config: context.config,
-			workspaceDir: context.workspace,
-			sessionKey: context.sessionId,
-			channel: context.channel,
-			chatId: context.chatId,
-			sandboxed: context.restrictToWorkspace
+			config,
+			workspaceDir: workspace,
+			sessionKey: sessionId,
+			channel,
+			chatId,
+			sandboxed: restrictToWorkspace
 		};
 		this.registry = new ToolRegistry();
 		this.tools.clear();
@@ -11210,26 +11789,17 @@ function readAccountIdForHints(metadata, sessionMetadata) {
 //#endregion
 //#region src/cli/commands/ncp/nextclaw-ncp-context-builder.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) {
+function isRecord$2(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;
+	const messageMetadata = input.messages.slice().reverse().find((message) => isRecord$2(message.metadata))?.metadata;
 	return {
-		...isRecord$1(messageMetadata) ? structuredClone(messageMetadata) : {},
-		...isRecord$1(input.metadata) ? structuredClone(input.metadata) : {}
+		...isRecord$2(messageMetadata) ? structuredClone(messageMetadata) : {},
+		...isRecord$2(input.metadata) ? structuredClone(input.metadata) : {}
 	};
 }
-function resolveRequestedSkillNames(metadata) {
-	const rawValue = metadata.requested_skills ?? metadata.requestedSkills;
-	const values = [];
-	if (Array.isArray(rawValue)) for (const item of rawValue) {
-		const normalized = normalizeString(item);
-		if (normalized) values.push(normalized);
-	}
-	else if (typeof rawValue === "string") values.push(...rawValue.split(/[,\s]+/g).map((item) => item.trim()).filter(Boolean));
-	return Array.from(new Set(values)).slice(0, 8);
-}
+const REQUESTED_SKILLS_METADATA_READER = new RequestedSkillsMetadataReader();
 function resolveRequestedToolNames(metadata) {
 	const rawValue = metadata.requested_tools ?? metadata.requestedTools;
 	if (!Array.isArray(rawValue)) return [];
@@ -11275,9 +11845,9 @@ 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, requestedSkillNames) {
-	if (requestedSkillNames.length === 0) return content;
-	return `[Requested skills for this turn: ${requestedSkillNames.join(", ")}]\n\n${content}`;
+function prependRequestedSkills(content, requestedSkillSelectors) {
+	if (requestedSkillSelectors.length === 0) return content;
+	return `[Requested skills for this turn: ${requestedSkillSelectors.join(", ")}]\n\n${content}`;
 }
 function buildSessionOrchestrationSection() {
 	return [
@@ -11333,12 +11903,12 @@ var NextclawNcpContextBuilder = class {
 			session,
 			requestMetadata
 		});
-		const requestedSkillNames = resolveRequestedSkillNames(requestMetadata);
+		const requestedSkills = REQUESTED_SKILLS_METADATA_READER.readSelection(requestMetadata);
 		const requestedToolNames = resolveRequestedToolNames(requestMetadata);
 		const currentTurn = buildCurrentTurnState({
 			input,
 			currentModel: effectiveModel,
-			formatPrompt: ({ text, timestamp }) => appendTimeHintForPrompt(prependRequestedSkills(text, requestedSkillNames), timestamp),
+			formatPrompt: ({ text, timestamp }) => appendTimeHintForPrompt(prependRequestedSkills(text, requestedSkills.selectors), timestamp),
 			assetStore: this.options.assetStore
 		});
 		effectiveModel = currentTurn.effectiveModel;
@@ -11386,7 +11956,7 @@ var NextclawNcpContextBuilder = class {
 			chatId,
 			sessionKey: input.sessionId,
 			thinkingLevel: runtimeThinking,
-			skillNames: requestedSkillNames,
+			skillNames: requestedSkills.selectors,
 			messageToolHints,
 			availableTools: buildToolCatalogEntries(toolDefinitions),
 			additionalSystemSections
@@ -11806,6 +12376,13 @@ function cloneInheritedMetadata(sourceMetadata) {
 	}
 	return nextMetadata;
 }
+function mergeMetadataOverrides(metadata, overrides) {
+	if (!overrides || Object.keys(overrides).length === 0) return metadata;
+	return {
+		...metadata,
+		...structuredClone(overrides)
+	};
+}
 function buildSessionId() {
 	return `ncp-${Date.now().toString(36)}-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
 }
@@ -11816,27 +12393,29 @@ function resolveSessionTitle(params) {
 	return readOptionalString$2(params.title) ?? summarizeTask(params.task);
 }
 function resolveSessionType(params) {
-	return readOptionalString$2(params.runtime) ?? readOptionalString$2(params.metadata.runtime) ?? readOptionalString$2(params.sessionType) ?? readOptionalString$2(params.metadata.session_type) ?? DEFAULT_SESSION_TYPE;
+	const { metadata, runtime, sessionType } = params;
+	return readOptionalString$2(runtime) ?? readOptionalString$2(metadata.runtime) ?? readOptionalString$2(sessionType) ?? readOptionalString$2(metadata.session_type) ?? DEFAULT_SESSION_TYPE;
 }
 function applySessionOverrides(params) {
-	params.metadata.session_type = params.sessionType;
-	params.metadata.runtime = params.sessionType;
-	params.metadata[SESSION_METADATA_LABEL_KEY] = params.title;
-	params.metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = params.lifecycle;
-	if (params.parentSessionId) {
-		params.metadata[CHILD_SESSION_PARENT_METADATA_KEY] = params.parentSessionId;
-		params.metadata[CHILD_SESSION_PROMOTED_METADATA_KEY] = false;
-	}
-	if (params.requestId) params.metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = params.requestId;
-	if (readOptionalString$2(params.model)) {
-		params.metadata.model = params.model?.trim();
-		params.metadata.preferred_model = params.model?.trim();
-	}
-	if (readOptionalString$2(params.thinkingLevel)) {
-		params.metadata.thinking = params.thinkingLevel?.trim();
-		params.metadata.preferred_thinking = params.thinkingLevel?.trim();
-	}
-	if (readOptionalString$2(params.projectRoot)) params.metadata.project_root = params.projectRoot?.trim();
+	const { lifecycle, metadata, model, parentSessionId, projectRoot, requestId, sessionType, thinkingLevel, title } = params;
+	metadata.session_type = sessionType;
+	metadata.runtime = sessionType;
+	metadata[SESSION_METADATA_LABEL_KEY] = title;
+	metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = lifecycle;
+	if (parentSessionId) {
+		metadata[CHILD_SESSION_PARENT_METADATA_KEY] = parentSessionId;
+		metadata[CHILD_SESSION_PROMOTED_METADATA_KEY] = false;
+	}
+	if (requestId) metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = requestId;
+	if (readOptionalString$2(model)) {
+		metadata.model = model?.trim();
+		metadata.preferred_model = model?.trim();
+	}
+	if (readOptionalString$2(thinkingLevel)) {
+		metadata.thinking = thinkingLevel?.trim();
+		metadata.preferred_thinking = thinkingLevel?.trim();
+	}
+	if (readOptionalString$2(projectRoot)) metadata.project_root = projectRoot?.trim();
 }
 var SessionCreationService = class {
 	constructor(sessionManager, getConfig, onSessionUpdated) {
@@ -11845,23 +12424,24 @@ var SessionCreationService = class {
 		this.onSessionUpdated = onSessionUpdated;
 	}
 	createSession = (params) => {
+		const { agentId, metadataOverrides, model, parentSessionId: rawParentSessionId, projectRoot, requestId: rawRequestId, runtime, sessionType: requestedSessionType, sourceSessionMetadata, task, thinkingLevel, title: requestedTitle } = params;
 		const sessionId = buildSessionId();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const session = this.sessionManager.getOrCreate(sessionId);
 		const resolvedAgentId = resolveSessionAgentId({
-			agentId: params.agentId,
+			agentId,
 			getConfig: this.getConfig
 		});
 		const title = resolveSessionTitle({
-			title: params.title,
-			task: params.task
+			title: requestedTitle,
+			task
 		});
-		const metadata = cloneInheritedMetadata(params.sourceSessionMetadata);
-		const parentSessionId = readOptionalString$2(params.parentSessionId);
-		const requestId = readOptionalString$2(params.requestId);
+		const metadata = cloneInheritedMetadata(sourceSessionMetadata);
+		const parentSessionId = readOptionalString$2(rawParentSessionId);
+		const requestId = readOptionalString$2(rawRequestId);
 		const sessionType = resolveSessionType({
-			runtime: params.runtime,
-			sessionType: params.sessionType,
+			runtime,
+			sessionType: requestedSessionType,
 			metadata
 		});
 		applySessionOverrides({
@@ -11871,12 +12451,13 @@ var SessionCreationService = class {
 			lifecycle: DEFAULT_LIFECYCLE,
 			parentSessionId,
 			requestId,
-			model: params.model,
-			thinkingLevel: params.thinkingLevel,
-			projectRoot: params.projectRoot
+			model,
+			thinkingLevel,
+			projectRoot
 		});
+		const nextMetadata = mergeMetadataOverrides(metadata, metadataOverrides);
 		session.agentId = resolvedAgentId;
-		session.metadata = metadata;
+		session.metadata = nextMetadata;
 		session.updatedAt = new Date(now);
 		this.sessionManager.save(session);
 		this.onSessionUpdated?.(sessionId);
@@ -11889,7 +12470,7 @@ var SessionCreationService = class {
 			...requestId ? { spawnedByRequestId: requestId } : {},
 			lifecycle: DEFAULT_LIFECYCLE,
 			title,
-			metadata,
+			metadata: nextMetadata,
 			createdAt: session.createdAt.toISOString(),
 			updatedAt: session.updatedAt.toISOString()
 		};
@@ -12019,7 +12600,7 @@ function createFailedSessionRequest(params) {
 	};
 }
 //#endregion
-//#region src/cli/commands/ncp/session-request/session-request-broker.ts
+//#region src/cli/commands/ncp/session-request/session-request-broker.service.ts
 var SessionRequestBroker = class {
 	constructor(sessionManager, sessionCreationService, deliveryService, resolveBackend, onSessionUpdated) {
 		this.sessionManager = sessionManager;
@@ -12029,13 +12610,14 @@ var SessionRequestBroker = class {
 		this.onSessionUpdated = onSessionUpdated;
 	}
 	spawnSessionAndRequest = async (params) => {
-		const { sourceSessionId, sourceToolCallId, sourceSessionMetadata, task, title, model, runtime, handoffDepth, sessionType, thinkingLevel, projectRoot, agentId, parentSessionId, notify } = params;
+		const { sourceSessionId, sourceToolCallId, sourceSessionMetadata, metadataOverrides, task, title, model, runtime, handoffDepth, sessionType, thinkingLevel, projectRoot, agentId, parentSessionId, notify } = params;
 		const requestId = randomUUID();
 		const createdSession = this.sessionCreationService.createSession({
 			...parentSessionId ? { parentSessionId } : {},
 			task,
 			title,
 			sourceSessionMetadata,
+			...metadataOverrides ? { metadataOverrides } : {},
 			agentId,
 			model,
 			runtime,
@@ -12335,25 +12917,423 @@ var SessionRequestDeliveryService = class {
 	};
 };
 //#endregion
-//#region src/cli/commands/shared/llm-usage-observer.ts
-var LlmUsageObserver = class {
-	constructor(recorder, source) {
-		this.recorder = recorder;
-		this.source = source;
+//#region src/cli/commands/ncp/session-search/session-search-index.manager.ts
+const AUTO_LABEL_MAX_LENGTH = 64;
+function normalizeWhitespace$1(value) {
+	return value.replace(/\s+/gu, " ").trim();
+}
+function truncateLabel(value) {
+	const characters = Array.from(value);
+	if (characters.length <= AUTO_LABEL_MAX_LENGTH) return value;
+	return `${characters.slice(0, AUTO_LABEL_MAX_LENGTH).join("")}…`;
+}
+function resolveSessionLabel(session) {
+	const metadataLabel = normalizeString(session.metadata?.label) ?? normalizeString(session.metadata?.session_label);
+	if (metadataLabel) return metadataLabel;
+	for (const message of session.messages) {
+		if (message.role !== "user") continue;
+		const text = normalizeString(extractTextFromNcpMessage(message));
+		if (text) return truncateLabel(text);
+	}
+	return "";
+}
+function buildSearchableContent(session) {
+	const lines = [];
+	for (const message of session.messages) {
+		if (message.role !== "user" && message.role !== "assistant") continue;
+		const text = normalizeString(extractTextFromNcpMessage(message));
+		if (!text) continue;
+		lines.push(`${message.role}: ${normalizeWhitespace$1(text)}`);
+	}
+	return lines.join("\n");
+}
+var SessionSearchIndexManager = class {
+	constructor(store) {
+		this.store = store;
+	}
+	indexSession = async (session) => {
+		const document = this.buildDocument(session);
+		if (!document) {
+			await this.store.deleteDocument(session.sessionId);
+			return;
+		}
+		await this.store.upsertDocument(document);
+	};
+	buildDocument(session) {
+		const label = resolveSessionLabel(session);
+		const content = buildSearchableContent(session);
+		if (!label && !content) return null;
+		return {
+			sessionId: session.sessionId,
+			label,
+			content,
+			updatedAt: session.updatedAt
+		};
 	}
-	observe = (params) => {
-		return this.recorder.record({
-			source: this.source,
-			model: params.model ?? null,
-			usage: params.usage
+};
+//#endregion
+//#region src/cli/commands/ncp/session-search/session-search-query.service.ts
+const SNIPPET_RADIUS = 80;
+const MAX_FULL_SNIPPET_LENGTH = 180;
+function normalizeWhitespace(value) {
+	return value.replace(/\s+/gu, " ").trim();
+}
+function sanitizeSearchToken(value) {
+	return value.replace(/["*]/gu, " ").replace(/\s+/gu, " ").trim();
+}
+function tokenizeSearchTerms(query) {
+	return normalizeWhitespace(query).split(" ").map(sanitizeSearchToken).filter((token) => token.length > 0);
+}
+function buildMatchExpression(query) {
+	const terms = tokenizeSearchTerms(query);
+	const normalizedTerms = (terms.length > 0 ? terms : [sanitizeSearchToken(query)]).filter((term) => term.length > 0);
+	if (normalizedTerms.length === 0) throw new Error("query must contain searchable text.");
+	return normalizedTerms.map((term) => `"${term.replace(/"/gu, "\"\"")}"*`).join(" AND ");
+}
+function findFirstMatchIndex(text, terms) {
+	const lowerText = text.toLowerCase();
+	let earliestIndex = -1;
+	for (const term of terms) {
+		const index = lowerText.indexOf(term.toLowerCase());
+		if (index < 0) continue;
+		if (earliestIndex < 0 || index < earliestIndex) earliestIndex = index;
+	}
+	return earliestIndex;
+}
+function buildSnippet(text, terms) {
+	const normalizedText = normalizeWhitespace(text);
+	if (normalizedText.length <= MAX_FULL_SNIPPET_LENGTH) return normalizedText;
+	const matchIndex = findFirstMatchIndex(normalizedText, terms);
+	if (matchIndex < 0) return `${normalizedText.slice(0, MAX_FULL_SNIPPET_LENGTH).trimEnd()}...`;
+	const start = Math.max(0, matchIndex - SNIPPET_RADIUS);
+	const end = Math.min(normalizedText.length, matchIndex + SNIPPET_RADIUS);
+	const prefix = start > 0 ? "..." : "";
+	const suffix = end < normalizedText.length ? "..." : "";
+	return `${prefix}${normalizedText.slice(start, end).trim()}${suffix}`;
+}
+function resolveMatchSource(hit, terms) {
+	return findFirstMatchIndex(hit.label, terms) >= 0 ? "label" : "content";
+}
+function normalizeLimit(limit) {
+	if (typeof limit !== "number" || !Number.isFinite(limit)) return 5;
+	const roundedLimit = Math.trunc(limit);
+	if (roundedLimit <= 0) return 5;
+	return Math.min(roundedLimit, 10);
+}
+var SessionSearchQueryService = class {
+	constructor(store) {
+		this.store = store;
+	}
+	search = async (request) => {
+		const query = normalizeString(request.query);
+		if (!query) throw new Error("query must be a non-empty string.");
+		const terms = tokenizeSearchTerms(query);
+		const matchExpression = buildMatchExpression(query);
+		const excludeSessionId = request.includeCurrentSession === true ? void 0 : normalizeString(request.currentSessionId) ?? void 0;
+		const result = await this.store.searchDocuments({
+			matchExpression,
+			limit: normalizeLimit(request.limit),
+			excludeSessionId
 		});
+		return {
+			query,
+			totalHits: result.total,
+			hits: result.hits.map((hit) => this.toSearchHit(hit, terms))
+		};
 	};
+	toSearchHit(hit, terms) {
+		const matchSource = resolveMatchSource(hit, terms);
+		const label = normalizeWhitespace(hit.label) || hit.sessionId;
+		const snippetSource = matchSource === "label" ? label : hit.content;
+		return {
+			sessionId: hit.sessionId,
+			label,
+			updatedAt: hit.updatedAt,
+			snippet: buildSnippet(snippetSource, terms),
+			matchSource,
+			rank: hit.rank
+		};
+	}
 };
-var ObservedProviderManager = class extends ProviderManager {
-	constructor(delegate, observer) {
-		super(delegate.get(null));
-		this.delegate = delegate;
-		this.observer = observer;
+//#endregion
+//#region src/cli/commands/ncp/session-search/session-search-store.service.ts
+const SESSION_SEARCH_TABLE = "session_search_index";
+var SessionSearchStoreService = class {
+	database = null;
+	constructor(databasePath) {
+		this.databasePath = databasePath;
+	}
+	initialize = async () => {
+		if (this.database) return;
+		mkdirSync(dirname(this.databasePath), { recursive: true });
+		this.database = new DatabaseSync(this.databasePath);
+		this.database.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE VIRTUAL TABLE IF NOT EXISTS ${SESSION_SEARCH_TABLE}
+      USING fts5(
+        session_id UNINDEXED,
+        label,
+        content,
+        updated_at UNINDEXED,
+        tokenize = 'unicode61'
+      );
+    `);
+	};
+	listIndexedSessionIds = async () => {
+		return this.requireDatabase().prepare(`
+      SELECT session_id AS sessionId
+      FROM ${SESSION_SEARCH_TABLE}
+    `).all().map((row) => typeof row.sessionId === "string" ? row.sessionId : "").filter((sessionId) => sessionId.length > 0);
+	};
+	upsertDocument = async (document) => {
+		const database = this.requireDatabase();
+		this.withTransaction(() => {
+			database.prepare(`
+        DELETE FROM ${SESSION_SEARCH_TABLE}
+        WHERE session_id = ?
+      `).run(document.sessionId);
+			database.prepare(`
+        INSERT INTO ${SESSION_SEARCH_TABLE} (session_id, label, content, updated_at)
+        VALUES (?, ?, ?, ?)
+      `).run(document.sessionId, document.label, document.content, document.updatedAt);
+		});
+	};
+	deleteDocument = async (sessionId) => {
+		this.requireDatabase().prepare(`
+      DELETE FROM ${SESSION_SEARCH_TABLE}
+      WHERE session_id = ?
+    `).run(sessionId);
+	};
+	searchDocuments = async (query) => {
+		const database = this.requireDatabase();
+		const countSql = this.buildSearchSql({
+			includeLimit: false,
+			excludeSessionId: Boolean(query.excludeSessionId)
+		});
+		const searchSql = this.buildSearchSql({
+			includeLimit: true,
+			excludeSessionId: Boolean(query.excludeSessionId)
+		});
+		const sharedParams = query.excludeSessionId ? [query.matchExpression, query.excludeSessionId] : [query.matchExpression];
+		const countRow = database.prepare(countSql).get(...sharedParams);
+		const rows = database.prepare(searchSql).all(...sharedParams, query.limit);
+		return {
+			total: typeof countRow?.total === "number" ? countRow.total : 0,
+			hits: rows.map((row) => ({
+				sessionId: typeof row.sessionId === "string" ? row.sessionId : "",
+				label: typeof row.label === "string" ? row.label : "",
+				content: typeof row.content === "string" ? row.content : "",
+				updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : "",
+				rank: typeof row.rank === "number" ? row.rank : 0
+			}))
+		};
+	};
+	close = async () => {
+		this.database?.close();
+		this.database = null;
+	};
+	buildSearchSql(params) {
+		const extraFilter = params.excludeSessionId ? "AND session_id <> ?" : "";
+		if (!params.includeLimit) return `
+        SELECT COUNT(*) AS total
+        FROM ${SESSION_SEARCH_TABLE}
+        WHERE ${SESSION_SEARCH_TABLE} MATCH ?
+        ${extraFilter}
+      `;
+		return `
+      SELECT
+        session_id AS sessionId,
+        label,
+        content,
+        updated_at AS updatedAt,
+        bm25(${SESSION_SEARCH_TABLE}) AS rank
+      FROM ${SESSION_SEARCH_TABLE}
+      WHERE ${SESSION_SEARCH_TABLE} MATCH ?
+      ${extraFilter}
+      ORDER BY rank, updated_at DESC
+      LIMIT ?
+    `;
+	}
+	withTransaction(work) {
+		const database = this.requireDatabase();
+		database.exec("BEGIN IMMEDIATE");
+		try {
+			work();
+			database.exec("COMMIT");
+		} catch (error) {
+			database.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	requireDatabase() {
+		if (!this.database) throw new Error("Session search store has not been initialized.");
+		return this.database;
+	}
+};
+//#endregion
+//#region src/cli/commands/ncp/session-search/session-search-tool.service.ts
+function isRecord$1(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: 10,
+				description: `Optional max hit count. Defaults to 5.`
+			},
+			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 > 10)) issues.push(`limit must be between 1 and 10.`);
+		if (typeof args.includeCurrentSession !== "undefined" && typeof includeCurrentSession === "undefined") issues.push("includeCurrentSession must be a boolean.");
+		return issues;
+	};
+	execute = async (args) => {
+		if (!isRecord$1(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/cli/commands/ncp/session-search/session-search-feature.service.ts
+var SessionSearchFeatureService = class {
+	store;
+	indexManager;
+	queryService;
+	pendingWork = Promise.resolve();
+	initialized = false;
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+		this.store = new SessionSearchStoreService(options.databasePath);
+		this.indexManager = new SessionSearchIndexManager(this.store);
+		this.queryService = new SessionSearchQueryService(this.store);
+	}
+	initialize = async () => {
+		if (this.initialized) return;
+		if (this.disposed) throw new Error("Session search feature has already been disposed.");
+		await this.store.initialize();
+		await this.enqueue(async () => {
+			const sessions = await this.options.sessionStore.listSessions();
+			const activeSessionIds = new Set(sessions.map((session) => session.sessionId));
+			for (const session of sessions) await this.indexManager.indexSession(session);
+			const indexedSessionIds = await this.store.listIndexedSessionIds();
+			for (const sessionId of indexedSessionIds) if (!activeSessionIds.has(sessionId)) await this.store.deleteDocument(sessionId);
+		});
+		this.initialized = true;
+	};
+	createTool = (params) => new SessionSearchTool(this.queryService, params);
+	handleSessionUpdated = async (sessionId) => {
+		if (this.disposed || !this.initialized) return;
+		await this.enqueue(async () => {
+			const session = await this.options.sessionStore.getSession(sessionId);
+			if (!session) {
+				await this.store.deleteDocument(sessionId);
+				return;
+			}
+			await this.indexManager.indexSession(session);
+		});
+	};
+	dispose = async () => {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.pendingWork;
+		await this.store.close();
+	};
+	enqueue(work) {
+		const next = this.pendingWork.then(work);
+		this.pendingWork = next.catch(() => void 0);
+		return next;
+	}
+};
+//#endregion
+//#region src/cli/commands/ncp/session-search/session-search-runtime.service.ts
+function formatErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+var SessionSearchRuntimeSupport = class {
+	feature;
+	constructor(params) {
+		this.onSessionUpdated = params.onSessionUpdated;
+		this.feature = new SessionSearchFeatureService({
+			sessionStore: new NextclawAgentSessionStore(params.sessionManager),
+			databasePath: params.databasePath
+		});
+	}
+	onSessionUpdated;
+	initialize = async () => {
+		await this.feature.initialize();
+	};
+	createTool = (params) => this.feature.createTool(params);
+	handleSessionUpdated = (sessionKey) => {
+		this.onSessionUpdated?.(sessionKey);
+		this.feature.handleSessionUpdated(sessionKey).catch((error) => {
+			console.warn(`[session-search] Failed to update ${sessionKey}: ${formatErrorMessage(error)}`);
+		});
+	};
+	dispose = async () => {
+		await this.feature.dispose();
+	};
+};
+//#endregion
+//#region src/cli/commands/shared/llm-usage-observer.ts
+var LlmUsageObserver = class {
+	constructor(recorder, source) {
+		this.recorder = recorder;
+		this.source = source;
+	}
+	observe = (params) => {
+		return this.recorder.record({
+			source: this.source,
+			model: params.model ?? null,
+			usage: params.usage
+		});
+	};
+};
+var ObservedProviderManager = class extends ProviderManager {
+	constructor(delegate, observer) {
+		super(delegate.get(null));
+		this.delegate = delegate;
+		this.observer = observer;
 	}
 	get(model) {
 		return this.delegate.get(model);
@@ -12385,7 +13365,7 @@ var ObservedProviderManager = class extends ProviderManager {
 //#endregion
 //#region src/cli/commands/ncp/runtime/ui-ncp-agent-handle.ts
 function createUiNcpAgentHandle(params) {
-	const { backend, runtimeRegistry, refreshPluginRuntimeRegistrations, applyExtensionRegistry, applyMcpConfig, dispose, assetStore } = params;
+	const { backend, runtimeRegistry, refreshPluginRuntimeRegistrations, refreshConfiguredRuntimeEntries, applyExtensionRegistry, applyMcpConfig, dispose, assetStore } = params;
 	return {
 		basePath: "/api/ncp/agent",
 		agentClientEndpoint: createAgentClientFromServer(backend),
@@ -12394,6 +13374,7 @@ function createUiNcpAgentHandle(params) {
 		sessionApi: backend,
 		listSessionTypes: (describeParams) => {
 			refreshPluginRuntimeRegistrations();
+			refreshConfiguredRuntimeEntries();
 			return runtimeRegistry.listSessionTypes(describeParams);
 		},
 		assetApi: {
@@ -12412,6 +13393,356 @@ function createUiNcpAgentHandle(params) {
 	};
 }
 //#endregion
+//#region src/cli/commands/learning-loop/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"];
+function readLearningLoopRuntimeConfig(config) {
+	return {
+		enabled: config.agents.learningLoop.enabled,
+		toolCallThreshold: config.agents.learningLoop.toolCallThreshold ?? 15
+	};
+}
+//#endregion
+//#region src/cli/commands/learning-loop/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/cli/commands/ncp/lifecycle-events/ncp-lifecycle-event.config.ts
+const agentRunStartedLifecycleEventKey = createTypedEventKey("agent.run.started");
+const agentRunFinishedLifecycleEventKey = createTypedEventKey("agent.run.finished");
+const agentMessageSentLifecycleEventKey = createTypedEventKey("agent.message.sent");
+const agentSessionUpdatedLifecycleEventKey = createTypedEventKey("agent.session.updated");
+//#endregion
+//#region src/cli/commands/learning-loop/learning-loop-feature.service.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 LearningLoopFeature = class {
+	inFlightSessionIds = /* @__PURE__ */ new Set();
+	unsubscribe = null;
+	constructor(config) {
+		this.config = config;
+	}
+	start = () => {
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.config.eventBus.on(agentRunFinishedLifecycleEventKey, this.handleRunFinished);
+	};
+	dispose = () => {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
+	};
+	handleRunFinished = (event) => {
+		this.handleRunFinishedInBackground(event).catch((error) => {
+			console.warn(`[learning-loop] Failed for ${event.sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	handleRunFinishedInBackground = async (event) => {
+		if (event.isChildSession || this.inFlightSessionIds.has(event.sessionId)) return;
+		const session = this.config.sessionStore.getIfExists(event.sessionId);
+		if (!session) return;
+		const runtimeConfig = this.readRuntimeConfig();
+		if (!runtimeConfig.enabled) return;
+		if (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.config.sessionRequester.spawnSessionAndRequest({
+				sourceSessionId: event.sessionId,
+				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.config.sessionStore.save(session);
+		} finally {
+			this.inFlightSessionIds.delete(event.sessionId);
+		}
+	};
+	readRuntimeConfig = () => {
+		if (this.config.resolveRuntimeConfig) return this.config.resolveRuntimeConfig();
+		return {
+			enabled: true,
+			toolCallThreshold: this.config.toolCallThreshold ?? 15
+		};
+	};
+	buildReviewTitle = (metadata) => {
+		const label = readSessionLabel(metadata);
+		return label ? `Learning loop: ${label}` : "Learning loop";
+	};
+};
+//#endregion
+//#region src/cli/commands/ncp/lifecycle-events/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/cli/commands/learning-loop/learning-loop-runtime.service.ts
+var LearningLoopRuntimeService = class {
+	globalEventBus;
+	lifecycleEventBridge;
+	learningLoopFeature;
+	unsubscribeEndpointEvents = null;
+	constructor(params) {
+		const { sessionManager, sessionRequestBroker, onSessionUpdated, globalEventBus, resolveLearningLoopConfig } = params;
+		this.globalEventBus = globalEventBus ?? createGlobalTypedEventBus({ onListenerError: ({ key, error }) => {
+			console.warn(`[global-event-bus] listener failed for ${key}: ${error instanceof Error ? error.message : String(error)}`);
+		} });
+		this.lifecycleEventBridge = new NcpLifecycleEventBridge(sessionManager, this.globalEventBus);
+		this.learningLoopFeature = new LearningLoopFeature({
+			eventBus: this.globalEventBus,
+			sessionStore: sessionManager,
+			sessionRequester: sessionRequestBroker,
+			resolveRuntimeConfig: resolveLearningLoopConfig
+		});
+		this.onSessionUpdated = onSessionUpdated;
+	}
+	onSessionUpdated;
+	handleSessionUpdated = (sessionKey) => {
+		this.onSessionUpdated?.(sessionKey);
+		this.lifecycleEventBridge.publishSessionUpdated(sessionKey);
+	};
+	attachBackend = (backend) => {
+		this.unsubscribeEndpointEvents?.();
+		this.unsubscribeEndpointEvents = backend.subscribe(this.lifecycleEventBridge.handleEndpointEvent);
+		this.learningLoopFeature.start();
+	};
+	dispose = () => {
+		this.learningLoopFeature.dispose();
+		this.unsubscribeEndpointEvents?.();
+		this.unsubscribeEndpointEvents = null;
+	};
+};
+//#endregion
+//#region src/cli/commands/ncp/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("|");
+}
+function createRuntimeFactory(registration) {
+	if (registration.kind !== "codex") return registration.createRuntime;
+	return (runtimeParams) => registration.createRuntime({
+		...runtimeParams,
+		sessionMetadata: {
+			...runtimeParams.sessionMetadata,
+			session_type: "codex",
+			codex_runtime_backend: "codex-sdk"
+		},
+		setSessionMetadata: (nextMetadata) => {
+			runtimeParams.setSessionMetadata({
+				...nextMetadata,
+				session_type: "codex",
+				codex_runtime_backend: "codex-sdk"
+			});
+		}
+	});
+}
+var PluginRuntimeRegistrationController = class {
+	pluginRuntimeScopes = /* @__PURE__ */ new Map();
+	pluginRuntimeSnapshotKey = "";
+	activeExtensionRegistry;
+	constructor(runtimeRegistry, getExtensionRegistry) {
+		this.runtimeRegistry = runtimeRegistry;
+		this.getExtensionRegistry = getExtensionRegistry;
+	}
+	refreshPluginRuntimeRegistrations = () => {
+		this.syncPluginRuntimeRegistrations(this.resolveActiveExtensionRegistry());
+	};
+	applyExtensionRegistry = (extensionRegistry) => {
+		this.activeExtensionRegistry = extensionRegistry;
+		this.syncPluginRuntimeRegistrations(extensionRegistry);
+	};
+	dispose = () => {
+		for (const scope of this.pluginRuntimeScopes.values()) scope.dispose();
+		this.pluginRuntimeScopes.clear();
+		this.activeExtensionRegistry = void 0;
+		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: createRuntimeFactory(registration),
+				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.activeExtensionRegistry ?? this.getExtensionRegistry?.();
+};
+//#endregion
 //#region src/cli/runtime-state/llm-usage-record.ts
 var LlmUsageRecordFactory = class {
 	create = (params) => {
@@ -12434,6 +13765,9 @@ var LlmUsageRecordFactory = class {
 		}
 		return next;
 	};
+	hasTelemetry = (usage) => {
+		return Object.keys(usage).length > 0;
+	};
 	buildSummary = (usage) => {
 		const promptTokens = usage.prompt_tokens ?? usage.input_tokens ?? 0;
 		const completionTokens = usage.completion_tokens ?? usage.output_tokens ?? 0;
@@ -12464,6 +13798,7 @@ var LlmUsageRecorder = class {
 	}
 	record = (params) => {
 		const record = this.recordFactory.create(params);
+		if (!this.recordFactory.hasTelemetry(record.usage)) return null;
 		this.snapshotStore.write(record);
 		this.historyStore.append(record);
 		return record;
@@ -12480,45 +13815,15 @@ var LlmUsageRecorder = class {
 };
 const llmUsageRecorder = new LlmUsageRecorder();
 //#endregion
-//#region src/cli/commands/ncp/create-ui-ncp-agent.ts
-const CODEX_RUNTIME_KIND = "codex";
-const CODEX_DIRECT_RUNTIME_BACKEND = "codex-sdk";
+//#region src/cli/commands/ncp/create-ui-ncp-agent.service.ts
 function isRecord(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function decorateCodexRuntimeFactoryParams(runtimeParams, backend) {
-	const nextSessionMetadata = {
-		...runtimeParams.sessionMetadata,
-		session_type: CODEX_RUNTIME_KIND,
-		codex_runtime_backend: backend
-	};
-	const setSessionMetadata = (nextMetadata) => {
-		runtimeParams.setSessionMetadata({
-			...nextMetadata,
-			session_type: CODEX_RUNTIME_KIND,
-			codex_runtime_backend: backend
-		});
-	};
-	setSessionMetadata(nextSessionMetadata);
-	return {
-		...runtimeParams,
-		sessionMetadata: nextSessionMetadata,
-		setSessionMetadata
-	};
-}
 function resolveNativeReasoningNormalizationMode(params) {
-	const runtimeEntry = params.config.ui.ncp.runtimes.native;
+	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 buildPluginRuntimeSnapshotKey(extensionRegistry) {
-	return (extensionRegistry?.ncpAgentRuntimes ?? []).map((registration) => [
-		registration.pluginId,
-		registration.kind,
-		registration.label,
-		registration.source
-	].join(":")).join("|");
-}
 async function createMcpRuntimeSupport(getConfig) {
 	let currentMcpConfig = getConfig();
 	const mcpRegistryService = new McpRegistryService({
@@ -12543,7 +13848,7 @@ async function createMcpRuntimeSupport(getConfig) {
 		}
 	};
 }
-function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore, sessionCreationService, sessionRequestBroker) {
+function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore, sessionCreationService, sessionRequestBroker, sessionSearchRuntimeSupport) {
 	const observedProviderManager = new ObservedProviderManager(params.providerManager, new LlmUsageObserver(llmUsageRecorder, "ui-ncp"));
 	return ({ stateManager, sessionMetadata, setSessionMetadata }) => {
 		const reasoningNormalizationMode = resolveNativeReasoningNormalizationMode({
@@ -12561,7 +13866,11 @@ function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore,
 			getExtensionRegistry: params.getExtensionRegistry,
 			sessionCreationService,
 			sessionRequestBroker,
-			getAdditionalTools: (context) => [...createAssetTools({ assetStore }), ...mcpToolRegistryAdapter.listToolsForRun({ agentId: context.agentId })]
+			getAdditionalTools: (context) => [
+				...createAssetTools({ assetStore }),
+				...mcpToolRegistryAdapter.listToolsForRun({ agentId: context.agentId }),
+				sessionSearchRuntimeSupport.createTool({ currentSessionId: context.sessionId })
+			]
 		});
 		return new DefaultNcpAgentRuntime({
 			contextBuilder: new NextclawNcpContextBuilder({
@@ -12578,93 +13887,121 @@ function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore,
 		});
 	};
 }
-function createCodexAwareRuntimeFactory(params) {
-	return (runtimeParams) => {
-		const decoratedRuntimeParams = decorateCodexRuntimeFactoryParams(runtimeParams, CODEX_DIRECT_RUNTIME_BACKEND);
-		return params.registration.createRuntime(decoratedRuntimeParams);
-	};
-}
-function resolveRegisteredRuntimeFactory(params) {
-	return params.registration.kind === CODEX_RUNTIME_KIND ? createCodexAwareRuntimeFactory(params) : params.registration.createRuntime;
+function createResolveOpenAiToolsForRuntime(params) {
+	const toolRegistry = new NextclawNcpToolRegistry({
+		bus: params.bus,
+		providerManager: params.providerManager,
+		sessionManager: params.sessionManager,
+		cronService: params.cronService,
+		gatewayController: params.gatewayController,
+		getConfig: params.getConfig,
+		getExtensionRegistry: params.getExtensionRegistry,
+		sessionCreationService: params.sessionCreationService,
+		sessionRequestBroker: params.sessionRequestBroker,
+		getAdditionalTools: (context) => [
+			...createAssetTools({ assetStore: params.assetStore }),
+			...params.toolRegistryAdapter.listToolsForRun({ agentId: context.agentId }),
+			params.sessionSearchRuntimeSupport.createTool({ currentSessionId: context.sessionId })
+		]
+	});
+	const contextBuilder = new NextclawNcpContextBuilder({
+		sessionManager: params.sessionManager,
+		toolRegistry,
+		getConfig: params.getConfig,
+		resolveMessageToolHints: params.resolveMessageToolHints,
+		assetStore: params.assetStore
+	});
+	return (input) => contextBuilder.prepare(input).tools;
 }
-var PluginRuntimeRegistrationController = class {
-	pluginRuntimeScopes = /* @__PURE__ */ new Map();
-	pluginRuntimeSnapshotKey = "";
-	activeExtensionRegistry;
-	constructor(runtimeRegistry, getExtensionRegistry) {
-		this.runtimeRegistry = runtimeRegistry;
-		this.getExtensionRegistry = getExtensionRegistry;
-	}
-	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 ?? []) {
-			const pluginId = registration.pluginId.trim() || registration.kind;
-			const scope = this.pluginRuntimeScopes.get(pluginId) ?? new DisposableStore();
-			this.pluginRuntimeScopes.set(pluginId, scope);
-			scope.add(this.runtimeRegistry.register({
-				kind: registration.kind,
-				label: registration.label,
-				createRuntime: resolveRegisteredRuntimeFactory({ registration }),
-				describeSessionType: registration.describeSessionType
-			}));
-		}
-	};
-	resolveActiveExtensionRegistry = () => this.activeExtensionRegistry ?? this.getExtensionRegistry?.();
-	refreshPluginRuntimeRegistrations = () => {
-		this.syncPluginRuntimeRegistrations(this.resolveActiveExtensionRegistry());
-	};
-	applyExtensionRegistry = (extensionRegistry) => {
-		this.activeExtensionRegistry = extensionRegistry;
-		this.syncPluginRuntimeRegistrations(extensionRegistry);
-	};
-	dispose = () => {
-		for (const scope of this.pluginRuntimeScopes.values()) scope.dispose();
-		this.pluginRuntimeScopes.clear();
-		this.activeExtensionRegistry = void 0;
-		this.pluginRuntimeSnapshotKey = "";
-	};
-};
 async function createUiNcpAgent(params) {
-	const sessionStore = new NextclawAgentSessionStore(params.sessionManager, { onSessionUpdated: params.onSessionUpdated });
+	const { getConfig, getExtensionRegistry, globalEventBus, onSessionRunStatusChanged, onSessionUpdated, providerManager, resolveMessageToolHints, sessionManager } = params;
+	const sessionSearchRuntimeSupport = new SessionSearchRuntimeSupport({
+		sessionManager,
+		onSessionUpdated,
+		databasePath: join(getDataDir(), "session-search.db")
+	});
+	const sessionStore = new NextclawAgentSessionStore(sessionManager, { onSessionUpdated: sessionSearchRuntimeSupport.handleSessionUpdated });
 	const runtimeRegistry = new UiNcpRuntimeRegistry();
-	const { toolRegistryAdapter, applyMcpConfig, dispose: disposeMcpRuntimeSupport } = await createMcpRuntimeSupport(params.getConfig);
+	const { toolRegistryAdapter, applyMcpConfig, dispose: disposeMcpRuntimeSupport } = await createMcpRuntimeSupport(getConfig);
 	const assetStore = new LocalAssetStore({ rootDir: join(getDataDir(), "assets") });
 	let backend = null;
-	const sessionCreationService = new SessionCreationService(params.sessionManager, params.getConfig, params.onSessionUpdated);
-	const createNativeRuntime = createNativeRuntimeFactory(params, toolRegistryAdapter, assetStore, sessionCreationService, new SessionRequestBroker(params.sessionManager, sessionCreationService, new SessionRequestDeliveryService(() => backend), () => backend, params.onSessionUpdated));
+	const sessionCreationService = new SessionCreationService(sessionManager, getConfig, sessionSearchRuntimeSupport.handleSessionUpdated);
+	const sessionRequestBroker = new SessionRequestBroker(sessionManager, sessionCreationService, new SessionRequestDeliveryService(() => backend), () => backend, sessionSearchRuntimeSupport.handleSessionUpdated);
+	const learningLoopRuntime = new LearningLoopRuntimeService({
+		sessionManager,
+		sessionRequestBroker,
+		onSessionUpdated: sessionSearchRuntimeSupport.handleSessionUpdated,
+		globalEventBus,
+		resolveLearningLoopConfig: () => readLearningLoopRuntimeConfig(getConfig())
+	});
+	const createNativeRuntime = createNativeRuntimeFactory({
+		...params,
+		getConfig,
+		getExtensionRegistry,
+		onSessionUpdated,
+		providerManager,
+		resolveMessageToolHints,
+		sessionManager
+	}, toolRegistryAdapter, assetStore, sessionCreationService, sessionRequestBroker, sessionSearchRuntimeSupport);
 	runtimeRegistry.register({
 		kind: "native",
 		label: "Native",
 		createRuntime: createNativeRuntime
 	});
-	const pluginRuntimeRegistrationController = new PluginRuntimeRegistrationController(runtimeRegistry, params.getExtensionRegistry);
+	const builtinNarpRegistrations = new BuiltinNarpRuntimeRegistrationService(getConfig).registerInto(runtimeRegistry);
+	const pluginRuntimeRegistrationController = new PluginRuntimeRegistrationController(runtimeRegistry, getExtensionRegistry);
+	const refreshConfiguredRuntimeEntries = () => {
+		runtimeRegistry.applyEntries(resolveUiNcpRuntimeEntries({
+			config: getConfig(),
+			providerKinds: runtimeRegistry.listProviderKinds()
+		}));
+	};
 	pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
+	refreshConfiguredRuntimeEntries();
+	await sessionSearchRuntimeSupport.initialize();
 	backend = new DefaultNcpAgentBackend({
 		endpointId: "nextclaw-ui-agent",
 		sessionStore,
-		onSessionRunStatusChanged: params.onSessionRunStatusChanged,
+		onSessionRunStatusChanged,
 		createRuntime: (runtimeParams) => {
 			pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
+			refreshConfiguredRuntimeEntries();
 			return runtimeRegistry.createRuntime({
 				...runtimeParams,
-				resolveAssetContentPath: (assetUri) => assetStore.resolveContentPath(assetUri)
+				resolveAssetContentPath: (assetUri) => assetStore.resolveContentPath(assetUri),
+				resolveTools: createResolveOpenAiToolsForRuntime({
+					bus: params.bus,
+					providerManager,
+					sessionManager,
+					cronService: params.cronService,
+					gatewayController: params.gatewayController,
+					getConfig,
+					getExtensionRegistry,
+					resolveMessageToolHints,
+					assetStore,
+					toolRegistryAdapter,
+					sessionCreationService,
+					sessionRequestBroker,
+					sessionSearchRuntimeSupport
+				})
 			});
 		}
 	});
 	await backend.start();
+	learningLoopRuntime.attachBackend(backend);
 	return createUiNcpAgentHandle({
 		backend,
 		runtimeRegistry,
 		refreshPluginRuntimeRegistrations: pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations,
+		refreshConfiguredRuntimeEntries,
 		applyExtensionRegistry: pluginRuntimeRegistrationController.applyExtensionRegistry,
 		applyMcpConfig,
 		dispose: async () => {
+			learningLoopRuntime.dispose();
+			for (const registration of builtinNarpRegistrations) registration.dispose();
 			pluginRuntimeRegistrationController.dispose();
 			await backend?.stop();
+			await sessionSearchRuntimeSupport.dispose();
 			await disposeMcpRuntimeSupport();
 		},
 		assetStore
@@ -13503,6 +14840,66 @@ async function runPromptOverNcp(params) {
 	};
 }
 //#endregion
+//#region src/cli/commands/ncp/runtime/runner/ncp-event-stream.ts
+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;
+	}
+}
+//#endregion
+//#region src/cli/commands/ncp/runtime/runner/channel-reply.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) {
+	if (!isReplyCapableChannel(params.channel)) return null;
+	const metadata = structuredClone(params.message.metadata ?? {});
+	const accountId = readString(params.route.accountId) ?? readString(metadata.accountId) ?? readString(metadata.account_id);
+	return {
+		target: {
+			conversationId: params.message.chatId,
+			...accountId ? { accountId } : {},
+			...Object.keys(metadata).length > 0 ? { metadata } : {}
+		},
+		channel: params.channel
+	};
+}
+async function dispatchChannelReplyRoute(params) {
+	const input = {
+		target: {
+			...params.route.target,
+			...params.agent.assetApi?.resolveContentPath ? { resolveAssetContentPath: params.agent.assetApi.resolveContentPath } : {}
+		},
+		eventStream: streamPromptOverNcp({
+			agent: params.agent,
+			sessionId: params.sessionId,
+			content: params.content,
+			attachments: params.attachments,
+			metadata: params.metadata,
+			abortSignal: params.abortSignal,
+			onEvent: params.onEvent
+		})
+	};
+	await params.route.channel.consumeNcpReply(input);
+}
+//#endregion
 //#region src/cli/commands/ncp/runtime/nextclaw-ncp-dispatch.ts
 function normalizeOptionalString(value) {
 	if (typeof value !== "string") return;
@@ -13541,67 +14938,9 @@ function buildRunMetadata(params) {
 		sender_id: params.message.senderId
 	};
 }
-function parseCommandOptionValue(type, rawValue) {
-	const value = rawValue.trim();
-	if (!value) return;
-	if (type === "number") {
-		const parsed = Number(value);
-		return Number.isFinite(parsed) ? parsed : void 0;
-	}
-	if (type === "boolean") {
-		const lowered = value.toLowerCase();
-		if ([
-			"1",
-			"true",
-			"yes",
-			"on"
-		].includes(lowered)) return true;
-		if ([
-			"0",
-			"false",
-			"no",
-			"off"
-		].includes(lowered)) return false;
-		return;
-	}
-	return value;
-}
-function parseCommandArgsFromText(commandName, rawTail, specs) {
-	if (!rawTail) return {};
-	const options = specs.find((item) => item.name.trim().toLowerCase() === commandName)?.options;
-	if (!options || options.length === 0) return {};
-	const tokens = rawTail.split(/\s+/).filter(Boolean);
-	const args = {};
-	let cursor = 0;
-	for (let index = 0; index < options.length; index += 1) {
-		if (cursor >= tokens.length) break;
-		const option = options[index];
-		const isLastOption = index === options.length - 1;
-		const rawValue = isLastOption ? tokens.slice(cursor).join(" ") : tokens[cursor];
-		cursor += isLastOption ? tokens.length - cursor : 1;
-		const parsedValue = parseCommandOptionValue(option.type, rawValue);
-		if (parsedValue !== void 0) args[option.name] = parsedValue;
-	}
-	return args;
-}
 async function executeSlashCommandMaybe(params) {
-	const trimmed = params.rawContent.trim();
-	if (!trimmed.startsWith("/")) return null;
-	const registry = new CommandRegistry(params.config, params.sessionManager);
-	const executeText = registry.executeText;
-	if (typeof executeText === "function") return (await executeText.call(registry, params.rawContent, {
-		channel: params.channel,
-		chatId: params.chatId,
-		senderId: "user",
-		sessionKey: params.sessionKey
-	}))?.content ?? null;
-	const commandRaw = trimmed.slice(1).trim();
-	if (!commandRaw) return null;
-	const [nameToken, ...restTokens] = commandRaw.split(/\s+/);
-	const commandName = nameToken.trim().toLowerCase();
-	if (!commandName) return null;
-	const args = parseCommandArgsFromText(commandName, restTokens.join(" ").trim(), registry.listSlashCommands());
-	return (await registry.execute(commandName, args, {
+	if (!params.rawContent.trim().startsWith("/")) return null;
+	return (await new CommandRegistry(params.config, params.sessionManager).executeText(params.rawContent, {
 		channel: params.channel,
 		chatId: params.chatId,
 		senderId: "user",
@@ -13626,6 +14965,48 @@ function formatUserFacingError(error, maxChars = 320) {
 	if (normalized.length <= maxChars) return normalized;
 	return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
 }
+async function dispatchChannelReplyRouteMaybe(params, context) {
+	if (context.message.channel === "system" || !params.getChannels) return false;
+	const replyRoute = resolveChannelReplyRoute({
+		channel: params.getChannels().getChannel(context.message.channel),
+		message: context.message,
+		route: context.route
+	});
+	if (!replyRoute) return false;
+	await dispatchChannelReplyRoute({
+		agent: context.agent,
+		route: replyRoute,
+		sessionId: context.route.sessionKey,
+		content: context.message.content,
+		attachments: context.message.attachments,
+		metadata: context.runMetadata
+	});
+	return true;
+}
+async function publishLegacyReply(params, context, result) {
+	if (context.message.channel === "system") {
+		params.onSystemSessionUpdated?.({
+			sessionKey: context.route.sessionKey,
+			message: context.message
+		});
+		return;
+	}
+	if (!result.text.trim()) {
+		await params.bus.publishOutbound(createTypingStopControlMessage(context.message));
+		return;
+	}
+	await params.bus.publishOutbound({
+		channel: context.message.channel,
+		chatId: context.message.chatId,
+		content: result.text,
+		media: [],
+		metadata: buildRunMetadata({
+			message: context.message,
+			route: context.route,
+			metadata: result.completedMessage.metadata
+		})
+	});
+}
 async function dispatchPromptOverNcp(params) {
 	const { message, route } = resolveDirectRoute({
 		config: params.config,
@@ -13664,6 +15045,7 @@ async function dispatchPromptOverNcp(params) {
 async function runGatewayInboundLoop(params) {
 	while (true) {
 		const message = await params.bus.consumeInbound();
+		let usedChannelReplyRoute = false;
 		try {
 			const explicitSessionKey = normalizeOptionalString(message.metadata.session_key_override);
 			const forcedAgentId = normalizeOptionalString(message.metadata.target_agent_id);
@@ -13673,46 +15055,36 @@ async function runGatewayInboundLoop(params) {
 				sessionKeyOverride: explicitSessionKey
 			});
 			const agent = requireNcpAgent(params.resolveNcpAgent, "gateway dispatch");
+			const runMetadata = buildRunMetadata({
+				message,
+				route
+			});
+			const context = {
+				agent,
+				message,
+				route,
+				runMetadata
+			};
+			if (await dispatchChannelReplyRouteMaybe(params, context)) {
+				usedChannelReplyRoute = true;
+				continue;
+			}
 			if (message.channel !== "system") await params.bus.publishOutbound(createAssistantStreamResetControlMessage(message));
-			const result = await runPromptOverNcp({
+			await publishLegacyReply(params, context, await runPromptOverNcp({
 				agent,
 				sessionId: route.sessionKey,
 				content: message.content,
 				attachments: message.attachments,
-				metadata: buildRunMetadata({
-					message,
-					route
-				}),
+				metadata: runMetadata,
 				onAssistantDelta: message.channel !== "system" ? (delta) => {
 					if (!delta) return;
 					params.bus.publishOutbound(createAssistantStreamDeltaControlMessage(message, delta));
 				} : void 0,
 				missingCompletedMessageError: `session "${route.sessionKey}" completed without a final assistant message`,
 				runErrorMessage: `session "${route.sessionKey}" failed`
-			});
-			if (message.channel === "system") {
-				params.onSystemSessionUpdated?.({
-					sessionKey: route.sessionKey,
-					message
-				});
-				continue;
-			}
-			if (!result.text.trim()) {
-				await params.bus.publishOutbound(createTypingStopControlMessage(message));
-				continue;
-			}
-			await params.bus.publishOutbound({
-				channel: message.channel,
-				chatId: message.chatId,
-				content: result.text,
-				media: [],
-				metadata: buildRunMetadata({
-					message,
-					route,
-					metadata: result.completedMessage.metadata
-				})
-			});
+			}));
 		} catch (error) {
+			if (usedChannelReplyRoute) continue;
 			await params.bus.publishOutbound({
 				channel: message.channel,
 				chatId: message.chatId,
@@ -13833,6 +15205,7 @@ async function startUiShell(params) {
 		cronService: params.cronService,
 		marketplace: params.marketplace,
 		remoteAccess: params.remoteAccess,
+		runtimeControl: params.runtimeControl,
 		getBootstrapStatus: params.getBootstrapStatus,
 		getPluginChannelBindings: params.getPluginChannelBindings,
 		getPluginUiMetadata: params.getPluginUiMetadata,
@@ -13858,6 +15231,7 @@ async function startUiShell(params) {
 async function startDeferredGatewayStartup(params) {
 	const { uiStartup, deferredNcpSessionService, bus, sessionManager, providerManager, cronService, gatewayController, getConfig, getExtensionRegistry, resolveMessageToolHints, hydrateCapabilities, startPluginGateways, startChannels, wakeFromRestartSentinel, onNcpAgentReady, publishSessionChange } = params;
 	logStartupTrace("service.deferred_startup.begin");
+	if (hydrateCapabilities) await measureStartupAsync("service.deferred_startup.hydrate_capabilities", hydrateCapabilities);
 	try {
 		const ncpAgent = await measureStartupAsync("service.deferred_startup.create_ui_ncp_agent", async () => await createUiNcpAgent({
 			bus,
@@ -13888,7 +15262,6 @@ async function startDeferredGatewayStartup(params) {
 	} catch (error) {
 		console.error(`UI NCP agent startup failed: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (hydrateCapabilities) await measureStartupAsync("service.deferred_startup.hydrate_capabilities", hydrateCapabilities);
 	await measureStartupAsync("service.deferred_startup.start_plugin_gateways", startPluginGateways);
 	await measureStartupAsync("service.deferred_startup.start_channels", startChannels);
 	await measureStartupAsync("service.deferred_startup.wake_restart_sentinel", wakeFromRestartSentinel);
@@ -13916,6 +15289,7 @@ async function runConfiguredGatewayRuntime(params) {
 			sessionManager: params.gateway.sessionManager,
 			getConfig: params.getConfig,
 			resolveNcpAgent: params.getLiveUiNcpAgent,
+			getChannels: () => params.gateway.reloader.getChannels(),
 			onSystemSessionUpdated: ({ sessionKey }) => onSystemSessionUpdated({ sessionKey })
 		}),
 		startDeferredStartup: () => startDeferredGatewayStartup({
@@ -13969,13 +15343,15 @@ function createNcpSessionRealtimeChangePublisher(params) {
 //#endregion
 //#region src/cli/commands/ncp/session/ncp-session-summary.ts
 function createNcpSessionSummary(params) {
+	const { sessionId, agentId, messages, updatedAt, status, metadata } = params;
 	return {
-		sessionId: params.sessionId,
-		...params.agentId ? { agentId: params.agentId } : {},
-		messageCount: params.messages.length,
-		updatedAt: params.updatedAt,
-		status: params.status,
-		...params.metadata ? { metadata: structuredClone(params.metadata) } : {}
+		sessionId,
+		...agentId ? { agentId } : {},
+		messageCount: messages.length,
+		updatedAt,
+		...messages.length > 0 ? { lastMessageAt: messages[messages.length - 1]?.timestamp ?? updatedAt } : {},
+		status,
+		...metadata ? { metadata: structuredClone(metadata) } : {}
 	};
 }
 //#endregion
@@ -14673,7 +16049,7 @@ var ServiceCommands = class {
 			runCliSubcommand: (args) => this.runCliSubcommand(args),
 			installBuiltinSkill: (slug, force) => this.installBuiltinMarketplaceSkill(slug, force)
 		}).createInstaller();
-		const remoteAccess = createRemoteAccessHost({
+		const { remoteAccess, runtimeControl } = createServiceUiHosts({
 			serviceCommands: this,
 			requestRestart: this.deps.requestRestart,
 			uiConfig: shellContext.uiConfig,
@@ -14693,6 +16069,7 @@ var ServiceCommands = class {
 				installer: marketplaceInstaller
 			},
 			remoteAccess,
+			runtimeControl,
 			getBootstrapStatus: () => bootstrapStatus.getStatus(),
 			openBrowserWindow: shellContext.uiConfig.open,
 			applyLiveConfigReload,
@@ -16059,6 +17436,42 @@ function registerAgentsCommands(program, runtime) {
 	agents.command("remove <agentId>").description("Remove an agent").option("--json", "Output JSON", false).action(async (agentId, opts) => runtime.agentsRemove(agentId, opts));
 }
 //#endregion
+//#region src/cli/commands/learning-loop/register-learning-loop-commands.ts
+function readLearningLoopThresholdOrExit(value) {
+	const threshold = Number.parseInt(value, 10);
+	if (!Number.isInteger(threshold) || threshold < 1) {
+		console.error(`Invalid learning loop threshold: ${value}. Expected an integer >= 1.`);
+		process.exit(1);
+	}
+	return threshold;
+}
+function registerLearningLoopCommands(program, runtime) {
+	const learningLoop = program.command("learning-loop").description("Manage the learning loop");
+	learningLoop.command("status").description("Show current learning loop settings").option("--json", "Output JSON", false).action((opts) => {
+		const status = readLearningLoopRuntimeConfig(loadConfig());
+		if (opts.json) {
+			console.log(JSON.stringify(status, null, 2));
+			return;
+		}
+		console.log("Learning loop");
+		console.log(`  enabled: ${status.enabled}`);
+		console.log(`  toolCallThreshold: ${status.toolCallThreshold}`);
+	});
+	learningLoop.command("enable").description("Enable the learning loop").action(async () => {
+		await runtime.configSet("agents.learningLoop.enabled", "true", { json: true });
+		console.log("✓ Enabled learning loop.");
+	});
+	learningLoop.command("disable").description("Disable the learning loop").action(async () => {
+		await runtime.configSet("agents.learningLoop.enabled", "false", { json: true });
+		console.log("✓ Disabled learning loop.");
+	});
+	learningLoop.command("threshold <count>").description("Set the tool-call threshold that triggers a learning-loop review").action(async (count) => {
+		const threshold = readLearningLoopThresholdOrExit(count);
+		await runtime.configSet("agents.learningLoop.toolCallThreshold", String(threshold), { json: true });
+		console.log(`✓ Updated learning loop tool-call threshold to ${threshold}.`);
+	});
+}
+//#endregion
 //#region src/cli/index.ts
 logStartupTrace("cli.index.module_loaded");
 const program = new Command();
@@ -16067,7 +17480,7 @@ const llmUsageCommands = new LlmUsageCommands();
 program.name(APP_NAME).description(`${LOGO} ${APP_NAME} - ${APP_TAGLINE}`).version(getPackageVersion$1(), "-v, --version", "show version");
 program.command("onboard").description(`Initialize ${APP_NAME} configuration and workspace`).action(async () => runtime.onboard());
 program.command("init").description(`Initialize ${APP_NAME} configuration and workspace`).option("-f, --force", "Overwrite existing template files").action(async (opts) => runtime.init({ force: Boolean(opts.force) }));
-program.command("login").description("Login to NextClaw platform and save token into providers.nextclaw.apiKey").option("--api-base <url>", "Platform API base (supports /v1 suffix)").option("--email <email>", "Login email").option("--password <password>", "Login password").action(async (opts) => runtime.login(opts));
+program.command("login").description("Sign in to NextClaw Platform and save the platform token locally (browser flow by default)").option("--api-base <url>", "Platform API base (supports /v1 suffix)").option("--email <email>", "Login email for direct password sign-in").option("--password <password>", "Login password for direct password sign-in").option("--no-open", "Do not open the browser automatically").action(async (opts) => runtime.login(opts));
 registerRemoteCommands(program, runtime.remote);
 program.command("gateway").description(`Start the ${APP_NAME} gateway`).option("-p, --port <port>", "Gateway port", "18790").option("-v, --verbose", "Verbose output", false).option("--ui", "Enable UI server", false).option("--ui-port <port>", "UI port").option("--ui-open", "Open browser when UI starts", false).action(async (opts) => runtime.gateway(opts));
 program.command("ui").description(`Start the ${APP_NAME} UI with gateway`).option("--port <port>", "UI port").option("--no-open", "Disable opening browser").action(async (opts) => runtime.ui(opts));
@@ -16107,6 +17520,7 @@ const config = program.command("config").description("Manage config values");
 config.command("get <path>").description("Get a config value by dot path").option("--json", "Output JSON", false).action((path, opts) => runtime.configGet(path, opts));
 config.command("set <path> <value>").description("Set a config value by dot path").option("--json", "Parse value as JSON", false).action((path, value, opts) => runtime.configSet(path, value, opts));
 config.command("unset <path>").description("Remove a config value by dot path").action((path) => runtime.configUnset(path));
+registerLearningLoopCommands(program, runtime);
 const mcp = program.command("mcp").description("Manage MCP servers");
 mcp.command("list").description("List configured MCP servers").option("--json", "Output JSON", false).action((opts) => runtime.mcpList(opts));
 mcp.command("add <name> [command...]").description("Add an MCP server (stdio by default, or use --transport http|sse)").allowUnknownOption(true).option("--transport <type>", "Transport type: stdio|http|sse", "stdio").option("--url <url>", "HTTP/SSE endpoint URL").option("--header <key=value>", "Transport header (repeatable)", withRepeatableTag, []).option("--env <key=value>", "stdio env var (repeatable)", withRepeatableTag, []).option("--cwd <dir>", "stdio working directory").option("--timeout-ms <ms>", "HTTP/SSE timeout in milliseconds").option("--stderr <mode>", "stdio stderr handling: inherit|pipe|ignore", "pipe").option("--disabled", "Create the server in disabled state", false).option("--all-agents", "Expose this server to all agents", false).option("--agent <id>", "Expose to an agent id (repeatable)", withRepeatableTag, []).option("--insecure", "Disable TLS verification for HTTP/SSE", false).action(async (name, command, opts) => runtime.mcpAdd(name, command ?? [], opts));