rulesync 16.36.0 → 16.38.0

package/dist/{import-D_iukHSy.js → import-BiyWNVZY.js}

@@ -591,6 +591,7 @@ const mcpProcessorToolTargetTuple = [
 	"junie",
 	"musecode",
 	"opencode",
+	"pool",
 	"qwencode",
 	"reasonix",
 	"roo",
@@ -3304,6 +3305,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",
@@ -4353,7 +4356,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",
@@ -6198,6 +6201,7 @@ const McpServerSchema = z.looseObject({
 	crushOauthClientSecret: z.optional(z.string()),
 	crushOauthCallbackPort: z.optional(z.int()),
 	crushSessionless: z.optional(z.boolean()),
+	poolAllow: z.optional(z.array(z.string())),
 	headers: z.optional(z.record(z.string(), z.string())),
 	/**
 	* The canonical per-server tool allowlist.
@@ -6629,6 +6633,7 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				"crushOauthClientSecret",
 				"crushOauthCallbackPort",
 				"crushSessionless",
+				"poolAllow",
 				"oauth_client_id",
 				"oauth_client_secret",
 				"oauth_callback_port",
@@ -8316,7 +8321,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.
@@ -8349,7 +8354,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);
@@ -8420,6 +8425,7 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		trigger: z.optional(z.string()),
 		globs: z.optional(z.array(z.string()))
 	})),
+	aiassistant: z.optional(z.looseObject({ apply: z.optional(z.string()) })),
 	devin: z.optional(z.looseObject({
 		trigger: z.optional(z.string()),
 		globs: z.optional(z.array(z.string())),
@@ -9644,6 +9650,8 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		paths: z.optional(z.union([z.string(), z.array(z.string())])),
 		"disable-model-invocation": z.optional(z.boolean()),
 		"user-invocable": z.optional(z.boolean()),
+		icon: z.optional(z.string()),
+		color: z.optional(z.string()),
 		metadata: z.optional(z.looseObject({}))
 	})),
 	factorydroid: z.optional(z.looseObject({
@@ -12921,6 +12929,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
@@ -13002,6 +13012,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
@@ -13106,6 +13130,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",
@@ -23658,14 +23684,23 @@ var ContinueHooks = class extends SettingsJsonHooks {
 * portable `command` field is written, which upstream copies to both when
 * neither is present. Note the cloud agent runs hooks in a Linux sandbox and
 * honors only `bash` and `command` — a `powershell` entry is ignored there.
+* VS Code reads the same file and maps `bash` to `osx` / `linux` and
+* `powershell` to `windows`; it also documents its own per-OS overrides
+* (`windows`, `linux`, `osx`) next to `command`, which are typed here so an
+* entry that uses them instead of a shell field is not mistaken for one
+* without a command.
 *
 * @see https://docs.github.com/en/copilot/reference/hooks-reference
+* @see https://code.visualstudio.com/docs/agents/reference/hooks-reference
 */
 const CopilotHookEntrySchema = z.looseObject({
 	type: z.string(),
 	bash: z.optional(z.string()),
 	powershell: z.optional(z.string()),
 	command: z.optional(z.string()),
+	windows: z.optional(z.string()),
+	linux: z.optional(z.string()),
+	osx: z.optional(z.string()),
 	cwd: z.optional(z.string()),
 	env: z.optional(z.record(z.string(), z.string())),
 	timeoutSec: z.optional(z.number()),
@@ -23756,17 +23791,30 @@ function resolveImportCommand$1(entry, logger) {
 *
 * Generate re-emits any non-canonical key verbatim through `rest`, so a key
 * dropped here does not survive an import → generate round trip. `cwd` is a
-* documented Copilot hook field and was previously lost that way.
+* documented Copilot hook field and was previously lost that way, as were the
+* VS Code per-OS overrides `windows` / `linux` / `osx`: an entry authored with
+* only those (no `command`) imported as a hook with no command at all and was
+* regenerated empty.
 *
 * @see https://docs.github.com/en/copilot/reference/hooks-reference
 * @see https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-hooks
+* @see https://code.visualstudio.com/docs/agents/reference/hooks-reference
 */
 function importPassthrough$1(entry) {
 	const passthrough = {};
 	if (entry.cwd !== void 0) passthrough.cwd = entry.cwd;
 	if (entry.env !== void 0) passthrough.env = entry.env;
+	for (const key of OS_OVERRIDE_KEYS) if (entry[key] !== void 0) passthrough[key] = entry[key];
 	return passthrough;
 }
+const OS_OVERRIDE_KEYS = [
+	"windows",
+	"linux",
+	"osx"
+];
+function hasOsOverride(passthrough) {
+	return OS_OVERRIDE_KEYS.some((key) => passthrough[key] !== void 0);
+}
 /**
 * Extract hooks from Copilot hooks JSON into canonical format.
 * Copilot format: { version: 1, hooks: { eventName: [...hookEntries] } }
@@ -23787,12 +23835,14 @@ function copilotHooksToCanonical(copilotHooks, logger) {
 			const entry = parseResult.data;
 			const { command, shell } = resolveImportCommand$1(entry, logger);
 			const timeout = entry.timeoutSec ?? entry.timeout;
+			const passthrough = importPassthrough$1(entry);
+			if (command === void 0 && hasOsOverride(passthrough)) logger?.warn(`Copilot hook on '${copilotEventName}' has only VS Code per-OS overrides (windows/linux/osx) and no portable command; it is preserved for copilot, but other targets will generate it without a command until a \`command\` is added.`);
 			defs.push({
 				type: "command",
 				...command !== void 0 && { command },
 				...shell !== void 0 && { shell },
 				...timeout !== void 0 && { timeout },
-				...importPassthrough$1(entry)
+				...passthrough
 			});
 		}
 		if (defs.length > 0) canonical[eventName] = defs;
@@ -23955,6 +24005,8 @@ const CopilotCliHookEntrySchema = z.looseObject({
 	bash: z.optional(z.string()),
 	powershell: z.optional(z.string()),
 	command: z.optional(z.string()),
+	exec: z.optional(z.string()),
+	args: z.optional(z.array(z.string())),
 	prompt: z.optional(z.string()),
 	url: z.optional(z.string()),
 	headers: z.optional(z.record(z.string(), z.string())),
@@ -23984,6 +24036,32 @@ function resolveExportMatcherPart({ matcher, matcherSupported, eventName, logger
 	return {};
 }
 /**
+* Pick the command fields of an exported `command` entry.
+*
+* A canonical `args` list (an empty one counts) selects the CLI's shell-free
+* form: `command` becomes `exec` and the list is written as `args`, so the
+* executable is spawned directly. The `shell` selector is meaningless there
+* and is dropped with a warning. Otherwise the canonical `shell` selector
+* picks the shell-specific field; without it the portable `command` field is
+* written, which upstream copies to both `bash` and `powershell`. Keying off
+* `shell` rather than `process.platform` keeps the generated file identical
+* on every machine.
+*/
+function resolveExportCommandPart({ def, eventName, logger }) {
+	if (Array.isArray(def.args)) {
+		if (def.shell !== void 0) logger?.warn(`Copilot CLI runs an \`exec\` hook without a shell; dropping shell "${def.shell}" on '${eventName}'.`);
+		return compact({
+			exec: def.command,
+			args: def.args,
+			env: def.env
+		});
+	}
+	return compact({
+		[def.shell ?? "command"]: def.command,
+		env: def.env
+	});
+}
+/**
 * Build the exported entries for a single canonical event. Returns an empty
 * array when no entries are emitted (e.g. all prompt hooks were skipped).
 */
@@ -24023,19 +24101,17 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else if (hookType === "command") {
-			const commandField = def.shell ?? "command";
-			entries.push({
-				type: "command",
-				...matcherPart,
-				...compact({
-					[commandField]: def.command,
-					env: def.env
-				}),
-				...timeoutPart,
-				...rest
-			});
-		}
+		else if (hookType === "command") entries.push({
+			type: "command",
+			...matcherPart,
+			...resolveExportCommandPart({
+				def,
+				eventName,
+				logger
+			}),
+			...timeoutPart,
+			...rest
+		});
 	}
 	return entries;
 }
@@ -24075,6 +24151,10 @@ function importPassthrough(entry) {
 /**
 * Resolve the canonical command and its `shell` selector from an imported entry.
 *
+* The CLI-only `exec` form maps to canonical `command` + `args`, the exec form
+* shared with AugmentCode and Claude Code, so it no longer imports as a hook
+* with no command at all.
+*
 * A shell-specific field carries its `shell` through so re-export writes the
 * same field back. An entry using only the portable `command` field leaves
 * `shell` unset, which re-export renders as the portable field again.
@@ -24088,6 +24168,13 @@ function importPassthrough(entry) {
 function resolveImportCommand(entry, logger) {
 	const hasBash = typeof entry.bash === "string";
 	const hasPowershell = typeof entry.powershell === "string";
+	if (typeof entry.exec === "string") {
+		if (hasBash || hasPowershell || typeof entry.command === "string") logger?.warn("Copilot CLI hook has both exec and a shell command; using exec and ignoring the shell fields, as the hooks reference says not to combine them.");
+		return {
+			command: entry.exec,
+			args: entry.args ?? []
+		};
+	}
 	if (hasBash && hasPowershell) {
 		logger?.warn("Copilot CLI hook has both bash and powershell commands; using bash and ignoring powershell, so the imported config does not depend on the machine the import ran on.");
 		return {
@@ -24137,11 +24224,12 @@ function copilotCliHooksToCanonical(rawHooks, logger) {
 				...passthrough
 			});
 			else {
-				const { command, shell } = resolveImportCommand(entry, logger);
+				const { command, shell, args } = resolveImportCommand(entry, logger);
 				defs.push({
 					type: "command",
 					...command !== void 0 && { command },
 					...shell !== void 0 && { shell },
+					...args !== void 0 && { args },
 					...matcherPart,
 					...timeoutPart,
 					...passthrough
@@ -24691,6 +24779,7 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 				...def.loop_limit !== void 0 && { loop_limit: def.loop_limit },
 				...def.matcher !== void 0 && def.matcher !== null && { matcher: def.matcher },
 				...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt },
+				...def.type === "prompt" && def.model !== void 0 && def.model !== null && { model: def.model },
 				...def.failClosed !== void 0 && def.failClosed !== null && { failClosed: def.failClosed }
 			}));
 			if (mappedDefs.length > 0) mappedHooks[cursorEventName] = mappedDefs;
@@ -37028,6 +37117,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 = join(".config", "poolside");
+/** Project skills root, relative to the project root. */
+const POOL_SKILLS_DIR_PATH = join(POOL_DIR, "skills");
+/** Global skills root, relative to the home directory. */
+const POOL_GLOBAL_SKILLS_DIR_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 ?? "", 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(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 = 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.
@@ -39475,6 +39921,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["pool", {
+		class: PoolMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
+		}
+	}],
 	["qwencode", {
 		class: QwencodeMcp,
 		meta: {
@@ -56696,7 +57151,7 @@ const AmpSkillFrontmatterSchema = 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 }) {
@@ -59175,8 +59630,11 @@ const CursorSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.string(),
 	paths: z.optional(z.union([z.string(), z.array(z.string())])),
+	globs: z.optional(z.union([z.string(), z.array(z.string())])),
 	"disable-model-invocation": z.optional(z.boolean()),
 	"user-invocable": z.optional(z.boolean()),
+	icon: z.optional(z.string()),
+	color: z.optional(z.string()),
 	metadata: z.optional(z.looseObject({}))
 });
 /**
@@ -59228,10 +59686,13 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 	}
 	toRulesyncSkill() {
 		const frontmatter = this.getFrontmatter();
+		const paths = frontmatter.paths ?? frontmatter.globs;
 		const cursorSection = {
-			...frontmatter.paths !== void 0 && { paths: frontmatter.paths },
+			...paths !== void 0 && { paths },
 			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
 			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
+			...frontmatter.icon !== void 0 && { icon: frontmatter.icon },
+			...frontmatter.color !== void 0 && { color: frontmatter.color },
 			...frontmatter.metadata !== void 0 && { metadata: frontmatter.metadata }
 		};
 		const rulesyncFrontmatter = {
@@ -59273,6 +59734,8 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 			...cursorSection?.paths !== void 0 && { paths: cursorSection.paths },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
+			...cursorSection?.icon !== void 0 && { icon: cursorSection.icon },
+			...cursorSection?.color !== void 0 && { color: cursorSection.color },
 			...metadata !== void 0 && { metadata }
 		};
 		return new CursorSkill({
@@ -61657,37 +62120,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 = join(".config", "poolside");
-/** Project skills root, relative to the project root. */
-const POOL_SKILLS_DIR_PATH = join(POOL_DIR, "skills");
-/** Global skills root, relative to the home directory. */
-const POOL_GLOBAL_SKILLS_DIR_PATH = join(POOL_GLOBAL_DIR, "skills");
-//#endregion
 //#region src/features/skills/pool-skill.ts
 const PoolSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -66032,11 +66464,17 @@ var CopilotSubagent = class CopilotSubagent extends ToolSubagent {
 *
 * Reference: https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/create-custom-agents-for-cli
 *            https://docs.github.com/en/copilot/reference/custom-agents-configuration
+*            https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference
 *
 * Per the configuration docs:
 *  - `description` is required.
 *  - `name`, `target`, `tools`, `model`, `disable-model-invocation`,
 *    `user-invocable`, `mcp-servers`, and `metadata` are optional.
+*  - The CLI command reference adds `models` (authored models in priority
+*    order, overriding `model` when both are set) and `modelPolicy`
+*    (`preferred` lets a `subagents` settings override or the `/subagents`
+*    picker replace the model; `required` locks dispatch to the authored
+*    list). CLI v1.0.81+; the shared reference page still lists `model` only.
 *
 * `looseObject` is used so that future additional fields are passed through
 * unchanged (consistent with the rest of rulesync's frontmatter schemas).
@@ -66047,6 +66485,8 @@ const CopilotCliSubagentFrontmatterSchema = z.looseObject({
 	target: z.optional(z.string()),
 	tools: z.optional(z.union([z.string(), z.array(z.string())])),
 	model: z.optional(z.string()),
+	models: z.optional(z.array(z.string())),
+	modelPolicy: z.optional(z.enum(["preferred", "required"])),
 	"disable-model-invocation": z.optional(z.boolean()),
 	"user-invocable": z.optional(z.boolean()),
 	"mcp-servers": z.optional(z.record(z.string(), z.unknown())),
@@ -70423,16 +70863,131 @@ var AgentsMdRule = class AgentsMdRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/utils/brace-aware-list.ts
+/**
+* Splits a comma-separated pattern list on the commas that separate its
+* entries, leaving the commas inside a brace group alone: in
+* `{src,lib}/**\/*.ts, tests/**\/*.test.ts` the first comma belongs to the
+* brace expansion and the second separates the two globs. Entries are trimmed;
+* empty entries are dropped.
+*
+* @example
+* splitBraceAwareList("src/**\/*.{ts,tsx}, docs/**")
+* // => ["src/**\/*.{ts,tsx}", "docs/**"]
+*/
+const splitBraceAwareList = (value) => {
+	const entries = [];
+	let current = "";
+	let braceDepth = 0;
+	for (const char of value) {
+		if (char === "{") braceDepth += 1;
+		else if (char === "}" && braceDepth > 0) braceDepth -= 1;
+		else if (char === "," && braceDepth === 0) {
+			entries.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	entries.push(current);
+	return entries.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+};
+/**
+* Upper bound on the patterns one glob may expand to; past it the glob is
+* returned verbatim, since `{a,b}` repeated k times yields 2^k branches.
+*/
+const MAX_BRACE_EXPANSIONS = 256;
+/** Matches an innermost brace group with at least one comma: `{a,b}`, not `{a}` or `{a,{b,c}}`. */
+const INNERMOST_BRACE_GROUP_REGEX = /\{([^{},]*(?:,[^{},]*)+)\}/;
+/**
+* Expands the comma alternations of a glob (`a.{ts,tsx}` → `a.ts`, `a.tsx`)
+* into one pattern per combination, innermost group first, so the result can
+* be handed to a consumer that splits its pattern list on bare commas. A glob
+* without a brace alternation is returned as is; a brace group without a
+* comma (e.g. `{a}`) is left untouched. A glob whose expansion would exceed
+* `MAX_BRACE_EXPANSIONS` patterns is returned as is as well.
+*
+* The cap is enforced on the work list itself rather than by counting the
+* groups up front: a nested group such as `{{a,b},c}` is rewritten into one
+* new group per inner alternative, so the number of patterns in flight is the
+* only bound that holds for arbitrary nesting.
+*
+* @example
+* expandBraceAlternations("src/**\/*.{ts,tsx}")
+* // => ["src/**\/*.ts", "src/**\/*.tsx"]
+*/
+const expandBraceAlternations = (glob) => {
+	let pending = [glob];
+	for (;;) {
+		const next = [];
+		let expanded = false;
+		for (const pattern of pending) {
+			const match = INNERMOST_BRACE_GROUP_REGEX.exec(pattern);
+			if (match === null) {
+				next.push(pattern);
+				continue;
+			}
+			expanded = true;
+			const prefix = pattern.slice(0, match.index);
+			const suffix = pattern.slice(match.index + match[0].length);
+			for (const alternative of (match[1] ?? "").split(",")) next.push(`${prefix}${alternative}${suffix}`);
+			if (next.length > MAX_BRACE_EXPANSIONS) return [glob];
+		}
+		if (!expanded) return [...new Set(next)];
+		pending = next;
+	}
+};
+//#endregion
 //#region src/features/rules/aiassistant-rule.ts
 /**
+* Rule types AI Assistant recognizes on the `apply:` metadata line. The values
+* are matched case-sensitively by the plugin, so they are emitted verbatim.
+* Any other value is carried through untouched (the plugin treats it as Off
+* today; a future build may recognize it).
+*/
+const AIASSISTANT_APPLY_VALUES = [
+	"always",
+	"manually",
+	"by model decision",
+	"by file patterns",
+	"off"
+];
+const isAiassistantApply = (value) => AIASSISTANT_APPLY_VALUES.includes(value);
+/**
+* Globs that match the whole project and so say nothing beyond "always".
+*/
+const UNIVERSAL_GLOBS$2 = /* @__PURE__ */ new Set(["**/*", "*"]);
+const METADATA_DELIMITER = "---";
+/**
+* Splits text into lines that keep their own line terminator, so the body can
+* be sliced back out of the file byte-for-byte. Lone `\r` counts as a break,
+* matching Kotlin's `lines()`, which the plugin uses on the block.
+*/
+const LINE_SPLIT_REGEX = /(?<=\r\n|\r(?!\n)|(?<!\r)\n)/;
+/**
+* The block is line-based, so a value must not carry a line break: one would
+* start a new `<field>: <value>` line and could override `apply:`.
+*/
+const flattenValue = (value) => value.split(/\r\n|\r|\n/).map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
+/**
 * Rule generator for JetBrains AI Assistant.
 *
 * AI Assistant reads project rules as flat Markdown files in
-* `.aiassistant/rules/*.md` (one file per rule, identified by filename). The rule
-* type (Always / Manually / By model decision / By file patterns) is configured
-* in the IDE, not in the file, so the generated files are plain Markdown with no
-* frontmatter. There is no special root file (unlike Junie's `guidelines.md`), so
-* every rule — root or non-root — is written as its own file under `rules/`.
+* `.aiassistant/rules/*.md` (one file per rule, identified by filename). There
+* is no special root file (unlike Junie's `guidelines.md`), so every rule —
+* root or non-root — is written as its own file under `rules/`.
+*
+* The rule type (Always / Manually / By model decision / By file patterns /
+* Off) is stored in the file itself as a leading `---` metadata block that the
+* IDE's "Rule type" selector edits in place. The block is not YAML: each line
+* is `<field>: <value>` split on the first colon, and `patterns` is a
+* comma-separated glob list, so it is written and parsed by hand here. A file
+* without an `apply:` line is treated as Off at retrieval time (it is never
+* attached automatically), which is why every generated file carries one.
+*
+* Field names and values come from the plugin (`AiRulesService`,
+* `AiRulesLLMBundle.properties`; verified on build 262.10968.75) — the docs
+* page describes the rule type only as an IDE setting.
 *
 * AI Assistant and Junie are different JetBrains products (real-time assistance
 * vs. autonomous agent) with different layouts, so this is a separate target.
@@ -70440,18 +70995,154 @@ var AgentsMdRule = class AgentsMdRule extends ToolRule {
 * @see https://www.jetbrains.com/help/ai-assistant/configure-project-rules.html
 */
 var AiassistantRule = class AiassistantRule extends ToolRule {
+	body;
+	metadata;
+	constructor({ body, metadata, ...rest }) {
+		super({
+			...rest,
+			fileContent: AiassistantRule.buildFileContent({
+				body,
+				metadata
+			})
+		});
+		this.body = body;
+		this.metadata = metadata;
+	}
 	static getSettablePaths(_options = {}) {
 		return { nonRoot: { relativeDirPath: AIASSISTANT_RULES_DIR_PATH } };
 	}
+	getBody() {
+		return this.body;
+	}
+	getMetadata() {
+		return this.metadata;
+	}
+	/**
+	* Serialize the metadata block the way the IDE writes it
+	* (`---\n<field>: <value>\n---`), followed by the body.
+	*/
+	static buildFileContent({ body, metadata }) {
+		if (metadata === void 0) return body;
+		const lines = [`apply: ${metadata.apply}`];
+		if (metadata.apply === "by model decision" && metadata.instructions) lines.push(`instructions: ${flattenValue(metadata.instructions)}`);
+		if (metadata.apply === "by file patterns" && metadata.patterns && metadata.patterns.length > 0) lines.push(`patterns: ${metadata.patterns.map(flattenValue).join(", ")}`);
+		return `${METADATA_DELIMITER}\n${lines.join("\n")}\n${METADATA_DELIMITER}\n\n${body}`;
+	}
+	/**
+	* Split a rule file into its metadata block and body. The plugin locates the
+	* block with `^---\s*([\s\S]*?)---\s*` (anchored at the very start of the
+	* file); this reads it line by line instead — a delimiter is a line that is
+	* exactly `---` — which is linear on any input and tolerates a BOM or blank
+	* lines before the block. Each line is split on its first colon and trimmed;
+	* unknown fields are ignored; a missing block or `apply:` line yields no
+	* metadata, while an unrecognized `apply:` value is kept verbatim.
+	*/
+	static parseFileContent(fileContent) {
+		const content = fileContent.replace(/^\uFEFF/, "").trimStart();
+		const lines = content.split(LINE_SPLIT_REGEX);
+		const closingIndex = lines[0]?.trim() === METADATA_DELIMITER ? lines.findIndex((line, index) => index > 0 && line.trim() === METADATA_DELIMITER) : -1;
+		if (closingIndex === -1) return {
+			metadata: void 0,
+			body: content.trim()
+		};
+		const body = lines.slice(closingIndex + 1).join("").trim();
+		const fields = /* @__PURE__ */ new Map();
+		for (const line of lines.slice(1, closingIndex)) {
+			const separatorIndex = line.indexOf(":");
+			if (separatorIndex === -1) continue;
+			fields.set(line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim());
+		}
+		const apply = fields.get("apply");
+		if (apply === void 0 || apply.length === 0) return {
+			metadata: void 0,
+			body
+		};
+		const instructions = fields.get("instructions");
+		const patterns = fields.get("patterns");
+		return {
+			metadata: {
+				apply,
+				...apply === "by model decision" && instructions && { instructions },
+				...apply === "by file patterns" && patterns && { patterns: splitBraceAwareList(patterns) }
+			},
+			body
+		};
+	}
+	/**
+	* Derive the metadata block from the canonical frontmatter, mirroring the
+	* Cursor mapping: an explicit `aiassistant.apply` wins; otherwise specific
+	* `globs` become `by file patterns`, a `description` on a rule with no
+	* `globs` at all becomes the `by model decision` condition, and everything
+	* else — the root rule, universal globs (which already say "every file",
+	* whatever the description), bare rules — is `always`.
+	*
+	* The plugin splits `patterns` on every comma, so a brace alternation such
+	* as `*.{ts,tsx}` is expanded into one glob per branch before it is written.
+	*/
+	static buildMetadata(frontmatter) {
+		const globs = (frontmatter.globs ?? []).map((glob) => flattenValue(glob)).filter((glob) => glob.length > 0).flatMap((glob) => expandBraceAlternations(glob));
+		const hasUniversalGlob = globs.some((glob) => UNIVERSAL_GLOBS$2.has(glob));
+		const instructions = frontmatter.description && flattenValue(frontmatter.description);
+		const explicitApply = frontmatter.aiassistant?.apply && flattenValue(frontmatter.aiassistant.apply);
+		const apply = explicitApply ? explicitApply : frontmatter.root !== true && globs.length > 0 && !hasUniversalGlob ? "by file patterns" : frontmatter.root !== true && globs.length === 0 && instructions ? "by model decision" : "always";
+		const patterns = globs;
+		return {
+			apply,
+			...apply === "by model decision" && instructions && { instructions },
+			...apply === "by file patterns" && patterns.length > 0 && { patterns }
+		};
+	}
+	/**
+	* Warn, at generate time, about a block the plugin cannot act on as the
+	* author presumably intended.
+	*/
+	static warnAboutMetadata({ metadata, relativeFilePath }) {
+		const { apply, instructions, patterns = [] } = metadata;
+		if (!isAiassistantApply(apply)) warnWithFallback(void 0, `${relativeFilePath}: aiassistant.apply "${apply}" is not one of ${AIASSISTANT_APPLY_VALUES.join(", ")}; it is written as is, and the current AI Assistant treats such a rule as Off.`);
+		if (apply === "by file patterns" && patterns.length === 0) warnWithFallback(void 0, `${relativeFilePath}: aiassistant.apply is "by file patterns" but the rule has no globs, so AI Assistant will never attach it.`);
+		if (apply === "by model decision" && !instructions) warnWithFallback(void 0, `${relativeFilePath}: aiassistant.apply is "by model decision" but the rule has no description, so AI Assistant has no condition to decide on.`);
+		const commaGlob = patterns.find((glob) => glob.includes(","));
+		if (commaGlob !== void 0) warnWithFallback(void 0, `${relativeFilePath}: the glob "${commaGlob}" contains a comma, which AI Assistant reads as a pattern separator.`);
+		if ([
+			apply,
+			instructions ?? "",
+			...patterns
+		].some((value) => value.includes("---"))) warnWithFallback(void 0, `${relativeFilePath}: a metadata value contains "---", which AI Assistant reads as the end of the metadata block.`);
+	}
 	toRulesyncRule() {
-		return this.toRulesyncRuleDefault();
+		const metadata = this.metadata;
+		const globs = metadata?.apply === "by file patterns" ? metadata.patterns ?? [] : metadata?.apply === "always" ? ["**/*"] : [];
+		const frontmatter = {
+			root: false,
+			targets: ["*"],
+			description: metadata?.apply === "by model decision" ? metadata.instructions : void 0,
+			globs
+		};
+		const derivedApply = metadata === void 0 ? void 0 : AiassistantRule.buildMetadata(frontmatter).apply;
+		const apply = metadata !== void 0 && derivedApply !== metadata.apply ? metadata.apply : void 0;
+		return new RulesyncRule({
+			outputRoot: process.cwd(),
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			frontmatter: {
+				...frontmatter,
+				...apply !== void 0 && { aiassistant: { apply } }
+			},
+			body: this.body
+		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
+		const metadata = this.buildMetadata(rulesyncRule.getFrontmatter());
+		this.warnAboutMetadata({
+			metadata,
+			relativeFilePath: rulesyncRule.getRelativeFilePath()
+		});
 		return new AiassistantRule({
 			outputRoot,
 			relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
 			relativeFilePath: rulesyncRule.getRelativeFilePath(),
-			fileContent: rulesyncRule.getBody(),
+			body: rulesyncRule.getBody(),
+			metadata,
 			validate,
 			root: false
 		});
@@ -70459,11 +71150,13 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
 		const relativeDirPath = this.getSettablePaths().nonRoot.relativeDirPath;
 		const fileContent = await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath));
+		const { metadata, body } = this.parseFileContent(fileContent);
 		return new AiassistantRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: fileContent.trim(),
+			body,
+			metadata,
 			validate,
 			root: false
 		});
@@ -70473,7 +71166,7 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: "",
+			body: "",
 			validate: false,
 			root: false
 		});
@@ -72030,40 +72723,14 @@ const CodebuddyRuleFrontmatterSchema = z.object({
 	enabled: z.optional(z.boolean())
 });
 /**
-* Splits a scalar `paths` value on the commas that separate patterns, leaving
-* the commas inside a brace group alone: CodeBuddy's memory docs say "You can
-* also combine multiple patterns with commas" and give
-* `paths: {src,lib}/**\/*.ts, tests/**\/*.test.ts` as the example, where the
-* first comma belongs to the brace expansion and the second separates the two
-* globs. Only a scalar is split — the docs describe the comma form for the
-* string shape, and a list already separates its patterns.
-*/
-function splitCodebuddyPathsScalar(paths) {
-	const patterns = [];
-	let current = "";
-	let braceDepth = 0;
-	for (const char of paths) {
-		if (char === "{") braceDepth += 1;
-		else if (char === "}" && braceDepth > 0) braceDepth -= 1;
-		else if (char === "," && braceDepth === 0) {
-			patterns.push(current);
-			current = "";
-			continue;
-		}
-		current += char;
-	}
-	patterns.push(current);
-	return patterns.map((pattern) => pattern.trim());
-}
-/**
 * Normalizes the documented `string` / `string[]` shapes of `paths` to the
 * list form the rest of the adapter works with, splitting a comma-separated
-* scalar into its patterns (see `splitCodebuddyPathsScalar`). An empty list
+* scalar into its patterns (see `splitBraceAwareList`). An empty list
 * and an empty string both mean "no paths".
 */
 function normalizeCodebuddyPaths(paths) {
 	if (paths === void 0) return;
-	const list = (typeof paths === "string" ? splitCodebuddyPathsScalar(paths) : paths).filter((path) => path.trim() !== "");
+	const list = (typeof paths === "string" ? splitBraceAwareList(paths) : paths).filter((path) => path.trim() !== "");
 	return list.length > 0 ? list : void 0;
 }
 /**
@@ -80280,4 +80947,4 @@ async function importChecksCore(params) {
 //#endregion
 export { RulesyncCommand as $, toPosixPath as $t, CLAUDECODE_MEMORIES_DIR_NAME as A, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as An, checkPathTraversal as At, RulesyncSubagent as B, stripControlCharacters as Bn, listDirectoryEntryNames as Bt, COMMANDCODE_DIR as C, RULESYNC_PERMISSIONS_SCHEMA_URL as Cn, withWarnOnceScope as Ct, CODEXCLI_DIR as D, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, assertDirectoryIfExists as Dt, CODEXCLI_BASH_RULES_FILE_NAME as E, RULESYNC_SKILLS_RELATIVE_DIR_PATH as En, applyFileMode as Et, caseFoldIdentity as F, formatError as Fn, getFileSize as Ft, RulesyncRuleFrontmatterSchema as G, readFileContentOrNull as Gt, RulesyncSkill as H, stripHiddenCharacters as Hn, listSubdirectoryNames as Ht, groupSpellingsByCaseFoldedIdentity as I, truncateText as In, getHomeDirectory as It, RulesyncIgnore as J, removeFile as Jt, RulesyncPermissions as K, removeDirectory as Kt, AUGMENTCODE_DIR as L, hasDeceptiveHiddenCharacters as Ln, isFileNotFoundError as Lt, CLAUDECODE_SKILLS_DIR_PATH as M, ALL_FEATURES as Mn, directoryExists as Mt, FACTORYDROID_DIR as N, ALL_FEATURES_WITH_WILDCARD as Nn, ensureDir as Nt, CLAUDECODE_DIR as O, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as On, assertTreeContainsNoSymlinks as Ot, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as P, DEPRECATED_FEATURE_REPLACEMENTS as Pn, fileExists as Pt, parseJsonc as Q, runWithDirectoryRollback as Qt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as R, hasEnclosingMarkOutsideKeycap as Rn, isFileSystemError as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Sn, resetRunWarningState as St, ChecksProcessor as T, RULESYNC_RULES_RELATIVE_DIR_PATH as Tn, ErrorCodes as Tt, RulesyncSkillFrontmatterSchema as U, pathEscapesRoot as Ut, RulesyncSubagentFrontmatterSchema as V, stripControlCharactersKeepingLineFeeds as Vn, listFilePathsRecursively as Vt, RulesyncRule as W, readFileContent as Wt, getRulesyncSourceCandidates as X, removeTempDirectory as Xt, RulesyncHooks as Y, removeFileStrict as Yt, resolveRulesyncSourceWritePath as Z, resolvePath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, JsonLogger as _t, getProcessorRegistryEntry as a, ToolTargetSchema as an, SHARED_USER_MANAGED_CONFIG_PATHS as at, CommandsProcessor as b, RULESYNC_MCP_SCHEMA_URL as bn, warnOnConflictingFlags as bt, RulesProcessor as c, MAX_FILE_SIZE as cn, mergeInputRootConfigs as ct, CODEBUDDY_DIR as d, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as dn, ConfigFileSchema as dt, writeFileBuffer as en, RulesyncCommandFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CONFIG_RELATIVE_FILE_PATH as fn, GITIGNORE_DESTINATION_KEY as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, ConsoleLogger as gt, shortenToWidth as h, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as hn, findControlCharacter as ht, inspectInputRoots as i, PACKAGING_TOOL_TARGETS as in, loadYaml as it, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as j, parseCommaSeparatedList as jn, createTempDirectory as jt, CLAUDECODE_LOCAL_RULE_FILE_NAME as k, RULESYNC_USER_CONFIG_DIR_NAME as kn, assertWritablePathInsideRoot as kt, SubagentsProcessor as l, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ln, resolveEffectiveInputRoots as lt, displayWidthOf as m, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as mn, assertTargetsFeaturesExclusive as mt, formatSourceLoadFailure as n, ALL_TOOL_TARGETS as nn, RulesyncCheckFrontmatterSchema as nt, convertFromTool as o, CURATED_RULES_FEATURE_SUBDIR as on, SKILL_FILE_NAME as ot, ELLIPSIS_WIDTH as p, RULESYNC_CONFIG_SCHEMA_URL as pn, SourceEntrySchema as pt, RulesyncMcp as q, removeDirectoryStrict as qt, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rn, stringifyFrontmatter as rt, isPackagingToolTarget as s, FEATURE_SOURCE_TREE_ENTRIES as sn, ConfigResolver as st, importFromTool as t, writeFileContent as tn, RulesyncCheck as tt, SkillsProcessor as u, RULESYNC_CHECKS_RELATIVE_DIR_PATH as un, CONFLICTING_TARGET_PAIRS as ut, HooksProcessor as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, WarningCollectingLogger as vt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as w, RULESYNC_RELATIVE_DIR_PATH as wn, CLIError as wt, QWENCODE_DIR as x, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as xn, withFallbackLoggerTarget as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_MCP_RELATIVE_FILE_PATH as yn, fallbackLogger as yt, getLocalSkillDirNames as z, quoteForLog as zn, isSymlink as zt };
 
-//# sourceMappingURL=import-D_iukHSy.js.map
+//# sourceMappingURL=import-BiyWNVZY.js.map