rulesync 16.36.0 → 16.38.0

package/dist/{import-D_daTMgR.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);
@@ -8445,6 +8450,7 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 		trigger: zod_mini.z.optional(zod_mini.z.string()),
 		globs: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 	})),
+	aiassistant: zod_mini.z.optional(zod_mini.z.looseObject({ apply: zod_mini.z.optional(zod_mini.z.string()) })),
 	devin: zod_mini.z.optional(zod_mini.z.looseObject({
 		trigger: zod_mini.z.optional(zod_mini.z.string()),
 		globs: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
@@ -9669,6 +9675,8 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		paths: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+		icon: zod_mini.z.optional(zod_mini.z.string()),
+		color: zod_mini.z.optional(zod_mini.z.string()),
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 	})),
 	factorydroid: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -12946,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
@@ -13027,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
@@ -13131,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",
@@ -23683,14 +23709,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 = zod_mini.z.looseObject({
 	type: zod_mini.z.string(),
 	bash: zod_mini.z.optional(zod_mini.z.string()),
 	powershell: zod_mini.z.optional(zod_mini.z.string()),
 	command: zod_mini.z.optional(zod_mini.z.string()),
+	windows: zod_mini.z.optional(zod_mini.z.string()),
+	linux: zod_mini.z.optional(zod_mini.z.string()),
+	osx: zod_mini.z.optional(zod_mini.z.string()),
 	cwd: zod_mini.z.optional(zod_mini.z.string()),
 	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	timeoutSec: zod_mini.z.optional(zod_mini.z.number()),
@@ -23781,17 +23816,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] } }
@@ -23812,12 +23860,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;
@@ -23980,6 +24030,8 @@ const CopilotCliHookEntrySchema = zod_mini.z.looseObject({
 	bash: zod_mini.z.optional(zod_mini.z.string()),
 	powershell: zod_mini.z.optional(zod_mini.z.string()),
 	command: zod_mini.z.optional(zod_mini.z.string()),
+	exec: zod_mini.z.optional(zod_mini.z.string()),
+	args: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	prompt: zod_mini.z.optional(zod_mini.z.string()),
 	url: zod_mini.z.optional(zod_mini.z.string()),
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
@@ -24009,6 +24061,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).
 */
@@ -24048,19 +24126,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;
 }
@@ -24100,6 +24176,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.
@@ -24113,6 +24193,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 {
@@ -24162,11 +24249,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
@@ -24716,6 +24804,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;
@@ -37053,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.
@@ -39500,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: {
@@ -56721,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 }) {
@@ -59200,8 +59655,11 @@ const CursorSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	paths: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	globs: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+	icon: zod_mini.z.optional(zod_mini.z.string()),
+	color: zod_mini.z.optional(zod_mini.z.string()),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
@@ -59253,10 +59711,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 = {
@@ -59298,6 +59759,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({
@@ -61682,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(),
@@ -66057,11 +66489,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).
@@ -66072,6 +66510,8 @@ const CopilotCliSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	target: zod_mini.z.optional(zod_mini.z.string()),
 	tools: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	model: zod_mini.z.optional(zod_mini.z.string()),
+	models: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	modelPolicy: zod_mini.z.optional(zod_mini.z.enum(["preferred", "required"])),
 	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
 	"mcp-servers": zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown())),
@@ -70448,16 +70888,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.
@@ -70465,18 +71020,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
 		});
@@ -70484,11 +71175,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((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
+		const { metadata, body } = this.parseFileContent(fileContent);
 		return new AiassistantRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: fileContent.trim(),
+			body,
+			metadata,
 			validate,
 			root: false
 		});
@@ -70498,7 +71191,7 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: "",
+			body: "",
 			validate: false,
 			root: false
 		});
@@ -72055,40 +72748,14 @@ const CodebuddyRuleFrontmatterSchema = zod_mini.z.object({
 	enabled: zod_mini.z.optional(zod_mini.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;
 }
 /**