rulesync 16.36.0 → 16.37.0

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

@@ -8445,6 +8445,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 +9670,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({
@@ -23683,14 +23686,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 +23793,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 +23837,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 +24007,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 +24038,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 +24103,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 +24153,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 +24170,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 +24226,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 +24781,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;
@@ -59200,8 +59266,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 +59322,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 +59370,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({
@@ -66057,11 +66131,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 +66152,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 +70530,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 +70662,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 +70817,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 +70833,7 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: "",
+			body: "",
 			validate: false,
 			root: false
 		});
@@ -72055,40 +72390,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;
 }
 /**

package/dist/index.cjs

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

package/dist/index.d.cts

@@ -499,6 +499,8 @@ declare const RulesyncSkillFrontmatterSchemaInternal: z.ZodMiniObject<{
     paths: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     "disable-model-invocation": z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     "user-invocable": z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    color: z.ZodMiniOptional<z.ZodMiniString<string>>;
     metadata: z.ZodMiniOptional<z.ZodMiniObject<{}, z.core.$loose>>;
   }, z.core.$loose>>;
   factorydroid: z.ZodMiniOptional<z.ZodMiniObject<{
@@ -725,6 +727,8 @@ type RulesyncSkillFrontmatterInput = {
     paths?: string | string[];
     "disable-model-invocation"?: boolean;
     "user-invocable"?: boolean;
+    icon?: string;
+    color?: string;
     metadata?: Record<string, unknown>;
   };
   factorydroid?: {