rulesync 16.37.0 → 16.38.0

package/dist/{import-xo5me5dm.cjs → import-DKBaTqsY.cjs}

@@ -444,36 +444,36 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$350 } = node_path.posix;
+const { join: join$351 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
 const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$350(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$351(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$350(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$350(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$351(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$351(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -616,6 +616,7 @@ const mcpProcessorToolTargetTuple = [
 	"junie",
 	"musecode",
 	"opencode",
+	"pool",
 	"qwencode",
 	"reasonix",
 	"roo",
@@ -3329,6 +3330,8 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".grok/config.toml",
 	".rovodev/config.yml",
 	".rovodev/mcp.json",
+	".poolside/settings.yaml",
+	".config/poolside/settings.yaml",
 	".tabnine/agent/settings.json",
 	".vibe/config.toml",
 	".zcode/config.json",
@@ -4378,7 +4381,7 @@ const PI_HOOK_EVENTS = [
 * adapter. Amp's `agent.start` / `agent.end` events describe the main agent
 * turn, not a subagent lifecycle, so they map to `beforeSubmitPrompt` / `stop`.
 *
-* @see https://ampcode.com/manual/plugin-api
+* @see https://ampcode.com/docs/plugin-api
 */
 const AMP_HOOK_EVENTS = [
 	"sessionStart",
@@ -6223,6 +6226,7 @@ const McpServerSchema = zod_mini.z.looseObject({
 	crushOauthClientSecret: zod_mini.z.optional(zod_mini.z.string()),
 	crushOauthCallbackPort: zod_mini.z.optional(zod_mini.z.int()),
 	crushSessionless: zod_mini.z.optional(zod_mini.z.boolean()),
+	poolAllow: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	/**
 	* The canonical per-server tool allowlist.
@@ -6654,6 +6658,7 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				"crushOauthClientSecret",
 				"crushOauthCallbackPort",
 				"crushSessionless",
+				"poolAllow",
 				"oauth_client_id",
 				"oauth_client_secret",
 				"oauth_callback_port",
@@ -8341,7 +8346,7 @@ const PERMISSION_OVERRIDE_KEY_ALIASES = {
 * them; treating a segment that carries one as static could name a directory
 * that no matched file actually lives under.
 */
-const GLOB_METACHARACTERS = /[*?[\]{}()!]/;
+const GLOB_METACHARACTERS$1 = /[*?[\]{}()!]/;
 /**
 * The directory every file matched by `glob` lives under, or `undefined` when
 * the pattern pins down no such directory.
@@ -8374,7 +8379,7 @@ function getGlobStaticPrefix(glob) {
 	const lastIndex = segments.length - 1;
 	const prefix = [];
 	for (const [index, segment] of segments.entries()) {
-		if (segment === "" || GLOB_METACHARACTERS.test(segment)) break;
+		if (segment === "" || GLOB_METACHARACTERS$1.test(segment)) break;
 		if (segment === ".") continue;
 		if (index === lastIndex) break;
 		prefix.push(segment);
@@ -12949,6 +12954,8 @@ const KIMI_CODE_HOME_CONFIG_SHARED_FILE_KEY = "config.toml";
 const REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY = "reasonix.toml";
 const REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY = ".reasonix/config.toml";
 const ROVODEV_CONFIG_SHARED_FILE_KEY = ".rovodev/config.yml";
+const POOL_PROJECT_SETTINGS_SHARED_FILE_KEY = ".poolside/settings.yaml";
+const POOL_GLOBAL_SETTINGS_SHARED_FILE_KEY = ".config/poolside/settings.yaml";
 /**
 * Build the `SHARED_CONFIG_OWNERSHIP` lookup key from a tool's settable paths.
 * Mirrors `sharedFileKey` in `src/lib/shared-file-derive.ts` (kept separate so
@@ -13030,6 +13037,20 @@ const KIMI_CODE_CONFIG_DECLARATION = {
 	}
 };
 /**
+* Pool settings (`.poolside/settings.yaml` / `~/.config/poolside/settings.yaml`):
+* the user's primary Pool settings file, so an unparseable root fails closed
+* rather than being replaced with generated output. `mcp_servers` is owned as
+* a whole key because the MCP writer emits the complete server map.
+*/
+const POOL_SETTINGS_DECLARATION = {
+	format: "yaml",
+	invalidRootPolicy: "error",
+	features: { mcp: {
+		kind: "replace-owned-keys",
+		ownedKeys: ["mcp_servers"]
+	} }
+};
+/**
 * ZCode's settings file, which also carries model/theme/permission keys
 * rulesync does not own. Both copies are the user's primary ZCode config, so
 * every writer refuses to read-modify-write a file it could not parse rather
@@ -13134,6 +13155,8 @@ const SHARED_CONFIG_OWNERSHIP = {
 	[HERMES_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
 	[HERMES_WIN32_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
 	[HERMES_HOME_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
+	[POOL_PROJECT_SETTINGS_SHARED_FILE_KEY]: POOL_SETTINGS_DECLARATION,
+	[POOL_GLOBAL_SETTINGS_SHARED_FILE_KEY]: POOL_SETTINGS_DECLARATION,
 	[TAKT_CONFIG_SHARED_FILE_KEY]: {
 		format: "yaml",
 		invalidRootPolicy: "error",
@@ -37119,6 +37142,363 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/constants/pool-paths.ts
+/**
+* Pool (Poolside's coding agent CLI) configuration-layout conventions.
+*
+* Pool reads `AGENTS.md` instruction files the same way the AGENTS.md standard
+* describes them: the personal `~/.config/poolside/AGENTS.md` (Pool itself
+* honours `XDG_CONFIG_HOME` upstream; rulesync writes only the XDG-default
+* path), the project-root `AGENTS.md`, and nested per-directory
+* `AGENTS.md` files from the repository root down through the working
+* directory, deeper files taking precedence. It skips ignored directories
+* (`.git/`, `node_modules/`, cache directories, repository ignore rules).
+*
+* Skills follow the Agent Skills format (`<name>/SKILL.md` bundles). Pool
+* scans `.poolside/skills/` (project) and `~/.config/poolside/skills/`
+* (global) plus the shared `.agents/skills/` / `~/.agents/skills/` roots and
+* the skill directories of other Agent Skills tools; rulesync writes only the
+* Pool-specific roots and leaves the shared ones to their own targets.
+*
+* @see https://docs.poolside.ai/agent-instructions
+* @see https://docs.poolside.ai/skills
+* @see https://github.com/poolsideai/pool
+*/
+/** Project-scoped `.poolside/` directory at the project root. */
+const POOL_DIR = ".poolside";
+/** Global config directory for Pool, relative to the home directory. */
+const POOL_GLOBAL_DIR = (0, node_path.join)(".config", "poolside");
+/** Project skills root, relative to the project root. */
+const POOL_SKILLS_DIR_PATH = (0, node_path.join)(POOL_DIR, "skills");
+/** Global skills root, relative to the home directory. */
+const POOL_GLOBAL_SKILLS_DIR_PATH = (0, node_path.join)(POOL_GLOBAL_DIR, "skills");
+/**
+* Pool's settings file name. MCP servers live under the top-level
+* `mcp_servers` key of `.poolside/settings.yaml` (project, committed) and
+* `~/.config/poolside/settings.yaml` (global); the untracked
+* `.poolside/settings.local.yaml` overlay is left to the user.
+*
+* @see https://docs.poolside.ai/mcp-servers
+* @see https://docs.poolside.ai/settings-file-reference
+*/
+const POOL_SETTINGS_FILE_NAME = "settings.yaml";
+/** Top-level key of Pool's settings file that holds the MCP server map. */
+const POOL_MCP_SERVERS_KEY = "mcp_servers";
+//#endregion
+//#region src/features/mcp/pool-mcp.ts
+/**
+* Single spelling of the settings.yaml codec/policy, matching the
+* `SHARED_CONFIG_OWNERSHIP` declaration for both scopes: fail closed on an
+* unparseable root rather than replacing the user's primary Pool settings with
+* generated output.
+*/
+function parsePoolSettings(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "yaml",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* The remote transports Pool's `transport.type` accepts. `streamable-http` is
+* the canonical rulesync name for what Pool calls `http`; everything else is
+* left to the caller to reject.
+*
+* @see https://docs.poolside.ai/mcp-servers
+*/
+function asPoolRemoteType(stated, url) {
+	if (stated === "sse") return "sse";
+	if (stated === "http" || stated === "streamable-http") return "http";
+	if (stated === void 0) return /^wss?:\/\//i.test(url) ? void 0 : "http";
+}
+/**
+* Pool spells remote headers as a list of `"Name: value"` strings rather than
+* a map, so the canonical record is flattened at generate time and split back
+* at the first `:` on import. A list entry without a `:` names no header and
+* is dropped with a warning — silently losing what may be a mistyped auth
+* header would leave the canonical file short of one without a trace.
+*/
+function headersRecordToPoolList(headers) {
+	return Object.entries(headers).map(([name, value]) => `${name}: ${value}`);
+}
+function poolHeadersListToRecord(serverName, headers) {
+	if (!isStringArray$2(headers)) return void 0;
+	const result = {};
+	for (const entry of headers) {
+		const separator = entry.indexOf(":");
+		const name = separator > 0 ? entry.slice(0, separator).trim() : "";
+		if (name === "" || PROTOTYPE_POLLUTION_KEYS.has(name)) {
+			warnWithFallback(void 0, `Ignored malformed header ${quoteValueForWarning(entry)} in Pool MCP server ${quoteValueForWarning(serverName)}: expected "Name: value"`);
+			continue;
+		}
+		result[name] = entry.slice(separator + 1).trim();
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Pool's `deny`/`enabled_tools` entries are glob patterns, while the canonical
+* `enabledTools`/`disabledTools` lists are literal tool names that the other
+* targets match verbatim. A pattern therefore imports as a name that matches
+* nothing elsewhere — a `deny` that quietly stops denying is the case worth
+* calling out — so it is copied as-is but warned about. `allow` is exempt: it
+* imports to the Pool-only `poolAllow`, where globs are exactly what Pool
+* expects and no other tool ever reads them.
+*/
+const GLOB_METACHARACTERS = /[*?[]/;
+/** Patterns named in the glob warning before the rest collapse to `(+N more)`. */
+const MAX_LISTED_GLOB_PATTERNS = 10;
+function importPoolToolList({ serverName, poolKey, value, warnOnGlobs }) {
+	if (!isStringArray$2(value)) {
+		warnWithFallback(void 0, `Ignored malformed value for ${poolKey} in Pool MCP server ${quoteValueForWarning(serverName)}: expected a list of strings`);
+		return;
+	}
+	if (!warnOnGlobs) return value;
+	const patterns = value.filter((entry) => GLOB_METACHARACTERS.test(entry));
+	if (patterns.length > 0) {
+		const listed = patterns.slice(0, MAX_LISTED_GLOB_PATTERNS).map(quoteValueForWarning);
+		const overflow = patterns.length - listed.length;
+		const shown = overflow > 0 ? `${listed.join(", ")} (+${overflow} more)` : listed.join(", ");
+		warnWithFallback(void 0, `${poolKey} in Pool MCP server ${quoteValueForWarning(serverName)} contains glob patterns (${shown}); other tools match the imported tool names literally`);
+	}
+	return value;
+}
+/**
+* Pool's `transport` block for a remote server, or `null` (after a warning)
+* when the server has no url or names a transport Pool cannot reach.
+*/
+function toPoolTransport(name, config, logger) {
+	const url = resolveRemoteMcpUrl(config);
+	if (!url) return warnAndSkipMcpServer({
+		toolName: "Pool",
+		serverName: name,
+		reason: "a remote transport without a url",
+		logger
+	});
+	const stated = config.type ?? config.transport;
+	const type = asPoolRemoteType(stated, url);
+	if (type === void 0) return warnAndSkipMcpServer({
+		toolName: "Pool",
+		serverName: name,
+		reason: stated === void 0 ? "a WebSocket url, which Pool's remote transports (http and sse) cannot reach" : `the "${stated}" transport, which Pool does not offer for remote servers (only http and sse)`,
+		logger
+	});
+	const transport = {
+		type,
+		url
+	};
+	if (config.headers && Object.keys(config.headers).length > 0) transport.headers = headersRecordToPoolList(config.headers);
+	return transport;
+}
+/**
+* The transport-specific part of a Pool server entry: a `transport` block for
+* remote servers, `command`/`args`/`cwd` for stdio ones. `null` (after a
+* warning) when the server cannot be written.
+*/
+function toPoolTransportFields(name, config, logger) {
+	if (isRemoteMcpServer(config)) {
+		const transport = toPoolTransport(name, config, logger);
+		return transport === null ? null : { transport };
+	}
+	const [command, ...args] = resolveLocalMcpCommand(config);
+	if (!command) return warnAndSkipMcpServer({
+		toolName: "Pool",
+		serverName: name,
+		reason: "a stdio transport without a command",
+		logger
+	});
+	const fields = {
+		command,
+		args
+	};
+	if (config.cwd) fields.cwd = config.cwd;
+	return fields;
+}
+/**
+* The fields shared by stdio and remote entries. Tool filters map onto Pool's
+* own switches — `enabledTools` becomes `enabled_tools` (the tools Pool
+* exposes at all) and `disabledTools` becomes `deny` (patterns agents may
+* never use); the Pool-only approval allowlist is authored as `poolAllow` and
+* written as `allow`. `disabled: true` is spelled the same on both sides.
+*/
+function toPoolCommonFields(config) {
+	const fields = {};
+	if (config.env && Object.keys(config.env).length > 0) fields.env = config.env;
+	if (config.enabledTools && config.enabledTools.length > 0) fields.enabled_tools = config.enabledTools;
+	if (config.poolAllow && config.poolAllow.length > 0) fields.allow = config.poolAllow;
+	if (config.disabledTools && config.disabledTools.length > 0) fields.deny = config.disabledTools;
+	if (config.disabled === true) fields.disabled = true;
+	return fields;
+}
+/**
+* Convert canonical rulesync servers to Pool's native `mcp_servers` shape:
+* stdio servers carry `command`/`args`/`cwd`/`env`, remote servers carry a
+* `transport` block (`type` of `http` or `sse`, `url`, optional `headers`
+* list) plus optional `env`; see `toPoolCommonFields` for the tool filters.
+*
+* @see https://docs.poolside.ai/mcp-servers
+*/
+function convertToPoolFormat(mcpServers, logger) {
+	const result = {};
+	for (const [name, config] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+		if (!isRecord$1(config)) continue;
+		if (declaresNoTransport(config)) {
+			warnAndSkipMcpServer({
+				toolName: "Pool",
+				serverName: name,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const transportFields = toPoolTransportFields(name, config, logger);
+		if (transportFields === null) continue;
+		result[name] = {
+			...transportFields,
+			...toPoolCommonFields(config)
+		};
+	}
+	return result;
+}
+const POOL_TO_CANONICAL_TOOL_LIST_KEYS = {
+	enabled_tools: "enabledTools",
+	deny: "disabledTools",
+	allow: "poolAllow"
+};
+/**
+* Convert Pool's native `mcp_servers` shape back to canonical rulesync
+* servers: the `transport` block is flattened to `type`/`url`/`headers`,
+* `enabled_tools` maps back to `enabledTools`, `deny` to `disabledTools` and
+* `allow` to the namespaced `poolAllow` (see `McpServerSchema`). Unknown keys
+* pass through untouched so an import keeps whatever a hand-authored entry
+* declared; generation back out is a whitelist, so only the keys
+* `convertToPoolFormat` writes are re-emitted.
+*/
+function convertFromPoolFormat(poolServers) {
+	const result = {};
+	for (const [name, config] of Object.entries(poolServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		const converted = {};
+		for (const [key, value] of Object.entries(config)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			if (key === "transport") {
+				if (!isRecord$1(value)) continue;
+				if (typeof value.type === "string") converted.type = value.type;
+				if (typeof value.url === "string") converted.url = value.url;
+				const headers = poolHeadersListToRecord(name, value.headers);
+				if (headers) converted.headers = headers;
+				continue;
+			}
+			const canonicalKey = Object.hasOwn(POOL_TO_CANONICAL_TOOL_LIST_KEYS, key) ? POOL_TO_CANONICAL_TOOL_LIST_KEYS[key] : void 0;
+			if (canonicalKey) {
+				const list = importPoolToolList({
+					serverName: name,
+					poolKey: key,
+					value,
+					warnOnGlobs: canonicalKey !== "poolAllow"
+				});
+				if (list) converted[canonicalKey] = list;
+				continue;
+			}
+			converted[key] = value;
+		}
+		result[name] = converted;
+	}
+	return result;
+}
+/**
+* Pool MCP servers.
+*
+* Pool reads MCP servers from the `mcp_servers` block of its settings file:
+* `<project>/.poolside/settings.yaml` at project scope (shared and committed)
+* and `~/.config/poolside/settings.yaml` at user scope. The untracked
+* `.poolside/settings.local.yaml` overlay, which Pool layers on top of both,
+* is left to the user. Every other top-level settings key is preserved and
+* the file is never deleted.
+*
+* @see https://docs.poolside.ai/mcp-servers
+* @see https://docs.poolside.ai/settings-file-reference
+*/
+var PoolMcp = class PoolMcp extends ToolMcp {
+	settings;
+	constructor(params) {
+		super(params);
+		this.settings = parsePoolSettings(this.fileContent ?? "", (0, node_path.join)(this.relativeDirPath, this.relativeFilePath));
+	}
+	getSettings() {
+		return this.settings;
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: global ? POOL_GLOBAL_DIR : POOL_DIR,
+			relativeFilePath: POOL_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
+		return new PoolMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const converted = convertToPoolFormat(Object.fromEntries(Object.entries(rulesyncMcp.getMcpServers()).map(([serverName, serverConfig]) => {
+			const rawServer = rulesyncMcp.getRawMcpServer(serverName);
+			const poolAllow = isRecord$1(rawServer) ? rawServer.poolAllow : void 0;
+			return [serverName, {
+				...serverConfig,
+				...isStringArray$2(poolAllow) && { poolAllow }
+			}];
+		})), logger);
+		return new PoolMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { [POOL_MCP_SERVERS_KEY]: converted },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const converted = convertFromPoolFormat(isRecord$1(this.settings["mcp_servers"]) ? this.settings[POOL_MCP_SERVERS_KEY] : {});
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: converted }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new PoolMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/qwencode-mcp.ts
 /**
 * Map rulesync's canonical per-server tool filters to Qwen Code's field names.
@@ -39566,6 +39946,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["pool", {
+		class: PoolMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
+		}
+	}],
 	["qwencode", {
 		class: QwencodeMcp,
 		meta: {
@@ -56787,7 +57176,7 @@ const AmpSkillFrontmatterSchema = zod_mini.z.looseObject({
 * Amp natively reads Agent Skills following the open standard: a directory with a
 * `SKILL.md` carrying `name`/`description` frontmatter, scoped to the project
 * (`.agents/skills/`) and user-wide (`~/.config/agents/skills/`).
-* @see https://ampcode.com/manual
+* @see https://ampcode.com/docs/customize/skills
 */
 var AmpSkill = class AmpSkill extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = AMP_SKILLS_PROJECT_DIR, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
@@ -61756,37 +62145,6 @@ var PiSkill = class PiSkill extends ToolSkill {
 	}
 };
 //#endregion
-//#region src/constants/pool-paths.ts
-/**
-* Pool (Poolside's coding agent CLI) configuration-layout conventions.
-*
-* Pool reads `AGENTS.md` instruction files the same way the AGENTS.md standard
-* describes them: the personal `~/.config/poolside/AGENTS.md` (Pool itself
-* honours `XDG_CONFIG_HOME` upstream; rulesync writes only the XDG-default
-* path), the project-root `AGENTS.md`, and nested per-directory
-* `AGENTS.md` files from the repository root down through the working
-* directory, deeper files taking precedence. It skips ignored directories
-* (`.git/`, `node_modules/`, cache directories, repository ignore rules).
-*
-* Skills follow the Agent Skills format (`<name>/SKILL.md` bundles). Pool
-* scans `.poolside/skills/` (project) and `~/.config/poolside/skills/`
-* (global) plus the shared `.agents/skills/` / `~/.agents/skills/` roots and
-* the skill directories of other Agent Skills tools; rulesync writes only the
-* Pool-specific roots and leaves the shared ones to their own targets.
-*
-* @see https://docs.poolside.ai/agent-instructions
-* @see https://docs.poolside.ai/skills
-* @see https://github.com/poolsideai/pool
-*/
-/** Project-scoped `.poolside/` directory at the project root. */
-const POOL_DIR = ".poolside";
-/** Global config directory for Pool, relative to the home directory. */
-const POOL_GLOBAL_DIR = (0, node_path.join)(".config", "poolside");
-/** Project skills root, relative to the project root. */
-const POOL_SKILLS_DIR_PATH = (0, node_path.join)(POOL_DIR, "skills");
-/** Global skills root, relative to the home directory. */
-const POOL_GLOBAL_SKILLS_DIR_PATH = (0, node_path.join)(POOL_GLOBAL_DIR, "skills");
-//#endregion
 //#region src/features/skills/pool-skill.ts
 const PoolSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_import = require("./import-xo5me5dm.cjs");
+const require_import = require("./import-DKBaTqsY.cjs");
 //#region src/index.ts
 async function generate(options = {}) {
 	const { silent = true, verbose = false, ...rest } = options;

package/dist/index.d.cts

@@ -14,7 +14,7 @@ declare const FeatureSchema: z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
 type Feature = z.infer<typeof FeatureSchema>;
 //#endregion
 //#region src/types/tool-target-tuples.d.ts
-declare const ALL_TOOL_TARGET_TUPLES: readonly [readonly ["agentsmd", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "augmentcode-legacy", "bob", "claudecode", "claudecode-legacy", "cline", "codebuddy", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kimi-code", "kiro", "kiro-cli", "kiro-ide", "musecode", "opencode", "pi", "pool", "qwencode", "reasonix", "replit", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode", "dsh"], readonly ["aiassistant", "antigravity-cli", "augmentcode", "bob", "claudecode", "claudecode-legacy", "cline", "continue", "crush", "cursor", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "qwencode", "reasonix", "roo", "tabnine", "devin", "vibe", "warp", "zed", "zoocode"], readonly ["aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "kilo", "kiro", "kiro-cli", "kiro-ide", "junie", "musecode", "opencode", "qwencode", "reasonix", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode"], readonly ["agentsmd", "antigravity-cli", "antigravity-ide", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "cursor", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "zoocode", "rovodev", "tabnine", "takt", "devin", "warp", "zcode"], readonly ["kilo", "agentsmd", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "copilot", "copilotcli", "cortexcode", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "roo", "zoocode", "rovodev", "tabnine", "takt", "vibe", "zcode"], readonly ["agentsmd", "agentsskills", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "musecode", "opencode", "pi", "pool", "qwencode", "reasonix", "replit", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode", "dsh"], readonly ["amp", "cline", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "kilo", "cursor", "claudecode", "claudecode-plugin", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "opencode", "pi", "factorydroid", "goose", "hermesagent", "kimi-code", "deepagents", "kiro", "kiro-cli", "kiro-ide", "devin", "augmentcode", "bob", "junie", "vibe", "qwencode", "reasonix", "tabnine", "grokcli", "zcode"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "crush", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "zed", "zoocode"], readonly ["amp", "augmentcode", "cursor", "factorydroid", "hermesagent", "rovodev", "takt"]];
+declare const ALL_TOOL_TARGET_TUPLES: readonly [readonly ["agentsmd", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "augmentcode-legacy", "bob", "claudecode", "claudecode-legacy", "cline", "codebuddy", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kimi-code", "kiro", "kiro-cli", "kiro-ide", "musecode", "opencode", "pi", "pool", "qwencode", "reasonix", "replit", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode", "dsh"], readonly ["aiassistant", "antigravity-cli", "augmentcode", "bob", "claudecode", "claudecode-legacy", "cline", "continue", "crush", "cursor", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "qwencode", "reasonix", "roo", "tabnine", "devin", "vibe", "warp", "zed", "zoocode"], readonly ["aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "kilo", "kiro", "kiro-cli", "kiro-ide", "junie", "musecode", "opencode", "pool", "qwencode", "reasonix", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode"], readonly ["agentsmd", "antigravity-cli", "antigravity-ide", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "cursor", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "zoocode", "rovodev", "tabnine", "takt", "devin", "warp", "zcode"], readonly ["kilo", "agentsmd", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "copilot", "copilotcli", "cortexcode", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "roo", "zoocode", "rovodev", "tabnine", "takt", "vibe", "zcode"], readonly ["agentsmd", "agentsskills", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "augmentcode", "bob", "claudecode", "claudecode-plugin", "claudecode-legacy", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "musecode", "opencode", "pi", "pool", "qwencode", "reasonix", "replit", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "devin", "zcode", "zed", "zoocode", "dsh"], readonly ["amp", "cline", "antigravity-cli", "antigravity-ide", "antigravity-plugin", "kilo", "cursor", "claudecode", "claudecode-plugin", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "cortexcode", "crush", "opencode", "pi", "factorydroid", "goose", "hermesagent", "kimi-code", "deepagents", "kiro", "kiro-cli", "kiro-ide", "devin", "augmentcode", "bob", "junie", "vibe", "qwencode", "reasonix", "tabnine", "grokcli", "zcode"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "cline", "codexcli", "commandcode", "continue", "copilot", "copilotcli", "crush", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "kimi-code", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "rovodev", "tabnine", "takt", "vibe", "warp", "zed", "zoocode"], readonly ["amp", "augmentcode", "cursor", "factorydroid", "hermesagent", "rovodev", "takt"]];
 //#endregion
 //#region src/types/tool-targets.d.ts
 type AllToolTarget = (typeof ALL_TOOL_TARGET_TUPLES)[number][number];

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types/features.ts","../src/types/tool-target-tuples.ts","../src/types/tool-targets.ts","../src/lib/convert.ts","../src/types/ai-dir.ts","../src/features/skills/rulesync-skill.ts","../src/lib/generate.ts","../src/lib/import.ts","../src/index.ts"],"mappings":";;qBAaa;cA+BP,eAAa,EAAA,uBAAA,EAAA;;;;;;;;;IAAoE,EAAA;KAE3E,UAAU,EAAE,aAAa;;;cCsTxB;;;KC1VR,wBAAwB;qBAEhB,4BAA4B,kBAAkB;cAM9C,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjB,aAAa,EAAE,aAAa;;;KCH5B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCWU;EAEN;EACA;;EAGA;EACA,OAAO;;KAqBD;EACV;EACA,YAAY;;;;;;;;EAQZ;;;;;;;EAOA;;KAmnBU;EACV;EACA;EACA;EACA;IACE;IACA;IACA,cAAc;;EAEhB,aAAa;EACb;;KAGU,qBAAqB,KAC/B;uBAIoB;;;;qBAID;;;;qBAKA;;;;qBAKA;;;;YAKT;IACR;IACA;IACA,cAAc;;;;;YAMN,YAAY;;;;qBAKH;EAEnB,cACE,YACA,iBACA,SACA,UACA,YACA,UACC;SAyBU,QAAQ,SAAS,qBAAqB,QAAQ;EAI3D;EAIA;EAIA;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;;;EAgBA;EAqBA;EAqBA;IAEM;IACA;IACA,cAAc;;EAMpB,iBAAiB;;;;EAOjB;EAIA;EAIA,YAAY,cAAc,cAAc,cAAc;;;;;;;;;;iBAajC;;iBAWN;;;;;;iBASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCA;iBA8CM;;;;;iBA6GN;;;;;;;iBAsDM;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+FE,kBACrB,oBACA,yBACA,iBACA,0BACC,QAAQ;WAwGF,YAAY;;;;cC70CjB,wCAAsC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsX1C,EAAA,KAAA;KAMU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,yBAAyB;EACzB,WAAW;EACX;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;;EAEF;IACE;IACA,WAAW;IACX;IACA;;EAEF;IACE;IACA;MACE;MACA;MACA;MACA;MACA;MACA;;IAEF;MACE;;IAEF;MACE,QAAQ;QACN;QACA;QACA;QACA;QACA;;;;EAIN;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb,MAAM;EACN,MAAM;EACN,QAAQ;EACR,MAAM;EACN;IACE;IACA;IACA;IACA;IACA;IACA,cAAc;IACd;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;IACA;IACA;IACA,WAAW;;EAEb;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;;EAEF,cAAc;EACd;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;IACA;;EAEF,cAAc;EACd,aAAa;EACb,WAAW;EACX,UAAU;EACV;IACE;IACA;;EAEF;IACE;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA,WAAW;;;KAKH,2BAA2B,EAAE,aAAa;KAO1C;EACV;EACA;EACA;EACA,aAAa;EACb;EACA,aAAa;EACb;EACA;;KAGU;EACV;;KAGU;EACV;EACA;EACA;EACA;;;;;;cAOW,sBAAsB;EACjC,cACE,YACA,iBACA,SACA,aACA,MACA,YACA,UACA,UACC;SAsBI,oBAAoB;EAU3B,kBAAkB;EAQlB;EAIA,YAAY;SAcC,UACX,YACA,iBACA,SACA,UACC,6BAA6B,QAAQ;;;;KCvqB9B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;;;;;;EAMA;;;;;EAKA,0BAA0B;;KA0ZhB;;;KCrbA;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KC/CG;EACH;EACA;EACA;EACA;;YAGU,kBAAkB;EAC5B,UAAU;EACV,WAAW;EACX;;;;;;;;;;;;;EAaA;;;;;;;;EAQA;EACA;EACA;EACA;EACA;EACA;EACA;;YAGU,gBAAgB;EAC1B,QAAQ;EACR,WAAW;;YAGD,iBAAiB;EAC3B,MAAM;EACN,IAAI;EACJ,WAAW;EACX;;wBAGoB,SAAS,UAAS,kBAAuB,QAAQ;wBAyBjD,eAAe,SAAS,gBAAgB,QAAQ;wBAehD,gBAAgB,SAAS,iBAAiB,QAAQ"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types/features.ts","../src/types/tool-target-tuples.ts","../src/types/tool-targets.ts","../src/lib/convert.ts","../src/types/ai-dir.ts","../src/features/skills/rulesync-skill.ts","../src/lib/generate.ts","../src/lib/import.ts","../src/index.ts"],"mappings":";;qBAaa;cA+BP,eAAa,EAAA,uBAAA,EAAA;;;;;;;;;IAAoE,EAAA;KAE3E,UAAU,EAAE,aAAa;;;cCuTxB;;;KC3VR,wBAAwB;qBAEhB,4BAA4B,kBAAkB;cAM9C,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjB,aAAa,EAAE,aAAa;;;KCH5B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCWU;EAEN;EACA;;EAGA;EACA,OAAO;;KAqBD;EACV;EACA,YAAY;;;;;;;;EAQZ;;;;;;;EAOA;;KAmnBU;EACV;EACA;EACA;EACA;IACE;IACA;IACA,cAAc;;EAEhB,aAAa;EACb;;KAGU,qBAAqB,KAC/B;uBAIoB;;;;qBAID;;;;qBAKA;;;;qBAKA;;;;YAKT;IACR;IACA;IACA,cAAc;;;;;YAMN,YAAY;;;;qBAKH;EAEnB,cACE,YACA,iBACA,SACA,UACA,YACA,UACC;SAyBU,QAAQ,SAAS,qBAAqB,QAAQ;EAI3D;EAIA;EAIA;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;;;EAgBA;EAqBA;EAqBA;IAEM;IACA;IACA,cAAc;;EAMpB,iBAAiB;;;;EAOjB;EAIA;EAIA,YAAY,cAAc,cAAc,cAAc;;;;;;;;;;iBAajC;;iBAWN;;;;;;iBASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCA;iBA8CM;;;;;iBA6GN;;;;;;;iBAsDM;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+FE,kBACrB,oBACA,yBACA,iBACA,0BACC,QAAQ;WAwGF,YAAY;;;;cC70CjB,wCAAsC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsX1C,EAAA,KAAA;KAMU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,yBAAyB;EACzB,WAAW;EACX;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;;EAEF;IACE;IACA,WAAW;IACX;IACA;;EAEF;IACE;IACA;MACE;MACA;MACA;MACA;MACA;MACA;;IAEF;MACE;;IAEF;MACE,QAAQ;QACN;QACA;QACA;QACA;QACA;;;;EAIN;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb,MAAM;EACN,MAAM;EACN,QAAQ;EACR,MAAM;EACN;IACE;IACA;IACA;IACA;IACA;IACA,cAAc;IACd;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA;IACA;IACA;IACA,WAAW;;EAEb;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;;EAEF,cAAc;EACd;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;IACA;;EAEF,cAAc;EACd,aAAa;EACb,WAAW;EACX,UAAU;EACV;IACE;IACA;;EAEF;IACE;IACA;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA,WAAW;;;KAKH,2BAA2B,EAAE,aAAa;KAO1C;EACV;EACA;EACA;EACA,aAAa;EACb;EACA,aAAa;EACb;EACA;;KAGU;EACV;;KAGU;EACV;EACA;EACA;EACA;;;;;;cAOW,sBAAsB;EACjC,cACE,YACA,iBACA,SACA,aACA,MACA,YACA,UACA,UACC;SAsBI,oBAAoB;EAU3B,kBAAkB;EAQlB;EAIA,YAAY;SAcC,UACX,YACA,iBACA,SACA,UACC,6BAA6B,QAAQ;;;;KCvqB9B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;;;;;;EAMA;;;;;EAKA,0BAA0B;;KA0ZhB;;;KCrbA;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KC/CG;EACH;EACA;EACA;EACA;;YAGU,kBAAkB;EAC5B,UAAU;EACV,WAAW;EACX;;;;;;;;;;;;;EAaA;;;;;;;;EAQA;EACA;EACA;EACA;EACA;EACA;EACA;;YAGU,gBAAgB;EAC1B,QAAQ;EACR,WAAW;;YAGD,iBAAiB;EAC3B,MAAM;EACN,IAAI;EACJ,WAAW;EACX;;wBAGoB,SAAS,UAAS,kBAAuB,QAAQ;wBAyBjD,eAAe,SAAS,gBAAgB,QAAQ;wBAehD,gBAAgB,SAAS,iBAAiB,QAAQ"}