rulesync 38.0.0 → 39.0.0

package/dist/{import-B9NOtObR.cjs → import-HHSMWQi-.cjs}

@@ -457,36 +457,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$426 } = node_path.posix;
+const { join: join$439 } = 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$426(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$439(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$426(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$426(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$439(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$439(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$439(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$426(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$426(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$439(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$439(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";
@@ -544,6 +544,7 @@ const rulesProcessorToolTargetTuple = [
 	"cursor",
 	"deepagents",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -573,6 +574,7 @@ const rulesProcessorToolTargetTuple = [
 	"trae",
 	"vibe",
 	"warp",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -582,6 +584,7 @@ const rulesProcessorToolTargetTuple = [
 ];
 const ignoreProcessorToolTargetTuple = [
 	"aiassistant",
+	"androidstudio",
 	"antigravity-cli",
 	"augmentcode",
 	"bob",
@@ -592,6 +595,7 @@ const ignoreProcessorToolTargetTuple = [
 	"continue",
 	"crush",
 	"cursor",
+	"firebender",
 	"grokcli",
 	"hermesagent",
 	"junie",
@@ -639,6 +643,7 @@ const mcpProcessorToolTargetTuple = [
 	"deepagents",
 	"dsh",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -668,6 +673,7 @@ const mcpProcessorToolTargetTuple = [
 	"vibe-plugin",
 	"warp",
 	"warpcli",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -694,6 +700,7 @@ const commandsProcessorToolTargetTuple = [
 	"copilot",
 	"cursor",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -749,6 +756,7 @@ const subagentsProcessorToolTargetTuple = [
 	"devin",
 	"devin-plugin",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"hermesagent",
@@ -773,6 +781,7 @@ const subagentsProcessorToolTargetTuple = [
 	"takt",
 	"vibe",
 	"vibe-plugin",
+	"xum",
 	"zcode",
 	"zcode-plugin"
 ];
@@ -780,6 +789,7 @@ const skillsProcessorToolTargetTuple = [
 	"agentsmd",
 	"agentsskills",
 	"aiassistant",
+	"androidstudio",
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
@@ -803,6 +813,7 @@ const skillsProcessorToolTargetTuple = [
 	"cursor",
 	"deepagents",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -832,6 +843,7 @@ const skillsProcessorToolTargetTuple = [
 	"vibe",
 	"vibe-plugin",
 	"warp",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -866,6 +878,7 @@ const hooksProcessorToolTargetTuple = [
 	"pi",
 	"pool",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"hermesagent",
 	"kimi-code",
@@ -3780,6 +3793,8 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".devin/config.json",
 	".dsh/cordis.patch.yml",
 	".factory/settings.json",
+	"firebender.json",
+	".firebender/firebender.json",
 	".grok/config.toml",
 	".grok/sandbox.toml",
 	".letta/settings.json",
@@ -4241,14 +4256,103 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	} } });
 	return gray_matter.default.stringify(file, cleanFrontmatter);
 }
+/**
+* Thrown in place of gray-matter's built-in JavaScript engine.
+*
+* gray-matter picks the parser from the text after the opening fence, so a
+* file that opens with `---js` or `---javascript` has its frontmatter handed
+* to `eval()`. Frontmatter here comes from third-party skills, fetched sources
+* and untrusted repositories, so that would run arbitrary code on the machine
+* of whoever generates or imports it. Every engine name that resolves to code
+* execution is mapped to this refusal; {@link assertYamlFrontmatterLanguage}
+* refuses those fences earlier still, so this is the second line of defense.
+*/
+function refuseExecutableFrontmatter() {
+	throw new Error("Frontmatter written in an executable language (JavaScript / CoffeeScript) is not supported; use YAML");
+}
+const REFUSED_FRONTMATTER_ENGINE = {
+	parse: refuseExecutableFrontmatter,
+	stringify: refuseExecutableFrontmatter
+};
+/**
+* Engines passed to every gray-matter parse. Supplying them merges over
+* gray-matter's defaults, so the JavaScript engine (and the CoffeeScript names
+* a plugin could register) can never be reached through an alias.
+*
+* `patches/gray-matter@4.0.3.patch` also deletes the JavaScript engine, but a
+* pnpm patch only applies inside this repository: gray-matter is an external
+* dependency of the published package, so an installed rulesync runs the
+* unpatched gray-matter, and this override plus the language check are what
+* protect it. Exported for the test that pins that.
+*/
+const FRONTMATTER_PARSE_OPTIONS = { engines: {
+	javascript: REFUSED_FRONTMATTER_ENGINE,
+	js: REFUSED_FRONTMATTER_ENGINE,
+	coffee: REFUSED_FRONTMATTER_ENGINE,
+	coffeescript: REFUSED_FRONTMATTER_ENGINE,
+	cson: REFUSED_FRONTMATTER_ENGINE
+} };
+/** Frontmatter languages accepted after the opening `---` fence. */
+const ALLOWED_FRONTMATTER_LANGUAGE_PATTERN = /^(?:ya?ml)?$/i;
+/**
+* Read the opening frontmatter fence the way gray-matter does, or return
+* `undefined` when gray-matter would see no frontmatter at all.
+*
+* gray-matter strips one byte order mark, treats `---` as a fence only when a
+* fourth `-` does not follow, and takes the language from the text between the
+* fence and the first `\r?\n`, trimmed — dropping the last character when
+* there is no line break at all. Every check below that has to agree with
+* gray-matter on where the block is (the language check, the size guard, the
+* repair pass) goes through this one reading, so none of them can be bypassed
+* by a fence line gray-matter accepts and a stricter pattern would not (a
+* stray `\r` before the line break, say).
+*/
+function readFrontmatterFence(content) {
+	const offset = content.startsWith("") ? 1 : 0;
+	const text = content.slice(offset);
+	if (!text.startsWith("---") || text.charAt(3) === "-") return;
+	const afterFence = text.slice(3);
+	const lineBreak = /\r?\n/.exec(afterFence);
+	const language = afterFence.slice(0, lineBreak ? lineBreak.index : -1).trim();
+	const lineBreakStart = lineBreak ? offset + 3 + lineBreak.index : void 0;
+	return {
+		language,
+		lineBreakStart,
+		lineEnd: lineBreak && lineBreakStart !== void 0 ? lineBreakStart + lineBreak[0].length : void 0
+	};
+}
+/**
+* Refuse a frontmatter fence that names any language other than YAML.
+*
+* Only YAML is ever written by rulesync or by the tools it targets, so anything
+* else — `---js` above all, whose block gray-matter would `eval()` — is
+* rejected before gray-matter sees the content.
+*/
+function assertYamlFrontmatterLanguage(content) {
+	const fence = readFrontmatterFence(content);
+	if (fence && !ALLOWED_FRONTMATTER_LANGUAGE_PATTERN.test(fence.language)) throw new Error(`Unsupported frontmatter language ${JSON.stringify(fence.language.slice(0, 40))}; only YAML frontmatter is supported`);
+}
+/**
+* The number of characters gray-matter would hand to the YAML parser as the
+* frontmatter block. Unlike {@link findFrontmatterBlockBounds}, a missing
+* closing fence does not make this zero: gray-matter then parses everything
+* after the fence line, so that is what the size guard has to measure.
+*/
+function measureFrontmatterBlockChars(content) {
+	const fence = readFrontmatterFence(content);
+	if (fence?.lineBreakStart === void 0) return 0;
+	const rest = content.slice(fence.lineBreakStart);
+	const closeIndex = rest.indexOf("\n---");
+	return closeIndex === -1 ? rest.length : closeIndex;
+}
 function parseFrontmatter(content, filePath) {
 	let frontmatter;
 	let body;
 	let hasFrontmatter;
 	try {
-		const bounds = findFrontmatterBlockBounds(content);
-		if (bounds && bounds.blockEnd - bounds.blockStart > 65536) throw new Error(`Frontmatter block is larger than ${MAX_FRONTMATTER_RAW_CHARS} characters; refusing to parse it (a complex YAML key can cost memory while parsing, before any post-parse budget applies)`);
-		const result = (0, gray_matter.default)(content, {});
+		assertYamlFrontmatterLanguage(content);
+		if (measureFrontmatterBlockChars(content) > 65536) throw new Error(`Frontmatter block is larger than ${MAX_FRONTMATTER_RAW_CHARS} characters; refusing to parse it (a complex YAML key can cost memory while parsing, before any post-parse budget applies)`);
+		const result = (0, gray_matter.default)(content, FRONTMATTER_PARSE_OPTIONS);
 		frontmatter = deepRemoveNullishObject(result.data);
 		body = result.content;
 		hasFrontmatter = result.matter !== "" || content.trimStart().startsWith("---");
@@ -4307,22 +4411,28 @@ function repairFrontmatterLine(line) {
 }
 /**
 * Locate a raw `---`-delimited frontmatter block's bounds within `content`,
-* without parsing it. Shared by the size guard in {@link parseFrontmatter} and
-* the YAML repair pass below, so both agree on exactly what gray-matter would
-* treat as the block: gray-matter ends it at the first `\n---`, with no
-* requirement that the delimiter be alone on its line, so a stricter pattern
-* here would run past gray-matter's delimiter and act on text that is really
-* the body.
+* without parsing it, for the YAML repair pass below and the rule loaders that
+* pre-process `globs:`. The opening fence is read exactly as gray-matter reads
+* it ({@link readFrontmatterFence}); an explicit `yaml` / `yml` language is
+* still YAML, any other language yields no bounds. gray-matter ends the block
+* at the first `\n---`, with no requirement that the delimiter be alone on its
+* line, so a stricter pattern here would run past gray-matter's delimiter and
+* act on text that is really the body. A block with no closing fence has no
+* bounds; the size guard measures that case separately.
 */
 function findFrontmatterBlockBounds(content) {
-	const opening = /^\uFEFF?---[^\S\r\n]*\r?\n/.exec(content);
-	if (!opening) return;
-	const blockStart = opening[0].length;
-	const closing = /\r?\n---/.exec(content.slice(blockStart));
+	const fence = readFrontmatterFence(content);
+	if (fence?.lineBreakStart === void 0 || fence.lineEnd === void 0 || !ALLOWED_FRONTMATTER_LANGUAGE_PATTERN.test(fence.language)) return;
+	const blockStart = fence.lineEnd;
+	const closing = /\r?\n---/.exec(content.slice(fence.lineBreakStart));
 	if (!closing) return;
+	if (closing.index === 0) return {
+		blockStart,
+		blockEnd: blockStart
+	};
 	return {
 		blockStart,
-		blockEnd: blockStart + closing.index
+		blockEnd: fence.lineBreakStart + closing.index
 	};
 }
 /**
@@ -4354,8 +4464,9 @@ function repairMalformedFrontmatterYaml(content) {
 * narrow — one pass, top-level entries only, and the original error is what
 * surfaces if it does not help, so a genuinely broken file still fails with the
 * message that describes what is actually wrong with it. A file with no closing
-* `---`, or one whose opening fence carries a language tag, is not repaired at
-* all: neither is a frontmatter block gray-matter would have read.
+* `---` is not repaired at all, and one whose opening fence names a language
+* other than YAML is refused outright (an explicit `---yaml` / `---yml` fence
+* is repaired like a plain one).
 *
 * @see https://agentskills.io/client-implementation/adding-skills-support
 */
@@ -4720,6 +4831,29 @@ const CURSOR_HOOK_EVENTS = [
 	"workspaceOpen"
 ];
 /**
+* Hook events supported by Firebender.
+*
+* Firebender's `hooks.json` follows Cursor's layout, and every event it fires
+* is spelled like its canonical counterpart, so no name mapping is needed.
+* @see https://docs.firebender.com/multi-agent/hooks
+*/
+const FIREBENDER_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"subagentStart",
+	"subagentStop",
+	"preToolUse",
+	"postToolUse",
+	"beforeShellExecution",
+	"afterShellExecution",
+	"beforeMCPExecution",
+	"afterMCPExecution",
+	"beforeReadFile",
+	"afterFileEdit",
+	"preCompact",
+	"stop"
+];
+/**
 * Hook events supported by Claude Code.
 *
 * Covers the full documented event surface.
@@ -6067,6 +6201,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	version: zod_mini.z.optional(zod_mini.z.number()),
 	hooks: canonicalHooksRecordSchema,
 	cursor: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	firebender: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	claudecode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	copilot: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	copilotcli: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -7170,7 +7305,7 @@ const McpServerSchema = zod_mini.z.looseObject({
 	crushSessionless: zod_mini.z.optional(zod_mini.z.boolean()),
 	crushChannelEnabled: zod_mini.z.optional(zod_mini.z.boolean()),
 	crushChannelReply: zod_mini.z.optional(CrushChannelReplySchema),
-	zcodeOauth: zod_mini.z.optional(zod_mini.z.looseObject({ type: zod_mini.z.string() })),
+	zcodeOauth: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	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())),
 	/**
@@ -7272,6 +7407,7 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	devin: zod_mini.z.optional(toolScopedMcpSchema),
 	dsh: zod_mini.z.optional(toolScopedMcpSchema),
 	factorydroid: zod_mini.z.optional(toolScopedMcpSchema),
+	firebender: zod_mini.z.optional(toolScopedMcpSchema),
 	gitlabduo: zod_mini.z.optional(toolScopedMcpSchema),
 	goose: zod_mini.z.optional(toolScopedMcpSchema),
 	grokcli: zod_mini.z.optional(toolScopedMcpSchema),
@@ -7296,6 +7432,7 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	vibe: zod_mini.z.optional(toolScopedMcpSchema),
 	warp: zod_mini.z.optional(toolScopedMcpSchema),
 	warpcli: zod_mini.z.optional(toolScopedMcpSchema),
+	xum: zod_mini.z.optional(toolScopedMcpSchema),
 	zed: zod_mini.z.optional(toolScopedMcpSchema)
 });
 /**
@@ -13091,6 +13228,35 @@ const CRUSH_CONFIG_DECLARATION = {
 	}
 };
 /**
+* Firebender's `firebender.json`, shared by the project (`<project>/firebender.json`)
+* and personal (`~/.firebender/firebender.json`) spellings so a policy edit
+* lands on both. The file also carries `rules`, `commands`, `mcpEnvFile`,
+* `worktrees` and `useCursorRules` keys rulesync does not own, so every writer
+* refuses to read-modify-write a file it could not parse. Each feature owns
+* one whole top-level key: `ignore` (recomputed from `.rulesync/.aiignore`),
+* `mcpServers` (the complete server map) and `agents` (recomputed from the
+* existing list, with the entries for rulesync's own agent directory replaced).
+* https://docs.firebender.com/api-reference/syntax
+*/
+const FIREBENDER_CONFIG_DECLARATION = {
+	format: "json",
+	invalidRootPolicy: "error",
+	features: {
+		ignore: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["ignore"]
+		},
+		subagents: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["agents"]
+		},
+		mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["mcpServers"]
+		}
+	}
+};
+/**
 * What the two Claude Code settings files have in common: both are plain JSON,
 * and both validate against the one published schema, which the gateway
 * points every file it writes at. `.claude/settings.local.json` is the same
@@ -13330,6 +13496,15 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: ["servers"]
 		} }
 	},
+	".xum/mcp.jsonc": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: { mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["servers"]
+		} }
+	},
 	".qwen/settings.json": {
 		format: "json",
 		features: {
@@ -13417,6 +13592,8 @@ const SHARED_CONFIG_OWNERSHIP = {
 	".zcode/cli/config.json": ZCODE_CONFIG_DECLARATION,
 	"crush.json": CRUSH_CONFIG_DECLARATION,
 	".config/crush/crush.json": CRUSH_CONFIG_DECLARATION,
+	"firebender.json": FIREBENDER_CONFIG_DECLARATION,
+	".firebender/firebender.json": FIREBENDER_CONFIG_DECLARATION,
 	".bob/settings.json": {
 		format: "json",
 		invalidRootPolicy: "error",
@@ -20251,6 +20428,178 @@ var FactorydroidCommand = class FactorydroidCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/firebender-paths.ts
+/**
+* Firebender (the coding agent plugin for Android Studio and other JetBrains
+* IDEs) keeps project configuration under `.firebender/` plus a project-root
+* `firebender.json`, and user configuration under `~/.firebender/` (including
+* `~/.firebender/firebender.json`).
+*
+* @see https://docs.firebender.com/api-reference/syntax
+* @see https://docs.firebender.com/api-reference/rules
+* @see https://docs.firebender.com/api-reference/commands
+* @see https://docs.firebender.com/api-reference/agents
+* @see https://docs.firebender.com/api-reference/skills
+* @see https://docs.firebender.com/api-reference/agents-md
+* @see https://docs.firebender.com/multi-agent/hooks
+*/
+const FIREBENDER_DIR = ".firebender";
+/**
+* `firebender.json`: at the project root for project scope, and under
+* `~/.firebender/` for the personal config. It is shared by the ignore
+* (`ignore`), MCP (`mcpServers`) and subagents (`agents`) features.
+*/
+const FIREBENDER_CONFIG_FILE_NAME = "firebender.json";
+/** `.firebender/AGENTS.md`, the first file Firebender looks for in both scopes. */
+const FIREBENDER_AGENTS_MD_FILE_NAME = "AGENTS.md";
+(0, node_path.join)(FIREBENDER_DIR, "rules");
+/** Commands: `.firebender/commands/*.mdc` (project) and `~/.firebender/commands/*.mdc` (global). */
+const FIREBENDER_COMMANDS_DIR_PATH = (0, node_path.join)(FIREBENDER_DIR, "commands");
+/** Agents: Markdown files registered through the `agents` array of `firebender.json`. */
+const FIREBENDER_AGENTS_DIR_NAME = "agents";
+const FIREBENDER_AGENTS_DIR_PATH = (0, node_path.join)(FIREBENDER_DIR, FIREBENDER_AGENTS_DIR_NAME);
+/** Skills: `.firebender/skills/<name>/SKILL.md` (project) and `~/.firebender/skills/` (global). */
+const FIREBENDER_SKILLS_DIR_PATH = (0, node_path.join)(FIREBENDER_DIR, "skills");
+/** Hooks: `.firebender/hooks.json` (project) and `~/.firebender/hooks.json` (global). */
+const FIREBENDER_HOOKS_FILE_NAME = "hooks.json";
+/**
+* The directory holding `firebender.json` for a scope: the project root, or
+* `~/.firebender/` for the personal config.
+*/
+function getFirebenderConfigDir({ global }) {
+	return global ? FIREBENDER_DIR : ".";
+}
+//#endregion
+//#region src/features/commands/firebender-command.ts
+/**
+* Frontmatter of a Firebender command. Every field is optional: `name`
+* defaults to the file name, `model` is `default`, `quick` or a model ID, and
+* `mode` is one of `auto`, `read`, `write` or `composer`. Unknown keys are
+* preserved.
+*
+* @see https://docs.firebender.com/api-reference/commands
+*/
+const FirebenderCommandFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	mode: zod_mini.z.optional(zod_mini.z.string())
+});
+const FIREBENDER_COMMAND_EXTENSION = ".mdc";
+/**
+* Command generator for Firebender: one `.mdc` file per command under
+* `.firebender/commands/` (project) and `~/.firebender/commands/` (global),
+* with optional `name` / `description` / `model` / `mode` frontmatter. The
+* canonical `description` is written as is; `name`, `model` and `mode` come
+* from the `firebender:` section of the rulesync command.
+*
+* @see https://docs.firebender.com/api-reference/commands
+*/
+var FirebenderCommand = class FirebenderCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = FirebenderCommandFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true })
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: FIREBENDER_COMMANDS_DIR_PATH };
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	toRulesyncCommand() {
+		const { description, ...restFields } = this.frontmatter;
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description,
+			...Object.keys(restFields).length > 0 && { firebender: restFields }
+		};
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath.replace(/\.mdc$/, ".md"),
+			fileContent: stringifyFrontmatter(this.body, rulesyncFrontmatter),
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const firebenderFields = rulesyncFrontmatter.firebender ?? {};
+		const frontmatter = {
+			...rulesyncFrontmatter.description && { description: rulesyncFrontmatter.description },
+			...firebenderFields
+		};
+		return new FirebenderCommand({
+			outputRoot,
+			frontmatter,
+			body: rulesyncCommand.getBody(),
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath().replace(/\.md$/, FIREBENDER_COMMAND_EXTENSION),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = FirebenderCommandFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "firebender"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = FirebenderCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new FirebenderCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new FirebenderCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {},
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/commands/gitlabduo-command.ts
 /**
 * GitLab Duo CLI custom slash commands are Markdown files named after the
@@ -20843,6 +21192,60 @@ var GrokcliCommand = class GrokcliCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/features/shared/hermes-plugin-commands.ts
+/**
+* Normalize a name into a Hermes Agent plugin slash command name.
+*
+* `ctx.register_command()` lowercases the name, and Hermes' messaging gateway
+* looks plugin commands up with every `_` turned into `-`
+* (`gateway/run_inbound_hooks.py`), so only a lowercase, hyphenated name is
+* reachable from every surface.
+*/
+function hermesSlashName(value) {
+	return value.toLowerCase().replace(/[ _]/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
+/**
+* Python helpers shared by the generated Hermes command plugins.
+*
+* A plugin slash command runs outside any agent turn, so it cannot call
+* `delegate_task` (which requires a parent agent). Instead the handler queues
+* its prompt as a user message with `ctx.inject_message()`, passing the calling
+* session's key: a `session_key` handler keyword on newer Hermes, or
+* `HERMES_SESSION_KEY` from the session context the gateway binds around the
+* handler on older releases.
+*/
+function getHermesQueueUserMessagePython({ pluginName }) {
+	return `def _session_key(kwargs):
+    session_key = kwargs.get("session_key")
+    if session_key:
+        return session_key
+    try:
+        from gateway.session_context import get_session_env
+    except Exception:
+        return None
+    return get_session_env("HERMES_SESSION_KEY") or None
+
+
+def _queue_user_message(ctx, message, kwargs, label):
+    """Queue *message* as the session's next user turn; return an error reply, or None."""
+    session_key = _session_key(kwargs)
+    try:
+        if session_key:
+            queued = ctx.inject_message(message, role="user", session_key=session_key)
+        else:
+            queued = ctx.inject_message(message, role="user")
+    except Exception as error:
+        return f"Could not queue {label}: {error}"
+    if not queued:
+        return (
+            f"Hermes refused to queue {label}: there is no active session, or this plugin "
+            "may not inject messages. In gateway sessions, set "
+            "plugins.entries.${pluginName}.allow_gateway_injection: true in config.yaml."
+        )
+    return None
+`;
+}
+//#endregion
 //#region src/features/skills/agentsskills-skill.ts
 const AgentsSkillsSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -21325,9 +21728,6 @@ const HermesCommandSpecSchema = zod_mini.z.object({
 	description: zod_mini.z.string(),
 	prompt: zod_mini.z.string()
 });
-function hermesSlashName(value) {
-	return value.toLowerCase().replace(/[ _]/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
-}
 function getPluginManifestContent$2() {
 	return [
 		"name: rulesync-commands",
@@ -21361,6 +21761,8 @@ def _load_commands():
     return commands
 
 
+${getHermesQueueUserMessagePython({ pluginName: "rulesync-commands" })}
+
 def _register_command(ctx, command):
     slug = command.get("slug")
     if not slug:
@@ -21370,31 +21772,22 @@ def _register_command(ctx, command):
     prompt = command.get("prompt") or ""
 
     def handler(args=None, **kwargs):
-        del kwargs
         raw_args = ""
         if isinstance(args, dict):
             raw_args = args.get("args") or args.get("context") or args.get("prompt") or ""
         elif args is not None:
             raw_args = str(args)
 
-        context_parts = [prompt] if prompt else []
+        parts = [prompt] if prompt else []
         if raw_args:
-            context_parts.append(f"User arguments:\\n{raw_args}")
+            parts.append(f"User arguments:\\n{raw_args}")
 
-        # delegate_task takes no model-facing "toolsets" argument: the child
-        # inherits the parent's enabled toolsets. "tasks" is the only shape its
-        # schema advertises; a top-level "goal" is an unadvertised legacy path.
-        return ctx.dispatch_tool(
-            "delegate_task",
-            {
-                "tasks": [
-                    {
-                        "goal": description,
-                        "context": "\\n\\n".join(context_parts),
-                    },
-                ],
-            },
-        )
+        # A slash command runs outside any agent turn, so calling delegate_task
+        # here fails with "delegate_task requires a parent agent context".
+        # Queue the command prompt as the session's next user message instead.
+        label = f"the /{slug} command"
+        error = _queue_user_message(ctx, "\\n\\n".join(parts) or description, kwargs, label)
+        return error or f"Queued {label}."
 
     ctx.register_command(slug, handler, description)
 
@@ -25266,6 +25659,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["firebender", {
+		class: FirebenderCommand,
+		meta: {
+			extension: "mdc",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: false
+		}
+	}],
 	["goose", {
 		class: GooseCommand,
 		meta: {
@@ -32549,6 +32952,116 @@ var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/firebender-hooks.ts
+/**
+* Hooks generator for Firebender.
+*
+* Firebender reads `.firebender/hooks.json` (project) and
+* `~/.firebender/hooks.json` (global). The file follows Cursor's layout — a
+* `version` plus a `hooks` map from camelCase event names to lists of
+* `{ command, timeout?, loop_limit?, matcher? }` entries — and every event is
+* spelled like its canonical counterpart. The per-hook `type` accepts
+* `"command" | "prompt"`, but the docs never say what a prompt hook does, so
+* only command hooks are generated (the HooksProcessor warns about the rest).
+*
+* @see https://docs.firebender.com/multi-agent/hooks
+*/
+var FirebenderHooks = class FirebenderHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: FIREBENDER_DIR,
+			relativeFilePath: FIREBENDER_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = FirebenderHooks.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
+		return new FirebenderHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
+		const config = rulesyncHooks.getJson();
+		const supportedEvents = new Set(FIREBENDER_HOOK_EVENTS);
+		const sharedHooks = {};
+		for (const [event, defs] of Object.entries(config.hooks)) if (supportedEvents.has(event)) sharedHooks[event] = defs;
+		const mergedHooks = {
+			...sharedHooks,
+			...config.firebender?.hooks
+		};
+		const firebenderHooks = {};
+		for (const [eventName, defs] of Object.entries(mergedHooks)) {
+			const mappedDefs = defs.filter((def) => (def.type ?? "command") === "command").filter((def) => typeof def.command === "string" && def.command.length > 0).map((def) => ({
+				command: def.command,
+				...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
+				...def.loop_limit !== void 0 && { loop_limit: def.loop_limit },
+				...def.matcher !== void 0 && def.matcher !== null && { matcher: def.matcher }
+			}));
+			if (mappedDefs.length > 0) firebenderHooks[eventName] = mappedDefs;
+		}
+		const paths = FirebenderHooks.getSettablePaths({ global });
+		const merged = mergeGeneratedHookLists({
+			existingContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "",
+			generatedHooks: firebenderHooks,
+			shape: "flat",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
+			logger
+		});
+		const fileContent = JSON.stringify({
+			version: config.version ?? 1,
+			hooks: merged.hooks
+		}, null, 2);
+		return new FirebenderHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			ownedHookRefs: preserveUnowned ? merged.owned : void 0,
+			validate
+		});
+	}
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ toolHooks } = {}) {
+		return toolHooks instanceof FirebenderHooks ? toolHooks.getOwnershipLockFiles() : [];
+	}
+	toRulesyncHooks() {
+		const parsed = JSON.parse(this.getFileContent());
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks: parsed.hooks ?? {},
+			overrideKey: "firebender",
+			version: parsed.version ?? 1
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new FirebenderHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/gitlabduo-hooks.ts
 const GITLABDUO_CONVERTER_CONFIG = {
 	supportedEvents: GITLABDUO_HOOK_EVENTS,
@@ -36959,6 +37472,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command", "prompt"],
 		supportsMatcher: true
 	}],
+	["firebender", {
+		class: FirebenderHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: FIREBENDER_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
+	}],
 	["claudecode", {
 		class: ClaudecodeHooks,
 		meta: {
@@ -37830,6 +38354,67 @@ var AiassistantIgnore = class AiassistantIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/constants/androidstudio-paths.ts
+/**
+* Gemini in Android Studio configuration-layout conventions.
+*
+* Only the Android Studio-specific files are owned by the `androidstudio`
+* target. The shared `AGENTS.md` and `.agents/skills/` surfaces Gemini also
+* reads belong to the `agentsmd` and `agentsskills` targets.
+*/
+const ANDROIDSTUDIO_IGNORE_FILE_NAME = ".aiexclude";
+const ANDROIDSTUDIO_SKILLS_DIR_PATH = (0, node_path.join)(".android-studio", "skills");
+//#endregion
+//#region src/features/ignore/androidstudio-ignore.ts
+/**
+* Ignore generator for Gemini in Android Studio.
+*
+* Gemini reads `.aiexclude` files (gitignore syntax) anywhere in the project;
+* each one applies to the files at or below its directory and blocks both the
+* chat and the editor AI features such as code completion. Rulesync writes the
+* project-root file only. There is no user-level variant.
+*
+* @see https://developer.android.com/studio/gemini/aiexclude
+*/
+var AndroidstudioIgnore = class AndroidstudioIgnore extends ToolIgnore {
+	static getSettablePaths() {
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: ANDROIDSTUDIO_IGNORE_FILE_NAME
+		};
+	}
+	toRulesyncIgnore() {
+		return this.toRulesyncIgnoreDefault();
+	}
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore }) {
+		return new AndroidstudioIgnore({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.getSettablePaths().relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent()
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath));
+		return new AndroidstudioIgnore({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.getSettablePaths().relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new AndroidstudioIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/antigravity-cli-ignore.ts
 /**
 * Antigravity CLI is the successor to Gemini CLI and is built on the same
@@ -38491,6 +39076,95 @@ var DevinIgnore = class DevinIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/ignore/firebender-ignore.ts
+function readIgnorePatterns(fileContent) {
+	const ignore = parseSharedConfig({
+		format: "json",
+		fileContent
+	}).ignore;
+	if (!Array.isArray(ignore)) return [];
+	return ignore.filter((pattern) => typeof pattern === "string");
+}
+/**
+* Ignore generator for Firebender.
+*
+* Firebender reads gitignore-style patterns from the `ignore` array of
+* `firebender.json` (project root) and `~/.firebender/firebender.json`
+* (personal); the two lists are appended together. The file is shared with the
+* MCP (`mcpServers`) and subagents (`agents`) features and carries settings
+* rulesync does not own, so only the `ignore` key is written and the file is
+* never deleted.
+*
+* @see https://docs.firebender.com/api-reference/syntax
+*/
+var FirebenderIgnore = class FirebenderIgnore extends ToolIgnore {
+	constructor(params) {
+		super(params);
+		this.patterns = readIgnorePatterns(this.fileContent || "{}");
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: getFirebenderConfigDir({ global }),
+			relativeFilePath: FIREBENDER_CONFIG_FILE_NAME
+		};
+	}
+	/** `firebender.json` is a user-managed config file, so rulesync never deletes it. */
+	isDeletable() {
+		return false;
+	}
+	toRulesyncIgnore() {
+		return new RulesyncIgnore({
+			outputRoot: ".",
+			relativeDirPath: RulesyncIgnore.getSettablePaths().recommended.relativeDirPath,
+			relativeFilePath: RulesyncIgnore.getSettablePaths().recommended.relativeFilePath,
+			fileContent: this.patterns.filter((pattern) => pattern.length > 0).join("\n")
+		});
+	}
+	static async fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore, global = false }) {
+		const patterns = rulesyncIgnore.getFileContent().split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const managedPatterns = [...new Set(patterns)];
+		return new FirebenderIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "ignore",
+				existingContent,
+				patch: { ignore: managedPatterns.length > 0 ? managedPatterns : void 0 },
+				filePath
+			}),
+			validate: true,
+			global
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
+		return new FirebenderIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new FirebenderIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/grokcli-ignore.ts
 /** The base built-in profile the rulesync profile extends (Grok's own default). */
 const GROKCLI_SANDBOX_BASE_PROFILE = "workspace";
@@ -39808,6 +40482,7 @@ var ZedIgnore = class ZedIgnore extends ToolIgnore {
 const IgnoreProcessorToolTargetSchema = zod_mini.z.enum(ignoreProcessorToolTargetTuple);
 const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["aiassistant", { class: AiassistantIgnore }],
+	["androidstudio", { class: AndroidstudioIgnore }],
 	["antigravity-cli", { class: AntigravityCliIgnore }],
 	["augmentcode", { class: AugmentcodeIgnore }],
 	["bob", { class: BobIgnore }],
@@ -39818,6 +40493,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["continue", { class: ContinueIgnore }],
 	["crush", { class: CrushIgnore }],
 	["cursor", { class: CursorIgnore }],
+	["firebender", { class: FirebenderIgnore }],
 	["grokcli", { class: GrokcliIgnore }],
 	["hermesagent", { class: HermesagentIgnore }],
 	["junie", { class: JunieIgnore }],
@@ -39842,6 +40518,7 @@ const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
 const ignoreProcessorGlobalToolTargets = [
 	"continue",
 	"devin",
+	"firebender",
 	"grokcli",
 	"kilo",
 	"kiro",
@@ -45339,6 +46016,171 @@ var FactorydroidMcp = class FactorydroidMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/firebender-mcp.ts
+/**
+* The keys of the canonical server schema. Firebender reads only `command`,
+* `args`, `env`, `url` and `headers` of them, so the rest are dropped; a key
+* NOT on this list is unknown to rulesync and passed through untouched, so a
+* Firebender-native field such as `deferLoading` written in the tool-scoped
+* `firebender.mcpServers` block (or on a shared server) survives.
+*/
+const CANONICAL_MCP_SERVER_KEYS$1 = new Set(Object.keys(McpServerSchema.def.shape));
+function passthroughNonCanonicalFields$1(serverConfig) {
+	return Object.fromEntries(Object.entries(serverConfig).filter(([key]) => !CANONICAL_MCP_SERVER_KEYS$1.has(key)));
+}
+/**
+* Translate one canonical server into Firebender's `mcpServers` entry, or
+* return `null` (with a warning) for a server Firebender cannot express. A
+* stdio server is `{ command, args?, env? }`, a remote one `{ url, headers? }`;
+* Firebender has no `type` field and no per-server disable switch.
+*
+* @see https://docs.firebender.com/api-reference/syntax
+*/
+function convertServerToFirebenderFormat({ serverName, serverConfig, logger }) {
+	if (serverConfig.disabled === true) return warnAndSkipMcpServer({
+		toolName: "Firebender",
+		serverName,
+		reason: "`disabled: true`, and Firebender has no per-server disable switch",
+		logger
+	});
+	if (declaresNoTransport(serverConfig)) return warnAndSkipMcpServer({
+		toolName: "Firebender",
+		serverName,
+		reason: "no command or url",
+		logger
+	});
+	const passthrough = passthroughNonCanonicalFields$1(serverConfig);
+	if (isRemoteMcpServer(serverConfig)) {
+		const url = resolveRemoteMcpUrl(serverConfig);
+		if (url === void 0) return warnAndSkipMcpServer({
+			toolName: "Firebender",
+			serverName,
+			reason: "a remote transport but no url",
+			logger
+		});
+		return {
+			...passthrough,
+			url,
+			...serverConfig.headers !== void 0 && { headers: serverConfig.headers }
+		};
+	}
+	const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+	if (command === void 0) return warnAndSkipMcpServer({
+		toolName: "Firebender",
+		serverName,
+		reason: "a local transport but no command",
+		logger
+	});
+	return {
+		...passthrough,
+		command,
+		...args.length > 0 && { args },
+		...serverConfig.env !== void 0 && { env: serverConfig.env }
+	};
+}
+/**
+* MCP generator for Firebender.
+*
+* Firebender reads MCP servers from the `mcpServers` key of `firebender.json`
+* (project root) and `~/.firebender/firebender.json` (personal; it wins on
+* name clashes). The file is shared with the ignore (`ignore`) and subagents
+* (`agents`) features and carries settings rulesync does not own, so only the
+* `mcpServers` key is written and the file is never deleted.
+*
+* @see https://docs.firebender.com/api-reference/syntax
+*/
+var FirebenderMcp = class FirebenderMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = parseSharedConfig({
+			format: "json",
+			fileContent: this.fileContent || "{}"
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: getFirebenderConfigDir({ global }),
+			relativeFilePath: FIREBENDER_CONFIG_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 FirebenderMcp({
+			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 mcpServers = {};
+		for (const [serverName, serverConfig] of Object.entries(rulesyncMcp.getMcpServers())) {
+			const converted = convertServerToFirebenderFormat({
+				serverName,
+				serverConfig,
+				logger
+			});
+			if (converted !== null) mcpServers[serverName] = converted;
+		}
+		return new FirebenderMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : void 0 },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const servers = this.json.mcpServers;
+		const mcpServers = {};
+		if (isMcpServers(servers)) {
+			for (const [serverName, server] of Object.entries(servers)) if (server !== null && typeof server === "object" && !Array.isArray(server)) mcpServers[serverName] = server;
+		}
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	/**
+	* `firebender.json` is a user-managed file shared with other features (the
+	* ignore feature's `ignore`, the subagents feature's `agents`), so it must
+	* not be deleted.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new FirebenderMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/gitlabduo-mcp.ts
 const CANONICAL_TO_GITLABDUO_TRANSPORT = {
 	local: "stdio",
@@ -52030,6 +52872,248 @@ var WarpcliMcp = class extends WarpMcp {
 	}
 };
 //#endregion
+//#region src/constants/xum-paths.ts
+/**
+* Xum configuration-layout conventions.
+*
+* Xum (Coder's desktop app and `xum run` CLI for running coding agents in
+* parallel workspaces, formerly Mux) keeps its project assets under a `.xum/`
+* directory at the project root and the matching user assets under `~/.xum/`.
+* Legacy `.mux/` files are still read when the matching `.xum/` file is
+* missing; rulesync writes only the `.xum/` paths.
+*
+* @see https://xum.cdr.dev/reference/mux-compatibility
+*/
+const XUM_DIR = ".xum";
+const XUM_RULE_FILE_NAME = "AGENTS.md";
+const XUM_LOCAL_RULE_FILE_NAME = "AGENTS.local.md";
+const XUM_MCP_FILE_NAME = "mcp.jsonc";
+const XUM_AGENTS_DIR_PATH = (0, node_path.join)(XUM_DIR, "agents");
+const XUM_SKILLS_DIR_PATH = (0, node_path.join)(XUM_DIR, "skills");
+//#endregion
+//#region src/features/mcp/xum-mcp.ts
+const EMPTY_XUM_MCP_CONFIG = JSON.stringify({ servers: {} }, null, 2);
+/** Characters that never need quoting in a POSIX shell word. */
+const SHELL_SAFE_WORD = /^[A-Za-z0-9_\-.,:/@%+=]+$/;
+/**
+* A command string free of quotes, escapes, expansions and operators, which
+* can be split on whitespace back into argv without changing its meaning.
+*/
+const SPLIT_SAFE_COMMAND = /^[^'"\\$`|&;<>(){}*?[\]~#!\n]+$/;
+/** Single-quote one argv element for the POSIX shell Xum runs commands in. */
+function quoteShellWord(value) {
+	if (SHELL_SAFE_WORD.test(value)) return value;
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+* Build the shell command string a Xum stdio server is launched with. A
+* `command` string is kept verbatim (Xum itself treats it as a raw shell
+* string, so `npx -y pkg` authored as one string keeps working); an explicit
+* argv (`command` as an array) and every `args` element are quoted where
+* needed, so `/opt/my tools/srv` stays one word.
+*/
+function buildCommandString(server) {
+	const args = server.args ?? [];
+	if (Array.isArray(server.command)) {
+		const [executable] = server.command;
+		if (executable === void 0 || executable.trim() === "") return void 0;
+		return [...server.command, ...args].map(quoteShellWord).join(" ");
+	}
+	if (typeof server.command !== "string" || server.command.trim() === "") return void 0;
+	return [server.command, ...args.map(quoteShellWord)].join(" ");
+}
+/** Split a plain command string back into `command` + `args` when it is safe to. */
+function splitCommandString(command) {
+	const trimmed = command.trim();
+	if (!SPLIT_SAFE_COMMAND.test(trimmed)) return { command };
+	const [head, ...rest] = trimmed.split(/\s+/);
+	if (head === void 0) return { command };
+	return rest.length > 0 ? {
+		command: head,
+		args: rest
+	} : { command: head };
+}
+function resolveXumServerKind(server) {
+	const candidate = server.type ?? server.transport;
+	if (candidate === "stdio" || candidate === "local") return "stdio";
+	if (candidate === "http" || candidate === "streamable-http") return "http";
+	if (candidate === "sse") return "sse";
+	if (candidate !== void 0) return { unsupported: candidate };
+	if (server.command !== void 0) return "stdio";
+	const url = server.url ?? server.httpUrl;
+	if (typeof url === "string") return /^wss?:\/\//i.test(url) ? { unsupported: "ws" } : "auto";
+}
+/** Convert one canonical server into a Xum `servers` entry, or `null` to skip it. */
+function convertServerToXum({ name, server, logger }) {
+	const skip = (reason) => {
+		warnWithFallback(logger, `Xum MCP: skipping ${quoteValueForWarning(name)} because ${reason}.`);
+		return null;
+	};
+	const kind = resolveXumServerKind(server);
+	if (kind === void 0) return skip("it has neither a command nor a URL");
+	if (typeof kind === "object") return skip(`it uses the "${kind.unsupported}" transport, which Xum does not support (only stdio, http and sse)`);
+	const settings = {};
+	if (server.disabled === true) settings.disabled = true;
+	if (isStringArray$1(server.enabledTools)) settings.toolAllowlist = server.enabledTools;
+	if (kind !== "stdio") {
+		const url = server.url ?? server.httpUrl;
+		if (typeof url !== "string" || url === "") return skip("it has no URL");
+		return {
+			...kind !== "auto" && { transport: kind },
+			url,
+			...isPlainObject$1(server.headers) && Object.keys(server.headers).length > 0 && { headers: server.headers },
+			...settings
+		};
+	}
+	const command = buildCommandString(server);
+	if (command === void 0) return skip("it has no command");
+	const dropped = [...isPlainObject$1(server.env) && Object.keys(server.env).length > 0 ? ["env"] : [], ...typeof server.cwd === "string" ? ["cwd"] : []];
+	if (dropped.length > 0) warnWithFallback(logger, `Xum MCP: ${quoteValueForWarning(name)} sets ${dropped.join(" and ")}, which Xum's mcp.jsonc cannot express; the server is written without it (Xum starts stdio servers with your shell environment in the workspace directory).`);
+	return Object.keys(settings).length > 0 ? {
+		command,
+		...settings
+	} : command;
+}
+/** Copy only the string values of a header map (secret references have no canonical form). */
+function copyStringHeaders(value) {
+	if (!isPlainObject$1(value)) return void 0;
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (!PROTOTYPE_POLLUTION_KEYS.has(key) && typeof entry === "string") result[key] = entry;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/** Read a Xum `servers` map back into the canonical shape. */
+function convertFromXumFormat(servers) {
+	if (!isPlainObject$1(servers)) return {};
+	const result = {};
+	for (const [name, entry] of Object.entries(servers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+		if (typeof entry === "string") {
+			result[name] = splitCommandString(entry);
+			continue;
+		}
+		if (!isPlainObject$1(entry)) continue;
+		const server = {};
+		if (typeof entry.url === "string") {
+			if (entry.transport === "http" || entry.transport === "sse") server.type = entry.transport;
+			server.url = entry.url;
+			const headers = copyStringHeaders(entry.headers);
+			if (headers !== void 0) server.headers = headers;
+		} else if (typeof entry.command === "string") Object.assign(server, splitCommandString(entry.command));
+		else continue;
+		if (entry.disabled === true) server.disabled = true;
+		if (isStringArray$1(entry.toolAllowlist)) server.enabledTools = entry.toolAllowlist;
+		result[name] = server;
+	}
+	return result;
+}
+/**
+* Xum MCP configuration.
+*
+* Xum reads `~/.xum/mcp.jsonc` (user) and the repo override `.xum/mcp.jsonc`
+* (project; a server there wins over the user one of the same name). Both are
+* a JSONC document with a `servers` map:
+*
+* - a stdio server is a shell command string (the object form `{ command }`
+*   carries `disabled` / `toolAllowlist`); Xum's mcp.jsonc has no `env` or
+*   `cwd`, so those are dropped with a warning;
+* - a remote server is `{ transport: "http" | "sse" | "auto", url, headers }`
+*   (the transport defaults to auto-detection).
+*
+* rulesync owns only `servers`; other top-level keys (Xum writes
+* `enabledPluginServers` into the user file) are preserved. The project file
+* may be removed by `--delete`; the user file never is.
+*
+* @see https://xum.cdr.dev/config/mcp-servers
+* @see https://github.com/coder/xum/blob/main/src/node/services/mcpConfigService.ts
+*/
+var XumMcp = class XumMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = parseSharedConfig({
+			format: "jsonc",
+			fileContent: this.fileContent,
+			filePath: (0, node_path.join)(this.relativeDirPath, this.relativeFilePath),
+			invalidRootPolicy: "error",
+			jsoncParseErrors: "error"
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	isDeletable() {
+		return !this.global;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: XUM_DIR,
+			relativeFilePath: XUM_MCP_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)) ?? EMPTY_XUM_MCP_CONFIG;
+		return new XumMcp({
+			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) ?? EMPTY_XUM_MCP_CONFIG;
+		const servers = {};
+		for (const [name, server] of Object.entries(rulesyncMcp.getMcpServers())) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+			const entry = convertServerToXum({
+				name,
+				server,
+				logger
+			});
+			if (entry !== null) servers[name] = entry;
+		}
+		return new XumMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { servers },
+				filePath,
+				logger
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromXumFormat(this.json.servers);
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new XumMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/zcode-mcp.ts
 /**
 * Single spelling of the config.json codec/policy, matching the
@@ -52291,8 +53375,8 @@ const ZCODE_ENABLE_KEYS = /* @__PURE__ */ new Set(["enable", "enabled"]);
 * and unknown keys pass through untouched so an import keeps whatever a
 * hand-authored entry declared. `timeoutMs` is lifted back into the canonical
 * `timeout` (milliseconds); when the server also states a `timeout`, ZCode
-* has already dropped that one, so `timeoutMs` replaces it. A ZCode-shaped
-* `oauth` is imported as the namespaced `zcodeOauth`, so its client secret is
+* has already dropped that one, so `timeoutMs` replaces it. Any record
+* `oauth` is imported as the namespaced `zcodeOauth`, so a client secret is
 * never emitted to another tool. Generation back out is a whitelist, so only
 * the keys `convertToZcodeFormat` writes are re-emitted.
 *
@@ -52318,7 +53402,7 @@ function convertFromZcodeFormat({ zcodeServers }) {
 				continue;
 			}
 			if (key === "timeout" && typeof config.timeoutMs === "number") continue;
-			if (key === "oauth" && isZcodeOauth(value)) {
+			if (key === "oauth" && isRecord$1(value)) {
 				converted[ZCODE_OAUTH_CANONICAL_KEY] = value;
 				continue;
 			}
@@ -52964,6 +54048,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["firebender", {
+		class: FirebenderMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["goose", {
 		class: GooseMcp,
 		meta: {
@@ -53234,6 +54327,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["xum", {
+		class: XumMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: false
+		}
+	}],
 	["devin", {
 		class: DevinMcp,
 		meta: {
@@ -76445,6 +77547,11 @@ const TOOL_DISPLAY = [
 		label: "Factory Droid",
 		group: "ai"
 	},
+	{
+		key: "firebender",
+		label: "Firebender",
+		group: "ai"
+	},
 	{
 		key: "opencode",
 		label: "OpenCode",
@@ -76600,6 +77707,11 @@ const TOOL_DISPLAY = [
 		label: "JetBrains AI Assistant",
 		group: "ai"
 	},
+	{
+		key: "androidstudio",
+		label: "Gemini in Android Studio",
+		group: "ai"
+	},
 	{
 		key: "junie",
 		label: "JetBrains Junie",
@@ -76635,6 +77747,11 @@ const TOOL_DISPLAY = [
 		label: "Warp Agent CLI",
 		group: "ai"
 	},
+	{
+		key: "xum",
+		label: "Xum",
+		group: "ai"
+	},
 	{
 		key: "replit",
 		label: "Replit",
@@ -77779,6 +78896,27 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/androidstudio-skill.ts
+/**
+* Gemini in Android Studio skills follow the Agent Skills open standard
+* (`<name>/SKILL.md` with `name` and `description` frontmatter), so this target
+* reuses {@link AgentsSkillsSkill} with Android Studio's own location:
+* `.android-studio/skills/` at the project root (project) or in the home
+* directory (global). The shared `.agents/skills/` location Android Studio also
+* reads belongs to the `agentsskills` target.
+*
+* @see https://developer.android.com/studio/gemini/skills
+*/
+var AndroidstudioSkill = class extends AgentsSkillsSkill {
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: ANDROIDSTUDIO_SKILLS_DIR_PATH };
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("androidstudio");
+	}
+};
+//#endregion
 //#region src/features/skills/antigravity-plugin-skill.ts
 var AntigravityPluginSkill = class extends AntigravityIdeSkill {
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
@@ -81247,6 +82385,26 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/firebender-skill.ts
+/**
+* Firebender skills follow the Agent Skills layout (`<name>/SKILL.md` with the
+* required `name` and `description` frontmatter, plus optional supporting
+* files), so this target reuses {@link AgentsSkillsSkill} with Firebender's
+* recommended locations: `.firebender/skills/` (project) and
+* `~/.firebender/skills/` (user).
+*
+* @see https://docs.firebender.com/api-reference/skills
+*/
+var FirebenderSkill = class extends AgentsSkillsSkill {
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: FIREBENDER_SKILLS_DIR_PATH };
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("firebender");
+	}
+};
+//#endregion
 //#region src/features/skills/gitlabduo-skill.ts
 /**
 * GitLab Duo skills follow the Agent Skills standard (`name` and `description`
@@ -84782,6 +85940,27 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/xum-skill.ts
+/**
+* Xum skills follow the Agent Skills layout (`<name>/SKILL.md` with the
+* required `name` and `description` frontmatter; the directory name is
+* lowercase letters, digits and single hyphens up to 64 characters, and
+* `name` must match it), so this target reuses {@link AgentsSkillsSkill} with
+* Xum's locations: `.xum/skills/` (project) and `~/.xum/skills/` (user).
+* Within one directory `.xum/skills` wins over `.agents/skills`.
+*
+* @see https://xum.cdr.dev/agents/agent-skills
+*/
+var XumSkill = class extends AgentsSkillsSkill {
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: XUM_SKILLS_DIR_PATH };
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("xum");
+	}
+};
+//#endregion
 //#region src/features/skills/zcode-skill.ts
 const ZcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -85197,6 +86376,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: false
 		}
 	}],
+	["androidstudio", {
+		class: AndroidstudioSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["amp", {
 		class: AmpSkill,
 		meta: {
@@ -85382,6 +86569,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["firebender", {
+		class: FirebenderSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["goose", {
 		class: GooseSkill,
 		meta: {
@@ -85632,6 +86827,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["xum", {
+		class: XumSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["devin", {
 		class: DevinSkill,
 		meta: {
@@ -89478,6 +90681,338 @@ var FactorydroidSubagent = class FactorydroidSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/firebender-subagent.ts
+/**
+* Frontmatter of a Firebender agent file. `tools` is a comma-separated string
+* of tool groups (`read`, `edit`, `execution`, `other`) and MCP tools
+* (`mcp_<server>_<tool>`); `model` is `small`, `medium`, `large`, `inherit` or a
+* model ID; `callable` lets the main agent delegate to it. Unknown keys are
+* preserved.
+*
+* @see https://docs.firebender.com/api-reference/agents
+*/
+const FirebenderSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	color: zod_mini.z.optional(zod_mini.z.string()),
+	icon: zod_mini.z.optional(zod_mini.z.string()),
+	tools: zod_mini.z.optional(zod_mini.z.string()),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	callable: zod_mini.z.optional(zod_mini.z.boolean())
+});
+/**
+* The `agents` entry Firebender resolves to an agent file rulesync writes:
+* relative to the project root for the project config, and to `~/.firebender`
+* for the personal one.
+*/
+function toAgentsEntry({ relativeFilePath, global }) {
+	const fileName = toPosixPath(relativeFilePath);
+	return global ? node_path.posix.join(FIREBENDER_AGENTS_DIR_NAME, fileName) : node_path.posix.join(toPosixPath(FIREBENDER_AGENTS_DIR_PATH), fileName);
+}
+/**
+* The agent file name an existing `agents` entry points at when it lies
+* directly inside the directory rulesync writes agents to
+* (`.firebender/agents/` in the project; `agents/` or `~/.firebender/agents/`
+* in the personal config), or `undefined` for any other entry
+* (`~/firebender-agents/...`, an absolute path, a nested path).
+*/
+function managedAgentFileName({ entry, global }) {
+	const normalized = toPosixPath(entry).replace(/^\.\//, "");
+	const prefix = global ? `${FIREBENDER_AGENTS_DIR_NAME}/` : `${toPosixPath(FIREBENDER_AGENTS_DIR_PATH)}/`;
+	const homePrefix = `~/${toPosixPath(FIREBENDER_AGENTS_DIR_PATH)}/`;
+	const rest = normalized.startsWith(prefix) ? normalized.slice(prefix.length) : global && normalized.startsWith(homePrefix) ? normalized.slice(homePrefix.length) : void 0;
+	return rest !== void 0 && rest.endsWith(".md") && !rest.includes("/") ? rest : void 0;
+}
+/**
+* Subagent generator for Firebender.
+*
+* Each agent is a Markdown file with YAML frontmatter, written to
+* `.firebender/agents/<name>.md` (project) or `~/.firebender/agents/<name>.md`
+* (global). Firebender only loads agents listed in the `agents` array of
+* `firebender.json`, so generation also registers every file there — see
+* {@link FirebenderAgentsRegistry}. Rulesync subagents are meant to be
+* delegated to, so `callable: true` is written unless the `firebender:`
+* section says otherwise.
+*
+* @see https://docs.firebender.com/api-reference/agents
+*/
+var FirebenderSubagent = class FirebenderSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate !== false) {
+			const result = FirebenderSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({ ...rest });
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: FIREBENDER_AGENTS_DIR_PATH };
+	}
+	/**
+	* Generation also read-modify-writes the `agents` key of `firebender.json`,
+	* so the write is declared for the shared-file order derivation.
+	*/
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		return [{
+			relativeDirPath: getFirebenderConfigDir({ global }),
+			relativeFilePath: FIREBENDER_CONFIG_FILE_NAME
+		}];
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, callable, ...rest } = this.frontmatter;
+		const firebenderSection = {
+			...rest,
+			...callable !== true && { callable: callable ?? false }
+		};
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name: name ?? (0, node_path.basename)(this.getRelativeFilePath(), ".md"),
+				description,
+				...Object.keys(firebenderSection).length > 0 && { firebender: firebenderSection }
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	/**
+	* Every targeted subagent becomes its own agent file, plus one
+	* {@link FirebenderAgentsRegistry} that lists them in `firebender.json`.
+	* The registry is emitted even when no subagent is targeted, so agents a
+	* previous run registered are retracted once their files are gone. The
+	* agent directory is listed up front so the registry can tell a registered
+	* file that still exists (kept, whoever wrote it) from a stale one.
+	*/
+	static async fromRulesyncSubagents({ outputRoot = process.cwd(), rulesyncSubagents, global = false, logger, deleteOrphans = false }) {
+		const agentsDirPath = this.getSettablePaths({ global }).relativeDirPath;
+		const agentsDirEscapesRoot = await writablePathEscapesRoot({
+			rootPath: outputRoot,
+			targetPath: (0, node_path.join)(outputRoot, agentsDirPath, "agent.md")
+		});
+		const existingAgentFileNames = new Set(agentsDirEscapesRoot ? [] : await listDirectoryEntryNames((0, node_path.join)(outputRoot, agentsDirPath)));
+		const subagents = rulesyncSubagents.map((rulesyncSubagent) => this.fromRulesyncSubagent({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			rulesyncSubagent,
+			global
+		}));
+		const registry = new FirebenderAgentsRegistry({
+			outputRoot,
+			relativeDirPath: getFirebenderConfigDir({ global }),
+			relativeFilePath: FIREBENDER_CONFIG_FILE_NAME,
+			entries: subagents.map((subagent) => toAgentsEntry({
+				relativeFilePath: subagent.getRelativeFilePath(),
+				global
+			})),
+			existingAgentFileNames,
+			deleteOrphans,
+			frozen: agentsDirEscapesRoot,
+			global,
+			logger
+		});
+		return [...subagents, registry];
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const firebenderSection = rulesyncFrontmatter.firebender ?? {};
+		const frontmatter = {
+			name: rulesyncFrontmatter.name,
+			...rulesyncFrontmatter.description !== void 0 && { description: rulesyncFrontmatter.description },
+			callable: true,
+			...firebenderSection
+		};
+		const body = rulesyncSubagent.getBody();
+		return new FirebenderSubagent({
+			outputRoot,
+			frontmatter,
+			body,
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent: stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true }),
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = FirebenderSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "firebender"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body } = parseFrontmatter(fileContent, filePath);
+		const result = FirebenderSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new FirebenderSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new FirebenderSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+/**
+* The `agents` array of `firebender.json`, which Firebender requires to load
+* an agent file. Every generated agent is registered. An existing entry that
+* points into rulesync's agent directory is kept while its file exists (a
+* hand-written agent there stays registered) and dropped, with a warning, once
+* the file is gone. Under `--delete` the orphan sweep removes every agent file
+* there that this run does not generate, but only after this file is written,
+* so in that mode such entries are dropped here too and a single run
+* converges. Every other entry and every other key of the file is kept.
+* The array is merged into the file on disk at write time and the file itself
+* is never deleted.
+*/
+var FirebenderAgentsRegistry = class extends ToolSubagent {
+	entries;
+	existingAgentFileNames;
+	deleteOrphans;
+	frozen;
+	logger;
+	mergedContent = null;
+	constructor({ entries, existingAgentFileNames = /* @__PURE__ */ new Set(), deleteOrphans = false, frozen = false, logger, ...rest }) {
+		super({
+			...rest,
+			fileContent: ""
+		});
+		this.entries = entries;
+		this.existingAgentFileNames = existingAgentFileNames;
+		this.deleteOrphans = deleteOrphans;
+		this.frozen = frozen;
+		this.logger = logger;
+	}
+	getEntries() {
+		return this.entries;
+	}
+	isDeletable() {
+		return false;
+	}
+	shouldMergeExistingFileContent() {
+		return true;
+	}
+	setFileContent(newFileContent) {
+		this.mergedContent = this.mergeInto(newFileContent);
+	}
+	getFileContent() {
+		if (this.mergedContent === null) this.mergedContent = this.mergeInto("");
+		return this.mergedContent;
+	}
+	mergeInto(existingContent) {
+		const paths = {
+			relativeDirPath: this.getRelativeDirPath(),
+			relativeFilePath: this.getRelativeFilePath()
+		};
+		const filePath = (0, node_path.join)(this.getOutputRoot(), paths.relativeDirPath, paths.relativeFilePath);
+		const existing = parseSharedConfig({
+			format: "json",
+			fileContent: existingContent,
+			filePath,
+			invalidRootPolicy: "error"
+		});
+		if (this.frozen) return applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "subagents",
+			existingContent,
+			patch: { agents: existing.agents },
+			filePath,
+			logger: this.logger
+		});
+		const existingEntries = Array.isArray(existing.agents) ? existing.agents : [];
+		const generatedByFileName = new Map(this.entries.map((entry) => [managedAgentFileName({
+			entry,
+			global: this.global
+		}) ?? entry, entry]));
+		const agents = [];
+		const placed = /* @__PURE__ */ new Set();
+		const dropped = [];
+		for (const entry of existingEntries) {
+			const fileName = typeof entry === "string" ? managedAgentFileName({
+				entry,
+				global: this.global
+			}) : void 0;
+			if (fileName === void 0) {
+				agents.push(entry);
+				continue;
+			}
+			const generated = generatedByFileName.get(fileName);
+			if (generated !== void 0) {
+				if (!placed.has(fileName)) {
+					agents.push(generated);
+					placed.add(fileName);
+				}
+			} else if (!this.deleteOrphans && this.existingAgentFileNames.has(fileName)) agents.push(entry);
+			else dropped.push(String(entry));
+		}
+		for (const [fileName, entry] of generatedByFileName) if (!placed.has(fileName)) {
+			agents.push(entry);
+			placed.add(fileName);
+		}
+		if (dropped.length > 0) this.logger?.warn(`Unregistered Firebender agent(s) ${dropped.map((entry) => quoteValueForWarning(entry)).join(", ")} from ${filePath}: ` + (this.deleteOrphans ? "--delete removes agent files that .rulesync/subagents/ no longer generates." : "the agent file no longer exists."));
+		return applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "subagents",
+			existingContent,
+			patch: { agents: agents.length > 0 ? agents : void 0 },
+			filePath,
+			logger: this.logger
+		});
+	}
+	toRulesyncSubagent() {
+		throw new Error(`${this.getRelativePathFromCwd()} registers Firebender agents and is not a subagent itself.`);
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+};
+//#endregion
 //#region src/features/subagents/goose-subagent.ts
 /**
 * Goose custom agents (v1.34.0+) are Markdown files with YAML frontmatter —
@@ -89765,13 +91300,13 @@ function subagentSlug(relativeFilePath) {
 	return (0, node_path.basename)(relativeFilePath, ".md").replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function hermesCommandName(slug) {
-	return `rulesync_subagent_${slug}`;
+	return hermesSlashName(`rulesync-subagent-${slug}`);
 }
 function getPluginManifestContent() {
 	return [
 		"name: rulesync-subagents",
 		"version: \"1.0.0\"",
-		"description: Exposes RuleSync subagents as Hermes native delegation commands.",
+		"description: Exposes RuleSync subagents as Hermes slash commands that queue a delegation prompt.",
 		""
 	].join("\n");
 }
@@ -89779,9 +91314,12 @@ function getPluginInitContent() {
 	return `"""RuleSync-generated Hermes subagent commands."""
 
 import json
+import logging
+import re
 from pathlib import Path
 
 
+logger = logging.getLogger(__name__)
 SUBAGENTS_DIR = Path(__file__).resolve().parents[2] / "rulesync" / "subagents"
 
 
@@ -89801,52 +91339,71 @@ def _load_subagents():
     return subagents
 
 
-def _register_subagent(ctx, subagent):
+def _command_name(subagent, slug):
+    # The spec carries the name Rulesync normalized; Hermes' messaging gateway
+    # resolves plugin commands with "_" turned into "-", so keep it hyphenated.
+    hermes = subagent.get("hermes")
+    name = hermes.get("command") if isinstance(hermes, dict) else None
+    name = name or f"rulesync-subagent-{slug}"
+    # Mirrors hermesSlashName() in src/features/shared/hermes-plugin-commands.ts.
+    name = re.sub(r"[ _]", "-", str(name).lower())
+    name = re.sub(r"[^a-z0-9-]", "", name)
+    return re.sub(r"-{2,}", "-", name).strip("-")
+
+
+${getHermesQueueUserMessagePython({ pluginName: "rulesync-subagents" })}
+
+def _register_subagent(ctx, subagent, registered):
     slug = subagent.get("slug")
     if not slug:
         return
 
-    command_name = f"rulesync_subagent_{slug}"
+    command_name = _command_name(subagent, slug)
+    if command_name in registered:
+        logger.warning(
+            "rulesync-subagents: %s and %s both map to /%s; keeping the first.",
+            registered[command_name],
+            subagent.get("_path"),
+            command_name,
+        )
+        return
+    registered[command_name] = subagent.get("_path")
+
     name = subagent.get("name") or slug
     description = subagent.get("description") or f"Delegate work to the {name} RuleSync subagent."
     system_prompt = subagent.get("prompt") or ""
 
     def handler(args=None, **kwargs):
-        del kwargs
         user_context = ""
         if isinstance(args, dict):
             user_context = args.get("context") or args.get("task") or args.get("prompt") or ""
         elif args is not None:
             user_context = str(args)
 
-        context_parts = []
+        # A slash command runs outside any agent turn, so calling delegate_task
+        # here fails with "delegate_task requires a parent agent context".
+        # Queue the brief as a user message instead; the agent then delegates.
+        parts = [
+            f"Use the delegate_task tool to hand the following task to a subagent "
+            f"acting as the {name} RuleSync subagent.",
+            f"Goal: {description}",
+        ]
         if system_prompt:
-            context_parts.append(system_prompt)
+            parts.append(f"Subagent instructions:\\n{system_prompt}")
         if user_context:
-            context_parts.append(user_context)
+            parts.append(f"Task details:\\n{user_context}")
 
-        # delegate_task takes no model-facing "toolsets" argument: a subagent
-        # inherits the parent's enabled toolsets (role="orchestrator" is the
-        # only knob that changes them). "tasks" is the only shape its schema
-        # advertises; a top-level "goal" is an unadvertised legacy path.
-        return ctx.dispatch_tool(
-            "delegate_task",
-            {
-                "tasks": [
-                    {
-                        "goal": description,
-                        "context": "\\n\\n".join(context_parts),
-                    },
-                ],
-            },
-        )
+        label = f"the {name} subagent task"
+        error = _queue_user_message(ctx, "\\n\\n".join(parts), kwargs, label)
+        return error or f"Queued {label}; the agent will delegate it."
 
     ctx.register_command(command_name, handler, description)
 
 
 def register(ctx):
+    registered = {}
     for subagent in _load_subagents():
-        _register_subagent(ctx, subagent)
+        _register_subagent(ctx, subagent, registered)
 `;
 }
 function getEnabledPluginConfigContent({ currentContent, global }) {
@@ -89877,7 +91434,7 @@ function getSubagentSpec(rulesyncSubagent) {
 		prompt: rulesyncSubagent.getBody(),
 		hermes: {
 			command: hermesCommandName(slug),
-			dispatch: "delegate_task"
+			dispatch: "inject_message"
 		}
 	};
 }
@@ -92669,6 +94226,166 @@ var VibeSubagent = class VibeSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/xum-subagent.ts
+/**
+* The built-in agent a rulesync subagent inherits from when its `xum` block
+* names neither a `base` nor its own `tools`. Xum gives an agent no tools at
+* all unless some agent in its `base` chain declares them, so a definition
+* without either would be a prompt that cannot read or edit anything.
+*/
+const XUM_DEFAULT_BASE_AGENT = "exec";
+/**
+* Frontmatter of a Xum agent definition. `name` (the display name) is
+* required; the other documented fields are typed loosely and unknown keys are
+* kept (looseObject) so a round trip never drops them.
+*
+* @see https://xum.cdr.dev/agents
+*/
+const XumSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	base: zod_mini.z.optional(zod_mini.z.string()),
+	disabled: zod_mini.z.optional(zod_mini.z.boolean()),
+	ui: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	prompt: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	subagent: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	ai: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	tools: zod_mini.z.optional(zod_mini.z.looseObject({}))
+});
+/**
+* Subagent generator for Xum (formerly Mux).
+*
+* Xum reads custom agent definitions — Markdown with YAML frontmatter — from
+* the top level of `.xum/agents/` (project) and `~/.xum/agents/` (user); the
+* body is the agent's instruction prompt. The file name (without `.md`) is the
+* agent id, so it must be lowercase letters and digits with single `-` / `_`
+* separators; Xum skips other files with a warning.
+*
+* rulesync writes `name` and `description`, spreads the `xum` section (`base`,
+* `ui`, `prompt`, `subagent`, `ai`, `tools`, ...) on top, and fills two
+* defaults so the definition works as a delegated subagent out of the box:
+* `subagent.runnable: true` (required for `task({ agentId })` to spawn it) and,
+* when the section sets neither `base` nor `tools`, `base: exec`.
+*
+* @see https://xum.cdr.dev/agents
+*/
+var XumSubagent = class XumSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate !== false) {
+			const result = XumSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({ ...rest });
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: XUM_AGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, ...restFields } = this.frontmatter;
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name,
+				description,
+				...Object.keys(restFields).length > 0 && { xum: restFields }
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const xumSection = this.filterToolSpecificSection(rulesyncFrontmatter.xum ?? {}, ["name", "description"]);
+		const subagentSection = xumSection.subagent;
+		const result = XumSubagentFrontmatterSchema.safeParse({
+			name: rulesyncFrontmatter.name,
+			...rulesyncFrontmatter.description && { description: rulesyncFrontmatter.description },
+			...xumSection.base === void 0 && xumSection.tools === void 0 && { base: XUM_DEFAULT_BASE_AGENT },
+			...xumSection,
+			subagent: {
+				runnable: true,
+				...isPlainObject$1(subagentSection) ? subagentSection : {}
+			}
+		});
+		if (!result.success) throw new Error(`Invalid xum subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
+		const body = rulesyncSubagent.getBody();
+		return new XumSubagent({
+			outputRoot,
+			frontmatter: result.data,
+			body,
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent: stringifyFrontmatter(body, result.data),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = XumSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "xum"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body } = parseFrontmatter(fileContent, filePath);
+		const result = XumSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new XumSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			fileContent,
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new XumSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/zcode-subagent.ts
 const ZcodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -93134,6 +94851,17 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["firebender", {
+		class: FirebenderSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			emitsEmptyAggregate: true,
+			emitsEmptyAggregateOnDelete: true,
+			filePattern: "*.md"
+		}
+	}],
 	["goose", {
 		class: GooseSubagent,
 		meta: {
@@ -93361,6 +95089,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.toml"
 		}
 	}],
+	["xum", {
+		class: XumSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["zcode", {
 		class: ZcodeSubagent,
 		meta: {
@@ -93415,6 +95152,7 @@ function compareRelativePathsShallowestFirst(left, right) {
 var SubagentsProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
+	deleteOrphans;
 	getFactory;
 	/**
 	* Whether the last `loadRulesyncFiles` found a `subagents/` directory under
@@ -93422,13 +95160,14 @@ var SubagentsProcessor = class extends FeatureProcessor {
 	* agents in its Pool settings are its own and must not be retracted.
 	*/
 	rulesyncSourceDirFound = false;
-	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, getFactory = defaultGetFactory$1, dryRun = false, logger }) {
+	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, getFactory = defaultGetFactory$1, dryRun = false, deleteOrphans = false, logger }) {
 		super({
 			outputRoot,
 			inputRoots,
 			dryRun,
 			logger
 		});
+		this.deleteOrphans = deleteOrphans;
 		const result = SubagentsProcessorToolTargetSchema.safeParse(toolTarget);
 		if (!result.success) throw new Error(`Invalid tool target for SubagentsProcessor: ${toolTarget}. ${formatError(result.error)}`);
 		this.toolTarget = result.data;
@@ -93436,7 +95175,9 @@ var SubagentsProcessor = class extends FeatureProcessor {
 		this.getFactory = getFactory;
 	}
 	emitsToolFilesForEmptySource() {
-		return this.rulesyncSourceDirFound && this.getFactory(this.toolTarget).meta.emitsEmptyAggregate === true;
+		const { meta } = this.getFactory(this.toolTarget);
+		if (meta.emitsEmptyAggregate !== true) return false;
+		return this.rulesyncSourceDirFound || this.deleteOrphans && meta.emitsEmptyAggregateOnDelete === true;
 	}
 	async convertRulesyncFilesToToolFiles(rulesyncFiles) {
 		const rulesyncSubagents = rulesyncFiles.filter((file) => file instanceof RulesyncSubagent);
@@ -93452,11 +95193,12 @@ var SubagentsProcessor = class extends FeatureProcessor {
 		});
 		if (factory.class.fromRulesyncSubagents) {
 			if (targeted.length === 0 && !this.emitsToolFilesForEmptySource()) return [];
-			const toolSubagents = factory.class.fromRulesyncSubagents({
+			const toolSubagents = await factory.class.fromRulesyncSubagents({
 				outputRoot: this.outputRoot,
 				rulesyncSubagents: targeted,
 				global: this.global,
-				logger: this.logger
+				logger: this.logger,
+				deleteOrphans: this.deleteOrphans && !this.hasRulesyncSourceLoadFailure()
 			});
 			return Array.isArray(toolSubagents) ? toolSubagents : [toolSubagents];
 		}
@@ -94202,7 +95944,7 @@ const isAiassistantApply = (value) => AIASSISTANT_APPLY_VALUES.includes(value);
 /**
 * Globs that match the whole project and so say nothing beyond "always".
 */
-const UNIVERSAL_GLOBS$5 = /* @__PURE__ */ new Set(["**/*", "*"]);
+const UNIVERSAL_GLOBS$6 = /* @__PURE__ */ new Set(["**/*", "*"]);
 const METADATA_DELIMITER = "---";
 /**
 * Splits text into lines that keep their own line terminator, so the body can
@@ -94327,7 +96069,7 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 	*/
 	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$5.has(glob));
+		const hasUniversalGlob = globs.some((glob) => UNIVERSAL_GLOBS$6.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";
@@ -96981,7 +98723,7 @@ function normalizePatternList(value) {
 * an always-on rule into a "when any file is in context" rule. Dropped on
 * generate and mapped back on import.
 */
-const UNIVERSAL_GLOBS$4 = /* @__PURE__ */ new Set(["**/*", "*"]);
+const UNIVERSAL_GLOBS$5 = /* @__PURE__ */ new Set(["**/*", "*"]);
 /**
 * Rule generator for Continue (continuedev/continue), the open-source IDE
 * extension and CLI (`cn`).
@@ -97095,7 +98837,7 @@ var ContinueRule = class ContinueRule extends ToolRule {
 		if (alwaysApply === true) return;
 		const targetGlobs = continueGlobs ?? parentGlobs;
 		if (!targetGlobs || targetGlobs.length === 0) return;
-		if (targetGlobs.every((glob) => UNIVERSAL_GLOBS$4.has(glob.trim()))) return;
+		if (targetGlobs.every((glob) => UNIVERSAL_GLOBS$5.has(glob.trim()))) return;
 		return targetGlobs;
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
@@ -97587,7 +99329,7 @@ const CursorRuleFrontmatterSchema = zod_mini.z.object({
 * does not already say. Same pair the Cline and Qwen Code adapters treat as
 * universal.
 */
-const UNIVERSAL_GLOBS$3 = /* @__PURE__ */ new Set(["**/*", "*"]);
+const UNIVERSAL_GLOBS$4 = /* @__PURE__ */ new Set(["**/*", "*"]);
 var CursorRule = class CursorRule extends ToolRule {
 	frontmatter;
 	body;
@@ -97628,7 +99370,8 @@ var CursorRule = class CursorRule extends ToolRule {
 	}
 	/**
 	* Custom parse function for Cursor MDC files
-	* MDC files don't support quotes in YAML, so we need to handle patterns like *.ts specially
+	* MDC files don't support quotes in YAML, so we need to handle patterns like *.ts specially.
+	* Also used by Firebender, whose `.firebender/rules/*.mdc` files carry the same frontmatter.
 	*/
 	static parseCursorFrontmatter(fileContent, filePath) {
 		const bounds = findFrontmatterBlockBounds(fileContent);
@@ -97691,7 +99434,7 @@ var CursorRule = class CursorRule extends ToolRule {
 	static resolveCursorGlobs({ cursorSpecificGlobs, parentGlobs, alwaysApply }) {
 		const targetGlobs = cursorSpecificGlobs !== void 0 ? cursorSpecificGlobs : parentGlobs;
 		if (!targetGlobs || targetGlobs.length === 0) return;
-		if (alwaysApply && targetGlobs.every((glob) => UNIVERSAL_GLOBS$3.has(glob.trim()))) return;
+		if (alwaysApply && targetGlobs.every((glob) => UNIVERSAL_GLOBS$4.has(glob.trim()))) return;
 		return targetGlobs.join(",");
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
@@ -98605,6 +100348,211 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/firebender-rule.ts
+/**
+* Frontmatter of a Firebender `.mdc` rule. Every field is optional; `globs`
+* is one comma-separated string, and a YAML list is tolerated on import.
+*/
+const FirebenderRuleFrontmatterSchema = zod_mini.z.looseObject({
+	description: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.string())),
+	globs: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))),
+	alwaysApply: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.boolean()))
+});
+/** Globs that match every file, and so add nothing to an always-applied rule. */
+const UNIVERSAL_GLOBS$3 = /* @__PURE__ */ new Set(["**/*", "*"]);
+function normalizeGlobs$2(globs) {
+	if (globs === null || globs === void 0) return [];
+	return (typeof globs === "string" ? globs.split(",") : globs).map((glob) => glob.trim()).filter((glob) => glob.length > 0);
+}
+/**
+* Rule generator for Firebender.
+*
+* Root rule: Firebender looks for `.firebender/AGENTS.md` first (then the
+* project-root `AGENTS.md`, then the same pair in parent directories, then
+* `~/.firebender/AGENTS.md`) and uses the first file it finds, so the root rule
+* is written to `.firebender/AGENTS.md` in the project and to
+* `~/.firebender/AGENTS.md` globally, where it does not collide with the
+* project-root `AGENTS.md` the `agentsmd` target owns.
+*
+* Non-root rules: `.firebender/rules/*.mdc` (project) and
+* `~/.firebender/rules/*.mdc` (personal), each with optional Cursor-style
+* frontmatter: `description`, `globs` (one comma-separated string) and
+* `alwaysApply`. A rule with specific globs is written with
+* `alwaysApply: false` and those globs; every other rule is always applied.
+*
+* @see https://docs.firebender.com/api-reference/rules
+* @see https://docs.firebender.com/api-reference/agents-md
+*/
+var FirebenderRule = class FirebenderRule extends ToolRule {
+	frontmatter;
+	body;
+	constructor({ frontmatter = {}, body, ...rest }) {
+		if (rest.validate && !rest.root) {
+			const result = FirebenderRuleFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		const resolvedBody = body ?? rest.fileContent;
+		super({
+			...rest,
+			fileContent: rest.root ? resolvedBody : stringifyFrontmatter(resolvedBody, FirebenderRule.toOutputFrontmatter(frontmatter), { avoidBlockScalars: true })
+		});
+		this.frontmatter = frontmatter;
+		this.body = resolvedBody;
+	}
+	static getSettablePaths({ excludeToolDir } = {}) {
+		return {
+			root: {
+				relativeDirPath: buildToolPath(FIREBENDER_DIR, ".", excludeToolDir),
+				relativeFilePath: FIREBENDER_AGENTS_MD_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(FIREBENDER_DIR, "rules", excludeToolDir) }
+		};
+	}
+	/**
+	* The frontmatter written to a `.mdc` file: `alwaysApply` first, then the
+	* flattened `description`, then the globs joined the way Firebender's docs
+	* spell them (`"*.kt, *.kts"`).
+	*/
+	static toOutputFrontmatter(frontmatter) {
+		const description = typeof frontmatter.description === "string" ? frontmatter.description.replace(/[\r\n\u0085\u2028\u2029]+/g, " ").trim() : "";
+		const globs = normalizeGlobs$2(frontmatter.globs);
+		return {
+			...typeof frontmatter.alwaysApply === "boolean" && { alwaysApply: frontmatter.alwaysApply },
+			...description !== "" && { description },
+			...globs.length > 0 && { globs: globs.join(", ") }
+		};
+	}
+	/**
+	* Derives the Firebender frontmatter from the canonical one: specific globs
+	* make a file-scoped rule, everything else (no globs, universal globs) is
+	* always applied. Firebender splits `globs` on every comma, so a brace
+	* alternation such as `*.{ts,tsx}` is expanded into one glob per branch.
+	*/
+	static buildFrontmatter(frontmatter) {
+		const globs = normalizeGlobs$2(frontmatter.globs ?? []).flatMap((glob) => expandBraceAlternations(glob));
+		const specificGlobs = globs.filter((glob) => !UNIVERSAL_GLOBS$3.has(glob));
+		const isFileScoped = specificGlobs.length > 0 && specificGlobs.length === globs.length;
+		const description = frontmatter.description?.trim() || void 0;
+		return {
+			alwaysApply: !isFileScoped,
+			...description !== void 0 && { description },
+			...isFileScoped && { globs: specificGlobs.join(", ") }
+		};
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
+		const paths = this.getSettablePaths();
+		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+		if (rulesyncFrontmatter.root ?? false) return new FirebenderRule({
+			outputRoot,
+			relativeDirPath: paths.root.relativeDirPath,
+			relativeFilePath: paths.root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: true,
+			description: rulesyncFrontmatter.description,
+			globs: rulesyncFrontmatter.globs
+		});
+		return new FirebenderRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath: rulesyncRule.getRelativeFilePath().replace(/\.md$/, ".mdc"),
+			frontmatter: this.buildFrontmatter(rulesyncFrontmatter),
+			body: rulesyncRule.getBody(),
+			fileContent: "",
+			validate,
+			root: false
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true }) {
+		const paths = this.getSettablePaths();
+		if (relativeFilePath === paths.root.relativeFilePath && (relativeDirPath === void 0 || relativeDirPath === paths.root.relativeDirPath)) {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.root.relativeDirPath, paths.root.relativeFilePath));
+			return new FirebenderRule({
+				outputRoot,
+				relativeDirPath: paths.root.relativeDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				fileContent,
+				validate,
+				root: true
+			});
+		}
+		const filePath = (0, node_path.join)(outputRoot, paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body } = CursorRule.parseCursorFrontmatter(fileContent, filePath);
+		const result = FirebenderRuleFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new FirebenderRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			fileContent: "",
+			validate,
+			root: false
+		});
+	}
+	toRulesyncRule() {
+		if (this.isRoot()) return this.toRulesyncRuleDefault();
+		const sourceGlobs = normalizeGlobs$2(this.frontmatter.globs);
+		const alwaysApply = this.frontmatter.alwaysApply ?? void 0;
+		const description = this.frontmatter.description?.trim() || void 0;
+		const globs = alwaysApply === true || sourceGlobs.length === 0 ? ["**/*"] : sourceGlobs;
+		return new RulesyncRule({
+			outputRoot: process.cwd(),
+			frontmatter: {
+				targets: ["*"],
+				root: false,
+				...description !== void 0 && { description },
+				globs
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath().replace(/\.mdc$/, ".md"),
+			validate: true
+		});
+	}
+	validate() {
+		if (this.isRoot() || !this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = FirebenderRuleFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const paths = this.getSettablePaths();
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath === paths.root.relativeDirPath;
+		return new FirebenderRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: isRoot
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "firebender"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/gitlabduo-rule.ts
 /**
 * GitLab Duo CLI reads custom rules from a single plain-Markdown file:
@@ -101886,6 +103834,117 @@ var WarpRule = class extends NestedAgentsmdRule {
 	}
 };
 //#endregion
+//#region src/features/rules/xum-rule.ts
+/** An ATX level-1 heading line (`# Title`), which Xum's parser treats as an H1. */
+const ATX_H1_LINE = /^ {0,3}#(?:[ \t]|$)/;
+/**
+* Make `body` start at a level-1 heading, adding `# <heading>` when it does not
+* already open with one.
+*
+* Xum reads `.xum/AGENTS.md` (and appends `AGENTS.local.md`) as one Markdown
+* document and treats a `Mode:` / `Model:` / `Tool:` heading as a scoped
+* section that runs until the next heading of the same or a higher level.
+* Fragments rulesync concatenates into that document — folded topic rules and
+* the local overlay — would otherwise fall inside a scoped section the
+* preceding fragment ends with, and Xum would inject them only in that mode.
+* Only an H1 closes a section of any level, so each such fragment opens with
+* one.
+*
+* @see https://github.com/coder/xum/blob/main/src/node/utils/main/markdown.ts
+*/
+function ensureXumSectionBoundary({ body, heading }) {
+	const firstLine = body.split(/\r?\n/).find((line) => line.trim() !== "");
+	if (firstLine !== void 0 && ATX_H1_LINE.test(firstLine)) return body;
+	const safeHeading = heading.replaceAll(/[\r\n:]/g, " ").trim() || "Instructions";
+	return body.trim() === "" ? `# ${safeHeading}\n` : `# ${safeHeading}\n\n${body}`;
+}
+/** The heading a folded rule opens with: its file name without the extension. */
+function xumRuleHeading(rulesyncRule) {
+	const fileName = (0, node_path.basename)(rulesyncRule.getRelativeFilePath());
+	return fileName.slice(0, fileName.length - (0, node_path.extname)(fileName).length);
+}
+/**
+* Rule generator for Xum (Coder's parallel coding-agent app, formerly Mux).
+*
+* Xum layers its own `.xum/AGENTS.md` (project) and `~/.xum/AGENTS.md` (user)
+* on top of the shared root `AGENTS.md` / `AGENT.md` / `CLAUDE.md`, which the
+* `agentsmd` target already writes, so this target writes only the
+* Xum-dedicated file. Only these files honor the `## Model: <regex>` and
+* `## Mode: <mode>` scoped sections; rulesync passes the body through as-is,
+* so such sections authored in a rule keep working. The personal
+* `.xum/AGENTS.local.md` overlay is written for a `localRoot: true` rule.
+*
+* @see https://xum.cdr.dev/agents/instruction-files
+*/
+var XumRule = class XumRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return { root: {
+			relativeDirPath: XUM_DIR,
+			relativeFilePath: XUM_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
+		return new XumRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		return new XumRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: isRoot ? rulesyncRule.getBody() : ensureXumSectionBoundary({
+				body: rulesyncRule.getBody(),
+				heading: xumRuleHeading(rulesyncRule)
+			}),
+			validate,
+			root: isRoot
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new XumRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "AGENTS.md" && relativeDirPath === ".xum"
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "xum"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/zcode-rule.ts
 var ZcodeRule = class ZcodeRule extends ToolRule {
 	constructor({ fileContent, root, ...rest }) {
@@ -102374,6 +104433,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "compose"
 		}
 	}],
+	["firebender", {
+		class: FirebenderRule,
+		meta: {
+			extension: "mdc",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["goose", {
 		class: GooseRule,
 		meta: {
@@ -102657,6 +104724,17 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["xum", {
+		class: XumRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold",
+			localRootMode: "separate-local-file",
+			localRootFileName: XUM_LOCAL_RULE_FILE_NAME
+		}
+	}],
 	["devin", {
 		class: DevinRule,
 		meta: {
@@ -103427,18 +105505,39 @@ var RulesProcessor = class extends FeatureProcessor {
 			root: true,
 			localRoot
 		});
-		if (isClassOrSubclassOf({
-			candidate: factory.class,
-			base: QwencodeRule
-		})) return new QwencodeRule({
-			outputRoot: this.outputRoot,
-			relativeDirPath: relativeDirPath ?? ".qwen",
-			relativeFilePath: fileName,
-			fileContent: body,
-			validate: true,
-			root: true,
+		return this.buildToolDirLocalRootFile({
+			factory,
+			fileName,
+			body,
+			relativeDirPath,
 			localRoot
 		});
+	}
+	/**
+	* Qwen Code and Xum read the personal local file from their tool directory
+	* (`.qwen/QWEN.local.md`, `.xum/AGENTS.local.md`), not the project root
+	* (project scope only; global handling never reaches here).
+	*/
+	buildToolDirLocalRootFile({ factory, fileName, body, relativeDirPath, localRoot }) {
+		const toolDirEntry = [[QwencodeRule, QWENCODE_DIR], [XumRule, XUM_DIR]].find(([base]) => isClassOrSubclassOf({
+			candidate: factory.class,
+			base
+		}));
+		if (toolDirEntry) {
+			const [toolDirClass, toolDir] = toolDirEntry;
+			return new toolDirClass({
+				outputRoot: this.outputRoot,
+				relativeDirPath: relativeDirPath ?? toolDir,
+				relativeFilePath: fileName,
+				fileContent: toolDirClass === XumRule && !localRoot ? ensureXumSectionBoundary({
+					body,
+					heading: "Local instructions"
+				}) : body,
+				validate: true,
+				root: true,
+				localRoot
+			});
+		}
 		return null;
 	}
 	/**
@@ -106190,6 +108289,7 @@ async function generateSubagentsCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			deleteOrphans: config.getDelete(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({