@yejiming/dsh-data-agent 0.0.9 → 0.0.10

package/lib/{connections-DeauhaZi.js → connections-WmjuUrDj.js}

@@ -1,5 +1,7 @@
 import "./defaults-DP4RyRh1.js";
-import { resolve } from "node:path";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { posix, resolve, win32 } from "node:path";
 import z from "schemastery";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 //#region src/sql.ts
@@ -595,7 +597,8 @@ function quoteStringLiteral(value) {
 /** Loader schema for one client override (all fields optional at input). */
 const clientConfigSchema = z.object({
 	command: z.string(),
-	args: z.array(z.string())
+	args: z.array(z.string()),
+	searchPaths: z.array(z.string())
 });
 /** Loader schema for the whole `clients` config object (any type key). */
 const clientsSchema = z.dict(clientConfigSchema).default({});
@@ -891,6 +894,291 @@ function parseColumns(type, stdout) {
 	return columns;
 }
 //#endregion
+//#region src/client-discovery.ts
+/**
+* Cross-platform database CLI discovery.
+*
+* The subprocess provider remains the authority for executable validation.
+* This module only builds a bounded, platform-aware PATH fallback when the
+* provider cannot resolve the configured/default bare command from its
+* current execution environment. No shell, registry, or recursive scan is
+* involved, and the exact discovery environment is returned for spawn.
+* @module @yejiming/dsh-data-agent/client-discovery
+*/
+/** Maximum child names consumed from one known version/formula directory. */
+const MAX_DYNAMIC_ENTRIES = 64;
+/** Production host facts. */
+const DEFAULT_SYSTEM = {
+	platform: process.platform,
+	env: process.env,
+	homeDir: homedir(),
+	cwd: process.cwd(),
+	async readDirectory(directory) {
+		return await readdir(directory);
+	}
+};
+const HOME_ENV_BY_TYPE = {
+	mysql: ["MYSQL_HOME"],
+	postgres: ["PGHOME", "PGROOT"],
+	sqlite: ["SQLITE_HOME"],
+	oracle: ["ORACLE_HOME"],
+	hive: ["HIVE_HOME"],
+	impala: ["IMPALA_HOME"]
+};
+function pathApi(platform) {
+	return platform === "win32" ? win32 : posix;
+}
+function environmentValue(env, name, platform) {
+	if (platform !== "win32") return env[name];
+	const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+	return key === void 0 ? void 0 : env[key];
+}
+function expandHome(directory, system, paths) {
+	const trimmed = directory.trim();
+	if (trimmed === "~") return system.homeDir;
+	if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) return paths.join(system.homeDir, trimmed.slice(2));
+	return paths.isAbsolute(trimmed) ? paths.normalize(trimmed) : paths.resolve(system.cwd, trimmed);
+}
+function normalizeDirectories(directories, system, paths) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of directories) {
+		if (raw.trim() === "") continue;
+		const directory = expandHome(raw, system, paths);
+		const key = system.platform === "win32" ? directory.toLowerCase() : directory;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(directory);
+	}
+	return result;
+}
+function clientHomeDirectories(type, system, paths) {
+	const result = [];
+	for (const name of HOME_ENV_BY_TYPE[type]) {
+		const value = environmentValue(system.env, name, system.platform)?.trim();
+		if (value === void 0 || value === "") continue;
+		result.push(paths.join(value, "bin"), value);
+	}
+	return result;
+}
+function macFixedDirectories(type) {
+	return [
+		"/opt/homebrew/bin",
+		...{
+			mysql: [
+				"/opt/homebrew/opt/mysql-client/bin",
+				"/opt/homebrew/opt/mysql/bin",
+				"/usr/local/opt/mysql-client/bin",
+				"/usr/local/opt/mysql/bin",
+				"/usr/local/mysql/bin"
+			],
+			postgres: [
+				"/opt/homebrew/opt/libpq/bin",
+				"/usr/local/opt/libpq/bin",
+				"/Applications/Postgres.app/Contents/Versions/latest/bin"
+			],
+			sqlite: ["/opt/homebrew/opt/sqlite/bin", "/usr/local/opt/sqlite/bin"],
+			oracle: [],
+			hive: ["/opt/homebrew/opt/hive/bin", "/usr/local/opt/hive/bin"],
+			impala: ["/opt/homebrew/opt/impala/bin", "/usr/local/opt/impala/bin"]
+		}[type],
+		"/usr/local/bin",
+		"/opt/local/bin",
+		"/usr/bin"
+	];
+}
+function linuxFixedDirectories(system, paths) {
+	return [
+		paths.join(system.homeDir, ".local", "bin"),
+		"/home/linuxbrew/.linuxbrew/bin",
+		paths.join(system.homeDir, ".linuxbrew", "bin"),
+		"/usr/local/bin",
+		"/usr/bin",
+		"/snap/bin",
+		paths.join(system.homeDir, ".nix-profile", "bin"),
+		"/nix/var/nix/profiles/default/bin"
+	];
+}
+function windowsFixedDirectories(type, system, paths) {
+	const localAppData = environmentValue(system.env, "LOCALAPPDATA", system.platform);
+	const userProfile = environmentValue(system.env, "USERPROFILE", system.platform) ?? system.homeDir;
+	const chocolatey = environmentValue(system.env, "ChocolateyInstall", system.platform);
+	const programData = environmentValue(system.env, "ProgramData", system.platform) ?? "C:\\ProgramData";
+	const programFiles = environmentValue(system.env, "ProgramFiles", system.platform) ?? "C:\\Program Files";
+	const typeSpecific = {
+		mysql: [],
+		postgres: [],
+		sqlite: [paths.join("C:\\", "sqlite"), paths.join(programFiles, "SQLite")],
+		oracle: [],
+		hive: [],
+		impala: []
+	};
+	return [
+		...localAppData === void 0 ? [] : [paths.join(localAppData, "Microsoft", "WinGet", "Links")],
+		paths.join(userProfile, "scoop", "shims"),
+		...chocolatey === void 0 ? [] : [paths.join(chocolatey, "bin")],
+		paths.join(programData, "chocolatey", "bin"),
+		...typeSpecific[type]
+	];
+}
+function formulaPattern(type) {
+	switch (type) {
+		case "mysql": return /^(?:mysql|mysql-client)(?:@.+)?$/i;
+		case "postgres": return /^(?:postgresql(?:@.+)?|libpq)$/i;
+		case "sqlite": return /^sqlite(?:@.+)?$/i;
+		case "oracle": return /^(?:oracle|instantclient)(?:@.+)?$/i;
+		case "hive": return /^hive(?:@.+)?$/i;
+		case "impala": return /^impala(?:@.+)?$/i;
+	}
+}
+function dynamicDirectories(type, system, paths) {
+	const result = [];
+	if (system.platform === "darwin") {
+		const pattern = formulaPattern(type);
+		result.push({
+			root: "/opt/homebrew/opt",
+			accepts: (name) => pattern.test(name),
+			suffix: ["bin"]
+		}, {
+			root: "/usr/local/opt",
+			accepts: (name) => pattern.test(name),
+			suffix: ["bin"]
+		});
+		if (type === "postgres") result.push({
+			root: "/Library/PostgreSQL",
+			accepts: () => true,
+			suffix: ["bin"]
+		}, {
+			root: "/Applications/Postgres.app/Contents/Versions",
+			accepts: (name) => name !== "latest",
+			suffix: ["bin"]
+		});
+		if (type === "oracle") result.push({
+			root: "/opt/oracle",
+			accepts: (name) => /^instantclient/i.test(name),
+			suffix: []
+		});
+	} else if (system.platform === "linux") {
+		const pattern = formulaPattern(type);
+		result.push({
+			root: "/home/linuxbrew/.linuxbrew/opt",
+			accepts: (name) => pattern.test(name),
+			suffix: ["bin"]
+		}, {
+			root: paths.join(system.homeDir, ".linuxbrew", "opt"),
+			accepts: (name) => pattern.test(name),
+			suffix: ["bin"]
+		});
+	} else if (system.platform === "win32") {
+		const roots = [environmentValue(system.env, "ProgramFiles", system.platform) ?? "C:\\Program Files", environmentValue(system.env, "ProgramFiles(x86)", system.platform) ?? "C:\\Program Files (x86)"];
+		for (const root of roots) if (type === "mysql") result.push({
+			root: paths.join(root, "MySQL"),
+			accepts: () => true,
+			suffix: ["bin"]
+		}, {
+			root,
+			accepts: (name) => /^MariaDB/i.test(name),
+			suffix: ["bin"]
+		});
+		else if (type === "postgres") result.push({
+			root: paths.join(root, "PostgreSQL"),
+			accepts: () => true,
+			suffix: ["bin"]
+		});
+		else if (type === "oracle") result.push({
+			root: paths.join(root, "Oracle"),
+			accepts: () => true,
+			suffix: ["bin"]
+		});
+	}
+	return result;
+}
+async function expandDynamicDirectories(descriptors, system, paths, signal) {
+	return (await Promise.all(descriptors.map(async (descriptor) => {
+		signal.throwIfAborted();
+		let names;
+		try {
+			names = await system.readDirectory(descriptor.root);
+		} catch {
+			return [];
+		}
+		signal.throwIfAborted();
+		return names.filter((name) => descriptor.accepts(name)).sort((left, right) => right.localeCompare(left, void 0, {
+			numeric: true,
+			sensitivity: "base"
+		})).slice(0, MAX_DYNAMIC_ENTRIES).map((name) => paths.join(descriptor.root, name, ...descriptor.suffix));
+	}))).flat();
+}
+/** Build ordered fallback directories without recursively scanning the host. */
+async function buildClientSearchDirectories(type, config, signal, system = DEFAULT_SYSTEM) {
+	const paths = pathApi(system.platform);
+	const configured = config?.searchPaths ?? [];
+	const homes = clientHomeDirectories(type, system, paths);
+	const fixed = system.platform === "win32" ? windowsFixedDirectories(type, system, paths) : system.platform === "darwin" ? macFixedDirectories(type) : linuxFixedDirectories(system, paths);
+	const dynamic = await expandDynamicDirectories(dynamicDirectories(type, system, paths), system, paths, signal);
+	signal.throwIfAborted();
+	return normalizeDirectories([
+		...configured,
+		...homes,
+		...fixed,
+		...dynamic
+	], system, paths);
+}
+function hasPathSeparator(command) {
+	return command.includes("/") || command.includes("\\");
+}
+function withSearchPath(explicitEnv, directories, system) {
+	const pathName = system.platform === "win32" ? Object.keys(system.env).find((name) => name.toLowerCase() === "path") ?? "Path" : "PATH";
+	const explicitPathName = Object.keys(explicitEnv).find((name) => system.platform === "win32" ? name.toLowerCase() === "path" : name === "PATH");
+	const parentPath = explicitPathName === void 0 ? environmentValue(system.env, "PATH", system.platform) : explicitEnv[explicitPathName];
+	const separator = system.platform === "win32" ? ";" : ":";
+	const prefix = directories.join(separator);
+	const combined = parentPath === void 0 || parentPath === "" ? prefix : `${prefix}${separator}${parentPath}`;
+	const result = { ...explicitEnv };
+	if (explicitPathName !== void 0 && explicitPathName !== pathName) delete result[explicitPathName];
+	result[pathName] = combined;
+	return result;
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function checkedDirectoriesText(directories) {
+	const visible = directories.slice(0, 16);
+	const suffix = directories.length > visible.length ? `，另有${directories.length - visible.length}个目录` : "";
+	return visible.length === 0 ? "无补充目录" : `${visible.join("、")}${suffix}`;
+}
+/**
+* Resolve one configured/default client. Current PATH (or an explicit path)
+* always wins. Only a missing bare command activates bounded PATH discovery.
+*/
+async function resolveClientExecutable(options) {
+	const system = options.system ?? DEFAULT_SYSTEM;
+	let initialError;
+	try {
+		return {
+			executable: await options.resolveExecutable(options.command, options.env, options.signal),
+			env: options.env,
+			searchedDirectories: []
+		};
+	} catch (error) {
+		options.signal.throwIfAborted();
+		initialError = error;
+	}
+	if (pathApi(system.platform).isAbsolute(options.command) || hasPathSeparator(options.command)) throw new Error(`无法解析数据库客户端 "${options.command}"（类型 ${options.type}：${errorText(initialError)}）；该显式路径不会回退到默认命令，请检查 clients.${options.type}.command`);
+	const directories = await buildClientSearchDirectories(options.type, options.config, options.signal, system);
+	const discoveryEnv = withSearchPath(options.env, directories, system);
+	try {
+		return {
+			executable: await options.resolveExecutable(options.command, discoveryEnv, options.signal),
+			env: discoveryEnv,
+			searchedDirectories: directories
+		};
+	} catch (fallbackError) {
+		options.signal.throwIfAborted();
+		throw new Error(`无法解析数据库客户端 "${options.command}"（类型 ${options.type}；当前PATH：${errorText(initialError)}；补充PATH：${errorText(fallbackError)}）。已检查：${checkedDirectoriesText(directories)}；请确认客户端已安装，或配置 clients.${options.type}.command / clients.${options.type}.searchPaths`);
+	}
+}
+//#endregion
 //#region src/query.ts
 /** Read one collected stream from offset 0. */
 function readCaptured(reader) {
@@ -934,15 +1222,16 @@ async function runClientQuery(ctx, connection, sql, options, externalSignal, int
 	if (externalSignal.aborted) controller.abort(externalSignal.reason);
 	else externalSignal.addEventListener("abort", onExternalAbort, { once: true });
 	try {
-		let executable;
-		try {
-			executable = await ctx.subprocess.resolveExecutable(template.command, template.env, controller.signal);
-		} catch (error) {
-			controller.signal.throwIfAborted();
-			throw new Error(`无法解析数据库客户端 "${template.command}"（${error instanceof Error ? error.message : String(error)}）；请确认客户端已安装，或在 data-agent 插件配置的 clients 中覆盖命令名/路径`);
-		}
+		const resolution = await resolveClientExecutable({
+			type: connection.type,
+			command: template.command,
+			config: options.clients[connection.type],
+			env: template.env,
+			signal: controller.signal,
+			resolveExecutable: ctx.subprocess.resolveExecutable.bind(ctx.subprocess)
+		});
 		const handle = ctx.subprocess.spawn({
-			argv: [executable, ...template.args],
+			argv: [resolution.executable, ...template.args],
 			cwd: process.cwd(),
 			stdio: {
 				stdin: { data: `${template.stdinPrefix}${sql}\n` },
@@ -951,7 +1240,7 @@ async function runClientQuery(ctx, connection, sql, options, externalSignal, int
 			},
 			graceMs: options.graceMs ?? 5e3,
 			signal: controller.signal,
-			env: template.env
+			env: resolution.env
 		});
 		let outcome;
 		try {

package/lib/index.js

@@ -1,6 +1,9 @@
-import { o as clientsSchema, t as createConnectionService } from "./connections-DeauhaZi.js";
+import { o as clientsSchema, t as createConnectionService } from "./connections-WmjuUrDj.js";
 import { a as DEFAULT_PRESET_ID, i as DEFAULT_MAX_RESULT_CHARS, o as DEFAULT_QUERY_TIMEOUT_MS, r as DEFAULT_MAX_QUERY_CHARS, t as DEFAULT_CONNECT_TIMEOUT_MS } from "./defaults-DP4RyRh1.js";
-import { access, cp, mkdir, readFile } from "node:fs/promises";
+import { r as apply$1 } from "./command-LFgLb6el.js";
+import { n as apply$2 } from "./tool-Dka6RyEp.js";
+import { createHash } from "node:crypto";
+import { access, cp, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -109,24 +112,32 @@ function createDomainConnectionPersistence(domain) {
 //#endregion
 //#region src/index.ts
 /**
-* Data Agent server half for the dsh web GUI. The host row provides the
+* Data Agent profile entry. The host row provides the
 * `dataAgentConnections` service (shared non-secret profile/binding storage;
 * temporary passwords stay process-local), seeds config connections (`connections`, `'*'` =
-* wildcard default), and installs the `data-agent` agent preset into
-* `$DSH_HOME/.agent-presets/` (idempotent, never overwrites a user-edited
-* directory).
+* wildcard default), installs the `data-agent` agent preset into
+* `$DSH_HOME/.agent-presets/`, and preloads the preset-scoped database tools
+* and command through this profile bundle entry.
 *
 * The HTTP routes live in the separate `./routes` entry
 * (`@yejiming/dsh-data-agent/routes`, cordis row `data-agent-routes`) so
-* this row keeps working in headless profiles without a webserver; the
-* database tools themselves live in the `./tool` entry and are mounted only
-* by the data-agent preset.
+* this row keeps working in headless profiles without a webserver. The
+* database implementations still have public `./tool` and `./command`
+* exports, but the shipped preset does not dynamically import those package
+* subpaths. Loading them here keeps Desktop on the same profile-startup path
+* as other UI bundles and avoids Electron ASAR package-resolution drift.
 * @module @yejiming/dsh-data-agent
 */
 /** Cordis plugin name (diagnostics only). */
 const name = "data-agent";
-/** Services required before the store can serve. */
-const inject = ["subprocess", "credentials"];
+/** Services required before the profile entry can mount its preset layer. */
+const inject = [
+	"agentPresets",
+	"commands",
+	"credentials",
+	"subprocess",
+	"tools"
+];
 /** Loader schema with deployment defaults (no library defaults). */
 const Config = z.object({
 	presetId: z.string().default(DEFAULT_PRESET_ID),
@@ -135,6 +146,7 @@ const Config = z.object({
 	introspectMaxTables: z.number().step(1).min(1).default(500),
 	queryTimeoutMs: z.number().step(1).min(1e3).default(DEFAULT_QUERY_TIMEOUT_MS),
 	maxResultChars: z.number().step(1).min(1024).default(DEFAULT_MAX_RESULT_CHARS),
+	maxRows: z.number().step(1).min(1).default(100),
 	maxQueryChars: z.number().step(1).min(1024).default(DEFAULT_MAX_QUERY_CHARS),
 	readonly: z.boolean().default(false),
 	persistConnections: z.boolean().default(true),
@@ -168,26 +180,57 @@ function resolveDshHome(env = process.env) {
 }
 /**
 * Install the packaged `preset/data-agent/` directory into
-* `$DSH_HOME/.agent-presets/<presetId>/`. Idempotent: an existing target
-* directory is left untouched (user edits survive); `installPreset: false`
-* never calls this. Best-effort — a failure logs a warning with manual
-* install instructions instead of failing the boot.
+* `$DSH_HOME/.agent-presets/<presetId>/`. Idempotent: an existing target is
+* normally left untouched. The exact package-owned 0.0.9 composition is
+* migrated once because its two dynamic package rows are incompatible with
+* DSH Desktop's unpacked-ASAR loader; user-edited compositions are never
+* overwritten. `installPreset: false` never calls this. Best-effort — a
+* failure logs a warning with manual install instructions instead of failing
+* the boot.
 */
 async function installPreset(ctx, presetId) {
 	const targetDir = join(resolveDshHome(), ".agent-presets", presetId);
+	const sourceDir = fileURLToPath(new URL("../preset/data-agent/", import.meta.url));
 	try {
 		await access(targetDir);
-		ctx.logger.info("data-agent: preset \"%s\" already present at %s, skipping install", presetId, targetDir);
-		await diagnoseExistingPreset(ctx, targetDir);
-		return;
+		return await synchronizeExistingPreset(ctx, targetDir, sourceDir, presetId);
 	} catch {}
-	const sourceDir = fileURLToPath(new URL("../preset/data-agent/", import.meta.url));
 	try {
 		await mkdir(targetDir, { recursive: true });
 		await cp(sourceDir, targetDir, { recursive: true });
 		ctx.logger.info("data-agent: installed preset \"%s\" to %s", presetId, targetDir);
+		return true;
 	} catch (error) {
 		ctx.logger.warn("data-agent: failed to install preset \"%s\" to %s (%s); copy preset/data-agent/ manually to enable the 数据模式 preset", presetId, targetDir, error instanceof Error ? error.message : String(error));
+		return false;
+	}
+}
+/** SHA-256 of the unmodified 0.0.9 composition that imported /tool and /command dynamically. */
+const LEGACY_PRESET_0_0_9_SHA256 = "bae875a90d638ea78715030246b0f8a9f1a2c3359ca61febb6ceb59d0fcd930a";
+/** Public for regression tests of the non-destructive preset migration gate. */
+function isLegacyManagedPreset(source) {
+	return createHash("sha256").update(source).digest("hex") === LEGACY_PRESET_0_0_9_SHA256;
+}
+/** Upgrade only the exact package-owned legacy composition; preserve every edited preset. */
+async function synchronizeExistingPreset(ctx, targetDir, sourceDir, presetId) {
+	const composition = join(targetDir, "agent.cordis.yml");
+	try {
+		const current = await readFile(composition, "utf8");
+		if (isLegacyManagedPreset(current)) {
+			const replacement = await readFile(join(sourceDir, "agent.cordis.yml"), "utf8");
+			await writeFile(composition, replacement, "utf8");
+			ctx.logger.info("data-agent: migrated preset at %s to profile-preloaded tools (removed dynamic /tool and /command rows)", composition);
+			return true;
+		}
+		if (current.includes("@yejiming/dsh-data-agent/tool") || current.includes("@yejiming/dsh-data-agent/command")) {
+			ctx.logger.warn("data-agent: user-edited preset at %s still imports /tool or /command dynamically; remove those rows so the profile-preloaded preset capabilities can activate in DSH Desktop", composition);
+			return false;
+		}
+		ctx.logger.info("data-agent: preset \"%s\" already present at %s, skipping install", presetId, targetDir);
+		return true;
+	} catch (error) {
+		ctx.logger.warn("data-agent: could not inspect existing preset %s (%s); it was not overwritten", composition, error instanceof Error ? error.message : String(error));
+		return false;
 	}
 }
 /** Exact profile-local package installation command used by diagnostics/docs. */
@@ -196,24 +239,32 @@ function profileInstallCommand(profile) {
 }
 /** Actionable diagnostic for a roster-visible preset whose profile lacks this package. */
 function missingProfileDependencyMessage(profile) {
-	return `data-agent preset is visible, but profile "${profile}" cannot resolve @yejiming/dsh-data-agent/tool or /command. Run: ${profileInstallCommand(profile)}`;
+	return `data-agent preset is visible, but its profile-preloaded capabilities are absent from profile "${profile}". Run: ${profileInstallCommand(profile)}`;
 }
-/** Warn without overwriting when a pre-existing user preset lacks the command row. */
-async function diagnoseExistingPreset(ctx, targetDir) {
-	const composition = join(targetDir, "agent.cordis.yml");
-	try {
-		if ((await readFile(composition, "utf8")).includes("@yejiming/dsh-data-agent/command")) return;
-		const profile = process.env.DSH_PROFILE?.trim();
-		const installHint = profile !== void 0 && profile.length > 0 ? profileInstallCommand(profile) : `${profileInstallCommand("web")}；${profileInstallCommand("dsh-tui")}`;
-		ctx.logger.warn("data-agent: existing user preset at %s does not contain the database-command row; the file was not overwritten. Back it up, then add name: \"@yejiming/dsh-data-agent/command\". Also install this package in the target profile: %s", composition, installHint);
-	} catch (error) {
-		ctx.logger.warn("data-agent: could not inspect existing preset %s (%s); it was not overwritten", composition, error instanceof Error ? error.message : String(error));
-	}
+/**
+* Register the statically imported database tools and command under the exact
+* standing key owned by the data-agent preset. Selecting the preset performs
+* no package import and only links the agent scope to this key.
+*/
+async function mountPresetCapabilities(ctx, key, scopeTag, config) {
+	const scoped = ctx.extend({ [scopeTag]: key });
+	apply$2(scoped, config);
+	apply$1(scoped);
+}
+/** Read the host-owned scope tag from AgentPresets' already-created standing mount. */
+async function standingScopeTag(ctx, presetId, key) {
+	const pending = ctx.agentPresets.standing?.get(presetId);
+	if (pending === void 0) throw new Error(`data-agent: preset "${presetId}" has no standing scope after standingKeyFor()`);
+	const standing = await pending;
+	if (standing.key !== key) throw new Error(`data-agent: preset "${presetId}" standing scope changed during profile preload`);
+	const tag = Object.getOwnPropertySymbols(standing.scope.ctx).find((candidate) => Reflect.get(standing.scope.ctx, candidate) === key);
+	if (tag === void 0) throw new Error(`data-agent: preset "${presetId}" standing context exposes no scope tag`);
+	return tag;
 }
 /**
-* Mount the data-agent host row: connection store, config-seeded
-* connections, and preset self-install. HTTP routes are the sibling
-* `data-agent-routes` row (`./routes`).
+* Mount the data-agent profile row: connection store, config-seeded
+* connections, preset installation, and profile-preloaded preset capabilities.
+* HTTP routes are the sibling `data-agent-routes` row (`./routes`).
 * @param ctx - host cordis context.
 * @param config - validated loader configuration.
 */
@@ -225,6 +276,7 @@ async function apply(ctx, config) {
 		introspectMaxTables: config.introspectMaxTables,
 		queryTimeoutMs: config.queryTimeoutMs,
 		maxResultChars: config.maxResultChars,
+		maxRows: config.maxRows,
 		maxQueryChars: config.maxQueryChars,
 		readonly: config.readonly,
 		persistConnections: config.persistConnections,
@@ -255,6 +307,7 @@ async function apply(ctx, config) {
 			store.set(sessionId, connection);
 		}
 	};
+	const presetReady = resolved.installPreset ? await installPreset(ctx, resolved.presetId) : false;
 	if (resolved.persistConnections) {
 		const domain = await (await ensureStorageDomain(ctx)).open(connectionStorageSpec);
 		ctx.effect(() => () => domain.close(), "data-agent: close connection storage domain");
@@ -263,7 +316,17 @@ async function apply(ctx, config) {
 		ctx.logger.warn("data-agent: persistConnections=false; connection state is process-local and cannot restore across Web/TUI");
 		mountService(ctx);
 	}
-	if (resolved.installPreset) await installPreset(ctx, resolved.presetId);
+	if (presetReady) {
+		const standingKey = await ctx.agentPresets.standingKeyFor(resolved.presetId);
+		await mountPresetCapabilities(ctx, standingKey, await standingScopeTag(ctx, resolved.presetId, standingKey), {
+			queryTimeoutMs: resolved.queryTimeoutMs,
+			maxResultChars: resolved.maxResultChars,
+			maxRows: resolved.maxRows,
+			maxQueryChars: resolved.maxQueryChars,
+			readonly: resolved.readonly,
+			clients: resolved.clients
+		});
+	}
 }
 /**
 * Reuse a surface-provided storage stack (Web) or mount the same JSON stack
@@ -289,4 +352,4 @@ async function ensureStorageDomain(ctx) {
 	return facility;
 }
 //#endregion
-export { Config, apply, inject, installPreset, missingProfileDependencyMessage, name, profileInstallCommand, resolveDshHome };
+export { Config, apply, inject, installPreset, isLegacyManagedPreset, missingProfileDependencyMessage, mountPresetCapabilities, name, profileInstallCommand, resolveDshHome };