rulesync 38.0.0 → 39.0.0

package/dist/{import-CoFTCNq7.js → import-CfVOkld5.js}

@@ -522,6 +522,7 @@ const rulesProcessorToolTargetTuple = [
 	"cursor",
 	"deepagents",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -551,6 +552,7 @@ const rulesProcessorToolTargetTuple = [
 	"trae",
 	"vibe",
 	"warp",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -560,6 +562,7 @@ const rulesProcessorToolTargetTuple = [
 ];
 const ignoreProcessorToolTargetTuple = [
 	"aiassistant",
+	"androidstudio",
 	"antigravity-cli",
 	"augmentcode",
 	"bob",
@@ -570,6 +573,7 @@ const ignoreProcessorToolTargetTuple = [
 	"continue",
 	"crush",
 	"cursor",
+	"firebender",
 	"grokcli",
 	"hermesagent",
 	"junie",
@@ -617,6 +621,7 @@ const mcpProcessorToolTargetTuple = [
 	"deepagents",
 	"dsh",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -646,6 +651,7 @@ const mcpProcessorToolTargetTuple = [
 	"vibe-plugin",
 	"warp",
 	"warpcli",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -672,6 +678,7 @@ const commandsProcessorToolTargetTuple = [
 	"copilot",
 	"cursor",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -727,6 +734,7 @@ const subagentsProcessorToolTargetTuple = [
 	"devin",
 	"devin-plugin",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"hermesagent",
@@ -751,6 +759,7 @@ const subagentsProcessorToolTargetTuple = [
 	"takt",
 	"vibe",
 	"vibe-plugin",
+	"xum",
 	"zcode",
 	"zcode-plugin"
 ];
@@ -758,6 +767,7 @@ const skillsProcessorToolTargetTuple = [
 	"agentsmd",
 	"agentsskills",
 	"aiassistant",
+	"androidstudio",
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
@@ -781,6 +791,7 @@ const skillsProcessorToolTargetTuple = [
 	"cursor",
 	"deepagents",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"grokcli",
 	"gitlabduo",
@@ -810,6 +821,7 @@ const skillsProcessorToolTargetTuple = [
 	"vibe",
 	"vibe-plugin",
 	"warp",
+	"xum",
 	"devin",
 	"devin-plugin",
 	"zcode",
@@ -844,6 +856,7 @@ const hooksProcessorToolTargetTuple = [
 	"pi",
 	"pool",
 	"factorydroid",
+	"firebender",
 	"goose",
 	"hermesagent",
 	"kimi-code",
@@ -3758,6 +3771,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",
@@ -4219,14 +4234,103 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	} } });
 	return matter.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 = matter(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 = matter(content, FRONTMATTER_PARSE_OPTIONS);
 		frontmatter = deepRemoveNullishObject(result.data);
 		body = result.content;
 		hasFrontmatter = result.matter !== "" || content.trimStart().startsWith("---");
@@ -4285,22 +4389,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
 	};
 }
 /**
@@ -4332,8 +4442,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
 */
@@ -4698,6 +4809,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.
@@ -6045,6 +6179,7 @@ const HooksConfigSchema = z.looseObject({
 	version: z.optional(z.number()),
 	hooks: canonicalHooksRecordSchema,
 	cursor: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	firebender: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	claudecode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	copilot: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	copilotcli: z.optional(z.looseObject({
@@ -7148,7 +7283,7 @@ const McpServerSchema = z.looseObject({
 	crushSessionless: z.optional(z.boolean()),
 	crushChannelEnabled: z.optional(z.boolean()),
 	crushChannelReply: z.optional(CrushChannelReplySchema),
-	zcodeOauth: z.optional(z.looseObject({ type: z.string() })),
+	zcodeOauth: z.optional(z.looseObject({})),
 	poolAllow: z.optional(z.array(z.string())),
 	headers: z.optional(z.record(z.string(), z.string())),
 	/**
@@ -7250,6 +7385,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	devin: z.optional(toolScopedMcpSchema),
 	dsh: z.optional(toolScopedMcpSchema),
 	factorydroid: z.optional(toolScopedMcpSchema),
+	firebender: z.optional(toolScopedMcpSchema),
 	gitlabduo: z.optional(toolScopedMcpSchema),
 	goose: z.optional(toolScopedMcpSchema),
 	grokcli: z.optional(toolScopedMcpSchema),
@@ -7274,6 +7410,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	vibe: z.optional(toolScopedMcpSchema),
 	warp: z.optional(toolScopedMcpSchema),
 	warpcli: z.optional(toolScopedMcpSchema),
+	xum: z.optional(toolScopedMcpSchema),
 	zed: z.optional(toolScopedMcpSchema)
 });
 /**
@@ -13069,6 +13206,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
@@ -13308,6 +13474,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: {
@@ -13395,6 +13570,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",
@@ -20229,6 +20406,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";
+join(FIREBENDER_DIR, "rules");
+/** Commands: `.firebender/commands/*.mdc` (project) and `~/.firebender/commands/*.mdc` (global). */
+const FIREBENDER_COMMANDS_DIR_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 = join(FIREBENDER_DIR, FIREBENDER_AGENTS_DIR_NAME);
+/** Skills: `.firebender/skills/<name>/SKILL.md` (project) and `~/.firebender/skills/` (global). */
+const FIREBENDER_SKILLS_DIR_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 = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	model: z.optional(z.string()),
+	mode: z.optional(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 ${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 ${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 = 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
@@ -20821,6 +21170,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 = z.looseObject({
 	name: z.string(),
@@ -21303,9 +21706,6 @@ const HermesCommandSpecSchema = z.object({
 	description: z.string(),
 	prompt: 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",
@@ -21339,6 +21739,8 @@ def _load_commands():
     return commands
 
 
+${getHermesQueueUserMessagePython({ pluginName: "rulesync-commands" })}
+
 def _register_command(ctx, command):
     slug = command.get("slug")
     if not slug:
@@ -21348,31 +21750,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)
 
@@ -25244,6 +25637,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: {
@@ -32527,6 +32930,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(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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "",
+			generatedHooks: firebenderHooks,
+			shape: "flat",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull(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,
@@ -36937,6 +37450,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: {
@@ -37808,6 +38332,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 = 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(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
@@ -38469,6 +39054,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 = 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(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";
@@ -39786,6 +40460,7 @@ var ZedIgnore = class ZedIgnore extends ToolIgnore {
 const IgnoreProcessorToolTargetSchema = z.enum(ignoreProcessorToolTargetTuple);
 const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["aiassistant", { class: AiassistantIgnore }],
+	["androidstudio", { class: AndroidstudioIgnore }],
 	["antigravity-cli", { class: AntigravityCliIgnore }],
 	["augmentcode", { class: AugmentcodeIgnore }],
 	["bob", { class: BobIgnore }],
@@ -39796,6 +40471,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 }],
@@ -39820,6 +40496,7 @@ const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
 const ignoreProcessorGlobalToolTargets = [
 	"continue",
 	"devin",
+	"firebender",
 	"grokcli",
 	"kilo",
 	"kiro",
@@ -45317,6 +45994,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(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 = 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",
@@ -52008,6 +52850,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 = join(XUM_DIR, "agents");
+const XUM_SKILLS_DIR_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: 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(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 = 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
@@ -52269,8 +53353,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.
 *
@@ -52296,7 +53380,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;
 			}
@@ -52942,6 +54026,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["firebender", {
+		class: FirebenderMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["goose", {
 		class: GooseMcp,
 		meta: {
@@ -53212,6 +54305,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["xum", {
+		class: XumMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: false
+		}
+	}],
 	["devin", {
 		class: DevinMcp,
 		meta: {
@@ -76423,6 +77525,11 @@ const TOOL_DISPLAY = [
 		label: "Factory Droid",
 		group: "ai"
 	},
+	{
+		key: "firebender",
+		label: "Firebender",
+		group: "ai"
+	},
 	{
 		key: "opencode",
 		label: "OpenCode",
@@ -76578,6 +77685,11 @@ const TOOL_DISPLAY = [
 		label: "JetBrains AI Assistant",
 		group: "ai"
 	},
+	{
+		key: "androidstudio",
+		label: "Gemini in Android Studio",
+		group: "ai"
+	},
 	{
 		key: "junie",
 		label: "JetBrains Junie",
@@ -76613,6 +77725,11 @@ const TOOL_DISPLAY = [
 		label: "Warp Agent CLI",
 		group: "ai"
 	},
+	{
+		key: "xum",
+		label: "Xum",
+		group: "ai"
+	},
 	{
 		key: "replit",
 		label: "Replit",
@@ -77757,6 +78874,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) {
@@ -81225,6 +82363,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`
@@ -84760,6 +85918,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 = z.looseObject({
 	name: z.string(),
@@ -85175,6 +86354,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: false
 		}
 	}],
+	["androidstudio", {
+		class: AndroidstudioSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["amp", {
 		class: AmpSkill,
 		meta: {
@@ -85360,6 +86547,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["firebender", {
+		class: FirebenderSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["goose", {
 		class: GooseSkill,
 		meta: {
@@ -85610,6 +86805,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["xum", {
+		class: XumSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["devin", {
 		class: DevinSkill,
 		meta: {
@@ -89456,6 +90659,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 = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	color: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	tools: z.optional(z.string()),
+	model: z.optional(z.string()),
+	callable: z.optional(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 ? posix.join(FIREBENDER_AGENTS_DIR_NAME, fileName) : 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 ${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 ?? 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: join(outputRoot, agentsDirPath, "agent.md")
+		});
+		const existingAgentFileNames = new Set(agentsDirEscapesRoot ? [] : await listDirectoryEntryNames(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 ${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 = 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 = 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 —
@@ -89743,13 +91278,13 @@ function subagentSlug(relativeFilePath) {
 	return 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");
 }
@@ -89757,9 +91292,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"
 
 
@@ -89779,52 +91317,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 }) {
@@ -89855,7 +91412,7 @@ function getSubagentSpec(rulesyncSubagent) {
 		prompt: rulesyncSubagent.getBody(),
 		hermes: {
 			command: hermesCommandName(slug),
-			dispatch: "delegate_task"
+			dispatch: "inject_message"
 		}
 	};
 }
@@ -92647,6 +94204,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 = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	base: z.optional(z.string()),
+	disabled: z.optional(z.boolean()),
+	ui: z.optional(z.looseObject({})),
+	prompt: z.optional(z.looseObject({})),
+	subagent: z.optional(z.looseObject({})),
+	ai: z.optional(z.looseObject({})),
+	tools: z.optional(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 ${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 ${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 = 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 = z.looseObject({
 	name: z.string(),
@@ -93112,6 +94829,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: {
@@ -93339,6 +95067,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.toml"
 		}
 	}],
+	["xum", {
+		class: XumSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["zcode", {
 		class: ZcodeSubagent,
 		meta: {
@@ -93393,6 +95130,7 @@ function compareRelativePathsShallowestFirst(left, right) {
 var SubagentsProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
+	deleteOrphans;
 	getFactory;
 	/**
 	* Whether the last `loadRulesyncFiles` found a `subagents/` directory under
@@ -93400,13 +95138,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;
@@ -93414,7 +95153,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);
@@ -93430,11 +95171,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];
 		}
@@ -94180,7 +95922,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
@@ -94305,7 +96047,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";
@@ -96959,7 +98701,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`).
@@ -97073,7 +98815,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 }) {
@@ -97565,7 +99307,7 @@ const CursorRuleFrontmatterSchema = 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;
@@ -97606,7 +99348,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);
@@ -97669,7 +99412,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 }) {
@@ -98583,6 +100326,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 = z.looseObject({
+	description: z.optional(z.nullable(z.string())),
+	globs: z.optional(z.nullable(z.union([z.string(), z.array(z.string())]))),
+	alwaysApply: z.optional(z.nullable(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 ${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(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 = 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 ${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:
@@ -101864,6 +103812,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 = basename(rulesyncRule.getRelativeFilePath());
+	return fileName.slice(0, fileName.length - 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 = join(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent(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 }) {
@@ -102352,6 +104411,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "compose"
 		}
 	}],
+	["firebender", {
+		class: FirebenderRule,
+		meta: {
+			extension: "mdc",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["goose", {
 		class: GooseRule,
 		meta: {
@@ -102635,6 +104702,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: {
@@ -103405,18 +105483,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;
 	}
 	/**
@@ -106168,6 +108267,7 @@ async function generateSubagentsCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			deleteOrphans: config.getDelete(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -106792,4 +108892,4 @@ async function importChecksCore(params) {
 //#endregion
 export { RulesyncHooks as $, removeDirectoryStrict as $t, groupSpellingsByCaseFoldedIdentity as A, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as An, applyFileMode as At, QWENCODE_LOCAL_RULE_FILE_NAME as B, parseCommaSeparatedList as Bn, getFileSizeAndExecutableBit as Bt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as C, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as Cn, fallbackLogger as Ct, FACTORYDROID_DIR as D, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Dn, withWarnOnceScope as Dt, ChecksProcessor as E, RULESYNC_IGNORE_RELATIVE_FILE_PATH as En, resetRunWarningState as Et, CLAUDECODE_LOCAL_RULE_FILE_NAME as F, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Fn, createTempDirectory as Ft, RulesyncSubagentFrontmatterSchema as G, truncateText as Gn, listDirectoryEntryNames as Gt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as H, ALL_FEATURES_WITH_WILDCARD as Hn, isFileNotFoundError as Ht, CLAUDECODE_MEMORIES_DIR_NAME as I, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as In, directoryExists as It, RulesyncRule as J, quoteForLog as Jn, pathEscapesRoot as Jt, RulesyncSkill as K, hasDeceptiveHiddenCharacters as Kn, listFilePathsRecursively as Kt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as L, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Ln, ensureDir as Lt, CODEXCLI_DIR as M, RULESYNC_PERMISSIONS_SCHEMA_URL as Mn, assertTreeContainsNoSymlinks as Mt, CLAUDECODE_AGENT_MEMORY_LOCAL_DIR_NAME as N, RULESYNC_RELATIVE_DIR_PATH as Nn, assertWritablePathInsideRoot as Nt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as O, RULESYNC_MCP_RELATIVE_FILE_PATH as On, CLIError as Ot, CLAUDECODE_DIR as P, RULESYNC_RULES_RELATIVE_DIR_PATH as Pn, checkPathTraversal as Pt, RulesyncIgnore as Q, removeDirectory as Qt, CLAUDECODE_SKILLS_DIR_PATH as R, RULESYNC_USER_CONFIG_DIR_NAME as Rn, fileExists as Rt, COMMANDCODE_DIR as S, RULESYNC_CONFIG_SCHEMA_URL as Sn, WarningCollectingLogger as St, CODEBUDDY_LOCAL_RULE_FILE_NAME as T, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Tn, withFallbackLoggerTarget as Tt, getLocalSkillDirNames as U, DEPRECATED_FEATURE_REPLACEMENTS as Un, isFileSystemError as Ut, AUGMENTCODE_DIR as V, ALL_FEATURES as Vn, getHomeDirectory as Vt, RulesyncSubagent as W, formatError as Wn, isSymlink as Wt, RulesyncPermissions as X, stripControlCharactersKeepingLineFeeds as Xn, readFileContent as Xt, RulesyncRuleFrontmatterSchema as Y, stripControlCharacters as Yn, posixRelativePathEscapesRoot as Yt, RulesyncMcp as Z, stripHiddenCharacters as Zn, readFileContentOrNull as Zt, CRUSH_LOCAL_RULE_FILE_NAME as _, MAX_FILE_SIZE as _n, SourceEntrySchema as _t, getProcessorRegistryEntry as a, runWithDirectoryRollback as an, RulesyncCheck as at, LETTACODE_DIR as b, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as bn, ConsoleLogger as bt, RulesProcessor as c, writeFileBuffer as cn, loadYaml as ct, ELLIPSIS_WIDTH as d, ALL_TOOL_TARGETS as dn, ConfigResolver as dt, removeFile as en, getRulesyncSourceCandidates as et, displayWidthOf as f, ALL_TOOL_TARGETS_WITH_WILDCARD as fn, mergeInputRootConfigs as ft, HooksProcessor as g, FEATURE_SOURCE_TREE_ENTRIES as gn, GITIGNORE_DESTINATION_KEY as gt, IgnoreProcessor as h, CURATED_RULES_FEATURE_SUBDIR as hn, ConfigFileSchema as ht, inspectInputRoots as i, resolvedRelativePath as in, RulesyncCommandFrontmatterSchema as it, CODEXCLI_BASH_RULES_FILE_NAME as j, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as jn, assertDirectoryIfExists as jt, caseFoldIdentity as k, RULESYNC_MCP_SCHEMA_URL as kn, ErrorCodes as kt, SubagentsProcessor as l, writeFileContent as ln, SHARED_USER_MANAGED_CONFIG_PATHS as lt, McpProcessor as m, ToolTargetSchema as mn, CONFLICTING_TARGET_PAIRS as mt, formatSourceLoadFailure as n, removeTempDirectory as nn, parseJsonc as nt, convertFromTool as o, splitPathSegments as on, RulesyncCheckFrontmatterSchema as ot, shortenToWidth as p, PACKAGING_TOOL_TARGETS as pn, resolveEffectiveInputRoots as pt, RulesyncSkillFrontmatterSchema as q, hasEnclosingMarkOutsideKeycap as qn, listSubdirectoryNames as qt, generate as r, resolvePath as rn, RulesyncCommand as rt, isPackagingToolTarget as s, toPosixPath as sn, stringifyFrontmatter as st, importFromTool as t, removeFileStrict as tn, resolveRulesyncSourceWritePath as tt, SkillsProcessor as u, mapWithConcurrency as un, SKILL_FILE_NAME as ut, CommandsProcessor as v, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as vn, assertTargetsFeaturesExclusive as vt, CODEBUDDY_DIR as w, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as wn, warnOnConflictingFlags as wt, LETTACODE_SETTINGS_LOCAL_FILE_NAME as x, RULESYNC_CONFIG_RELATIVE_FILE_PATH as xn, JsonLogger as xt, REASONIX_LOCAL_RULE_FILE_NAME as y, RULESYNC_CHECKS_RELATIVE_DIR_PATH as yn, findControlCharacter as yt, QWENCODE_DIR as z, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as zn, findFilesByGlobs as zt };
 
-//# sourceMappingURL=import-CoFTCNq7.js.map
+//# sourceMappingURL=import-CfVOkld5.js.map