rulesync 16.1.0 → 16.2.0

package/dist/{import-BmXT7mRS.js → import-CArKOPG_.js}

@@ -192,6 +192,7 @@ const ignoreProcessorToolTargetTuple = [
 	"kiro-cli",
 	"kiro-ide",
 	"qwencode",
+	"reasonix",
 	"roo",
 	"devin",
 	"vibe",
@@ -249,6 +250,7 @@ const commandsProcessorToolTargetTuple = [
 	"cursor",
 	"factorydroid",
 	"goose",
+	"grokcli",
 	"hermesagent",
 	"junie",
 	"kilo",
@@ -404,6 +406,7 @@ const checksProcessorToolTargetTuple = [
 	"amp",
 	"cursor",
 	"hermesagent",
+	"rovodev",
 	"takt"
 ];
 //#endregion
@@ -1057,6 +1060,17 @@ const ConfigFileSchema = z.object({
 });
 z.required(ConfigParamsSchema);
 /**
+* Normalizes the configuration file location to an absolute path.
+*
+* `ConfigResolver` always supplies the path it actually loaded; the fallback
+* only covers direct programmatic construction, where the conventional
+* location next to the input root is the best guess.
+*/
+function normalizeConfigFilePath({ configFilePath, inputRoot }) {
+	if (configFilePath === void 0) return join(inputRoot, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+	return isAbsolute(configFilePath) ? configFilePath : resolve(configFilePath);
+}
+/**
 * Conflicting target pairs that cannot be used together
 */
 const CONFLICTING_TARGET_PAIRS = [["augmentcode", "augmentcode-legacy"], ["claudecode", "claudecode-legacy"]];
@@ -1127,8 +1141,9 @@ var Config = class Config {
 	dryRun;
 	check;
 	inputRoot;
+	configFilePath;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, flattenedCommandNaming, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, flattenedCommandNaming, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, configFilePath, sources, configFileTargets }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -1161,6 +1176,10 @@ var Config = class Config {
 		this.dryRun = dryRun ?? false;
 		this.check = check ?? false;
 		this.inputRoot = inputRoot === void 0 ? process.cwd() : isAbsolute(inputRoot) ? inputRoot : resolve(inputRoot);
+		this.configFilePath = normalizeConfigFilePath({
+			configFilePath,
+			inputRoot: this.inputRoot
+		});
 		this.sources = sources ?? [];
 	}
 	/**
@@ -1354,6 +1373,14 @@ var Config = class Config {
 	getInputRoot() {
 		return this.inputRoot;
 	}
+	/**
+	* Returns the absolute path of the configuration file this config was
+	* resolved from. The file itself may not exist — `rulesync` runs fine
+	* without one — so callers must treat this as a location, not a guarantee.
+	*/
+	getConfigFilePath() {
+		return this.configFilePath;
+	}
 	getSources() {
 		return this.sources;
 	}
@@ -1576,6 +1603,7 @@ var ConfigResolver = class {
 				fallback: getDefaults().check
 			}),
 			inputRoot: resolvedInputRoot !== void 0 ? resolve(resolvedInputRoot) : cwd,
+			configFilePath: validatedConfigPath,
 			sources: configByFile.sources ?? getDefaults().sources,
 			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
 			configFileTargets: extractConfigFileTargets(configByFile.targets)
@@ -3986,10 +4014,30 @@ const ClinePermissionsOverrideSchema = z.looseObject({
 * portable and keeps them out of other tools' configs. Mirrors the OpenCode
 * override; each value may be a bare action string or a pattern map.
 *
+* `sandbox` is the sibling top-level block that governs the sandbox Kilo runs
+* commands in: `enabled` (boolean), `network` (`"deny"` and friends),
+* `allowed_hosts` (a list of `host` / `host:port` destination exceptions) and
+* `writable_paths`. It has no canonical permission category, so it is authored
+* here and emitted only for Kilo.
+*
+* Upstream restricts what a *project* config may say: `allowed_hosts` and
+* `writable_paths` are honored from the global config only, and a project
+* config may merely tighten (`enabled: true`, `network: "deny"`) — a
+* project-level network denial even clears the global destination exceptions.
+* rulesync mirrors that: at project scope only `enabled` and `network` are
+* written, and the rest are dropped with a warning rather than emitted into a
+* file Kilo would ignore.
+*
 * @example
 * { "permission": { "external_directory": "deny", "doom_loop": "ask" } }
+* @example
+* { "sandbox": { "enabled": true, "network": "deny" } }
+* @see https://kilo.ai/docs/getting-started/settings/sandboxing
 */
-const KiloPermissionsOverrideSchema = z.looseObject({ permission: z.optional(z.record(z.string(), OpencodeOverridePermissionValueSchema)) });
+const KiloPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(z.record(z.string(), OpencodeOverridePermissionValueSchema)),
+	sandbox: z.optional(z.looseObject({}))
+});
 /**
 * Tool-scoped override block for Claude Code. Claude Code's `permissions` object
 * (in `.claude/settings.json`) carries non-list fields that have no canonical
@@ -5298,6 +5346,26 @@ const CURSOR_IGNORE_FILE_NAME = ".cursorignore";
 const CURSOR_PERMISSIONS_FILE_NAME = "cli.json";
 const CURSOR_PERMISSIONS_GLOBAL_FILE_NAME = "cli-config.json";
 //#endregion
+//#region src/constants/rovodev-paths.ts
+const ROVODEV_DIR = ".rovodev";
+const ROVODEV_SKILLS_DIR_PATH = join(ROVODEV_DIR, "skills");
+const ROVODEV_SUBAGENTS_DIR_PATH = join(ROVODEV_DIR, "subagents");
+const ROVODEV_MODULAR_RULES_DIR_PATH = join(ROVODEV_DIR, ".rulesync", "modular-rules");
+const ROVODEV_RULE_FILE_NAME = "AGENTS.md";
+const ROVODEV_LEGACY_RULE_FILE_NAME = "AGENTS.local.md";
+const ROVODEV_MCP_FILE_NAME = "mcp.json";
+const ROVODEV_CONFIG_FILE_NAME = "config.yml";
+const ROVODEV_AGENTS_SKILLS_DIR_PATH = join(".agents", "skills");
+const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
+const ROVODEV_PROMPTS_DIR_PATH = join(ROVODEV_DIR, "prompts");
+/**
+* Custom instructions for Rovo Dev's code reviews: a plain-Markdown file (no
+* frontmatter) in the repository root's `.rovodev/` folder. Note the leading
+* dot in the file name.
+* @see https://support.atlassian.com/rovo/docs/set-custom-instructions-for-code-reviews/
+*/
+const ROVODEV_REVIEW_AGENT_FILE_NAME = ".review-agent.md";
+//#endregion
 //#region src/constants/takt-paths.ts
 const TAKT_DIR = ".takt";
 const TAKT_FACETS_SUBDIR = "facets";
@@ -5759,12 +5827,19 @@ function slugifyCheckName(value) {
 	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/, "");
 }
 //#endregion
-//#region src/features/checks/cursor-check.ts
+//#region src/features/checks/aggregated-check-file.ts
 /**
-* Marks where one check starts inside the single instruction file. Bugbot reads
-* the file as prose, and an HTML comment is invisible in rendered Markdown, so
-* the marker carries the check identity without changing what Bugbot is told.
+* Shared machinery for the tools whose checks surface is **one aggregated
+* instruction file** rather than a file per check — Cursor Bugbot's
+* `.cursor/BUGBOT.md` and Rovo Dev's `.rovodev/.review-agent.md`.
+*
+* Both read the file as free prose, so the check identities have to be carried
+* in something invisible to the reader: an HTML-comment marker per section.
+* That marker convention, the escaping that keeps a check body from splitting
+* itself, and the import-side split are the same for both files, so they live
+* here once.
 */
+/** Marks where one check starts inside the single instruction file. */
 const CHECK_MARKER_PATTERN = /^<!--\s*rulesync:check:(.+?)\s*-->[ \t]*$/gm;
 /**
 * A marker line a check body wrote itself — a rulesync doc fragment quoted in a
@@ -5775,17 +5850,16 @@ const CHECK_MARKER_PATTERN = /^<!--\s*rulesync:check:(.+?)\s*-->[ \t]*$/gm;
 */
 const ESCAPABLE_MARKER_PATTERN = /^(<!--\s*rulesync:)((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
 const ESCAPED_MARKER_PATTERN = /^(<!--\s*rulesync:)literal-((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
-const FALLBACK_CHECK_NAME = "bugbot";
-function renderMarker(name) {
+function renderCheckMarker(name) {
 	return `<!-- rulesync:check:${name} -->`;
 }
-function escapeMarkers(content) {
+function escapeCheckMarkers(content) {
 	return content.replace(ESCAPABLE_MARKER_PATTERN, "$1literal-$2");
 }
-function unescapeMarkers(content) {
+function unescapeCheckMarkers(content) {
 	return content.replace(ESCAPED_MARKER_PATTERN, "$1$2");
 }
-function findMarkers(fileContent) {
+function findCheckMarkers(fileContent) {
 	CHECK_MARKER_PATTERN.lastIndex = 0;
 	const markers = [];
 	let match = CHECK_MARKER_PATTERN.exec(fileContent);
@@ -5800,23 +5874,47 @@ function findMarkers(fileContent) {
 	return markers;
 }
 /**
-* The instruction text one check contributes. Bugbot has no field to put a
-* summary in, so `description` is used only when there is no body — the same
-* fallback the file-stem heading above it gets.
+* Whether the file holds instruction text ahead of the first marker — the
+* question the "generating replaces this" warning asks. A file with no marker
+* at all is entirely hand-written, so it qualifies; an empty one does not,
+* since there is nothing to replace.
+*/
+function hasHandWrittenPreamble(fileContent) {
+	const firstMarkerStart = findCheckMarkers(fileContent)[0]?.start ?? fileContent.length;
+	return fileContent.slice(0, firstMarkerStart).trim().length > 0;
+}
+/**
+* Whether the file is nothing but sections rulesync generated — the question
+* the deletion guard asks, and a stricter one than
+* {@link hasHandWrittenPreamble}. A file carrying no marker at all is not
+* rulesync's to remove even when it is empty: rulesync never wrote it, so an
+* empty one is somebody's placeholder rather than our leftover.
+*/
+function isOnlyGeneratedSections(fileContent) {
+	const firstMarkerStart = findCheckMarkers(fileContent)[0]?.start;
+	if (firstMarkerStart === void 0) return false;
+	return fileContent.slice(0, firstMarkerStart).trim().length === 0;
+}
+/**
+* The instruction text one check contributes. Neither file has a field to put a
+* summary in, so `description` is used only when there is no body.
 */
 function toInstruction(rulesyncCheck) {
 	const body = rulesyncCheck.getBody().trim();
 	if (body.length > 0) return body;
 	return rulesyncCheck.getFrontmatter().description?.trim() ?? "";
 }
-function renderSection(rulesyncCheck) {
+function renderCheckSection(rulesyncCheck) {
 	const name = basename(rulesyncCheck.getRelativeFilePath(), ".md");
 	const heading = `## ${name}`;
 	const instruction = toInstruction(rulesyncCheck);
-	const lines = [renderMarker(name), heading];
-	if (instruction.length > 0) lines.push("", escapeMarkers(instruction));
+	const lines = [renderCheckMarker(name), heading];
+	if (instruction.length > 0) lines.push("", escapeCheckMarkers(instruction));
 	return lines.join("\n");
 }
+function renderCheckFile(rulesyncChecks) {
+	return `${rulesyncChecks.map(renderCheckSection).join("\n\n")}\n`;
+}
 /** Drop the heading generate writes, so a round trip does not stack headings. */
 function stripGeneratedHeading(section, name) {
 	const [firstLine, ...rest] = section.split("\n");
@@ -5824,6 +5922,53 @@ function stripGeneratedHeading(section, name) {
 	return section.trim();
 }
 /**
+* Split an aggregated instruction file back into one check per section.
+*
+* Content ahead of the first marker — and a hand-written file with no markers
+* at all — becomes a single check named `fallbackName`, so nothing in the file
+* is dropped.
+*/
+function splitCheckFile({ fileContent, fallbackName }) {
+	const sections = [];
+	const markers = findCheckMarkers(fileContent);
+	const preambleEnd = markers[0]?.start ?? fileContent.length;
+	const preamble = fileContent.slice(0, preambleEnd).trim();
+	if (preamble.length > 0) sections.push({
+		name: fallbackName,
+		content: unescapeCheckMarkers(preamble)
+	});
+	for (const [index, marker] of markers.entries()) {
+		const sectionEnd = markers[index + 1]?.start ?? fileContent.length;
+		const markerName = marker.name.trim();
+		const name = slugifyCheckName(markerName) || fallbackName;
+		const content = stripGeneratedHeading(fileContent.slice(marker.end, sectionEnd).trim(), markerName);
+		sections.push({
+			name,
+			content: unescapeCheckMarkers(content)
+		});
+	}
+	const used = /* @__PURE__ */ new Set();
+	return sections.map(({ name, content }) => {
+		let uniqueName = name;
+		let suffix = 2;
+		while (used.has(uniqueName)) {
+			uniqueName = `${name}-${suffix}`;
+			suffix += 1;
+		}
+		used.add(uniqueName);
+		return new RulesyncCheck({
+			outputRoot: ".",
+			relativeDirPath: RULESYNC_CHECKS_RELATIVE_DIR_PATH,
+			relativeFilePath: `${uniqueName}.md`,
+			frontmatter: { targets: ["*"] },
+			body: content
+		});
+	});
+}
+//#endregion
+//#region src/features/checks/cursor-check.ts
+const FALLBACK_CHECK_NAME$1 = "bugbot";
+/**
 * Checks adapter for Cursor Bugbot (`.cursor/BUGBOT.md`).
 *
 * Bugbot takes one aggregated instruction file per directory rather than a file
@@ -5880,9 +6025,7 @@ var CursorCheck = class CursorCheck extends ToolCheck {
 		const paths = CursorCheck.getSettablePaths();
 		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath ?? "BUGBOT.md"));
 		if (fileContent === null) return true;
-		const firstMarkerStart = findMarkers(fileContent)[0]?.start;
-		if (firstMarkerStart === void 0) return false;
-		return fileContent.slice(0, firstMarkerStart).trim().length === 0;
+		return isOnlyGeneratedSections(fileContent);
 	}
 	static fromRulesyncCheck(_params) {
 		throw new Error("Cursor checks are built from all checks at once; use fromRulesyncChecks.");
@@ -5892,10 +6035,8 @@ var CursorCheck = class CursorCheck extends ToolCheck {
 		const paths = CursorCheck.getSettablePaths({ global });
 		const relativeFilePath = paths.relativeFilePath ?? "BUGBOT.md";
 		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
-		const existingContent = await readFileContentOrNull(filePath) ?? "";
-		const firstMarkerStart = findMarkers(existingContent)[0]?.start ?? existingContent.length;
-		if (existingContent.slice(0, firstMarkerStart).trim().length > 0) logger?.warn(`Cursor checks: ${filePath} holds instructions rulesync did not write, and generating replaces the whole file. Run \`rulesync import --targets cursor --features checks\` first to keep them.`);
-		const fileContent = `${rulesyncChecks.map(renderSection).join("\n\n")}\n`;
+		if (hasHandWrittenPreamble(await readFileContentOrNull(filePath) ?? "")) logger?.warn(`Cursor checks: ${filePath} holds instructions rulesync did not write, and generating replaces the whole file. Run \`rulesync import --targets cursor --features checks\` first to keep them.`);
+		const fileContent = renderCheckFile(rulesyncChecks);
 		return [new CursorCheck({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -5938,41 +6079,9 @@ var CursorCheck = class CursorCheck extends ToolCheck {
 		return first;
 	}
 	toRulesyncChecks() {
-		const fileContent = this.getFileContent();
-		const sections = [];
-		const markers = findMarkers(fileContent);
-		const preambleEnd = markers[0]?.start ?? fileContent.length;
-		const preamble = fileContent.slice(0, preambleEnd).trim();
-		if (preamble.length > 0) sections.push({
-			name: FALLBACK_CHECK_NAME,
-			content: unescapeMarkers(preamble)
-		});
-		for (const [index, marker] of markers.entries()) {
-			const sectionEnd = markers[index + 1]?.start ?? fileContent.length;
-			const markerName = marker.name.trim();
-			const name = slugifyCheckName(markerName) || FALLBACK_CHECK_NAME;
-			const content = stripGeneratedHeading(fileContent.slice(marker.end, sectionEnd).trim(), markerName);
-			sections.push({
-				name,
-				content: unescapeMarkers(content)
-			});
-		}
-		const used = /* @__PURE__ */ new Set();
-		return sections.map(({ name, content }) => {
-			let uniqueName = name;
-			let suffix = 2;
-			while (used.has(uniqueName)) {
-				uniqueName = `${name}-${suffix}`;
-				suffix += 1;
-			}
-			used.add(uniqueName);
-			return new RulesyncCheck({
-				outputRoot: ".",
-				relativeDirPath: RULESYNC_CHECKS_RELATIVE_DIR_PATH,
-				relativeFilePath: `${uniqueName}.md`,
-				frontmatter: { targets: ["*"] },
-				body: content
-			});
+		return splitCheckFile({
+			fileContent: this.getFileContent(),
+			fallbackName: FALLBACK_CHECK_NAME$1
 		});
 	}
 };
@@ -5994,8 +6103,22 @@ var CursorCheck = class CursorCheck extends ToolCheck {
 */
 /** Project-root instruction file auto-injected by Hermes Agent. */
 const HERMESAGENT_RULE_FILE_NAME = ".hermes.md";
-/** Root directory for Hermes Agent global configuration (the HERMES_HOME dir). */
+/**
+* Root directory for Hermes Agent global configuration (the HERMES_HOME dir).
+* Also the project-local plugin tree, which is `.hermes/` on every platform.
+*/
 const HERMESAGENT_GLOBAL_DIR = ".hermes";
+/**
+* Home-relative global profile root on Windows: upstream defaults to
+* `%LOCALAPPDATA%\hermes` there, not `~/.hermes`.
+* Resolve it through `getHermesagentGlobalDir()` rather than reading it directly.
+*
+* Home-relative rather than read from `LOCALAPPDATA`, matching how every other
+* Windows global path in rulesync is spelled (`ZED_GLOBAL_WIN32_DIR`,
+* `WARP_WIN32_DIR`). A profile with `LOCALAPPDATA` redirected elsewhere is not
+* followed; those users should set `HERMES_HOME` explicitly.
+*/
+const HERMESAGENT_GLOBAL_WIN32_DIR = join("AppData", "Local", "hermes");
 /** MCP servers and other settings live in `config.yaml` under `~/.hermes/`. */
 const HERMESAGENT_CONFIG_FILE_NAME = "config.yaml";
 const HERMESAGENT_CONFIG_FILE_PATH = join(HERMESAGENT_GLOBAL_DIR, HERMESAGENT_CONFIG_FILE_NAME);
@@ -6218,6 +6341,114 @@ var HermesagentCheck = class HermesagentCheck extends ToolCheck {
 	}
 };
 //#endregion
+//#region src/features/checks/rovodev-check.ts
+const FALLBACK_CHECK_NAME = "review-agent";
+/**
+* Checks adapter for Rovo Dev CLI's code-review custom instructions
+* (`.rovodev/.review-agent.md`).
+*
+* Rovo Dev takes one plain-Markdown instruction file at the repository root's
+* `.rovodev/` folder — no frontmatter, and note the leading dot in the file
+* name. Like Cursor Bugbot it is a single aggregated file rather than a file
+* per check, so every `.rulesync/checks/*.md` targeting Rovo Dev collapses into
+* it via {@link fromRulesyncChecks}, with each check written as a marked
+* section (see `aggregated-check-file.ts` for the marker convention the two
+* adapters share).
+*
+* Rovo Dev reads the file as free prose, so a check's `severity` and `tools`
+* have no equivalent there: they are not written and do not come back on
+* import. Neither does `description` whenever the check also has a body.
+*
+* Project scope only — these are per-repository review instructions, and Rovo
+* Dev documents no user-level equivalent. (The `permissions` adapter for the
+* same tool is the opposite: global only.)
+*
+* @see https://support.atlassian.com/rovo/docs/set-custom-instructions-for-code-reviews/
+*/
+var RovodevCheck = class RovodevCheck extends ToolCheck {
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: ROVODEV_DIR,
+			relativeFilePath: ROVODEV_REVIEW_AGENT_FILE_NAME
+		};
+	}
+	static isTargetedByRulesyncCheck(rulesyncCheck) {
+		return this.isTargetedByRulesyncCheckDefault({
+			rulesyncCheck,
+			toolTarget: "rovodev"
+		});
+	}
+	/**
+	* Ownership guard the processor consults before it deletes anything for this
+	* tool. `.review-agent.md` is a file Rovo Dev's own documentation tells users
+	* to hand-write, so anything in it that rulesync did not write is not
+	* rulesync's to remove — dropping the last check targeting Rovo Dev must not
+	* take somebody's hand-written review instructions with it.
+	*/
+	static async canDeleteAuxiliaryFiles({ outputRoot }) {
+		const paths = RovodevCheck.getSettablePaths();
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath ?? ".review-agent.md"));
+		if (fileContent === null) return true;
+		return isOnlyGeneratedSections(fileContent);
+	}
+	static fromRulesyncCheck(_params) {
+		throw new Error("Rovo Dev checks are built from all checks at once; use fromRulesyncChecks.");
+	}
+	static async fromRulesyncChecks({ outputRoot = process.cwd(), rulesyncChecks, global = false, logger }) {
+		if (rulesyncChecks.length === 0) return [];
+		const paths = RovodevCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? ".review-agent.md";
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		if (hasHandWrittenPreamble(await readFileContentOrNull(filePath) ?? "")) logger?.warn(`Rovo Dev checks: ${filePath} holds instructions rulesync did not write, and generating replaces the whole file. Run \`rulesync import --targets rovodev --features checks\` first to keep them.`);
+		return [new RovodevCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent: renderCheckFile(rulesyncChecks),
+			global
+		})];
+	}
+	static async fromFile({ outputRoot = process.cwd(), global = false }) {
+		const paths = RovodevCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? ".review-agent.md";
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		return new RovodevCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent: await readFileContentOrNull(filePath) ?? "",
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new RovodevCheck({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncCheck() {
+		const first = this.toRulesyncChecks()[0];
+		if (!first) throw new Error(`No check instructions found in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}.`);
+		return first;
+	}
+	toRulesyncChecks() {
+		return splitCheckFile({
+			fileContent: this.getFileContent(),
+			fallbackName: FALLBACK_CHECK_NAME
+		});
+	}
+};
+//#endregion
 //#region src/constants/codexcli-paths.ts
 const CODEXCLI_DIR = ".codex";
 const CODEXCLI_PROMPTS_DIR_PATH = join(CODEXCLI_DIR, "prompts");
@@ -6330,11 +6561,14 @@ function mergeSharedConfigDeep({ base, patch }) {
 }
 const CLAUDE_SETTINGS_SHARED_FILE_KEY = ".claude/settings.json";
 const HERMES_CONFIG_SHARED_FILE_KEY = ".hermes/config.yaml";
+const HERMES_WIN32_CONFIG_SHARED_FILE_KEY = "AppData/Local/hermes/config.yaml";
+const HERMES_HOME_CONFIG_SHARED_FILE_KEY = "config.yaml";
 const TAKT_CONFIG_SHARED_FILE_KEY = ".takt/config.yaml";
 const CODEXCLI_CONFIG_SHARED_FILE_KEY = ".codex/config.toml";
 const GROKCLI_CONFIG_SHARED_FILE_KEY = ".grok/config.toml";
 const VIBE_CONFIG_SHARED_FILE_KEY = ".vibe/config.toml";
 const KIMI_CODE_CONFIG_SHARED_FILE_KEY = ".kimi-code/config.toml";
+const KIMI_CODE_HOME_CONFIG_SHARED_FILE_KEY = "config.toml";
 const REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY = "reasonix.toml";
 const REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY = ".reasonix/config.toml";
 /**
@@ -6358,6 +6592,65 @@ const sharedConfigFileKey = ({ relativeDirPath, relativeFilePath }) => {
 * lock-step with the writers derived from the processor registry, so an
 * undeclared writer fails CI instead of merging by accident.
 */
+/**
+* Hermes writes one `config.yaml`, but its global profile root has three
+* spellings (`~/.hermes`, the win32 `%LOCALAPPDATA%\hermes`, and `HERMES_HOME`
+* itself). They are the same file with the same owners, so the declaration is
+* written once and shared — a policy edit cannot land on one spelling only.
+*/
+const HERMES_CONFIG_DECLARATION = {
+	format: "yaml",
+	features: {
+		commands: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["plugins"]
+		},
+		subagents: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["plugins"]
+		},
+		mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["mcp_servers"]
+		},
+		hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		},
+		permissions: {
+			kind: "deep-merge",
+			replaceKeys: ["permissions"]
+		}
+	}
+};
+/**
+* Kimi Code's user config: hooks owns the flat `hooks` array; permissions owns
+* the ordered rule list and optional coarse default mode. `KIMI_CODE_HOME` can
+* name the profile directory itself, so the file has two spellings that share
+* one declaration — a policy edit cannot land on only one of them.
+*/
+const KIMI_CODE_CONFIG_DECLARATION = {
+	format: "toml",
+	invalidRootPolicy: "error",
+	features: {
+		hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		},
+		mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["mcp"]
+		},
+		permissions: {
+			kind: "replace-owned-keys",
+			ownedKeys: [
+				"permission",
+				"default_permission_mode",
+				"tools"
+			]
+		}
+	}
+};
 const SHARED_CONFIG_OWNERSHIP = {
 	[CLAUDE_SETTINGS_SHARED_FILE_KEY]: {
 		format: "json",
@@ -6376,31 +6669,9 @@ const SHARED_CONFIG_OWNERSHIP = {
 			}
 		}
 	},
-	[HERMES_CONFIG_SHARED_FILE_KEY]: {
-		format: "yaml",
-		features: {
-			commands: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["plugins"]
-			},
-			subagents: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["plugins"]
-			},
-			mcp: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["mcp_servers"]
-			},
-			hooks: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["hooks"]
-			},
-			permissions: {
-				kind: "deep-merge",
-				replaceKeys: ["permissions"]
-			}
-		}
-	},
+	[HERMES_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
+	[HERMES_WIN32_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
+	[HERMES_HOME_CONFIG_SHARED_FILE_KEY]: HERMES_CONFIG_DECLARATION,
 	[TAKT_CONFIG_SHARED_FILE_KEY]: {
 		format: "yaml",
 		invalidRootPolicy: "error",
@@ -6446,6 +6717,10 @@ const SHARED_CONFIG_OWNERSHIP = {
 	".config/zed/settings.json": {
 		format: "json",
 		features: {
+			ignore: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["private_files"]
+			},
 			mcp: {
 				kind: "replace-owned-keys",
 				ownedKeys: ["context_servers"]
@@ -6459,6 +6734,10 @@ const SHARED_CONFIG_OWNERSHIP = {
 	"AppData/Roaming/Zed/settings.json": {
 		format: "json",
 		features: {
+			ignore: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["private_files"]
+			},
 			mcp: {
 				kind: "replace-owned-keys",
 				ownedKeys: ["context_servers"]
@@ -6715,31 +6994,15 @@ const SHARED_CONFIG_OWNERSHIP = {
 			}
 		}
 	},
-	[KIMI_CODE_CONFIG_SHARED_FILE_KEY]: {
-		format: "toml",
-		invalidRootPolicy: "error",
-		features: {
-			hooks: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["hooks"]
-			},
-			mcp: {
-				kind: "replace-owned-keys",
-				ownedKeys: ["mcp"]
-			},
-			permissions: {
-				kind: "replace-owned-keys",
-				ownedKeys: [
-					"permission",
-					"default_permission_mode",
-					"tools"
-				]
-			}
-		}
-	},
+	[KIMI_CODE_CONFIG_SHARED_FILE_KEY]: KIMI_CODE_CONFIG_DECLARATION,
+	[KIMI_CODE_HOME_CONFIG_SHARED_FILE_KEY]: KIMI_CODE_CONFIG_DECLARATION,
 	[REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY]: {
 		format: "toml",
 		features: {
+			ignore: {
+				kind: "custom",
+				policyFunction: "applyIgnoreReadDenies"
+			},
 			mcp: {
 				kind: "replace-owned-keys",
 				ownedKeys: ["plugins"]
@@ -6757,6 +7020,10 @@ const SHARED_CONFIG_OWNERSHIP = {
 	[REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY]: {
 		format: "toml",
 		features: {
+			ignore: {
+				kind: "custom",
+				policyFunction: "applyIgnoreReadDenies"
+			},
 			mcp: {
 				kind: "replace-owned-keys",
 				ownedKeys: ["plugins"]
@@ -7201,6 +7468,13 @@ const toolCheckFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.json"
 		}
 	}],
+	["rovodev", {
+		class: RovodevCheck,
+		meta: {
+			supportsGlobal: false,
+			filePattern: ROVODEV_REVIEW_AGENT_FILE_NAME
+		}
+	}],
 	["takt", {
 		class: TaktCheck,
 		meta: {
@@ -7356,19 +7630,65 @@ var ChecksProcessor = class extends FeatureProcessor {
 	}
 };
 //#endregion
+//#region src/utils/tool-home.ts
+/**
+* Where the rulesync-side source files of a tool with a home override belong.
+*
+* A home override redirects the tool's OWN output, but the `.rulesync/` sources
+* imported back out of it are not part of the tool's profile — they stay under
+* the rulesync home. When no override is set, the native output root already is
+* that place.
+*/
+function getToolRulesyncOutputRoot({ nativeOutputRoot, global, toolHome }) {
+	return global && toolHome() ? getHomeDirectory() : nativeOutputRoot;
+}
+//#endregion
 //#region src/utils/hermesagent.ts
 function getHermesagentHome() {
 	const configuredHome = process.env.HERMES_HOME?.trim();
 	return configuredHome ? resolve(configuredHome) : void 0;
 }
+/**
+* The home-relative Hermes profile directory used when `HERMES_HOME` is unset.
+*
+* Upstream `_get_platform_default_hermes_home()` returns `%LOCALAPPDATA%\hermes`
+* on win32 and `~/.hermes` everywhere else, so the global output directory is
+* platform-dependent — a global generate on Windows that wrote `~/.hermes`
+* would land where Hermes never reads.
+*
+* @see https://github.com/NousResearch/hermes-agent `hermes_constants.py`
+*/
+function getHermesagentGlobalDir() {
+	return process.platform === "win32" ? HERMESAGENT_GLOBAL_WIN32_DIR : HERMESAGENT_GLOBAL_DIR;
+}
 function resolveHermesagentOutputRoot({ outputRoot, global }) {
 	return global ? getHermesagentHome() ?? outputRoot : outputRoot;
 }
+/**
+* Map a canonical `.hermes/...` path constant onto the directory rulesync
+* actually writes in the requested scope.
+*
+* Project scope keeps the constant as-is (the project tree is `.hermes/`
+* everywhere). Global scope strips the `.hermes` prefix and re-anchors it:
+* `HERMES_HOME` *is* the profile root, so nothing is prepended; otherwise the
+* platform default directory takes its place.
+*/
 function getHermesagentRelativeDirPath({ global, relativeDirPath }) {
-	if (!global || !getHermesagentHome()) return relativeDirPath;
+	if (!global) return relativeDirPath;
 	const relativePath = relative(HERMESAGENT_GLOBAL_DIR, relativeDirPath);
-	if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) throw new Error(`Hermes Agent global path must be within ${HERMESAGENT_GLOBAL_DIR}: ${relativeDirPath}`);
-	return relativePath;
+	try {
+		checkPathTraversal({
+			relativePath: relativeDirPath,
+			intendedRootDir: "."
+		});
+		checkPathTraversal({
+			relativePath,
+			intendedRootDir: HERMESAGENT_GLOBAL_DIR
+		});
+	} catch {
+		throw new Error(`Hermes Agent global path must be within ${HERMESAGENT_GLOBAL_DIR}: ${relativeDirPath}`);
+	}
+	return getHermesagentHome() ? relativePath || "." : join(getHermesagentGlobalDir(), relativePath);
 }
 function getHermesagentRelativeFilePath({ global, relativeFilePath }) {
 	return join(getHermesagentRelativeDirPath({
@@ -7376,8 +7696,53 @@ function getHermesagentRelativeFilePath({ global, relativeFilePath }) {
 		relativeDirPath: dirname(relativeFilePath)
 	}), basename(relativeFilePath));
 }
+/**
+* Every spelling `config.yaml` can take in global scope, so that the
+* shared-write derivation and the gateway ownership table it is checked against
+* see the same set of keys on every platform and with or without `HERMES_HOME`.
+*
+* `getHermesagentRelativeDirPath` resolves exactly one of these per process,
+* which would otherwise make the derived shared-file key depend on the ambient
+* environment — the drift guards would then go blind in precisely the
+* configuration this feature exists for.
+*/
+function getHermesagentSharedConfigWritePaths() {
+	return [
+		{
+			relativeDirPath: HERMESAGENT_GLOBAL_DIR,
+			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
+		},
+		{
+			relativeDirPath: HERMESAGENT_GLOBAL_WIN32_DIR,
+			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
+		},
+		{
+			relativeDirPath: ".",
+			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
+		}
+	];
+}
+/**
+* The `SHARED_CONFIG_OWNERSHIP` key of the `config.yaml` this scope actually
+* writes. All three spellings carry the same declaration, but passing the key of
+* the file being written keeps the write path and the drift guards reading the
+* same entry.
+*/
+function getHermesagentConfigSharedFileKey({ global }) {
+	return sharedConfigFileKey({
+		relativeDirPath: getHermesagentRelativeDirPath({
+			global,
+			relativeDirPath: HERMESAGENT_GLOBAL_DIR
+		}),
+		relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
+	});
+}
 function getHermesagentRulesyncOutputRoot({ nativeOutputRoot, global }) {
-	return global && getHermesagentHome() ? getHomeDirectory() : nativeOutputRoot;
+	return getToolRulesyncOutputRoot({
+		nativeOutputRoot,
+		global,
+		toolHome: getHermesagentHome
+	});
 }
 //#endregion
 //#region src/constants/agentsmd-paths.ts
@@ -9081,6 +9446,223 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/grokcli-paths.ts
+/**
+* Grok Build CLI (xAI) configuration-layout conventions.
+*
+* Single source of truth for where Grok Build expects its files. Grok Build
+* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
+* with project/global scopes resolved by the directory the CLI runs in
+* (`./.grok/config.toml` vs `~/.grok/config.toml`).
+*
+* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
+* `-s project` writes `./.grok/config.toml`, `-s user` writes
+* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
+* @see https://docs.x.ai/build/overview
+*/
+/** Root directory for Grok Build configuration, relative to the scope root. */
+const GROKCLI_DIR = ".grok";
+/** MCP servers and other settings live in `config.toml` under `.grok/`. */
+const GROKCLI_MCP_FILE_NAME = "config.toml";
+/**
+* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
+* permission mode, and other settings all live here; permissions reuse the same
+* file name as MCP since Grok consolidates everything into one config.
+*/
+const GROKCLI_CONFIG_FILE_NAME = "config.toml";
+/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
+const GROKCLI_SKILLS_DIR_PATH = join(GROKCLI_DIR, "skills");
+/**
+* Hooks directory under `.grok/`. Grok Build discovers hook config files from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global), each a
+* standalone JSON file using the Claude-Code-compatible nested `{ hooks: { … } }`
+* shape. rulesync writes all its hooks into a single `rulesync.json`.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const GROKCLI_HOOKS_DIR_PATH = join(GROKCLI_DIR, "hooks");
+/** rulesync-managed Grok hooks file under `.grok/hooks/`. */
+const GROKCLI_HOOKS_FILE_NAME = "rulesync.json";
+/**
+* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
+* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
+* (global), each a Markdown file with YAML frontmatter (verified via
+* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
+*/
+const GROKCLI_AGENTS_DIR_PATH = join(GROKCLI_DIR, "agents");
+/**
+* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
+* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
+* `grok inspect`, consistent with the `.grok/` global discovery used by the
+* MCP/skills/subagents adapters).
+*/
+const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
+/**
+* Custom slash commands directory. Grok's `find_command_paths` scans
+* `commands/*.md` under every discovered config dir — `.grok/commands/`
+* (project, walked from cwd up to the git root) and `~/.grok/commands/`
+* (global). The scan is **flat and non-recursive**, so subdirectory
+* namespacing (`git/commit.md` → `/git:commit`) is not supported the way it is
+* for Claude Code.
+*
+* Skills are collected before commands and win name collisions, so a
+* `.grok/skills/<name>/` shadows `.grok/commands/<name>.md`.
+* @see https://docs.x.ai/build/features/skills-plugins-marketplaces
+*/
+const GROKCLI_COMMANDS_DIR_PATH = join(GROKCLI_DIR, "commands");
+/**
+* Non-root rules directory. Grok scans `*.md` here — flat, sorted by name —
+* alongside the AGENTS.md family: `.grok/rules/` in each project directory it
+* walks, and `~/.grok/rules/` in the home scope.
+* @see https://docs.x.ai/build/overview
+*/
+const GROKCLI_RULES_DIR_PATH = join(GROKCLI_DIR, "rules");
+//#endregion
+//#region src/features/commands/grokcli-command.ts
+/**
+* Grok CLI custom slash commands are Markdown files under `.grok/commands/`
+* (project) / `~/.grok/commands/` (global), discovered by the same
+* Claude-Code-compatible frontmatter parser Grok uses for skills.
+*
+* Two upstream constraints shape this adapter:
+*
+* - The scan is **flat and non-recursive**, so nested namespacing is not
+*   modelled (`supportsSubdirectory: false` flattens nested rulesync commands
+*   onto their basename).
+* - Skills are collected before commands and win name collisions, so a
+*   `.grok/skills/<name>/` shadows `.grok/commands/<name>.md`.
+*
+* `description` and `argument-hint` describe the command, while
+* `user-invocable` (default true) and `disable-model-invocation` (default
+* false) control who may invoke it — the same pair `GrokcliSkill` emits.
+* @see https://docs.x.ai/build/features/skills-plugins-marketplaces
+*/
+const GrokcliCommandFrontmatterSchema = z.looseObject({
+	description: z.optional(z.string()),
+	"argument-hint": z.optional(z.string()),
+	"user-invocable": z.optional(z.boolean()),
+	"disable-model-invocation": z.optional(z.boolean())
+});
+var GrokcliCommand = class GrokcliCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = GrokcliCommandFrontmatterSchema.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)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: GROKCLI_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 && { grokcli: restFields }
+		};
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: stringifyFrontmatter(this.body, rulesyncFrontmatter),
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const grokcliFields = rulesyncFrontmatter.grokcli ?? {};
+		const grokcliFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...grokcliFields
+		};
+		const paths = this.getSettablePaths({ global });
+		return new GrokcliCommand({
+			outputRoot,
+			frontmatter: grokcliFrontmatter,
+			body: rulesyncCommand.getBody(),
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = GrokcliCommandFrontmatterSchema.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: "grokcli"
+		});
+	}
+	/**
+	* Warn when a rulesync skill would shadow a rulesync command.
+	*
+	* Grok collects skills before commands and lets skills win name collisions,
+	* so `.grok/skills/<name>/` makes `.grok/commands/<name>.md` unreachable.
+	* Both files are still written correctly — nothing is overwritten and no
+	* output is lost — so this warns rather than failing the run the way the
+	* Hermes check does, where the two surfaces really do write the same path.
+	*/
+	static async validateRulesyncCommands({ inputRoot, rulesyncCommands, logger }) {
+		const commandNames = new Set(rulesyncCommands.filter((command) => this.isTargetedByRulesyncCommand(command)).map((command) => basename(command.getRelativeFilePath(), ".md")));
+		if (commandNames.size === 0) return;
+		const shadowed = (await findFilesByGlobs(join(join(inputRoot, RULESYNC_SKILLS_RELATIVE_DIR_PATH), "**", "SKILL.md"))).map((filePath) => basename(dirname(filePath))).filter((skillName) => commandNames.has(skillName));
+		if (shadowed.length > 0) logger.warn(`Grok CLI resolves skills before commands, so these skills shadow the same-named commands, which will never be reachable: ${[...new Set(shadowed)].toSorted().join(", ")}. Rename either side to make both invocable.`);
+	}
+	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: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = GrokcliCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new GrokcliCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new GrokcliCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/skills/tool-skill.ts
 /** Ordered skill directory roots: primary first. */
 function toolSkillSearchRoots(paths) {
@@ -9715,7 +10297,7 @@ def register(ctx):
         _register_command(ctx, command)
 `;
 }
-function getEnabledPluginConfigContent$1(currentContent) {
+function getEnabledPluginConfigContent$1({ currentContent, global }) {
 	const config = parseSharedConfig({
 		format: "yaml",
 		fileContent: currentContent
@@ -9723,7 +10305,7 @@ function getEnabledPluginConfigContent$1(currentContent) {
 	const plugins = config.plugins && typeof config.plugins === "object" ? config.plugins : {};
 	const enabled = Array.isArray(plugins.enabled) ? plugins.enabled : [];
 	return applySharedConfigPatch({
-		fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+		fileKey: getHermesagentConfigSharedFileKey({ global }),
 		feature: "commands",
 		existingContent: currentContent,
 		patch: { plugins: {
@@ -9732,7 +10314,7 @@ function getEnabledPluginConfigContent$1(currentContent) {
 		} }
 	});
 }
-function getDisabledHermesCommandsPluginConfigContent(currentContent) {
+function getDisabledHermesCommandsPluginConfigContent({ currentContent, global }) {
 	const config = parseSharedConfig({
 		format: "yaml",
 		fileContent: currentContent
@@ -9740,7 +10322,7 @@ function getDisabledHermesCommandsPluginConfigContent(currentContent) {
 	const plugins = config.plugins && typeof config.plugins === "object" ? config.plugins : {};
 	const enabled = Array.isArray(plugins.enabled) ? plugins.enabled : [];
 	return applySharedConfigPatch({
-		fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+		fileKey: getHermesagentConfigSharedFileKey({ global }),
 		feature: "commands",
 		existingContent: currentContent,
 		patch: { plugins: {
@@ -9756,35 +10338,36 @@ var HermesagentCommandAuxiliaryFile = class extends ToolFile {
 			error: null
 		};
 	}
-	shouldMergeExistingFileContent() {
+	/**
+	* Whether this auxiliary file is the one at `relativeFilePath`, comparing
+	* against the scope-resolved location of that canonical `.hermes/...` path.
+	*/
+	matchesPath(relativeFilePath) {
 		return this.getRelativePathFromCwd() === toPosixPath(getHermesagentRelativeFilePath({
 			global: this.global,
-			relativeFilePath: HERMESAGENT_CONFIG_FILE_PATH
+			relativeFilePath
 		}));
 	}
+	shouldMergeExistingFileContent() {
+		return this.matchesPath(HERMESAGENT_CONFIG_FILE_PATH);
+	}
 	setFileContent(newFileContent) {
-		if (this.getRelativePathFromCwd() === toPosixPath(getHermesagentRelativeFilePath({
-			global: this.global,
-			relativeFilePath: HERMESAGENT_CONFIG_FILE_PATH
-		}))) {
-			super.setFileContent(getEnabledPluginConfigContent$1(newFileContent));
+		if (this.matchesPath(HERMESAGENT_CONFIG_FILE_PATH)) {
+			super.setFileContent(getEnabledPluginConfigContent$1({
+				currentContent: newFileContent,
+				global: this.global
+			}));
 			return;
 		}
 		super.setFileContent(newFileContent);
 	}
 	getFileContent() {
-		if (this.getRelativePathFromCwd() === toPosixPath(getHermesagentRelativeFilePath({
-			global: this.global,
-			relativeFilePath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_MANIFEST_PATH
-		}))) return getPluginManifestContent$2();
-		if (this.getRelativePathFromCwd() === toPosixPath(getHermesagentRelativeFilePath({
-			global: this.global,
-			relativeFilePath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_INIT_PATH
-		}))) return getPluginInitContent$2();
-		if (this.getRelativePathFromCwd() === toPosixPath(getHermesagentRelativeFilePath({
-			global: this.global,
-			relativeFilePath: HERMESAGENT_CONFIG_FILE_PATH
-		}))) return getEnabledPluginConfigContent$1(super.getFileContent());
+		if (this.matchesPath(HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_MANIFEST_PATH)) return getPluginManifestContent$2();
+		if (this.matchesPath(HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_INIT_PATH)) return getPluginInitContent$2();
+		if (this.matchesPath(HERMESAGENT_CONFIG_FILE_PATH)) return getEnabledPluginConfigContent$1({
+			currentContent: super.getFileContent(),
+			global: this.global
+		});
 		return super.getFileContent();
 	}
 };
@@ -9801,14 +10384,12 @@ var HermesagentCommand = class HermesagentCommand extends ToolCommand {
 			relativeDirPath: HERMESAGENT_RULESYNC_COMMANDS_DIR_PATH
 		}) };
 	}
-	static getExtraSharedWritePaths({ global = false } = {}) {
-		return [{
-			relativeDirPath: getHermesagentRelativeDirPath({
-				global,
-				relativeDirPath: HERMESAGENT_GLOBAL_DIR
-			}),
-			relativeFilePath: basename(HERMESAGENT_CONFIG_FILE_PATH)
-		}];
+	/**
+	* `config.yaml` under every spelling the global profile root can take.
+	* @see getHermesagentSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getHermesagentSharedConfigWritePaths();
 	}
 	static async validateRulesyncCommands({ inputRoot, rulesyncCommands }) {
 		const commandSlugs = /* @__PURE__ */ new Set();
@@ -9833,33 +10414,28 @@ var HermesagentCommand = class HermesagentCommand extends ToolCommand {
 	}
 	static async getAuxiliaryFiles({ toolCommands, outputRoot, global = false, forDeletion = false }) {
 		if (toolCommands.length === 0 && !forDeletion) return [];
+		const pluginDirPath = getHermesagentRelativeDirPath({
+			global,
+			relativeDirPath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_DIR_PATH
+		});
 		const pluginFiles = [
 			new HermesagentCommandAuxiliaryFile({
 				outputRoot,
-				relativeDirPath: getHermesagentRelativeDirPath({
-					global,
-					relativeDirPath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_DIR_PATH
-				}),
+				relativeDirPath: pluginDirPath,
 				relativeFilePath: basename(HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_MANIFEST_PATH),
 				fileContent: "",
 				global
 			}),
 			new HermesagentCommandAuxiliaryFile({
 				outputRoot,
-				relativeDirPath: getHermesagentRelativeDirPath({
-					global,
-					relativeDirPath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_DIR_PATH
-				}),
+				relativeDirPath: pluginDirPath,
 				relativeFilePath: basename(HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_OWNERSHIP_PATH),
 				fileContent: "Generated and owned by RuleSync.\n",
 				global
 			}),
 			new HermesagentCommandAuxiliaryFile({
 				outputRoot,
-				relativeDirPath: getHermesagentRelativeDirPath({
-					global,
-					relativeDirPath: HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_DIR_PATH
-				}),
+				relativeDirPath: pluginDirPath,
 				relativeFilePath: basename(HERMESAGENT_RULESYNC_COMMANDS_PLUGIN_INIT_PATH),
 				fileContent: "",
 				global
@@ -11094,19 +11670,6 @@ var RooCommand = class RooCommand extends ToolCommand {
 	}
 };
 //#endregion
-//#region src/constants/rovodev-paths.ts
-const ROVODEV_DIR = ".rovodev";
-const ROVODEV_SKILLS_DIR_PATH = join(ROVODEV_DIR, "skills");
-const ROVODEV_SUBAGENTS_DIR_PATH = join(ROVODEV_DIR, "subagents");
-const ROVODEV_MODULAR_RULES_DIR_PATH = join(ROVODEV_DIR, ".rulesync", "modular-rules");
-const ROVODEV_RULE_FILE_NAME = "AGENTS.md";
-const ROVODEV_LEGACY_RULE_FILE_NAME = "AGENTS.local.md";
-const ROVODEV_MCP_FILE_NAME = "mcp.json";
-const ROVODEV_CONFIG_FILE_NAME = "config.yml";
-const ROVODEV_AGENTS_SKILLS_DIR_PATH = join(".agents", "skills");
-const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
-const ROVODEV_PROMPTS_DIR_PATH = join(ROVODEV_DIR, "prompts");
-//#endregion
 //#region src/features/commands/rovodev-command.ts
 /**
 * Rovo Dev CLI "saved prompts": a file-based custom-command surface made of a
@@ -11690,6 +12253,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["grokcli", {
+		class: GrokcliCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: false
+		}
+	}],
 	["hermesagent", {
 		class: HermesagentCommand,
 		meta: {
@@ -11883,7 +12456,8 @@ var CommandsProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		await factory.class.validateRulesyncCommands?.({
 			inputRoot: this.inputRoot,
-			rulesyncCommands
+			rulesyncCommands,
+			logger: this.logger
 		});
 		const flattenedPathOrigins = /* @__PURE__ */ new Map();
 		const toolCommands = rulesyncCommands.map((rulesyncCommand) => {
@@ -12021,7 +12595,10 @@ var CommandsProcessor = class extends FeatureProcessor {
 		}));
 		const currentContent = await readFileContentOrNull(configPath);
 		if (currentContent === null) return changedCount;
-		const nextContent = getDisabledHermesCommandsPluginConfigContent(currentContent);
+		const nextContent = getDisabledHermesCommandsPluginConfigContent({
+			currentContent,
+			global: this.global
+		});
 		if (nextContent === currentContent) return changedCount;
 		if (this.dryRun) this.logger.info(`[DRY RUN] Would write: ${configPath}`);
 		else await writeFileContent(configPath, nextContent);
@@ -14483,64 +15060,6 @@ var GooseHooks = class GooseHooks extends ToolHooks {
 	}
 };
 //#endregion
-//#region src/constants/grokcli-paths.ts
-/**
-* Grok Build CLI (xAI) configuration-layout conventions.
-*
-* Single source of truth for where Grok Build expects its files. Grok Build
-* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
-* with project/global scopes resolved by the directory the CLI runs in
-* (`./.grok/config.toml` vs `~/.grok/config.toml`).
-*
-* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
-* `-s project` writes `./.grok/config.toml`, `-s user` writes
-* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
-* @see https://docs.x.ai/build/overview
-*/
-/** Root directory for Grok Build configuration, relative to the scope root. */
-const GROKCLI_DIR = ".grok";
-/** MCP servers and other settings live in `config.toml` under `.grok/`. */
-const GROKCLI_MCP_FILE_NAME = "config.toml";
-/**
-* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
-* permission mode, and other settings all live here; permissions reuse the same
-* file name as MCP since Grok consolidates everything into one config.
-*/
-const GROKCLI_CONFIG_FILE_NAME = "config.toml";
-/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
-const GROKCLI_SKILLS_DIR_PATH = join(GROKCLI_DIR, "skills");
-/**
-* Hooks directory under `.grok/`. Grok Build discovers hook config files from
-* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global), each a
-* standalone JSON file using the Claude-Code-compatible nested `{ hooks: { … } }`
-* shape. rulesync writes all its hooks into a single `rulesync.json`.
-* @see https://docs.x.ai/build/features/hooks
-*/
-const GROKCLI_HOOKS_DIR_PATH = join(GROKCLI_DIR, "hooks");
-/** rulesync-managed Grok hooks file under `.grok/hooks/`. */
-const GROKCLI_HOOKS_FILE_NAME = "rulesync.json";
-/**
-* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
-* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
-* (global), each a Markdown file with YAML frontmatter (verified via
-* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
-*/
-const GROKCLI_AGENTS_DIR_PATH = join(GROKCLI_DIR, "agents");
-/**
-* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
-* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
-* `grok inspect`, consistent with the `.grok/` global discovery used by the
-* MCP/skills/subagents adapters).
-*/
-const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
-/**
-* Non-root rules directory. Grok scans `*.md` here — flat, sorted by name —
-* alongside the AGENTS.md family: `.grok/rules/` in each project directory it
-* walks, and `~/.grok/rules/` in the home scope.
-* @see https://docs.x.ai/build/overview
-*/
-const GROKCLI_RULES_DIR_PATH = join(GROKCLI_DIR, "rules");
-//#endregion
 //#region src/features/hooks/grokcli-hooks.ts
 const GROKCLI_CONVERTER_CONFIG = {
 	supportedEvents: GROKCLI_HOOK_EVENTS,
@@ -14786,6 +15305,13 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
 		};
 	}
+	/**
+	* `config.yaml` under every spelling the global profile root can take.
+	* @see getHermesagentSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getHermesagentSharedConfigWritePaths();
+	}
 	constructor(params) {
 		super({
 			...params,
@@ -14823,7 +15349,7 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 	}
 	setFileContent(fileContent) {
 		this.fileContent = applySharedConfigPatch({
-			fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+			fileKey: getHermesagentConfigSharedFileKey({ global: this.global }),
 			feature: "hooks",
 			existingContent: fileContent,
 			patch: parseSharedConfig({
@@ -15199,8 +15725,38 @@ function getKimiCodeHome() {
 function getKimiCodeRelativeDirPath({ global, relativeDirPath = "." }) {
 	return global && getKimiCodeHome() ? relativeDirPath : join(KIMI_CODE_DIR, relativeDirPath);
 }
+/**
+* Both spellings the shared user `config.toml` can take: under `.kimi-code/`,
+* or at the root of `KIMI_CODE_HOME` when that override names the profile dir.
+* Declared unconditionally so the derived shared-file keys — and the drift
+* guards checked against them — do not depend on the ambient environment.
+*/
+function getKimiCodeSharedConfigWritePaths() {
+	return [{
+		relativeDirPath: KIMI_CODE_DIR,
+		relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
+	}, {
+		relativeDirPath: ".",
+		relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
+	}];
+}
+/**
+* The `SHARED_CONFIG_OWNERSHIP` key of the `config.toml` actually being written.
+* Both spellings carry the same declaration, but passing the key of the file
+* being written keeps the write path and the drift guards on the same entry.
+*/
+function getKimiCodeConfigSharedFileKey({ global }) {
+	return sharedConfigFileKey({
+		relativeDirPath: getKimiCodeRelativeDirPath({ global }),
+		relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
+	});
+}
 function getKimiCodeRulesyncOutputRoot({ nativeOutputRoot, global }) {
-	return global && getKimiCodeHome() ? getHomeDirectory() : nativeOutputRoot;
+	return getToolRulesyncOutputRoot({
+		nativeOutputRoot,
+		global,
+		toolHome: getKimiCodeHome
+	});
 }
 //#endregion
 //#region src/features/hooks/kimi-code-hooks.ts
@@ -15298,13 +15854,20 @@ var KimiCodeHooks = class KimiCodeHooks extends ToolHooks {
 	isDeletable() {
 		return false;
 	}
+	/**
+	* `config.toml` under both spellings its directory can take.
+	* @see getKimiCodeSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getKimiCodeSharedConfigWritePaths();
+	}
 	shouldMergeExistingFileContent() {
 		return true;
 	}
 	setFileContent(fileContent) {
 		const paths = KimiCodeHooks.getSettablePaths({ global: this.global });
 		this.fileContent = applySharedConfigPatch({
-			fileKey: KIMI_CODE_CONFIG_SHARED_FILE_KEY,
+			fileKey: getKimiCodeConfigSharedFileKey({ global: this.global }),
 			feature: "hooks",
 			existingContent: fileContent,
 			patch: parseSharedConfig({
@@ -17995,6 +18558,151 @@ var QwencodeIgnore = class QwencodeIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/shared/reasonix-config-table.ts
+/**
+* Shape-narrowing helpers for the Reasonix TOML config (`reasonix.toml` /
+* `~/.reasonix/config.toml`), shared by the features that read-modify-write it.
+*
+* TOML is only structurally validated on parse, so a hand-edited config can
+* hold any type under `permissions` or inside `allow`/`ask`/`deny`. Both the
+* `permissions` and `ignore` adapters have to narrow the same two shapes
+* before merging, so the narrowing lives here once rather than being re-spelled
+* (and re-diverging) per feature.
+*/
+/** Keep only the string entries of a TOML array; anything else becomes `[]`. */
+function toReasonixStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string");
+}
+/** Copy a TOML table; a non-table (scalar, array, missing) becomes `{}`. */
+function toReasonixTable(value) {
+	if (!isPlainObject$1(value)) return {};
+	return { ...value };
+}
+//#endregion
+//#region src/features/ignore/reasonix-ignore.ts
+const permissionsTableOf = (document) => toReasonixTable(document.permissions);
+/**
+* Reshape the parsed TOML document into the `permissions.allow/ask/deny` shape
+* {@link applyIgnoreReadDenies} operates on. Reasonix's `[permissions]` table
+* is Claude-Code-shaped (SPEC.md §3.7), so the entry-level ownership rule the
+* gateway already implements applies verbatim; only the surrounding file
+* format differs. Sibling keys such as `mode` pass through untouched.
+*/
+const asClaudeStyleSettings = (document) => {
+	const table = permissionsTableOf(document);
+	return {
+		...document,
+		permissions: {
+			...table,
+			allow: toReasonixStringArray(table.allow),
+			ask: toReasonixStringArray(table.ask),
+			deny: toReasonixStringArray(table.deny)
+		}
+	};
+};
+/**
+* Drop a `[permissions]` table that ended up with nothing in it, so an empty
+* `.rulesyncignore` does not add a bare table header to a file that never had
+* one.
+*/
+const withoutEmptyPermissions = (settings) => {
+	const document = { ...settings };
+	const permissions = document.permissions;
+	if (isPlainObject$1(permissions) && Object.keys(permissions).length === 0) delete document.permissions;
+	return document;
+};
+/**
+* Writes `.rulesyncignore` patterns as `Read(<pattern>)` entries in the
+* `[permissions] deny` table of `reasonix.toml` (project) /
+* `~/.reasonix/config.toml` (global).
+*
+* `deny` is the right target rather than `[sandbox] forbid_read`: deny rules
+* take glob specifiers (`Edit(docs/**)`) and are "a hard block in every mode",
+* while `forbid_read` is documented as absolute paths with no glob support.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/SPEC.md
+*/
+var ReasonixIgnore = class ReasonixIgnore extends ToolIgnore {
+	constructor(params) {
+		super(params);
+		const document = parseSharedConfig({
+			format: "toml",
+			fileContent: this.fileContent
+		});
+		this.patterns = toReasonixStringArray(permissionsTableOf(document).deny);
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: global ? REASONIX_GLOBAL_DIR : ".",
+			relativeFilePath: global ? REASONIX_GLOBAL_PERMISSIONS_FILE_NAME : REASONIX_PROJECT_PERMISSIONS_FILE_NAME
+		};
+	}
+	/**
+	* The config file also carries `[[plugins]]`, `[permissions]` rules from the
+	* permissions feature and user-authored tables, so rulesync must never
+	* delete it.
+	*/
+	isDeletable() {
+		return false;
+	}
+	toRulesyncIgnore() {
+		const rulesyncPatterns = this.patterns.filter((pattern) => isReadDenyEntry(pattern)).map((pattern) => pattern.slice(5, -1)).filter((pattern) => pattern.length > 0);
+		return new RulesyncIgnore({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RulesyncIgnore.getSettablePaths().recommended.relativeDirPath,
+			relativeFilePath: RulesyncIgnore.getSettablePaths().recommended.relativeFilePath,
+			fileContent: rulesyncPatterns.join("\n")
+		});
+	}
+	static async fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore, global = false }) {
+		const readDenies = rulesyncIgnore.getFileContent().split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map((pattern) => buildReadDenyEntry(pattern));
+		const paths = this.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingDocument = parseSharedConfig({
+			format: "toml",
+			fileContent: await readFileContentOrNull(filePath) ?? "",
+			filePath
+		});
+		const document = withoutEmptyPermissions(applyIgnoreReadDenies({
+			settings: asClaudeStyleSettings(existingDocument),
+			readDenies
+		}));
+		return new ReasonixIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: stringifySharedConfig({
+				format: "toml",
+				document
+			}),
+			validate: true,
+			global
+		});
+	}
+	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 ReasonixIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new ReasonixIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/roo-ignore.ts
 /**
 * RooIgnore represents ignore patterns for the Roo Code AI coding assistant.
@@ -18152,6 +18860,14 @@ const ZED_GLOBAL_WIN32_DIR = join("AppData", "Roaming", "Zed");
 function getZedGlobalDir() {
 	return process.platform === "win32" ? ZED_GLOBAL_WIN32_DIR : ZED_GLOBAL_DIR;
 }
+/**
+* The global config dir of the OTHER platform. `getZedGlobalDir()` resolves one
+* spelling per platform, but the shared-write derivation (and the gateway
+* ownership table it is checked against) must know both on every platform.
+*/
+function getZedOtherPlatformGlobalDir() {
+	return process.platform === "win32" ? ZED_GLOBAL_DIR : ZED_GLOBAL_WIN32_DIR;
+}
 const ZED_SETTINGS_FILE_NAME = "settings.json";
 const ZED_RULE_FILE_NAME = ".rules";
 const ZED_GLOBAL_RULE_FILE_NAME = "AGENTS.md";
@@ -18164,12 +18880,20 @@ var ZedIgnore = class ZedIgnore extends ToolIgnore {
 		const jsonValue = JSON.parse(this.fileContent);
 		this.patterns = jsonValue.private_files ?? [];
 	}
-	static getSettablePaths() {
+	static getSettablePaths({ global = false } = {}) {
 		return {
-			relativeDirPath: ZED_DIR,
+			relativeDirPath: global ? getZedGlobalDir() : ZED_DIR,
 			relativeFilePath: ZED_SETTINGS_FILE_NAME
 		};
 	}
+	/** @see getZedOtherPlatformGlobalDir */
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		if (!global) return [];
+		return [{
+			relativeDirPath: getZedOtherPlatformGlobalDir(),
+			relativeFilePath: ZED_SETTINGS_FILE_NAME
+		}];
+	}
 	/**
 	* ZedIgnore uses settings.json which is a user-managed config file.
 	* It should not be deleted by rulesync.
@@ -18180,48 +18904,53 @@ var ZedIgnore = class ZedIgnore extends ToolIgnore {
 	toRulesyncIgnore() {
 		const fileContent = this.patterns.filter((pattern) => pattern.length > 0).join("\n");
 		return new RulesyncIgnore({
-			outputRoot: this.outputRoot,
+			outputRoot: ".",
 			relativeDirPath: RulesyncIgnore.getSettablePaths().recommended.relativeDirPath,
 			relativeFilePath: RulesyncIgnore.getSettablePaths().recommended.relativeFilePath,
 			fileContent
 		});
 	}
-	static async fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore }) {
+	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 filePath = join(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath);
+		const paths = this.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingFileContent = await fileExists(filePath) ? await readFileContent(filePath) : "{}";
-		const mergedPatterns = uniq([...JSON.parse(existingFileContent).private_files ?? [], ...patterns].toSorted());
+		const managedPatterns = patterns.length > 0 ? [...new Set(patterns)].toSorted() : void 0;
 		return new ZedIgnore({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
 			fileContent: applySharedConfigPatch({
-				fileKey: sharedConfigFileKey(this.getSettablePaths()),
+				fileKey: sharedConfigFileKey(paths),
 				feature: "ignore",
 				existingContent: existingFileContent,
-				patch: { private_files: mergedPatterns },
+				patch: { private_files: managedPatterns },
 				filePath
 			}),
-			validate: true
+			validate: true,
+			global
 		});
 	}
-	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
-		const fileContent = await readFileContent(join(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath));
+	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 ZedIgnore({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		return new ZedIgnore({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "{}",
-			validate: false
+			validate: false,
+			global
 		});
 	}
 };
@@ -18243,6 +18972,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["kiro-cli", { class: KiroIgnore }],
 	["kiro-ide", { class: KiroIgnore }],
 	["qwencode", { class: QwencodeIgnore }],
+	["reasonix", { class: ReasonixIgnore }],
 	["roo", { class: RooIgnore }],
 	["devin", { class: DevinIgnore }],
 	["vibe", { class: VibeIgnore }],
@@ -18253,7 +18983,9 @@ const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
 const ignoreProcessorGlobalToolTargets = [
 	"kiro",
 	"kiro-cli",
-	"kiro-ide"
+	"kiro-ide",
+	"reasonix",
+	"zed"
 ];
 const defaultGetFactory$4 = (target) => {
 	const factory = toolIgnoreFactories.get(target);
@@ -20849,7 +21581,7 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 		}), isRecord(this.config.mcp_servers) ? this.config.mcp_servers : {});
 		this.config = merged;
 		super.setFileContent(applySharedConfigPatch({
-			fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+			fileKey: getHermesagentConfigSharedFileKey({ global: this.global }),
 			feature: "mcp",
 			existingContent: fileContent,
 			patch: { mcp_servers: merged.mcp_servers }
@@ -20867,6 +21599,13 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
 		};
 	}
+	/**
+	* `config.yaml` under every spelling the global profile root can take.
+	* @see getHermesagentSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getHermesagentSharedConfigWritePaths();
+	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
 		if (!global) throw new Error(HERMESAGENT_GLOBAL_ONLY_MESSAGE);
 		const paths = this.getSettablePaths({ global });
@@ -20893,7 +21632,7 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent: applySharedConfigPatch({
-				fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+				fileKey: getHermesagentConfigSharedFileKey({ global }),
 				feature: "mcp",
 				existingContent: fileContent,
 				patch: { mcp_servers: merged.mcp_servers }
@@ -21354,9 +22093,12 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 	* Merge a list of project rule file globs into the `instructions` array of the
 	* shared `kilo.jsonc` (or `kilo.json`) config, preserving every existing key
 	* (notably `mcp`/`tools` written by the MCP feature). In Kilo v7, files under
-	* `.kilo/rules/` are NOT auto-loaded; they are only picked up when listed in
-	* the `instructions` key. The resulting `instructions` list is deduped and
-	* sorted for a stable output.
+	* a *project* `.kilo/rules/` are NOT auto-loaded; they are only picked up
+	* when listed in the `instructions` key. (The home-scope `~/.kilo/rules/` is
+	* different — the rules migrator's `globalRulesDirs()` walks it on every
+	* config load — which is why `KiloRule` registers instructions in project
+	* scope only.) The resulting `instructions` list is deduped and sorted for a
+	* stable output.
 	*
 	* @see https://kilo.ai/docs/automate/mcp/using-in-kilo-code
 	*/
@@ -21569,7 +22311,7 @@ var KimiCodeMcpConfigToml = class KimiCodeMcpConfigToml extends ToolFile {
 		const existingContent = existing.content;
 		const existingSection = existing.mcp;
 		const fileContent = applySharedConfigPatch({
-			fileKey: KIMI_CODE_CONFIG_SHARED_FILE_KEY,
+			fileKey: getKimiCodeConfigSharedFileKey({ global: true }),
 			feature: "mcp",
 			existingContent,
 			patch: { mcp: {
@@ -21656,11 +22398,8 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 	* derivation sees this feature as one of that file's writers — it is not a
 	* settable path, since the servers themselves live in `mcp.json`.
 	*/
-	static getExtraSharedWritePaths({ global = false } = {}) {
-		return global ? [{
-			relativeDirPath: getKimiCodeRelativeDirPath({ global: true }),
-			relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
-		}] : [];
+	static getExtraSharedWritePaths() {
+		return getKimiCodeSharedConfigWritePaths();
 	}
 	/**
 	* The `[mcp]` defaults live in the shared user `config.toml`, not in
@@ -23296,16 +24035,11 @@ var ZedMcp = class ZedMcp extends ToolMcp {
 			relativeFilePath: ZED_SETTINGS_FILE_NAME
 		};
 	}
-	/**
-	* The global settings file of the OTHER platform: `getSettablePaths` resolves
-	* `~/.config/zed` vs `%APPDATA%\Zed` per platform, but the shared-write
-	* derivation (and the gateway ownership table it is checked against) must
-	* know both spellings on every platform.
-	*/
+	/** @see getZedOtherPlatformGlobalDir */
 	static getExtraSharedWritePaths({ global = false } = {}) {
 		if (!global) return [];
 		return [{
-			relativeDirPath: process.platform === "win32" ? ZED_GLOBAL_DIR : ZED_GLOBAL_WIN32_DIR,
+			relativeDirPath: getZedOtherPlatformGlobalDir(),
 			relativeFilePath: ZED_SETTINGS_FILE_NAME
 		}];
 	}
@@ -27735,6 +28469,13 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 			relativeFilePath: HERMESAGENT_CONFIG_FILE_NAME
 		};
 	}
+	/**
+	* `config.yaml` under every spelling the global profile root can take.
+	* @see getHermesagentSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getHermesagentSharedConfigWritePaths();
+	}
 	constructor(params) {
 		super({
 			...params,
@@ -27772,7 +28513,7 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 	}
 	setFileContent(fileContent) {
 		this.fileContent = applySharedConfigPatch({
-			fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+			fileKey: getHermesagentConfigSharedFileKey({ global: this.global }),
 			feature: "permissions",
 			existingContent: fileContent,
 			patch: parseSharedConfig({
@@ -28185,7 +28926,10 @@ const KiloPermissionSchema = z.union([z.enum([
 	"ask",
 	"deny"
 ]))]);
-const KiloPermissionsConfigSchema = z.looseObject({ permission: z.optional(z.record(z.string(), KiloPermissionSchema)) });
+const KiloPermissionsConfigSchema = z.looseObject({
+	permission: z.optional(z.record(z.string(), KiloPermissionSchema)),
+	sandbox: z.optional(z.unknown())
+});
 /**
 * Kilo permission keys that share a name with a canonical rulesync category and
 * therefore stay in the shared `permission` block. Everything else (Kilo-only
@@ -28242,6 +28986,25 @@ function collectKiloDenyPatterns(value) {
 	}
 	return [];
 }
+function asKiloRecord(value) {
+	return isPlainObject$1(value) ? { ...value } : {};
+}
+/**
+* The `sandbox` keys a *project* `kilo.jsonc` may state. Kilo honors
+* `allowed_hosts` and `writable_paths` from the global config only, and lets a
+* project config merely tighten — so writing the wider keys into a project file
+* would produce config Kilo ignores.
+* @see https://kilo.ai/docs/getting-started/settings/sandboxing
+*/
+const KILO_PROJECT_SCOPE_SANDBOX_KEYS = /* @__PURE__ */ new Set(["enabled", "network"]);
+function narrowSandboxToProjectScope({ authored, logger }) {
+	const emitted = {};
+	const dropped = [];
+	for (const [key, value] of Object.entries(authored)) if (KILO_PROJECT_SCOPE_SANDBOX_KEYS.has(key)) emitted[key] = value;
+	else dropped.push(key);
+	if (dropped.length > 0) logger?.warn(`Kilo honors these 'sandbox' keys from the global config only, so they were dropped from the project config: ${dropped.toSorted().join(", ")}. A project config may only tighten the sandbox ('enabled', 'network'); generate with --global to author the rest.`);
+	return emitted;
+}
 var KiloPermissions = class KiloPermissions extends ToolPermissions {
 	json;
 	constructor(params) {
@@ -28321,8 +29084,7 @@ var KiloPermissions = class KiloPermissions extends ToolPermissions {
 		const basePaths = KiloPermissions.getSettablePaths({ global });
 		const filePath = join(outputRoot, basePaths.relativeDirPath, basePaths.relativeFilePath);
 		const parsed = parseKiloJsoncStrict(await readFileContentOrNull(filePath) ?? "{}", filePath);
-		const parsedPermission = parsed.permission;
-		const existingPermission = parsedPermission && typeof parsedPermission === "object" && !Array.isArray(parsedPermission) ? { ...parsedPermission } : {};
+		const existingPermission = asKiloRecord(parsed.permission);
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const kiloOverride = rulesyncJson.kilo;
 		const incomingPermission = {
@@ -28348,6 +29110,18 @@ var KiloPermissions = class KiloPermissions extends ToolPermissions {
 			...parsed,
 			permission: mergedPermission
 		};
+		if (kiloOverride?.sandbox !== void 0) {
+			const authored = asKiloRecord(kiloOverride.sandbox);
+			const emitted = global ? authored : narrowSandboxToProjectScope({
+				authored,
+				logger
+			});
+			const merged = {
+				...asKiloRecord(parsed.sandbox),
+				...emitted
+			};
+			if (Object.keys(merged).length > 0) nextJson.sandbox = merged;
+		}
 		return new KiloPermissions({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -28362,9 +29136,14 @@ var KiloPermissions = class KiloPermissions extends ToolPermissions {
 		const overrideOnly = {};
 		for (const [key, value] of Object.entries(rawPermission)) if (isSharedKiloCategory(key)) shared[key] = typeof value === "string" ? { "*": value } : value;
 		else overrideOnly[key] = value;
-		const json = Object.keys(overrideOnly).length > 0 ? {
+		const sandbox = this.json.sandbox;
+		const override = {
+			...Object.keys(overrideOnly).length > 0 && { permission: overrideOnly },
+			...isPlainObject$1(sandbox) && { sandbox }
+		};
+		const json = Object.keys(override).length > 0 ? {
 			permission: shared,
-			kilo: { permission: overrideOnly }
+			kilo: override
 		} : { permission: shared };
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(json, null, 2) });
 	}
@@ -28605,6 +29384,13 @@ var KimiCodePermissions = class KimiCodePermissions extends ToolPermissions {
 	isDeletable() {
 		return false;
 	}
+	/**
+	* `config.toml` under both spellings its directory can take.
+	* @see getKimiCodeSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getKimiCodeSharedConfigWritePaths();
+	}
 	shouldMergeExistingFileContent() {
 		return true;
 	}
@@ -28619,7 +29405,7 @@ var KimiCodePermissions = class KimiCodePermissions extends ToolPermissions {
 			patch
 		});
 		this.fileContent = applySharedConfigPatch({
-			fileKey: KIMI_CODE_CONFIG_SHARED_FILE_KEY,
+			fileKey: getKimiCodeConfigSharedFileKey({ global: this.global }),
 			feature: "permissions",
 			existingContent: fileContent,
 			patch: {
@@ -29543,14 +30329,6 @@ function parseReasonixConfig(fileContent) {
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
 	return { ...parsed };
 }
-function toStringArray$1(value) {
-	if (!Array.isArray(value)) return [];
-	return value.filter((entry) => typeof entry === "string");
-}
-function toPermissionsTable(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-	return { ...value };
-}
 const REASONIX_OVERRIDE_AGENT_KEYS = ["plan_mode_read_only_commands"];
 /**
 * `[agent]` keys an older `reasonix.toml` may carry that left the documented
@@ -29607,12 +30385,12 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 		const config = rulesyncPermissions.getJson();
 		const { allow, ask, deny } = convertRulesyncToReasonixPermissions(config);
 		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toReasonixToolName(category)));
-		const existingPermissions = toPermissionsTable(parsed.permissions);
-		const preservedAllow = toStringArray$1(existingPermissions.allow).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
-		const preservedAsk = toStringArray$1(existingPermissions.ask).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
-		const preservedDeny = toStringArray$1(existingPermissions.deny).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const existingPermissions = toReasonixTable(parsed.permissions);
+		const preservedAllow = toReasonixStringArray(existingPermissions.allow).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const preservedAsk = toReasonixStringArray(existingPermissions.ask).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const preservedDeny = toReasonixStringArray(existingPermissions.deny).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
 		if (logger && managedToolNames.has("Read")) {
-			const droppedReadDenyEntries = toStringArray$1(existingPermissions.deny).filter((entry) => {
+			const droppedReadDenyEntries = toReasonixStringArray(existingPermissions.deny).filter((entry) => {
 				const { toolName } = parseReasonixPermissionEntry(entry);
 				return toolName === "Read";
 			});
@@ -29659,11 +30437,11 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 		});
 	}
 	toRulesyncPermissions() {
-		const permissions = toPermissionsTable(this.toml.permissions);
+		const permissions = toReasonixTable(this.toml.permissions);
 		const config = convertReasonixToRulesyncPermissions({
-			allow: toStringArray$1(permissions.allow),
-			ask: toStringArray$1(permissions.ask),
-			deny: toStringArray$1(permissions.deny)
+			allow: toReasonixStringArray(permissions.allow),
+			ask: toReasonixStringArray(permissions.ask),
+			deny: toReasonixStringArray(permissions.deny)
 		});
 		const sandbox = asReasonixRecord(this.toml.sandbox);
 		const agentPlanMode = pickReasonixKeys(this.toml.agent, [...REASONIX_OVERRIDE_AGENT_KEYS, ...REASONIX_RETIRED_AGENT_KEYS]);
@@ -29755,19 +30533,31 @@ const CATEGORY_TO_TOOL_KEYS = {
 		"open_files",
 		"expand_code_chunks",
 		"expand_folder",
-		"grep"
+		"grep",
+		"getJiraIssue",
+		"getConfluencePage"
 	],
 	edit: [
 		"find_and_replace_code",
 		"create_file",
 		"delete_file",
-		"move_file"
+		"move_file",
+		"createTechnicalPlan",
+		"createJiraIssue",
+		"updateJiraIssue",
+		"createConfluencePage",
+		"updateConfluencePage"
 	],
 	write: [
 		"create_file",
 		"delete_file",
 		"move_file",
-		"find_and_replace_code"
+		"find_and_replace_code",
+		"createTechnicalPlan",
+		"createJiraIssue",
+		"updateJiraIssue",
+		"createConfluencePage",
+		"updateConfluencePage"
 	]
 };
 const TOOL_KEY_TO_CATEGORY = {
@@ -29775,13 +30565,24 @@ const TOOL_KEY_TO_CATEGORY = {
 	expand_code_chunks: "read",
 	expand_folder: "read",
 	grep: "read",
+	getJiraIssue: "read",
+	getConfluencePage: "read",
 	find_and_replace_code: "edit",
 	create_file: "edit",
 	delete_file: "edit",
-	move_file: "edit"
+	move_file: "edit",
+	createTechnicalPlan: "edit",
+	createJiraIssue: "edit",
+	updateJiraIssue: "edit",
+	createConfluencePage: "edit",
+	updateConfluencePage: "edit"
 };
 const MANAGED_TOOL_KEYS = [.../* @__PURE__ */ new Set([...Object.values(CATEGORY_TO_TOOL_KEYS).flat(), ...Object.keys(TOOL_KEY_TO_CATEGORY)])];
-const OWNED_TOOL_PERMISSION_KEYS = ["bash", "allowedExternalPaths"];
+const OWNED_TOOL_PERMISSION_KEYS = [
+	"bash",
+	"allowedExternalPaths",
+	"default"
+];
 /**
 * Permissions adapter for Rovo Dev CLI.
 *
@@ -29795,9 +30596,16 @@ const OWNED_TOOL_PERMISSION_KEYS = ["bash", "allowedExternalPaths"];
 * Mapping decisions (rulesync canonical -> Rovo Dev):
 *   - `bash`: the catch-all `*` pattern -> `bash.default`; every other pattern ->
 *     a `bash.commands[]` entry `{ command: <pattern as regex>, permission }`.
+*   - the all-tools category `*`: its catch-all -> `toolPermissions.default`,
+*     the level Rovo Dev falls back to for any tool with no more specific
+*     setting (Rovo Dev's own default is `ask`).
 *   - `read` -> the inspection tools (`open_files`, `expand_code_chunks`,
-*     `expand_folder`, `grep`); `edit`/`write` -> the mutation tools
-*     (`find_and_replace_code`, `create_file`, `delete_file`, `move_file`).
+*     `expand_folder`, `grep`, `getJiraIssue`, `getConfluencePage`);
+*     `edit`/`write` -> the mutation tools (`find_and_replace_code`,
+*     `create_file`, `delete_file`, `move_file`, `createTechnicalPlan`,
+*     `createJiraIssue`, `updateJiraIssue`, `createConfluencePage`,
+*     `updateConfluencePage`) — so these two categories reach Jira and
+*     Confluence, not just the working tree.
 *     These Rovo Dev keys hold a single level (no per-pattern rules), so only the
 *     catch-all `*` of each category sets the level. Non-catch-all `allow` rules
 *     in those categories are surfaced as `allowedExternalPaths` so explicit path
@@ -29977,6 +30785,10 @@ function stripPermissiveOwnedValues(toolPermissions) {
 		delete toolPermissions.allowedExternalPaths;
 		strippedKeys.push("allowedExternalPaths");
 	}
+	if (toolPermissions.default === "allow") {
+		delete toolPermissions.default;
+		strippedKeys.push("default");
+	}
 	const bash = toolPermissions.bash;
 	if (isRecord(bash)) {
 		const stripped = { ...bash };
@@ -30001,10 +30813,19 @@ function stripPermissiveOwnedValues(toolPermissions) {
 function convertRulesyncToRovodevToolPermissions({ config, logger }) {
 	const toolPermissions = {};
 	const allowedExternalPaths = [];
-	const editCatchAll = config.permission.edit?.[CATCH_ALL_PATTERN$1];
-	const writeCatchAll = config.permission.write?.[CATCH_ALL_PATTERN$1];
-	if (editCatchAll && writeCatchAll && editCatchAll !== writeCatchAll) logger?.warn(`Rovo Dev maps both "edit" and "write" onto the same file-mutation tools, but they have conflicting catch-all permissions ("edit": "${editCatchAll}", "write": "${writeCatchAll}"). The stricter of the two ("${strictestAction(editCatchAll, writeCatchAll)}") is used.`);
+	warnOnEditWriteConflict({
+		config,
+		logger
+	});
 	for (const [category, rules] of Object.entries(config.permission)) {
+		if (category === CATCH_ALL_PATTERN$1) {
+			const toolWideDefault = convertAllToolsRules({
+				rules,
+				logger
+			});
+			if (toolWideDefault) toolPermissions.default = toolWideDefault;
+			continue;
+		}
 		if (category === "bash") {
 			const bash = convertBashRules(rules);
 			if (bash) toolPermissions.bash = bash;
@@ -30031,6 +30852,36 @@ function convertRulesyncToRovodevToolPermissions({ config, logger }) {
 	if (allowedExternalPaths.length > 0) toolPermissions.allowedExternalPaths = [...new Set(allowedExternalPaths)].toSorted();
 	return toolPermissions;
 }
+/**
+* `edit` and `write` collapse onto the same Rovo Dev file-mutation tools, so a
+* conflicting catch-all between them cannot be represented. Warn that the loss
+* is happening; the conversion keeps the stricter of the two — the same
+* fail-closed rule the import direction uses when those tools disagree, so the
+* resolution never grants more than the author asked for.
+*/
+function warnOnEditWriteConflict({ config, logger }) {
+	const editCatchAll = config.permission.edit?.[CATCH_ALL_PATTERN$1];
+	const writeCatchAll = config.permission.write?.[CATCH_ALL_PATTERN$1];
+	if (editCatchAll && writeCatchAll && editCatchAll !== writeCatchAll) logger?.warn(`Rovo Dev maps both "edit" and "write" onto the same file-mutation tools, but they have conflicting catch-all permissions ("edit": "${editCatchAll}", "write": "${writeCatchAll}"). The stricter of the two ("${strictestAction(editCatchAll, writeCatchAll)}") is used.`);
+}
+/**
+* The canonical all-tools category. Its catch-all sets the tool-wide
+* `toolPermissions.default`, the same way `bash`'s catch-all sets
+* `bash.default` — both are the level Rovo Dev falls back to. Pattern rules
+* under `*` have no counterpart (the default is a single level), so they are
+* reported and skipped like any other rule Rovo Dev cannot express.
+*/
+function convertAllToolsRules({ rules, logger }) {
+	let toolWideDefault;
+	for (const [pattern, action] of Object.entries(rules)) {
+		if (pattern === CATCH_ALL_PATTERN$1) {
+			toolWideDefault = action;
+			continue;
+		}
+		logger?.warn(`Rovo Dev's tool-wide default is a single level, so it cannot express the pattern "${pattern}" in the "*" category. Skipping it.`);
+	}
+	return toolWideDefault;
+}
 function convertBashRules(rules) {
 	const bash = {};
 	const commands = [];
@@ -30052,6 +30903,7 @@ function convertBashRules(rules) {
 */
 function convertRovodevToolPermissionsToRulesync(toolPermissions) {
 	const permission = {};
+	if (isPermissionAction(toolPermissions.default)) permission[CATCH_ALL_PATTERN$1] = { [CATCH_ALL_PATTERN$1]: toolPermissions.default };
 	const bash = toolPermissions.bash;
 	if (isRecord(bash)) {
 		const bashRules = {};
@@ -30062,12 +30914,15 @@ function convertRovodevToolPermissionsToRulesync(toolPermissions) {
 		if (Object.keys(bashRules).length > 0) permission.bash = bashRules;
 	}
 	const nestedTools = isRecord(toolPermissions.tools) ? toolPermissions.tools : {};
-	for (const [toolKey, category] of Object.entries(TOOL_KEY_TO_CATEGORY)) {
-		const value = Object.hasOwn(nestedTools, toolKey) ? nestedTools[toolKey] : toolPermissions[toolKey];
-		if (!isPermissionAction(value)) continue;
+	const implicitLevel = isPermissionAction(toolPermissions.default) ? toolPermissions.default : "ask";
+	for (const category of new Set(Object.values(TOOL_KEY_TO_CATEGORY))) {
+		const levels = Object.entries(TOOL_KEY_TO_CATEGORY).filter(([, mapped]) => mapped === category).map(([toolKey]) => {
+			const value = Object.hasOwn(nestedTools, toolKey) ? nestedTools[toolKey] : toolPermissions[toolKey];
+			return isPermissionAction(value) ? value : void 0;
+		});
+		if (levels.every((level) => level === void 0)) continue;
 		permission[category] ??= {};
-		const current = permission[category][CATCH_ALL_PATTERN$1];
-		permission[category][CATCH_ALL_PATTERN$1] = strictestAction(current, value);
+		permission[category][CATCH_ALL_PATTERN$1] = levels.reduce((strictest, level) => strictestAction(strictest, level ?? implicitLevel), permission[category][CATCH_ALL_PATTERN$1]);
 	}
 	if (isStringArray$1(toolPermissions.allowedExternalPaths)) for (const path of toolPermissions.allowedExternalPaths) {
 		permission.read ??= {};
@@ -30899,16 +31754,11 @@ var ZedPermissions = class ZedPermissions extends ToolPermissions {
 			relativeFilePath: ZED_SETTINGS_FILE_NAME
 		};
 	}
-	/**
-	* The global settings file of the OTHER platform: `getSettablePaths` resolves
-	* `~/.config/zed` vs `%APPDATA%\Zed` per platform, but the shared-write
-	* derivation (and the gateway ownership table it is checked against) must
-	* know both spellings on every platform.
-	*/
+	/** @see getZedOtherPlatformGlobalDir */
 	static getExtraSharedWritePaths({ global = false } = {}) {
 		if (!global) return [];
 		return [{
-			relativeDirPath: process.platform === "win32" ? ZED_GLOBAL_DIR : ZED_GLOBAL_WIN32_DIR,
+			relativeDirPath: getZedOtherPlatformGlobalDir(),
 			relativeFilePath: ZED_SETTINGS_FILE_NAME
 		}];
 	}
@@ -39480,7 +40330,7 @@ def register(ctx):
         _register_subagent(ctx, subagent)
 `;
 }
-function getEnabledPluginConfigContent(currentContent) {
+function getEnabledPluginConfigContent({ currentContent, global }) {
 	const config = parseSharedConfig({
 		format: "yaml",
 		fileContent: currentContent
@@ -39488,7 +40338,7 @@ function getEnabledPluginConfigContent(currentContent) {
 	const plugins = config.plugins && typeof config.plugins === "object" ? config.plugins : {};
 	const enabled = Array.isArray(plugins.enabled) ? plugins.enabled : [];
 	return applySharedConfigPatch({
-		fileKey: HERMES_CONFIG_SHARED_FILE_KEY,
+		fileKey: getHermesagentConfigSharedFileKey({ global }),
 		feature: "subagents",
 		existingContent: currentContent,
 		patch: { plugins: {
@@ -39539,6 +40389,10 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 		return !targets || targets.includes("*") || targets.includes("hermesagent");
 	}
 	static fromRulesyncSubagents({ rulesyncSubagents, outputRoot, global = false }) {
+		const pluginDirPath = getHermesagentRelativeDirPath({
+			global,
+			relativeDirPath: HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_DIR_PATH
+		});
 		return [
 			...rulesyncSubagents.map((rulesyncSubagent) => HermesagentSubagent.fromRulesyncSubagent({
 				relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
@@ -39547,20 +40401,14 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 				global
 			})),
 			new HermesagentSubagent({
-				relativeDirPath: getHermesagentRelativeDirPath({
-					global,
-					relativeDirPath: HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_DIR_PATH
-				}),
+				relativeDirPath: pluginDirPath,
 				relativeFilePath: basename(HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_MANIFEST_PATH),
 				fileContent: "",
 				outputRoot,
 				global
 			}),
 			new HermesagentSubagent({
-				relativeDirPath: getHermesagentRelativeDirPath({
-					global,
-					relativeDirPath: HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_DIR_PATH
-				}),
+				relativeDirPath: pluginDirPath,
 				relativeFilePath: basename(HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_INIT_PATH),
 				fileContent: "",
 				outputRoot,
@@ -39600,14 +40448,12 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 	* shared `~/.hermes/config.yaml` (enabling the `rulesync-subagents` plugin),
 	* so the write must be declared for the shared-file order derivation.
 	*/
-	static getExtraSharedWritePaths({ global = false } = {}) {
-		return global ? [{
-			relativeDirPath: getHermesagentRelativeDirPath({
-				global,
-				relativeDirPath: HERMESAGENT_GLOBAL_DIR
-			}),
-			relativeFilePath: basename(HERMESAGENT_CONFIG_FILE_PATH)
-		}] : [];
+	/**
+	* `config.yaml` under every spelling the global profile root can take.
+	* @see getHermesagentSharedConfigWritePaths
+	*/
+	static getExtraSharedWritePaths() {
+		return getHermesagentSharedConfigWritePaths();
 	}
 	static getSettablePathsForRulesyncSubagent(rulesyncSubagent) {
 		return [join(HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH, `${subagentSlug(rulesyncSubagent.getRelativePathFromCwd())}.json`)];
@@ -39640,7 +40486,10 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 	}
 	setFileContent(newFileContent) {
 		if (this.getRelativeFilePath() === basename(HERMESAGENT_CONFIG_FILE_PATH)) {
-			super.setFileContent(getEnabledPluginConfigContent(newFileContent));
+			super.setFileContent(getEnabledPluginConfigContent({
+				currentContent: newFileContent,
+				global: this.global
+			}));
 			return;
 		}
 		super.setFileContent(newFileContent);
@@ -39648,7 +40497,10 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 	getFileContent() {
 		if (this.getRelativeFilePath() === basename(HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_MANIFEST_PATH)) return getPluginManifestContent();
 		if (this.getRelativeFilePath() === basename(HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_INIT_PATH)) return getPluginInitContent();
-		if (this.getRelativeFilePath() === basename(HERMESAGENT_CONFIG_FILE_PATH)) return getEnabledPluginConfigContent(super.getFileContent());
+		if (this.getRelativeFilePath() === basename(HERMESAGENT_CONFIG_FILE_PATH)) return getEnabledPluginConfigContent({
+			currentContent: super.getFileContent(),
+			global: this.global
+		});
 		return super.getFileContent();
 	}
 };
@@ -44727,10 +45579,13 @@ var JunieRule = class JunieRule extends ToolRule {
 //#region src/features/rules/kilo-rule.ts
 var KiloRule = class KiloRule extends ToolRule {
 	static getSettablePaths({ global, excludeToolDir } = {}) {
-		if (global) return { root: {
-			relativeDirPath: buildToolPath(KILO_GLOBAL_DIR, ".", excludeToolDir),
-			relativeFilePath: KILO_RULE_FILE_NAME
-		} };
+		if (global) return {
+			root: {
+				relativeDirPath: buildToolPath(KILO_GLOBAL_DIR, ".", excludeToolDir),
+				relativeFilePath: KILO_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(KILO_DIR, KILO_RULES_DIR_NAME, excludeToolDir) }
+		};
 		return {
 			root: {
 				relativeDirPath: ".",
@@ -46315,6 +47170,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose",
 			additionalConventions: {
 				commands: { commandClass: AgentsmdCommand },
 				subagents: { subagentClass: AgentsmdSubagent },
@@ -46335,7 +47191,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose"
 		}
 	}],
 	["antigravity-cli", {
@@ -46412,7 +47269,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["copilot", {
@@ -46445,7 +47302,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["factorydroid", {
@@ -46453,7 +47310,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose"
 		}
 	}],
 	["goose", {
@@ -46462,7 +47320,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["hermesagent", {
@@ -46471,7 +47329,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["grokcli", {
@@ -46488,7 +47346,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["kilo", {
@@ -46497,7 +47355,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			mcpInstructionsRegistrar: KiloMcp
+			mcpInstructionsRegistrar: KiloMcp,
+			collisionPolicy: "compose"
 		}
 	}],
 	["kimi-code", {
@@ -46506,7 +47365,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["kiro", {
@@ -46539,7 +47398,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "toon",
-			mcpInstructionsRegistrar: OpencodeMcp
+			mcpInstructionsRegistrar: OpencodeMcp,
+			collisionPolicy: "compose"
 		}
 	}],
 	["pi", {
@@ -46548,7 +47408,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["qwencode", {
@@ -46566,7 +47426,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["replit", {
@@ -46623,7 +47483,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "toon",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["devin", {
@@ -46692,16 +47552,23 @@ var RulesProcessor = class extends FeatureProcessor {
 		const nonLocalRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().localRoot);
 		const factory = this.getFactory(this.toolTarget);
 		const { meta } = factory;
-		const toolRules = nonLocalRootRules.map((rulesyncRule) => {
+		const convertedRules = nonLocalRootRules.map((rulesyncRule) => {
 			if (!factory.class.isTargetedByRulesyncRule(rulesyncRule)) return null;
-			return factory.class.fromRulesyncRule({
-				outputRoot: this.outputRoot,
-				rulesyncRule,
-				validate: true,
-				global: this.global
-			});
+			return {
+				toolRule: factory.class.fromRulesyncRule({
+					outputRoot: this.outputRoot,
+					rulesyncRule,
+					validate: true,
+					global: this.global
+				}),
+				rulesyncRule
+			};
 		}).filter((rule) => rule !== null);
-		if (meta.foldsNonRootIntoRoot) this.foldNonRootRulesIntoRootRule(toolRules);
+		this.mergeRulesByOutputPath({
+			convertedRules,
+			collisionPolicy: meta.collisionPolicy ?? "preserve"
+		});
+		const toolRules = convertedRules.map(({ toolRule }) => toolRule);
 		this.applyLocalRootRules({
 			toolRules,
 			localRootRules,
@@ -46719,7 +47586,12 @@ var RulesProcessor = class extends FeatureProcessor {
 			toolRules,
 			factory
 		});
-		return [...toolRules, ...extraFiles];
+		const outputFiles = [...toolRules, ...extraFiles];
+		this.warnForOutputPathCollisions({
+			outputFiles,
+			convertedRules
+		});
+		return outputFiles;
 	}
 	/**
 	* Handle localRoot rules (only in non-global mode and when enabled). Mutates
@@ -46806,39 +47678,80 @@ var RulesProcessor = class extends FeatureProcessor {
 		});
 	}
 	/**
-	* Fold every non-root rule body into the single root rule file.
+	* Reconcile rules that resolve to the same output path.
 	*
-	* Used for tools whose rules engine reads only one root `AGENTS.md` and neither
-	* scans a `memories/` directory nor follows references (deepagents' dcode reads
-	* `.deepagents/AGENTS.md`; Warp reads root/subdir `AGENTS.md` but never
-	* `.warp/memories/`). Those rule classes emit both root and non-root rules to
-	* the same root path, so all bodies must be merged into one instance to avoid
-	* colliding on that path (last-writer-wins would silently drop content).
+	* Multiple root fragments are composed for tools that emit a fixed root file.
+	* The `fold` policy is for tools whose rules engine reads only one root file and
+	* neither scans a modular rules directory nor follows references. For example,
+	* dcode reads `.deepagents/AGENTS.md`, while Warp reads root or subdirectory
+	* `AGENTS.md` files but never `.warp/memories/`. Those adapters must fold every
+	* body into one instance because last-writer-wins would silently drop content.
+	* Plain-Markdown adapters can opt into `compose` for colliding modular outputs.
 	*
-	* The root rule (if any) becomes the merge target and leads the merged content;
-	* otherwise the first rule is used so a rule set without a root overview still
-	* produces a single, complete file. Mutates `toolRules` in place.
+	* A generated root rule becomes the merge target when present. A `fold` group
+	* without one uses its first rule. A group only composes when every rendered
+	* fragment is plain Markdown — a fragment carrying its own frontmatter block
+	* (e.g. Amp's `globs:` gate) would end up mid-body where the tool ignores it.
+	* Root-involved collisions that cannot be composed safely fail; other
+	* collisions remain separate and are reported by the final output-path check.
+	* Mutates `convertedRules` in place.
 	*/
-	foldNonRootRulesIntoRootRule(toolRules) {
-		if (toolRules.length <= 1) return;
+	mergeRulesByOutputPath({ convertedRules, collisionPolicy }) {
+		if (convertedRules.length <= 1) return;
 		const groups = /* @__PURE__ */ new Map();
-		for (const rule of toolRules) {
-			const path = join(rule.getRelativeDirPath(), rule.getRelativeFilePath());
+		for (const conversion of convertedRules) {
+			const path = join(conversion.toolRule.getRelativeDirPath(), conversion.toolRule.getRelativeFilePath());
 			const group = groups.get(path);
-			if (group) group.push(rule);
-			else groups.set(path, [rule]);
+			if (group) group.push(conversion);
+			else groups.set(path, [conversion]);
 		}
 		const survivors = /* @__PURE__ */ new Set();
-		for (const group of groups.values()) {
-			const target = group.find((rule) => rule.isRoot()) ?? group[0];
+		for (const [path, group] of groups) {
+			if (group.length === 1) {
+				const conversion = group[0];
+				if (conversion) {
+					if (collisionPolicy === "fold") conversion.toolRule.setFileContent(conversion.toolRule.getFileContent().trim());
+					survivors.add(conversion);
+				}
+				continue;
+			}
+			const rootConversion = group.find(({ toolRule }) => toolRule.isRoot());
+			const allGeneratedRulesAreRoots = group.every(({ toolRule }) => toolRule.isRoot());
+			const hasSourceRoot = group.some(({ rulesyncRule }) => rulesyncRule.getFrontmatter().root === true);
+			const allFragmentsArePlain = group.every(({ toolRule }) => !/^---\r?\n/.test(toolRule.getFileContent()));
+			const shouldCompose = (collisionPolicy === "fold" || collisionPolicy === "compose" || allGeneratedRulesAreRoots) && allFragmentsArePlain;
+			if (!shouldCompose && hasSourceRoot) throw new Error(`Multiple generated rules resolve to output path '${path}' for target '${this.toolTarget}', but this target cannot safely compose a collision involving a root rule. Source rules: ${formatRulePaths(group.map(({ rulesyncRule }) => rulesyncRule))}`);
+			if (!shouldCompose) {
+				for (const conversion of group) survivors.add(conversion);
+				continue;
+			}
+			const target = rootConversion ?? group[0];
 			if (!target) continue;
-			const mergedContent = [target, ...group.filter((rule) => rule !== target)].map((rule) => rule.getFileContent().trim()).filter((content) => content.length > 0).join("\n\n");
-			target.setFileContent(mergedContent);
+			const mergedContent = [target, ...group.filter((rule) => rule !== target)].map(({ toolRule }) => toolRule.getFileContent().trim()).filter((content) => content.length > 0).join("\n\n");
+			target.toolRule.setFileContent(mergedContent);
 			survivors.add(target);
 		}
-		for (let i = toolRules.length - 1; i >= 0; i--) {
-			const rule = toolRules[i];
-			if (rule && !survivors.has(rule)) toolRules.splice(i, 1);
+		for (let i = convertedRules.length - 1; i >= 0; i--) {
+			const conversion = convertedRules[i];
+			if (conversion && !survivors.has(conversion)) convertedRules.splice(i, 1);
+		}
+	}
+	warnForOutputPathCollisions({ outputFiles, convertedRules }) {
+		const seen = /* @__PURE__ */ new Map();
+		const describeSource = (file) => {
+			const source = convertedRules.find(({ toolRule }) => toolRule === file)?.rulesyncRule;
+			return source ? formatRulePaths([source]) : join(file.getRelativeDirPath(), file.getRelativeFilePath());
+		};
+		for (const file of outputFiles) {
+			const path = join(file.getRelativeDirPath(), file.getRelativeFilePath());
+			const key = path.toLowerCase();
+			const previous = seen.get(key);
+			if (previous) {
+				const previousPath = join(previous.getRelativeDirPath(), previous.getRelativeFilePath());
+				const pathDescription = previousPath === path ? `'${path}'` : `'${previousPath}' and '${path}' (compared case-insensitively, as on macOS and Windows)`;
+				this.logger.warn(`Both ${describeSource(previous)} and ${describeSource(file)} generate to ${pathDescription}; the last one wins wherever they collide.`);
+			}
+			seen.set(key, file);
 		}
 	}
 	/**
@@ -46998,14 +47911,13 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		}));
 		const factory = this.getFactory(this.toolTarget);
 		const targetedRootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().root).filter((rule) => factory.class.isTargetedByRulesyncRule(rule));
-		if (targetedRootRules.length > 1) throw new Error(`Multiple root rulesync rules found for target '${this.toolTarget}': ${formatRulePaths(targetedRootRules)}`);
 		if (targetedRootRules.length === 0 && rulesyncRules.length > 0) this.logger.warn(`No root rulesync rule file found for target '${this.toolTarget}'. Consider adding 'root: true' to one of your rule files in ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`);
 		const targetedLocalRootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().localRoot).filter((rule) => factory.class.isTargetedByRulesyncRule(rule));
 		if (targetedLocalRootRules.length > 1) throw new Error(`Multiple localRoot rules found for target '${this.toolTarget}': ${formatRulePaths(targetedLocalRootRules)}. Only one rule can have localRoot: true`);
 		if (targetedLocalRootRules.length > 0 && targetedRootRules.length === 0) throw new Error(`localRoot: true requires a root: true rule to exist for target '${this.toolTarget}' (found in ${formatRulePaths(targetedLocalRootRules)})`);
 		if (this.global) {
 			const globalPaths = factory.class.getSettablePaths({ global: true });
-			const supportsGlobalNonRoot = "nonRoot" in globalPaths && globalPaths.nonRoot !== null || factory.meta.supportsGlobal && factory.meta.foldsNonRootIntoRoot === true;
+			const supportsGlobalNonRoot = "nonRoot" in globalPaths && globalPaths.nonRoot !== null || factory.meta.supportsGlobal && factory.meta.collisionPolicy === "fold";
 			const nonRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().root && !rule.getFrontmatter().localRoot && factory.class.isTargetedByRulesyncRule(rule));
 			if (nonRootRules.length > 0 && !supportsGlobalNonRoot) this.logger.warn(`${nonRootRules.length} non-root rulesync rules found, but it's in global mode, so ignoring them: ${formatRulePaths(nonRootRules)}`);
 			if (targetedLocalRootRules.length > 0) this.logger.warn(`${targetedLocalRootRules.length} localRoot rules found, but localRoot is not supported in global mode, ignoring them: ${formatRulePaths(targetedLocalRootRules)}`);
@@ -47248,14 +48160,36 @@ async function assertPluginRootSafe(params) {
 }
 //#endregion
 //#region src/utils/tool-output-root.ts
+/** The environment variable each tool reads for its profile root. */
+const TOOL_HOME_ENV_VARS = {
+	hermesagent: "HERMES_HOME",
+	"kimi-code": "KIMI_CODE_HOME"
+};
+/**
+* Substitute a tool's home override (`HERMES_HOME`, `KIMI_CODE_HOME`) for the
+* output root in global scope.
+*
+* The override wins over `--output-roots`: it names where the tool itself reads
+* its profile, so writing anywhere else would produce files the tool ignores.
+*
+* A substituted value goes through the same `validateOutputRoot` the CLI and
+* config paths use, so an override of `/` or an unnormalized path is rejected
+* instead of silently becoming the output root. The rejection is re-thrown
+* naming the variable, since the user never passed an `--output-roots` flag.
+*/
 function resolveToolOutputRoot({ outputRoot, toolTarget, global }) {
 	if (!global) return outputRoot;
-	if (toolTarget === "hermesagent") return resolveHermesagentOutputRoot({
+	const resolved = toolTarget === "hermesagent" ? resolveHermesagentOutputRoot({
 		outputRoot,
 		global
-	});
-	if (toolTarget === "kimi-code") return getKimiCodeHome() ?? outputRoot;
-	return outputRoot;
+	}) : toolTarget === "kimi-code" ? getKimiCodeHome() ?? outputRoot : outputRoot;
+	if (resolved === outputRoot) return resolved;
+	try {
+		validateOutputRoot(resolved);
+	} catch (error) {
+		throw new Error(`${TOOL_HOME_ENV_VARS[toolTarget] ?? "The tool home override"} is not a usable output root: ${formatError(error)}`, { cause: error });
+	}
+	return resolved;
 }
 //#endregion
 //#region src/lib/convert.ts
@@ -48656,7 +49590,11 @@ async function generateChecksCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("checks")) continue;
 		const processor = new ChecksProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -49031,4 +49969,4 @@ async function importChecksCore(params) {
 //#endregion
 export { ErrorCodes as $, RULESYNC_SKILLS_RELATIVE_DIR_PATH as $t, RulesyncMcp as A, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as At, stringifyFrontmatter as B, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Bt, RulesyncSubagent as C, writeFileContent as Ct, RulesyncRule as D, ToolTargetSchema as Dt, RulesyncSkillFrontmatterSchema as E, PACKAGING_TOOL_TARGETS as Et, parseJsonc as F, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as Ft, ConfigFileSchema as G, RULESYNC_MCP_SCHEMA_URL as Gt, SHARED_USER_MANAGED_CONFIG_PATHS as H, RULESYNC_MCP_FILE_NAME as Ht, RulesyncCommand as I, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as It, ConsoleLogger as J, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as Jt, SourceEntrySchema as K, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Kt, RulesyncCommandFrontmatterSchema as L, RULESYNC_HOOKS_FILE_NAME as Lt, RulesyncHooks as M, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as Mt, getRulesyncSourceCandidates as N, RULESYNC_CONFIG_RELATIVE_FILE_PATH as Nt, RulesyncRuleFrontmatterSchema as O, MAX_FILE_SIZE as Ot, resolveRulesyncSourceWritePath as P, RULESYNC_CONFIG_SCHEMA_URL as Pt, CLIError as Q, RULESYNC_RULES_RELATIVE_DIR_PATH as Qt, RulesyncCheck as R, RULESYNC_HOOKS_LEGACY_FILE_NAME as Rt, getLocalSkillDirNames as S, toPosixPath as St, RulesyncSkill as T, ALL_TOOL_TARGETS_WITH_WILDCARD as Tt, SKILL_FILE_NAME as U, RULESYNC_MCP_LEGACY_FILE_NAME as Ut, loadYaml as V, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Vt, ConfigResolver as W, RULESYNC_MCP_RELATIVE_FILE_PATH as Wt, fallbackLogger as X, RULESYNC_PERMISSIONS_SCHEMA_URL as Xt, JsonLogger as Y, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Yt, warnOnConflictingFlags as Z, RULESYNC_RELATIVE_DIR_PATH as Zt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as _, removeFile as _t, convertFromTool as a, directoryExists as at, CODEXCLI_BASH_RULES_FILE_NAME as b, resolvePath as bt, SubagentsProcessor as c, findFilesByGlobs as ct, IgnoreProcessor as d, isSymlink as dt, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as en, assertDirectoryIfExists as et, HooksProcessor as f, listDirectoryFiles as ft, CLAUDECODE_MEMORIES_DIR_NAME as g, removeDirectoryStrict as gt, CLAUDECODE_LOCAL_RULE_FILE_NAME as h, removeDirectory as ht, getProcessorRegistryEntry as i, formatError as in, createTempDirectory as it, RulesyncIgnore as j, RULESYNC_CHECKS_RELATIVE_DIR_PATH as jt, RulesyncPermissions as k, RULESYNC_AIIGNORE_FILE_NAME as kt, SkillsProcessor as l, getFileSize as lt, CLAUDECODE_DIR as m, readFileContentOrNull as mt, checkRulesyncDirExists as n, ALL_FEATURES as nn, assertWritablePathInsideRoot as nt, isPackagingToolTarget as o, ensureDir as ot, CommandsProcessor as p, readFileContent as pt, findControlCharacter as q, RULESYNC_PERMISSIONS_FILE_NAME as qt, generate as r, ALL_FEATURES_WITH_WILDCARD as rn, checkPathTraversal as rt, RulesProcessor as s, fileExists as st, importFromTool as t, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as tn, assertTreeContainsNoSymlinks as tt, McpProcessor as u, getHomeDirectory as ut, CLAUDECODE_SKILLS_DIR_PATH as v, removeFileStrict as vt, RulesyncSubagentFrontmatterSchema as w, ALL_TOOL_TARGETS as wt, CODEXCLI_DIR as x, runWithDirectoryRollback as xt, ChecksProcessor as y, removeTempDirectory as yt, RulesyncCheckFrontmatterSchema as z, RULESYNC_HOOKS_RELATIVE_FILE_PATH as zt };
 
-//# sourceMappingURL=import-BmXT7mRS.js.map
+//# sourceMappingURL=import-CArKOPG_.js.map