rulesync 16.0.0 → 16.2.0

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

@@ -1,7 +1,7 @@
 import { ZodError } from "zod";
 import { meta, minLength, nonnegative, optional, refine, z } from "zod/mini";
 import { cp, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
-import path, { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep, win32 } from "node:path";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import os from "node:os";
 import { intersection, kebabCase, uniq } from "es-toolkit";
@@ -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",
@@ -268,6 +270,9 @@ const commandsProcessorToolTargetTuple = [
 const subagentsProcessorToolTargetTuple = [
 	"kilo",
 	"agentsmd",
+	"antigravity-cli",
+	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
 	"claudecode-plugin",
@@ -399,7 +404,9 @@ const permissionsProcessorToolTargetTuple = [
 ];
 const checksProcessorToolTargetTuple = [
 	"amp",
+	"cursor",
 	"hermesagent",
+	"rovodev",
 	"takt"
 ];
 //#endregion
@@ -1053,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"]];
@@ -1123,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
@@ -1157,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 ?? [];
 	}
 	/**
@@ -1350,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;
 	}
@@ -1572,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)
@@ -2109,7 +2141,10 @@ const HookDefinitionSchema = z.looseObject({
 	model: z.optional(safeString),
 	args: z.optional(z.array(safeString)),
 	metadata: z.optional(z.looseObject({})),
-	if: z.optional(safeString)
+	if: z.optional(safeString),
+	commandWindows: z.optional(safeString),
+	asyncRewake: z.optional(z.boolean()),
+	continueOnBlock: z.optional(z.boolean())
 });
 /**
 * All canonical hook event names.
@@ -2163,6 +2198,7 @@ const HOOK_EVENTS = [
 	"configChange",
 	"cwdChanged",
 	"fileChanged",
+	"directoryAdded",
 	"elicitation",
 	"elicitationResult"
 ];
@@ -2224,6 +2260,7 @@ const CLAUDE_HOOK_EVENTS = [
 	"configChange",
 	"cwdChanged",
 	"fileChanged",
+	"directoryAdded",
 	"postCompact",
 	"elicitation",
 	"elicitationResult"
@@ -2256,7 +2293,15 @@ const DEVIN_HOOK_EVENTS = [
 	"permissionRequest",
 	"postCompact"
 ];
-/** Hook events supported by OpenCode. */
+/**
+* Hook events supported by OpenCode.
+*
+* `preCompact` maps to `experimental.session.compacting`, which the plugin docs
+* document as a named `(input, output)` hook rather than an `event.type`
+* dispatch; the other entries are all generic events.
+*
+* @see https://opencode.ai/docs/plugins/
+*/
 const OPENCODE_HOOK_EVENTS = [
 	"sessionStart",
 	"preToolUse",
@@ -2264,9 +2309,19 @@ const OPENCODE_HOOK_EVENTS = [
 	"stop",
 	"afterFileEdit",
 	"afterShellExecution",
-	"permissionRequest"
+	"permissionRequest",
+	"preCompact",
+	"postCompact",
+	"afterError",
+	"fileChanged"
 ];
-/** Hook events supported by Kilo. (Currently identical to OpenCode) */
+/**
+* Hook events supported by Kilo. Identical to OpenCode: Kilo's plugin docs list
+* the same event surface, including `session.compacted`, `session.error`,
+* `file.watcher.updated` and the experimental compaction hook.
+*
+* @see https://kilo.ai/docs/automate/extending/plugins
+*/
 const KILO_HOOK_EVENTS = OPENCODE_HOOK_EVENTS;
 /**
 * Hook events supported by Pi Coding Agent, bridged through a generated
@@ -2333,7 +2388,8 @@ const COPILOT_HOOK_EVENTS = [
 * `sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`, `preMcpToolCall` ← `beforeMCPExecution`.
+* `notification`, `userPromptTransformed` ← `userPromptExpansion`,
+* `preMcpToolCall` ← `beforeMCPExecution`.
 *
 * `preMcpToolCall` (canonical `beforeMCPExecution`) was added in Copilot CLI
 * v1.0.51 (2026-05-20) for hook providers to control outgoing MCP request
@@ -2355,6 +2411,7 @@ const COPILOTCLI_HOOK_EVENTS = [
 	"preCompact",
 	"permissionRequest",
 	"notification",
+	"userPromptExpansion",
 	"beforeMCPExecution"
 ];
 /**
@@ -2399,6 +2456,7 @@ const DEEPAGENTS_HOOK_EVENTS = [
 /** Hook events supported by Codex CLI. */
 const CODEXCLI_HOOK_EVENTS = [
 	"sessionStart",
+	"sessionEnd",
 	"preToolUse",
 	"postToolUse",
 	"beforeSubmitPrompt",
@@ -2833,6 +2891,7 @@ const CANONICAL_TO_CLAUDE_EVENT_NAMES = {
 	configChange: "ConfigChange",
 	cwdChanged: "CwdChanged",
 	fileChanged: "FileChanged",
+	directoryAdded: "DirectoryAdded",
 	postCompact: "PostCompact",
 	elicitation: "Elicitation",
 	elicitationResult: "ElicitationResult"
@@ -2954,7 +3013,11 @@ const CANONICAL_TO_OPENCODE_EVENT_NAMES = {
 	stop: "session.idle",
 	afterFileEdit: "file.edited",
 	afterShellExecution: "command.executed",
-	permissionRequest: "permission.asked"
+	permissionRequest: "permission.asked",
+	preCompact: "experimental.session.compacting",
+	postCompact: "session.compacted",
+	afterError: "session.error",
+	fileChanged: "file.watcher.updated"
 };
 /**
 * Map canonical camelCase event names to Kilo dot-notation.
@@ -3030,6 +3093,7 @@ const CANONICAL_TO_COPILOTCLI_EVENT_NAMES = {
 	preCompact: "preCompact",
 	permissionRequest: "permissionRequest",
 	notification: "notification",
+	userPromptExpansion: "userPromptTransformed",
 	beforeMCPExecution: "preMcpToolCall"
 };
 /** Map GitHub Copilot CLI event names back to canonical camelCase. */
@@ -3039,6 +3103,7 @@ const COPILOTCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CA
 */
 const CANONICAL_TO_CODEXCLI_EVENT_NAMES = {
 	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
@@ -3461,6 +3526,25 @@ var RulesyncIgnore = class RulesyncIgnore extends RulesyncFile {
 //#endregion
 //#region src/types/mcp.ts
 const EnvVarNameSchema = z.string().check(refine((value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), "envVars entries must be valid environment variable names"));
+/**
+* One `envVars` entry. A bare name reads the variable from Codex's own
+* environment; the object form names the environment to read it from, where
+* `source = "remote"` reads from the remote executor environment.
+* @see https://learn.chatgpt.com/docs/extend/mcp
+*/
+const EnvVarEntrySchema = z.union([EnvVarNameSchema, z.strictObject({
+	name: EnvVarNameSchema,
+	source: z.optional(z.enum(["local", "remote"]))
+})]);
+/**
+* Whether a value is usable as `envVars`. Applied in both directions by the
+* codex adapter, so an entry read out of somebody's `config.toml` can never be
+* imported into a `.rulesync/mcp.jsonc` that the next generate would refuse to
+* parse.
+*/
+function isEnvVarEntryArray(value) {
+	return Array.isArray(value) && value.every((entry) => EnvVarEntrySchema.safeParse(entry).success);
+}
 const McpServerSchema = z.looseObject({
 	type: z.optional(z.enum([
 		"local",
@@ -3475,7 +3559,8 @@ const McpServerSchema = z.looseObject({
 	url: z.optional(z.string()),
 	httpUrl: z.optional(z.string()),
 	env: z.optional(z.record(z.string(), z.string())),
-	envVars: z.optional(z.array(EnvVarNameSchema)),
+	envVars: z.optional(z.array(EnvVarEntrySchema)),
+	experimentalEnvironment: z.optional(z.string()),
 	disabled: z.optional(z.boolean()),
 	networkTimeout: z.optional(z.number()),
 	timeout: z.optional(z.number()),
@@ -3641,6 +3726,8 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				"description",
 				"exposed",
 				"envVars",
+				"experimentalEnvironment",
+				"experimental_environment",
 				"enabled"
 			])];
 		}));
@@ -3927,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
@@ -3943,12 +4050,23 @@ const KiloPermissionsOverrideSchema = z.looseObject({ permission: z.optional(z.r
 * authored without modeling each one; the managed `allow`/`ask`/`deny` arrays are
 * ignored here (rulesync owns them).
 *
+* `sandbox` is the sibling top-level settings subtree that governs the sandbox
+* Claude Code runs commands in (`sandbox.network.*`, `sandbox.filesystem.*`,
+* `sandbox.credentials`, `sandbox.allowAppleEvents`, ...). It has no canonical
+* permission category either — it constrains how a permitted command runs
+* rather than which commands are permitted — so it is a loose passthrough on
+* the same terms, merged into the top level of `.claude/settings.json`.
+*
 * @example
 * { "permissions": { "defaultMode": "acceptEdits", "additionalDirectories": ["../shared"] } }
+* @example
+* { "sandbox": { "network": { "allowedDomains": ["example.com"], "strictAllowlist": true } } }
+* @see https://code.claude.com/docs/en/sandboxing
 */
 const ClaudecodePermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	permissions: z.optional(z.looseObject({}))
+	permissions: z.optional(z.looseObject({})),
+	sandbox: z.optional(z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Mistral Vibe. Vibe's per-tool `BaseToolConfig`
@@ -4221,19 +4339,24 @@ const AmpPermissionsOverrideSchema = z.looseObject({
 });
 /**
 * Tool-scoped override block for the Google Antigravity CLI. Antigravity's CLI
-* `settings.json` carries two global autonomy/sandbox knobs outside the
+* `settings.json` carries four global autonomy/sandbox knobs outside the
 * `permissions.allow/ask/deny` arrays rulesync manages: `toolPermission` (the
 * global autonomy preset — `request-review` (default) / `proceed-in-sandbox` /
-* `always-proceed` / `strict`) and `enableTerminalSandbox` (a boolean confining
-* agent-run commands to OS containment). Antigravity applies the allow/deny
+* `always-proceed` / `strict`), `enableTerminalSandbox` (a boolean confining
+* agent-run commands to OS containment), `artifactReviewPolicy` (whether the
+* agent's artifact changes are gated on a review prompt — `asks-for-review`
+* (default) / `agent-decides` / `always-proceed`) and `allowNonWorkspaceAccess`
+* (a boolean, off by default, letting the agent read or write files outside the
+* active workspace roots). Antigravity applies the allow/deny
 * lists as per-rule exceptions to the preset at runtime, so rulesync only
 * authors these keys verbatim — no precedence modeling is needed on our side.
 * Fields placed here are merged onto the top level of
 * `~/.gemini/antigravity-cli/settings.json` (global-only) and emitted only for
 * the CLI. The Antigravity IDE exposes the same concepts through a GUI (no
 * documented JSON schema), so this override does NOT apply to `antigravity-ide`.
-* Verified against https://antigravity.google/docs/cli/reference and
-* https://antigravity.google/docs/cli/sandbox.
+* Verified against https://antigravity.google/docs/cli/reference,
+* https://antigravity.google/docs/cli/sandbox and
+* https://antigravity.google/docs/cli/settings.
 *
 * @example
 * { "toolPermission": "strict", "enableTerminalSandbox": true }
@@ -4246,7 +4369,13 @@ const AntigravityCliPermissionsOverrideSchema = z.looseObject({
 		"always-proceed",
 		"strict"
 	])),
-	enableTerminalSandbox: z.optional(z.boolean())
+	enableTerminalSandbox: z.optional(z.boolean()),
+	artifactReviewPolicy: z.optional(z.enum([
+		"asks-for-review",
+		"agent-decides",
+		"always-proceed"
+	])),
+	allowNonWorkspaceAccess: z.optional(z.boolean())
 });
 /**
 * Tool-scoped override block for AugmentCode. AugmentCode's `toolPermissions[]`
@@ -4650,11 +4779,14 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		description: z.optional(z.string()),
 		globs: z.optional(z.array(z.string()))
 	})),
-	copilot: z.optional(z.looseObject({ excludeAgent: z.optional(z.union([
-		z.literal("code-review"),
-		z.literal("cloud-agent"),
-		z.literal("coding-agent")
-	])) })),
+	copilot: z.optional(z.looseObject({
+		excludeAgent: z.optional(z.union([
+			z.literal("code-review"),
+			z.literal("cloud-agent"),
+			z.literal("coding-agent")
+		])),
+		name: z.optional(z.string())
+	})),
 	antigravity: z.optional(z.looseObject({
 		trigger: z.optional(z.string()),
 		globs: z.optional(z.array(z.string()))
@@ -4862,6 +4994,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		arguments: z.optional(z.union([z.string(), z.array(z.string())])),
 		context: z.optional(z.string()),
 		agent: z.optional(z.string()),
+		background: z.optional(z.boolean()),
 		hooks: z.optional(z.looseObject({})),
 		shell: z.optional(z.string()),
 		"disable-model-invocation": z.optional(z.boolean()),
@@ -4913,7 +5046,9 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	copilotcli: z.optional(z.looseObject({
 		license: z.optional(z.string()),
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
-		"argument-hint": z.optional(z.string())
+		"argument-hint": z.optional(z.string()),
+		"user-invocable": z.optional(z.boolean()),
+		"disable-model-invocation": z.optional(z.boolean())
 	})),
 	pi: z.optional(z.looseObject({
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
@@ -5199,6 +5334,38 @@ function resolveUserInvocable({ rootFrontmatter, section }) {
 	return section?.["user-invocable"] ?? rootFrontmatter["user-invocable"];
 }
 //#endregion
+//#region src/constants/cursor-paths.ts
+const CURSOR_DIR = ".cursor";
+const CURSOR_COMMANDS_DIR_PATH = join(CURSOR_DIR, "commands");
+const CURSOR_SKILLS_DIR_PATH = join(CURSOR_DIR, "skills");
+const CURSOR_AGENTS_DIR_PATH = join(CURSOR_DIR, "agents");
+const CURSOR_BUGBOT_FILE_NAME = "BUGBOT.md";
+const CURSOR_MCP_FILE_NAME = "mcp.json";
+const CURSOR_HOOKS_FILE_NAME = "hooks.json";
+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";
@@ -5649,6 +5816,276 @@ var AmpCheck = class AmpCheck extends ToolCheck {
 	}
 };
 //#endregion
+//#region src/features/checks/check-slug.ts
+/**
+* Turn a name that came out of a tool's own config file into one safe to use as
+* a `.rulesync/checks/<name>.md` file name. Shared by the adapters whose checks
+* collapse into a single file, since the name they read back is whatever the
+* user wrote there.
+*/
+function slugifyCheckName(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/, "");
+}
+//#endregion
+//#region src/features/checks/aggregated-check-file.ts
+/**
+* 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
+* code block, say. Emitting it verbatim would split that check in two on the
+* next import, so `literal-` is inserted before `check:` on the way out and
+* taken off on the way back. `(?:literal-)*` makes it a ladder, so a body that
+* already contains an escaped marker survives the round trip too.
+*/
+const ESCAPABLE_MARKER_PATTERN = /^(<!--\s*rulesync:)((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
+const ESCAPED_MARKER_PATTERN = /^(<!--\s*rulesync:)literal-((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
+function renderCheckMarker(name) {
+	return `<!-- rulesync:check:${name} -->`;
+}
+function escapeCheckMarkers(content) {
+	return content.replace(ESCAPABLE_MARKER_PATTERN, "$1literal-$2");
+}
+function unescapeCheckMarkers(content) {
+	return content.replace(ESCAPED_MARKER_PATTERN, "$1$2");
+}
+function findCheckMarkers(fileContent) {
+	CHECK_MARKER_PATTERN.lastIndex = 0;
+	const markers = [];
+	let match = CHECK_MARKER_PATTERN.exec(fileContent);
+	while (match !== null) {
+		markers.push({
+			name: match[1] ?? "",
+			start: match.index,
+			end: match.index + match[0].length
+		});
+		match = CHECK_MARKER_PATTERN.exec(fileContent);
+	}
+	return markers;
+}
+/**
+* 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 renderCheckSection(rulesyncCheck) {
+	const name = basename(rulesyncCheck.getRelativeFilePath(), ".md");
+	const heading = `## ${name}`;
+	const instruction = toInstruction(rulesyncCheck);
+	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");
+	if (firstLine?.trim() === `## ${name}`) return rest.join("\n").trim();
+	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
+* per check, so every `.rulesync/checks/*.md` targeting Cursor collapses into
+* the repository-root `.cursor/BUGBOT.md` — hence {@link fromRulesyncChecks}
+* rather than the usual per-check conversion. Each check becomes one section:
+* an HTML-comment marker carrying the check name, an `## <name>` heading, and
+* the check body as the instruction text (the `description` is used when the
+* body is empty).
+*
+* Bugbot 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. So
+* is `description` whenever the check also has a body.
+*
+* Project scope only — Bugbot reads repository files, and there is no
+* user-level instruction file. Bugbot also merges nested `<dir>/.cursor/BUGBOT.md`
+* files found while traversing upward from changed files, but rulesync check
+* sources carry no directory-placement semantics, so only the root file is
+* generated.
+*
+* On import the markers split the file back into one check per section; content
+* before the first marker — and a hand-written file with no markers at all —
+* becomes a single `bugbot` check, so nothing in the file is dropped. A file
+* holding anything rulesync did not write is never deleted either (see
+* {@link canDeleteAuxiliaryFiles}), though generating checks for Cursor does
+* replace it — import first to keep what is there, which is warned about.
+*
+* @see https://cursor.com/docs/bugbot
+*/
+var CursorCheck = class CursorCheck extends ToolCheck {
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: CURSOR_DIR,
+			relativeFilePath: CURSOR_BUGBOT_FILE_NAME
+		};
+	}
+	static isTargetedByRulesyncCheck(rulesyncCheck) {
+		return this.isTargetedByRulesyncCheckDefault({
+			rulesyncCheck,
+			toolTarget: "cursor"
+		});
+	}
+	/**
+	* Ownership guard the processor consults before it deletes anything for this
+	* tool. `.cursor/BUGBOT.md` is a file Cursor'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 Cursor must not
+	* take somebody's hand-written review instructions with it. Deletion is
+	* therefore allowed only for a file that is nothing but generated sections:
+	* one that carries no marker at all, or that carries hand-written text ahead
+	* of the first marker, stays.
+	*/
+	static async canDeleteAuxiliaryFiles({ outputRoot }) {
+		const paths = CursorCheck.getSettablePaths();
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath ?? "BUGBOT.md"));
+		if (fileContent === null) return true;
+		return isOnlyGeneratedSections(fileContent);
+	}
+	static fromRulesyncCheck(_params) {
+		throw new Error("Cursor 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 = CursorCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? "BUGBOT.md";
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		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,
+			relativeFilePath,
+			fileContent,
+			global
+		})];
+	}
+	static async fromFile({ outputRoot = process.cwd(), global = false }) {
+		const paths = CursorCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? "BUGBOT.md";
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		return new CursorCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent: await readFileContentOrNull(filePath) ?? "",
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new CursorCheck({
+			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$1
+		});
+	}
+};
+//#endregion
 //#region src/constants/hermesagent-paths.ts
 /**
 * Hermes Agent configuration-layout conventions.
@@ -5666,8 +6103,22 @@ var AmpCheck = class AmpCheck 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);
@@ -5890,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");
@@ -6002,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";
 /**
@@ -6030,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",
@@ -6048,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",
@@ -6118,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"]
@@ -6131,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"]
@@ -6147,7 +6754,20 @@ const SHARED_CONFIG_OWNERSHIP = {
 		jsoncParseErrors: "error",
 		features: { permissions: {
 			kind: "replace-owned-keys",
-			ownedKeys: ["chat.tools.terminal.autoApprove"]
+			ownedKeys: [
+				"chat.tools.terminal.autoApprove",
+				"chat.tools.edits.autoApprove",
+				"chat.tools.urls.autoApprove"
+			]
+		} }
+	},
+	".vscode/mcp.json": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: { mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["servers"]
 		} }
 	},
 	".qwen/settings.json": {
@@ -6374,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"]
@@ -6416,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"]
@@ -6513,7 +7121,12 @@ const applyIgnoreReadDenies = (params) => {
 const applyPermissions = (params) => {
 	const { settings, managedToolNames, toolNameOf, allow, ask, deny, logger } = params;
 	const current = parsePermissionsBlock(settings);
-	const keepUnmanaged = (entries) => entries.filter((entry) => !managedToolNames.has(toolNameOf(entry)));
+	const emitted = /* @__PURE__ */ new Set([
+		...allow,
+		...ask,
+		...deny
+	]);
+	const keepUnmanaged = (entries) => entries.filter((entry) => !managedToolNames.has(toolNameOf(entry)) && !emitted.has(entry));
 	if (logger && managedToolNames.has(READ_TOOL_NAME)) {
 		const overwrittenReadDenies = current.deny.filter((entry) => toolNameOf(entry) === READ_TOOL_NAME);
 		if (overwrittenReadDenies.length > 0) logger.warn(`Permissions feature manages '${READ_TOOL_NAME}' tool and will overwrite ${overwrittenReadDenies.length} existing ${READ_TOOL_NAME} deny entries. Permissions take precedence.`);
@@ -6663,12 +7276,9 @@ function toRulesyncCheckFromGate({ gate, index, scope, editOnly }) {
 		body: ""
 	});
 }
-function slugify(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/, "");
-}
 function slugForGate({ gate, index, scope }) {
-	const slug = slugify(typeof gate === "string" ? gate : typeof gate.name === "string" ? gate.name : typeof gate.command === "string" ? gate.command : "");
-	return `${scope ? `${slugify(scope.name)}-` : ""}${slug.length > 0 ? slug : "quality-gate"}-${index + 1}`;
+	const slug = slugifyCheckName(typeof gate === "string" ? gate : typeof gate.name === "string" ? gate.name : typeof gate.command === "string" ? gate.command : "");
+	return `${scope ? `${slugifyCheckName(scope.name)}-` : ""}${slug.length > 0 ? slug : "quality-gate"}-${index + 1}`;
 }
 /**
 * Checks adapter for Takt (`.takt/config.yaml` project / `~/.takt/config.yaml`
@@ -6844,6 +7454,13 @@ const toolCheckFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["cursor", {
+		class: CursorCheck,
+		meta: {
+			supportsGlobal: false,
+			filePattern: CURSOR_BUGBOT_FILE_NAME
+		}
+	}],
 	["hermesagent", {
 		class: HermesagentCheck,
 		meta: {
@@ -6851,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: {
@@ -7006,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({
@@ -7026,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
@@ -7259,6 +7974,7 @@ var AgentsmdCommand = class AgentsmdCommand extends SimulatedCommand {
 const ANTIGRAVITY_DIR = ".agents";
 const ANTIGRAVITY_SKILLS_DIR_PATH = join(ANTIGRAVITY_DIR, "skills");
 const ANTIGRAVITY_WORKFLOWS_DIR_PATH = join(ANTIGRAVITY_DIR, "workflows");
+const ANTIGRAVITY_AGENTS_DIR_PATH = join(ANTIGRAVITY_DIR, "agents");
 const ANTIGRAVITY_MCP_FILE_NAME = "mcp_config.json";
 const ANTIGRAVITY_HOOKS_FILE_NAME = "hooks.json";
 const ANTIGRAVITY_IGNORE_FILE_NAME = ".geminiignore";
@@ -7269,6 +7985,7 @@ const ANTIGRAVITY_CLI_PERMISSIONS_FILE_NAME = "settings.json";
 const ANTIGRAVITY_CLI_GLOBAL_WORKFLOWS_DIR_PATH = join(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR, "global_workflows");
 const ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR = "config";
 const ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH = join(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR);
+const ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH = join(ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH, "agents");
 //#endregion
 //#region src/constants/antigravity-cli-paths.ts
 const ANTIGRAVITY_AGENTS_DIR = ANTIGRAVITY_DIR;
@@ -7827,6 +8544,7 @@ const CLAUDECODE_PLUGIN_HOOKS_DIR = "hooks";
 const CLAUDECODE_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
 const ANTIGRAVITY_PLUGIN_RULES_DIR = "rules";
 const ANTIGRAVITY_PLUGIN_SKILLS_DIR = "skills";
+const ANTIGRAVITY_PLUGIN_AGENTS_DIR = "agents";
 const ANTIGRAVITY_PLUGIN_MCP_FILE_NAME = "mcp_config.json";
 const ANTIGRAVITY_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
 //#endregion
@@ -8051,6 +8769,7 @@ const COPILOT_SKILLS_DIR_PATH = join(GITHUB_DIR, "skills");
 const COPILOT_AGENTS_DIR_PATH = join(GITHUB_DIR, "agents");
 const COPILOT_HOOKS_DIR_PATH = join(GITHUB_DIR, "hooks");
 const COPILOT_HOOKS_FILE_NAME = "copilot-hooks.json";
+const COPILOT_GLOBAL_HOOKS_FILE_NAME = "copilot-ide-hooks.json";
 const COPILOT_MCP_DIR = ".vscode";
 const COPILOT_MCP_FILE_NAME = "mcp.json";
 const COPILOT_VSCODE_SETTINGS_FILE_NAME = "settings.json";
@@ -8058,6 +8777,7 @@ const COPILOTCLI_MCP_FILE_NAME = "mcp-config.json";
 const COPILOTCLI_PROJECT_MCP_FILE_NAME = "mcp.json";
 const COPILOTCLI_AGENTS_DIR_PATH = join(COPILOT_DIR, "agents");
 const COPILOTCLI_HOOKS_DIR_PATH = join(COPILOT_DIR, "hooks");
+const COPILOT_GLOBAL_HOOKS_DIR_PATH = COPILOTCLI_HOOKS_DIR_PATH;
 const COPILOTCLI_HOOKS_FILE_NAME = "copilotcli-hooks.json";
 const COPILOT_SKILLS_GLOBAL_DIR_PATH = join(COPILOT_DIR, "skills");
 //#endregion
@@ -8181,17 +8901,6 @@ var CopilotCommand = class CopilotCommand extends ToolCommand {
 	}
 };
 //#endregion
-//#region src/constants/cursor-paths.ts
-const CURSOR_DIR = ".cursor";
-const CURSOR_COMMANDS_DIR_PATH = join(CURSOR_DIR, "commands");
-const CURSOR_SKILLS_DIR_PATH = join(CURSOR_DIR, "skills");
-const CURSOR_AGENTS_DIR_PATH = join(CURSOR_DIR, "agents");
-const CURSOR_MCP_FILE_NAME = "mcp.json";
-const CURSOR_HOOKS_FILE_NAME = "hooks.json";
-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/features/commands/cursor-command.ts
 const CursorCommandFrontmatterSchema = z.looseObject({
 	description: z.optional(z.string()),
@@ -8737,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) {
@@ -9371,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
@@ -9379,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: {
@@ -9388,7 +10314,7 @@ function getEnabledPluginConfigContent$1(currentContent) {
 		} }
 	});
 }
-function getDisabledHermesCommandsPluginConfigContent(currentContent) {
+function getDisabledHermesCommandsPluginConfigContent({ currentContent, global }) {
 	const config = parseSharedConfig({
 		format: "yaml",
 		fileContent: currentContent
@@ -9396,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: {
@@ -9412,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();
 	}
 };
@@ -9457,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();
@@ -9489,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
@@ -10750,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
@@ -11346,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: {
@@ -11539,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) => {
@@ -11677,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);
@@ -11960,6 +12881,13 @@ function groupDefinitionsByMatcher(definitions) {
 	}
 	return byMatcher;
 }
+/** `$CLAUDE_PROJECT_DIR` -> `${CLAUDE_PROJECT_DIR}`, the form the tool substitutes. */
+function bracePlaceholder(projectDirVar) {
+	return `\${${projectDirVar.replace(/^\$/, "")}}`;
+}
+function stripSurroundingQuotes(value) {
+	return value.replace(/^(["'])(.*)\1$/, "$2").replace(/^["']/, "");
+}
 /**
 * Apply the optional project directory variable prefix to a command string.
 */
@@ -11969,8 +12897,10 @@ function applyCommandPrefix({ def, converterConfig }) {
 	const unquotedCommand = trimmedCommand?.replace(/^["']/, "");
 	const isDotRelativeCommand = unquotedCommand?.startsWith(".") ?? false;
 	const isAbsoluteCommand = typeof unquotedCommand === "string" && (posix.isAbsolute(unquotedCommand) || win32.isAbsolute(unquotedCommand) || unquotedCommand.startsWith("~/"));
+	const isExecForm = (converterConfig.arrayPassthroughFields?.some(({ canonical }) => canonical === "args") ?? false) && Array.isArray(def.args);
 	if (!(converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && !isAbsoluteCommand && (!converterConfig.prefixDotRelativeCommandsOnly || isDotRelativeCommand)) || typeof trimmedCommand !== "string") return def.command;
 	const relativeCommand = trimmedCommand.replace(/^(["'])\.\//, "$1").replace(/^\.\//, "");
+	if (isExecForm) return `${bracePlaceholder(converterConfig.projectDirVar)}/${stripSurroundingQuotes(relativeCommand)}`;
 	return `"${converterConfig.projectDirVar}"/${relativeCommand}`;
 }
 /**
@@ -11978,8 +12908,11 @@ function applyCommandPrefix({ def, converterConfig }) {
 * canonical field name to its (possibly renamed) tool field name. Only boolean
 * values are carried through.
 */
-function emitBooleanPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "boolean").map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitBooleanPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return typeof def[canonical] === "boolean";
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured boolean passthrough fields back into canonical fields,
@@ -11993,8 +12926,11 @@ function importBooleanPassthroughFields({ h, converterConfig }) {
 * canonical field name to its (possibly renamed) tool field name. Only non-empty
 * string values are carried through.
 */
-function emitStringPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "string" && def[canonical] !== "").map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitStringPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return typeof def[canonical] === "string" && def[canonical] !== "";
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured string passthrough fields back into canonical fields,
@@ -12007,8 +12943,11 @@ function importStringPassthroughFields({ h, converterConfig }) {
 /**
 * Emit the configured string-array passthrough fields on the tool side.
 */
-function emitArrayPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.arrayPassthroughFields ?? []).filter(({ canonical }) => isStringArray(def[canonical])).map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitArrayPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.arrayPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return isStringArray(def[canonical]);
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured string-array passthrough fields, reversing
@@ -12085,14 +13024,17 @@ function buildToolHooks({ defs, converterConfig }) {
 		hooks.push({
 			...emitBooleanPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			...emitStringPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			...emitArrayPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			type: hookType,
@@ -12176,6 +13118,8 @@ function stripCommandPrefix({ command, converterConfig }) {
 	if (converterConfig.projectDirVar === "" || typeof cmd !== "string") return cmd;
 	const quotedPrefix = `"${converterConfig.projectDirVar}"/`;
 	if (cmd.startsWith(quotedPrefix)) return `./${cmd.slice(quotedPrefix.length)}`;
+	const bracedPrefix = `${bracePlaceholder(converterConfig.projectDirVar)}/`;
+	if (cmd.startsWith(bracedPrefix)) return `./${cmd.slice(bracedPrefix.length)}`;
 	if (cmd.includes(`${converterConfig.projectDirVar}/`)) {
 		const escapedVar = converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 		return cmd.replace(new RegExp(`^${escapedVar}\\/?`), "./");
@@ -12723,7 +13667,10 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"taskCreated",
 		"taskCompleted",
 		"teammateIdle",
-		"cwdChanged"
+		"cwdChanged",
+		"beforeSubmitPrompt",
+		"stop",
+		"directoryAdded"
 	]),
 	supportedHookTypes: /* @__PURE__ */ new Set([
 		"command",
@@ -12733,9 +13680,45 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"agent"
 	]),
 	emitsPromptModel: true,
-	stringPassthroughFields: [{
-		canonical: "if",
-		tool: "if"
+	stringPassthroughFields: [
+		{
+			canonical: "if",
+			tool: "if"
+		},
+		{
+			canonical: "statusMessage",
+			tool: "statusMessage"
+		},
+		{
+			canonical: "shell",
+			tool: "shell",
+			commandOnly: true
+		}
+	],
+	booleanPassthroughFields: [
+		{
+			canonical: "once",
+			tool: "once"
+		},
+		{
+			canonical: "async",
+			tool: "async",
+			commandOnly: true
+		},
+		{
+			canonical: "asyncRewake",
+			tool: "asyncRewake",
+			commandOnly: true
+		},
+		{
+			canonical: "continueOnBlock",
+			tool: "continueOnBlock"
+		}
+	],
+	arrayPassthroughFields: [{
+		canonical: "args",
+		tool: "args",
+		commandOnly: true
 	}]
 };
 var ClaudecodeHooks = class extends ToolHooks {
@@ -12843,7 +13826,14 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: CODEXCLI_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
-	passthroughFields: ["name", "description"]
+	passthroughFields: ["name", "description"],
+	stringPassthroughFields: [{
+		canonical: "commandWindows",
+		tool: "commandWindows"
+	}, {
+		canonical: "statusMessage",
+		tool: "statusMessage"
+	}]
 };
 /**
 * Build the content for `.codex/config.toml`, cleaning up the deprecated `codex_hooks` key.
@@ -13091,7 +14081,11 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			fileContent: params.fileContent ?? "{}"
 		});
 	}
-	static getSettablePaths(_options = {}) {
+	static getSettablePaths({ global = false } = {}) {
+		if (global) return {
+			relativeDirPath: COPILOT_GLOBAL_HOOKS_DIR_PATH,
+			relativeFilePath: COPILOT_GLOBAL_HOOKS_FILE_NAME
+		};
 		return {
 			relativeDirPath: COPILOT_HOOKS_DIR_PATH,
 			relativeFilePath: COPILOT_HOOKS_FILE_NAME
@@ -13105,11 +14099,12 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true }) {
-		const paths = CopilotHooks.getSettablePaths();
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+		const paths = CopilotHooks.getSettablePaths({ global });
 		const copilotHooks = canonicalToCopilotHooks(rulesyncHooks.getJson());
 		const fileContent = JSON.stringify({
 			version: 1,
@@ -13120,7 +14115,8 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
 	toRulesyncHooks(options) {
@@ -13164,10 +14160,16 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 * (`sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`, `preMcpToolCall`). Each entry supports three hook types:
+* `notification`, `userPromptTransformed`, `preMcpToolCall`). Each entry
+* supports three hook types:
 *
 * - `command` — the `bash` / `powershell` command-field shape with optional
-*   `timeoutSec`, plus optional `cwd` / `env`.
+*   `timeoutSec`, plus optional `cwd` / `env`. Upstream also accepts the
+*   portable `command` field (copied to both shells when neither is present)
+*   and `timeout` as an alias for `timeoutSec`; rulesync reads both on import.
+*   On generate the canonical `shell` selector picks `bash` or `powershell`,
+*   and without it the portable `command` field is written — so the generated
+*   file does not depend on the machine rulesync ran on.
 * - `prompt` — a `prompt` string (Copilot CLI only honors prompt hooks on
 *   `sessionStart`, so prompt hooks on other events are skipped).
 * - `http` — `url` / `headers` / `allowedEnvVars` with optional `timeoutSec`.
@@ -13193,11 +14195,11 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 *   all rulesync-managed Copilot CLI files under the single `~/.copilot/`
 *   root and will revisit if the spec later mandates an alternate layout.
 *
-* Hook entries on `preToolUse` / `postToolUse` may carry an optional `matcher`
-* field (a regex compiled as `^(?:PATTERN)$`, tested against `toolName`); it is
-* emitted on those events and dropped (with a warning) on any other event,
-* which never honors matchers. See changelog v1.0.36 (2026-04-24) and v1.0.63
-* (2026-06-15). Reference: https://docs.github.com/en/copilot/reference/hooks-reference
+* Hook entries on the six matcher-aware events (see
+* {@link COPILOTCLI_MATCHER_EVENTS}) may carry an optional `matcher` regex; it
+* is emitted on those events and dropped (with a warning) on any other event,
+* which never honors matchers.
+* Reference: https://docs.github.com/en/copilot/reference/hooks-reference
 *
 * The output JSON schema and platform-specific `bash` / `powershell` command
 * field selection match `copilot-hooks.ts`, but the event surface diverges (the
@@ -13212,19 +14214,30 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 * `Edit|Write`) are now honored instead of silently dropped").
 * @see https://docs.github.com/en/copilot/reference/hooks-reference
 */
-const COPILOTCLI_MATCHER_EVENTS = /* @__PURE__ */ new Set(["preToolUse", "postToolUse"]);
+const COPILOTCLI_MATCHER_EVENTS = /* @__PURE__ */ new Set([
+	"preToolUse",
+	"postToolUse",
+	"notification",
+	"permissionRequest",
+	"preCompact",
+	"subagentStart"
+]);
+/** Human-readable list of the matcher-aware events, for the drop warning. */
+const COPILOTCLI_MATCHER_EVENTS_LABEL = [...COPILOTCLI_MATCHER_EVENTS].join("/");
 const CopilotCliHookEntrySchema = z.looseObject({
 	type: z._default(z.string(), "command"),
 	matcher: z.optional(z.string()),
 	bash: z.optional(z.string()),
 	powershell: z.optional(z.string()),
+	command: z.optional(z.string()),
 	prompt: z.optional(z.string()),
 	url: z.optional(z.string()),
 	headers: z.optional(z.record(z.string(), z.string())),
 	allowedEnvVars: z.optional(z.array(z.string())),
 	cwd: z.optional(z.string()),
 	env: z.optional(z.record(z.string(), z.string())),
-	timeoutSec: z.optional(z.number())
+	timeoutSec: z.optional(z.number()),
+	timeout: z.optional(z.number())
 });
 /** Filter the shared config hooks down to events the Copilot CLI supports. */
 function filterSupportedCopilotCliHooks(hooks) {
@@ -13235,21 +14248,21 @@ function filterSupportedCopilotCliHooks(hooks) {
 }
 /**
 * Resolve the `matcher` part for an exported entry. Copilot CLI honors `matcher`
-* only on preToolUse/postToolUse entries; on any other event a matcher would be
-* silently dropped by the CLI, so we drop it here with a warning rather than
-* emitting a dead field.
+* only on the events listed in {@link COPILOTCLI_MATCHER_EVENTS}; on any other
+* event a matcher would be silently dropped by the CLI, so we drop it here with
+* a warning rather than emitting a dead field.
 */
 function resolveExportMatcherPart({ matcher, matcherSupported, eventName, logger }) {
 	if (matcher === void 0 || matcher === null || matcher === "") return {};
 	if (matcherSupported) return { matcher };
-	logger?.warn(`Copilot CLI hook matchers are only honored on preToolUse/postToolUse; dropping matcher "${matcher}" on '${eventName}'.`);
+	logger?.warn(`Copilot CLI hook matchers are only honored on ${COPILOTCLI_MATCHER_EVENTS_LABEL}; dropping matcher "${matcher}" on '${eventName}'.`);
 	return {};
 }
 /**
 * Build the exported entries for a single canonical event. Returns an empty
 * array when no entries are emitted (e.g. all prompt hooks were skipped).
 */
-function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchemaKeys, commandField, logger }) {
+function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchemaKeys, logger }) {
 	const matcherSupported = COPILOTCLI_MATCHER_EVENTS.has(eventName);
 	const entries = [];
 	for (const def of definitions) {
@@ -13285,22 +14298,24 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else if (hookType === "command") entries.push({
-			type: "command",
-			...matcherPart,
-			...compact({
-				[commandField]: def.command,
-				env: def.env
-			}),
-			...timeoutPart,
-			...rest
-		});
+		else if (hookType === "command") {
+			const commandField = def.shell ?? "command";
+			entries.push({
+				type: "command",
+				...matcherPart,
+				...compact({
+					[commandField]: def.command,
+					env: def.env
+				}),
+				...timeoutPart,
+				...rest
+			});
+		}
 	}
 	return entries;
 }
 function canonicalToCopilotCliHooks(config, logger) {
 	const canonicalSchemaKeys = Object.keys(HookDefinitionSchema.shape);
-	const commandField = process.platform === "win32" ? "powershell" : "bash";
 	const effectiveHooks = {
 		...filterSupportedCopilotCliHooks(config.hooks),
 		...config.copilot?.hooks,
@@ -13313,7 +14328,6 @@ function canonicalToCopilotCliHooks(config, logger) {
 			eventName,
 			definitions,
 			canonicalSchemaKeys,
-			commandField,
 			logger
 		});
 		if (entries.length > 0) out[copilotEventName] = entries;
@@ -13330,6 +14344,13 @@ function importPassthrough(entry) {
 	if (entry.env !== void 0) passthrough.env = entry.env;
 	return passthrough;
 }
+/**
+* Resolve the canonical command and its `shell` selector from an imported entry.
+*
+* A shell-specific field carries its `shell` through so re-export writes the
+* same field back. An entry using only the portable `command` field leaves
+* `shell` unset, which re-export renders as the portable field again.
+*/
 function resolveImportCommand(entry, logger) {
 	const hasBash = typeof entry.bash === "string";
 	const hasPowershell = typeof entry.powershell === "string";
@@ -13338,9 +14359,22 @@ function resolveImportCommand(entry, logger) {
 		const chosen = isWindows ? "powershell" : "bash";
 		const ignored = isWindows ? "bash" : "powershell";
 		logger?.warn(`Copilot CLI hook has both bash and powershell commands; using ${chosen} and ignoring ${ignored} on this platform.`);
-		return isWindows ? entry.powershell : entry.bash;
-	} else if (hasBash) return entry.bash;
-	else if (hasPowershell) return entry.powershell;
+		return isWindows ? {
+			command: entry.powershell,
+			shell: "powershell"
+		} : {
+			command: entry.bash,
+			shell: "bash"
+		};
+	} else if (hasBash) return {
+		command: entry.bash,
+		shell: "bash"
+	};
+	else if (hasPowershell) return {
+		command: entry.powershell,
+		shell: "powershell"
+	};
+	return typeof entry.command === "string" ? { command: entry.command } : {};
 }
 function copilotCliHooksToCanonical(rawHooks, logger) {
 	if (rawHooks === null || rawHooks === void 0 || typeof rawHooks !== "object") return {};
@@ -13353,7 +14387,7 @@ function copilotCliHooksToCanonical(rawHooks, logger) {
 			const parseResult = CopilotCliHookEntrySchema.safeParse(rawEntry);
 			if (!parseResult.success) continue;
 			const entry = parseResult.data;
-			const timeout = entry.timeoutSec;
+			const timeout = entry.timeoutSec ?? entry.timeout;
 			const timeoutPart = timeout !== void 0 ? { timeout } : {};
 			const matcherPart = entry.matcher !== void 0 && entry.matcher !== "" ? { matcher: entry.matcher } : {};
 			const passthrough = importPassthrough(entry);
@@ -13372,10 +14406,11 @@ function copilotCliHooksToCanonical(rawHooks, logger) {
 				...passthrough
 			});
 			else {
-				const command = resolveImportCommand(entry, logger);
+				const { command, shell } = resolveImportCommand(entry, logger);
 				defs.push({
 					type: "command",
 					...command !== void 0 && { command },
+					...shell !== void 0 && { shell },
 					...matcherPart,
 					...timeoutPart,
 					...passthrough
@@ -14025,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,
@@ -14328,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,
@@ -14365,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({
@@ -14515,7 +15499,23 @@ var JunieHooks = class JunieHooks extends ToolHooks {
 };
 //#endregion
 //#region src/features/hooks/opencode-style-generator.ts
-const NAMED_HOOKS = /* @__PURE__ */ new Set(["tool.execute.before", "tool.execute.after"]);
+/**
+* Tool events emitted as named `(input, ...)` hooks rather than through the
+* generic `event.type` dispatch, mapped to the expression a hook's `matcher`
+* regex is tested against — or `null` when the hook has no matchable subject,
+* in which case a matcher is dropped rather than compiled against a field that
+* does not exist.
+*
+* `experimental.session.compacting` receives `(input, output)` and exposes no
+* per-invocation identifier worth matching on, so it takes `null`.
+*
+* @see https://opencode.ai/docs/plugins/
+*/
+const NAMED_HOOK_MATCHER_SUBJECTS = {
+	"tool.execute.before": "input.tool",
+	"tool.execute.after": "input.tool",
+	"experimental.session.compacting": null
+};
 function escapeForTemplateLiteral(command) {
 	return command.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
@@ -14548,7 +15548,7 @@ function collectOpencodeStyleHandlers({ effectiveHooks, eventMap, namedEventHand
 			});
 		}
 		if (handlers.length > 0) {
-			const grouped = NAMED_HOOKS.has(toolEvent) ? namedEventHandlers : genericEventHandlers;
+			const grouped = Object.hasOwn(NAMED_HOOK_MATCHER_SUBJECTS, toolEvent) ? namedEventHandlers : genericEventHandlers;
 			const existing = grouped[toolEvent];
 			if (existing) existing.push(...handlers);
 			else grouped[toolEvent] = handlers;
@@ -14577,14 +15577,15 @@ function buildGenericEventBodyLines(genericEventHandlers) {
 function buildNamedEventBodyLines(namedEventHandlers) {
 	const bodyLines = [];
 	for (const [eventName, handlers] of Object.entries(namedEventHandlers)) {
+		const matcherSubject = NAMED_HOOK_MATCHER_SUBJECTS[eventName] ?? null;
 		bodyLines.push(`    "${eventName}": async (input) => {`);
 		for (const handler of handlers) {
 			const escapedCommand = escapeForTemplateLiteral(handler.command);
-			if (handler.matcher) {
+			if (handler.matcher && matcherSubject !== null) {
 				const safeMatcher = validateAndSanitizeMatcher(handler.matcher);
 				bodyLines.push("      {");
 				bodyLines.push(`        const __re = new RegExp("${safeMatcher}");`);
-				bodyLines.push(`        if (__re.test(input.tool)) {`);
+				bodyLines.push(`        if (__re.test(${matcherSubject})) {`);
 				bodyLines.push(`          await $\`${escapedCommand}\`;`);
 				bodyLines.push("        }");
 				bodyLines.push("      }");
@@ -14724,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
@@ -14823,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({
@@ -16220,7 +17258,7 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		class: CopilotHooks,
 		meta: {
 			supportsProject: true,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			supportsImport: true
 		},
 		supportedEvents: COPILOT_HOOK_EVENTS,
@@ -17520,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.
@@ -17677,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";
@@ -17689,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.
@@ -17705,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
 		});
 	}
 };
@@ -17768,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 }],
@@ -17778,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);
@@ -18697,8 +19904,20 @@ const RULESYNC_TO_CODEX_FIELD_MAP = {
 	disabledTools: "disabled_tools",
 	envVars: "env_vars"
 };
+const RULESYNC_TO_CODEX_SCALAR_FIELD_MAP = { experimentalEnvironment: "experimental_environment" };
+const CODEX_TO_RULESYNC_SCALAR_FIELD_MAP = Object.fromEntries(Object.entries(RULESYNC_TO_CODEX_SCALAR_FIELD_MAP).map(([canonical, codex]) => [codex, canonical]));
 const MAX_REMOVE_EMPTY_ENTRIES_DEPTH$1 = 32;
 /**
+* `env_vars` entries are either a bare variable name or `{ name, source }`,
+* where `source = "remote"` reads the variable from the remote executor
+* environment. The other renamed keys (`enabled_tools`, `disabled_tools`) stay
+* plain string arrays, so the widened check applies to `env_vars` only.
+* @see https://learn.chatgpt.com/docs/extend/mcp
+*/
+function isValidRenamedArray(key, value) {
+	return key === "env_vars" || key === "envVars" ? isEnvVarEntryArray(value) : isStringArray$1(value);
+}
+/**
 * Translate a server's `oauth` table from the canonical rulesync shape (Claude
 * Code style camelCase) into the shape Codex CLI understands. Codex expects the
 * OAuth client id under snake_case `client_id`; without it `codex mcp login`
@@ -18758,8 +19977,12 @@ function convertFromCodexFormat(codexMcp) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthFromCodex(value);
 			else if (Object.hasOwn(CODEX_TO_RULESYNC_FIELD_MAP, key)) {
 				const mappedKey = CODEX_TO_RULESYNC_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `Ignored malformed array for ${key} in MCP server ${name}`);
+			} else if (Object.hasOwn(CODEX_TO_RULESYNC_SCALAR_FIELD_MAP, key)) {
+				const mappedKey = CODEX_TO_RULESYNC_SCALAR_FIELD_MAP[key];
+				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
+				else warnWithFallback(void 0, `Ignored malformed value for ${key} in MCP server ${name}: expected a string`);
 			} else converted[key] = value;
 		}
 		result[name] = converted;
@@ -18781,8 +20004,12 @@ function convertToCodexFormat(mcpServers) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthToCodex(value);
 			else if (Object.hasOwn(RULESYNC_TO_CODEX_FIELD_MAP, key)) {
 				const mappedKey = RULESYNC_TO_CODEX_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string array, got ${typeof value}`);
+			} else if (Object.hasOwn(RULESYNC_TO_CODEX_SCALAR_FIELD_MAP, key)) {
+				const mappedKey = RULESYNC_TO_CODEX_SCALAR_FIELD_MAP[key];
+				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
+				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string, got ${typeof value}`);
 			} else converted[key] = value;
 		}
 		const previousName = originalNames.get(codexName);
@@ -18853,7 +20080,9 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			const rawServer = isRecord(rawMcpServers) ? rawMcpServers[serverName] : void 0;
 			return [serverName, {
 				...serverConfig,
-				...isRecord(rawServer) && isStringArray$1(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
+				...isRecord(rawServer) && isEnvVarEntryArray(rawServer.envVars) ? { envVars: rawServer.envVars } : {},
+				...isRecord(rawServer) && typeof rawServer.experimental_environment === "string" ? { experimentalEnvironment: rawServer.experimental_environment } : {},
+				...isRecord(rawServer) && typeof rawServer.experimentalEnvironment === "string" ? { experimentalEnvironment: rawServer.experimentalEnvironment } : {}
 			}];
 		})));
 		const filteredMcpServers = this.removeEmptyEntries(converted);
@@ -18924,9 +20153,6 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/copilot-mcp.ts
-function convertToCopilotFormat(mcpServers) {
-	return { servers: mcpServers };
-}
 function convertFromCopilotFormat(copilotConfig) {
 	return copilotConfig.servers ?? {};
 }
@@ -18955,13 +20181,21 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 			validate
 		});
 	}
-	static fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true }) {
-		const copilotConfig = convertToCopilotFormat(rulesyncMcp.getMcpServers());
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true }) {
+		const paths = this.getSettablePaths();
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
 		return new CopilotMcp({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
-			fileContent: JSON.stringify(copilotConfig, null, 2),
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { servers: rulesyncMcp.getMcpServers() },
+				filePath
+			}),
 			validate
 		});
 	}
@@ -20347,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 }
@@ -20365,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 });
@@ -20391,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 }
@@ -20644,7 +21885,7 @@ const KILO_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
 * impossible to start — no command, no URL — so it is written as the toggle it
 * resembles rather than dropped, but the loss is said out loud.
 */
-function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
+function warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger) {
 	const dropped = Object.keys(serverConfig).filter((key) => !KILO_TOGGLE_KEPT_KEYS.has(key));
 	if (dropped.length === 0) return;
 	logger?.warn(`Kilo MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
@@ -20657,7 +21898,7 @@ function convertServerToKiloFormat(serverName, serverConfig, existingEntry, logg
 	if (declaresNoTransport(serverConfig)) {
 		if (serverConfig.disabled === void 0) {
 			if (existingEntry !== void 0 && !isKiloTransportServer(existingEntry)) {
-				warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+				warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger);
 				return existingEntry;
 			}
 			return warnAndSkipMcpServer({
@@ -20667,7 +21908,7 @@ function convertServerToKiloFormat(serverName, serverConfig, existingEntry, logg
 				logger
 			});
 		}
-		warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+		warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger);
 		return { enabled: !serverConfig.disabled };
 	}
 	if (isRemoteMcpServer(serverConfig)) {
@@ -20852,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
 	*/
@@ -21067,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: {
@@ -21154,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
@@ -21293,13 +22534,49 @@ const OpencodeMcpRemoteServerSchema = z.looseObject({
 	headers: z.optional(z.record(z.string(), z.string())),
 	enabled: z._default(z.boolean(), true)
 });
-const OpencodeMcpServerSchema = z.union([OpencodeMcpLocalServerSchema, OpencodeMcpRemoteServerSchema]);
+const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
+const OPENCODE_MCP_TRANSPORT_KEYS = [
+	...Object.keys(OpencodeMcpLocalServerSchema.def.shape),
+	...Object.keys(OpencodeMcpRemoteServerSchema.def.shape),
+	...OPENCODE_PASSTHROUGH_SERVER_FIELDS
+].filter((key) => key !== "enabled");
+/**
+* A bare toggle entry: `{"enabled": <bool>}` with no transport of its own,
+* disabling a server another config layer defines. It is the third member of
+* OpenCode's own `mcp` union in the published schema, described in-source as
+* "the legacy `{ enabled: false }` form used to disable a server". Without this
+* arm the union rejects the entry and the whole MCP import aborts — taking
+* every valid server in the same file down with it.
+*
+* Loose, unlike the two transport arms, so a key OpenCode adds to a toggle
+* later does not bring that abort back — but refined to reject anything
+* carrying a key only a transport entry has. A plain loose arm would sit under
+* a malformed `local` or `remote` entry that happens to carry `enabled` and
+* swallow it, dropping its command, URL, or headers without a word instead of
+* failing the way it does today. Mirrors {@link KiloMcpToggleSchema}.
+*
+* @see https://opencode.ai/config.json
+*/
+const OpencodeMcpToggleSchema = z.looseObject({ enabled: z.boolean() }).check(refine((entry) => OPENCODE_MCP_TRANSPORT_KEYS.every((key) => !(key in entry)), "not a valid OpenCode MCP server: expected a local server ({type: \"local\", command: [...]}), a remote server ({type: \"remote\", url: \"...\"}), or a bare toggle ({enabled: <bool>}) carrying no field of either"));
+const OpencodeMcpServerSchema = z.union([
+	OpencodeMcpLocalServerSchema,
+	OpencodeMcpRemoteServerSchema,
+	OpencodeMcpToggleSchema
+]);
 const OpencodeConfigSchema = z.looseObject({
 	$schema: z.optional(z.string()),
 	mcp: z.optional(z.record(z.string(), OpencodeMcpServerSchema)),
 	tools: z.optional(z.record(z.string(), z.boolean()))
 });
 /**
+* Tell the two transport arms from a toggle entry. Both carry a `type` literal
+* and a toggle never does — the schema refuses one that tries — but the toggle
+* arm is loose, so its index signature hides that from `in` narrowing.
+*/
+function isOpencodeTransportServer(server) {
+	return server.type === "local" || server.type === "remote";
+}
+/**
 * Convert OpenCode native format back to standard MCP format
 * - type: "local" -> "stdio", "remote" -> "sse"
 * - command (array) -> command (first element) + args (rest)
@@ -21324,19 +22601,31 @@ function convertFromOpencodeFormat(opencodeMcp, tools) {
 		...convertOpencodeServers(opencodeMcp, tools)
 	};
 }
+/** Split the shared top-level `tools` map into this server's own two lists. */
+function splitOpencodeServerTools(serverName, tools) {
+	const enabledTools = [];
+	const disabledTools = [];
+	const prefix = `${serverName}_`;
+	for (const [toolName, enabled] of Object.entries(tools ?? {})) {
+		if (!toolName.startsWith(prefix)) continue;
+		const toolSuffix = toolName.slice(prefix.length);
+		(enabled ? enabledTools : disabledTools).push(toolSuffix);
+	}
+	return {
+		enabledTools,
+		disabledTools
+	};
+}
 function convertOpencodeServers(opencodeMcp, tools) {
 	return Object.fromEntries(Object.entries(opencodeMcp).map(([serverName, serverConfig]) => {
 		const extraFields = Object.fromEntries(Object.entries(serverConfig).filter(([key]) => !OPENCODE_KNOWN_SERVER_KEYS.has(key)));
-		const enabledTools = [];
-		const disabledTools = [];
-		const prefix = `${serverName}_`;
-		if (tools) {
-			for (const [toolName, enabled] of Object.entries(tools)) if (toolName.startsWith(prefix)) {
-				const toolSuffix = toolName.slice(prefix.length);
-				if (enabled) enabledTools.push(toolSuffix);
-				else disabledTools.push(toolSuffix);
-			}
-		}
+		const { enabledTools, disabledTools } = splitOpencodeServerTools(serverName, tools);
+		if (!isOpencodeTransportServer(serverConfig)) return [serverName, {
+			...extraFields,
+			disabled: serverConfig.enabled === false,
+			...enabledTools.length > 0 && { enabledTools },
+			...disabledTools.length > 0 && { disabledTools }
+		}];
 		if (serverConfig.type === "remote") return [serverName, {
 			...extraFields,
 			type: "sse",
@@ -21366,7 +22655,20 @@ function convertOpencodeServers(opencodeMcp, tools) {
 		}];
 	}));
 }
-const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
+const OPENCODE_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
+	"disabled",
+	"enabledTools",
+	"disabledTools"
+]);
+/**
+* Warn about the fields a transport-less server loses by being written as a
+* bare toggle, so the drop is never silent.
+*/
+function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
+	const dropped = Object.keys(serverConfig).filter((key) => !OPENCODE_TOGGLE_KEPT_KEYS.has(key));
+	if (dropped.length === 0) return;
+	logger?.warn(`OpenCode MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
+}
 /**
 * Convert standard MCP format to OpenCode native format
 * - type: "stdio" -> "local", "sse"/"http" -> "remote"
@@ -21376,11 +22678,27 @@ const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
 * - enabledTools/disabledTools -> top-level tools map (with server name prefix)
 * - OpenCode-supported extras (timeout, oauth) -> passed through verbatim
 */
-function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
+function convertServerToOpencodeFormat(serverName, serverConfig, existingEntry, logger) {
 	const serverRecord = serverConfig;
 	const passthrough = {};
 	for (const key of OPENCODE_PASSTHROUGH_SERVER_FIELDS) if (serverRecord[key] !== void 0) passthrough[key] = serverRecord[key];
 	const enabled = serverConfig.disabled !== void 0 ? !serverConfig.disabled : true;
+	if (declaresNoTransport(serverConfig)) {
+		if (serverConfig.disabled === void 0) {
+			if (existingEntry !== void 0 && !isOpencodeTransportServer(existingEntry)) {
+				warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+				return existingEntry;
+			}
+			return warnAndSkipMcpServer({
+				toolName: "OpenCode",
+				serverName,
+				reason: "no transport and no enabled state, so there is nothing to toggle",
+				logger
+			});
+		}
+		warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+		return { enabled };
+	}
 	if (isRemoteMcpServer(serverConfig)) {
 		const url = resolveRemoteMcpUrl(serverConfig);
 		if (url === void 0) return warnAndSkipMcpServer({
@@ -21401,7 +22719,7 @@ function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
 	if (commandArray.length === 0) return warnAndSkipMcpServer({
 		toolName: "OpenCode",
 		serverName,
-		reason: declaresNoTransport(serverConfig) ? "no transport at all" : "a local transport but no command",
+		reason: "a local transport but no command",
 		logger
 	});
 	return {
@@ -21413,11 +22731,11 @@ function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
 		...serverConfig.cwd && { cwd: serverConfig.cwd }
 	};
 }
-function convertToOpencodeFormat(mcpServers, logger) {
+function convertToOpencodeFormat(mcpServers, existingMcp, logger) {
 	const tools = {};
 	return {
 		mcp: Object.fromEntries(Object.entries(mcpServers).map(([serverName, serverConfig]) => {
-			const converted = convertServerToOpencodeFormat(serverName, serverConfig, logger);
+			const converted = convertServerToOpencodeFormat(serverName, serverConfig, existingMcp[serverName], logger);
 			if (serverConfig.enabledTools) for (const tool of serverConfig.enabledTools) tools[`${serverName}_${tool}`] = true;
 			if (serverConfig.disabledTools) for (const tool of serverConfig.disabledTools) tools[`${serverName}_${tool}`] = false;
 			return converted === null ? null : [serverName, converted];
@@ -21487,10 +22805,12 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
-		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(convertEnvVarRefsToToolFormat({
+		const transformedServers = convertEnvVarRefsToToolFormat({
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
-		}), logger);
+		});
+		const existingMcp = OpencodeConfigSchema.safeParse(parse(fileContent || "{}"));
+		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(transformedServers, (existingMcp.success ? existingMcp.data.mcp : void 0) ?? {}, logger);
 		return new OpencodeMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -22715,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
 		}];
 	}
@@ -23800,10 +25115,11 @@ function buildPermissionEntry$1(toolName, pattern) {
 * file (global scope only). The file holds other CLI settings besides
 * permissions, so it is never deleted.
 *
-* Two CLI-only autonomy/sandbox knobs outside the allow/ask/deny arrays —
-* `toolPermission` (the global autonomy preset) and `enableTerminalSandbox` — are
-* authored and round-tripped through the `antigravity-cli` permissions override
-* (see `AntigravityCliPermissionsOverrideSchema`).
+* Four CLI-only autonomy/sandbox knobs outside the allow/ask/deny arrays —
+* `toolPermission` (the global autonomy preset), `enableTerminalSandbox`,
+* `artifactReviewPolicy` and `allowNonWorkspaceAccess` — are authored and
+* round-tripped through the `antigravity-cli` permissions override (see
+* `AntigravityCliPermissionsOverrideSchema`).
 */
 var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPermissions {
 	constructor(params) {
@@ -23867,6 +25183,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 		const override = config["antigravity-cli"];
 		if (override?.toolPermission !== void 0) merged.toolPermission = override.toolPermission;
 		if (override?.enableTerminalSandbox !== void 0) merged.enableTerminalSandbox = override.enableTerminalSandbox;
+		if (override?.artifactReviewPolicy !== void 0) merged.artifactReviewPolicy = override.artifactReviewPolicy;
+		if (override?.allowNonWorkspaceAccess !== void 0) merged.allowNonWorkspaceAccess = override.allowNonWorkspaceAccess;
 		const fileContent = JSON.stringify(merged, null, 2);
 		return new AntigravityCliPermissions({
 			outputRoot,
@@ -23893,6 +25211,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 		const override = {};
 		if (typeof settings.toolPermission === "string") override.toolPermission = settings.toolPermission;
 		if (typeof settings.enableTerminalSandbox === "boolean") override.enableTerminalSandbox = settings.enableTerminalSandbox;
+		if (typeof settings.artifactReviewPolicy === "string") override.artifactReviewPolicy = settings.artifactReviewPolicy;
+		if (typeof settings.allowNonWorkspaceAccess === "boolean") override.allowNonWorkspaceAccess = settings.allowNonWorkspaceAccess;
 		const result = { ...config };
 		if (Object.keys(override).length > 0) result["antigravity-cli"] = override;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -24696,12 +26016,57 @@ function parseClaudePermissionEntry(entry) {
 	};
 }
 /**
+* Claude Code's file permission checks match only `Edit(path)` and `Read(path)`
+* rules. A `Write(path)`, `NotebookEdit(path)` or `Glob(path)` rule "is accepted
+* but never matched by those checks, so Claude Code warns at startup for each
+* allow, deny, or ask rule in one of these unmatched forms" — so a canonical
+* `write`/`notebookedit`/`glob` rule with a pattern is emitted in the form the
+* docs prescribe instead. A tool-name rule with no path is unaffected: it
+* matches the tool everywhere and produces no warning.
+* @see https://code.claude.com/docs/en/permissions
+*/
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Merge `patch` into `base`, recursing into plain objects so a sibling key at
+* any depth survives. Arrays and scalars are replaced, since a list the author
+* states is the list they mean.
+*/
+function deepMergeRecords(base, patch) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(patch)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+		const existing = merged[key];
+		merged[key] = isPlainRecord(existing) && isPlainRecord(value) ? deepMergeRecords(existing, value) : value;
+	}
+	return merged;
+}
+const CLAUDE_PATH_RULE_ALIASES = {
+	Write: "Edit",
+	NotebookEdit: "Edit",
+	Glob: "Read"
+};
+/**
 * Build a Claude Code permission entry like "Bash(npm run *)".
 * If the pattern is "*", returns just the tool name.
 */
 function buildClaudePermissionEntry(toolName, pattern) {
 	if (pattern === "*") return toolName;
-	return `${toolName}(${pattern})`;
+	return `${CLAUDE_PATH_RULE_ALIASES[toolName] ?? toolName}(${pattern})`;
+}
+/**
+* The Claude tool names the canonical config manages. Deliberately the tool
+* names the categories map to and *not* the aliases a path rule is rewritten
+* to: claiming `Edit` because a `write` rule exists would sweep away the
+* `Read`/`Edit` entries the ignore feature and the user wrote in the same file.
+* The rewritten entries are still rulesync's to place — `applyPermissions`
+* replaces an entry this run emits wherever it currently sits — and the
+* original name stays claimed so an entry an older rulesync wrote in the warned
+* form is cleaned up on the next generate.
+*/
+function managedClaudeToolNames(config) {
+	return new Set(Object.keys(config.permission).map((category) => toClaudeToolName(category)));
 }
 var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions {
 	constructor(params) {
@@ -24741,7 +26106,10 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 			throw new Error(`Failed to parse existing Claude settings at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
 		const config = rulesyncPermissions.getJson();
-		const { allow, ask, deny } = convertRulesyncToClaudePermissions(config);
+		const { allow, ask, deny } = convertRulesyncToClaudePermissions({
+			config,
+			logger
+		});
 		const overridePermissions = config.claudecode?.permissions;
 		if (overridePermissions && typeof overridePermissions === "object") {
 			const { allow: _a, ask: _k, deny: _d, ...nonListFields } = overridePermissions;
@@ -24750,7 +26118,9 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 				...nonListFields
 			};
 		}
-		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toClaudeToolName(category)));
+		const overrideSandbox = config.claudecode?.sandbox;
+		if (isPlainRecord(overrideSandbox)) settings.sandbox = deepMergeRecords(isPlainRecord(settings.sandbox) ? settings.sandbox : {}, overrideSandbox);
+		const managedToolNames = managedClaudeToolNames(config);
 		const merged = applyPermissions({
 			settings,
 			managedToolNames,
@@ -24784,6 +26154,11 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 		});
 		const { allow: _a, ask: _k, deny: _d, ...nonListFields } = permissions;
 		if (Object.keys(nonListFields).length > 0) config.claudecode = { permissions: nonListFields };
+		const { sandbox } = settings;
+		if (isPlainRecord(sandbox) && Object.keys(sandbox).length > 0) config.claudecode = {
+			...config.claudecode,
+			sandbox
+		};
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
 	}
 	validate() {
@@ -24805,14 +26180,18 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 /**
 * Convert rulesync permissions config to Claude Code allow/ask/deny arrays.
 */
-function convertRulesyncToClaudePermissions(config) {
+function convertRulesyncToClaudePermissions({ config, logger }) {
 	const allow = [];
 	const ask = [];
 	const deny = [];
+	const actionByEntry = /* @__PURE__ */ new Map();
 	for (const [category, rules] of Object.entries(config.permission)) {
 		const claudeToolName = toClaudeToolName(category);
 		for (const [pattern, action] of Object.entries(rules)) {
 			const entry = buildClaudePermissionEntry(claudeToolName, pattern);
+			const previous = actionByEntry.get(entry);
+			if (previous !== void 0 && previous !== action) logger?.warn(`Claude Code permissions: rules from different categories both resolve to "${entry}" with conflicting actions (${previous} and ${action}). Both are written; Claude Code applies deny first, then ask, then allow.`);
+			actionByEntry.set(entry, action);
 			switch (action) {
 				case "allow":
 					allow.push(entry);
@@ -25625,19 +27004,24 @@ function mapBashActionToDecision(action) {
 //#endregion
 //#region src/features/permissions/copilot-permissions.ts
 /**
-* The flat, dotted VS Code setting key this adapter manages. VS Code stores
-* settings with dotted keys flat at the document top level, so this is a single
-* literal key — not a nested `chat.tools.terminal` path.
+* The flat, dotted VS Code setting keys this adapter manages, one per canonical
+* permission category. VS Code stores settings with dotted keys flat at the
+* document top level, so each is a single literal key — not a nested
+* `chat.tools.terminal` path. All three share the same
+* pattern-to-boolean shape, so one conversion covers them.
+*
+* The canonical `read` and `write` categories stay unmapped: VS Code has no
+* read-approval surface, and folding `write` into the edits map alongside
+* `edit` would make the two indistinguishable on import.
+*
 * @see https://code.visualstudio.com/docs/agents/approvals
+* @see https://code.visualstudio.com/docs/copilot/chat/review-code-edits
 */
-const AUTO_APPROVE_KEY = "chat.tools.terminal.autoApprove";
-/**
-* The canonical permission category this adapter maps. Only shell/terminal
-* commands (`bash`) have a clean, high-fidelity representation in VS Code's
-* `chat.tools.terminal.autoApprove` map; other categories (read/edit/webfetch/
-* …) have no terminal-command equivalent and are intentionally not mapped.
-*/
-const TERMINAL_CATEGORY = "bash";
+const AUTO_APPROVE_KEYS = {
+	bash: "chat.tools.terminal.autoApprove",
+	edit: "chat.tools.edits.autoApprove",
+	webfetch: "chat.tools.urls.autoApprove"
+};
 function asAutoApproveMap(value) {
 	if (!isPlainObject$1(value)) return {};
 	const result = {};
@@ -25645,6 +27029,21 @@ function asAutoApproveMap(value) {
 	return result;
 }
 /**
+* Render one canonical category's rules as a VS Code auto-approve map. Returns
+* `undefined` when the category contributes nothing, so the key is retracted
+* rather than written as an empty object.
+*
+* The resulting map replaces the file's existing value wholesale — rulesync
+* owns these keys, so a rule dropped from the canonical config disappears from
+* the settings file too.
+*/
+function buildAutoApproveValue(rules) {
+	const autoApprove = {};
+	for (const [pattern, action] of Object.entries(rules)) if (action === "allow") autoApprove[pattern] = true;
+	else if (action === "deny") autoApprove[pattern] = false;
+	return Object.keys(autoApprove).length > 0 ? autoApprove : void 0;
+}
+/**
 * Permissions generator for GitHub Copilot Chat in VS Code.
 *
 * VS Code has no standalone, environment-agnostic Copilot policy file (like
@@ -25654,13 +27053,16 @@ function asAutoApproveMap(value) {
 * many unrelated keys, so reads and writes merge into the existing JSON
 * (touching only the one managed key) and the file is never deleted.
 *
-* Scope is deliberately limited to `chat.tools.terminal.autoApprove` — the one
-* clean, non-lossy mapping. The canonical `bash` category's per-pattern rules
-* map as: `allow` → `true` (auto-approve), `deny` → `false` (never approve),
-* and `ask` → the entry is OMITTED (VS Code then falls through to its default
-* in-chat approval prompt, i.e. "ask"). Only project scope is modeled: VS Code's
-* user-scope settings.json lives at a platform-dependent path outside rulesync's
-* home-relative global model.
+* Three canonical categories have a clean, non-lossy representation and are
+* mapped (see {@link AUTO_APPROVE_KEYS}): `bash`, `edit` and `webfetch`. In
+* every one, per-pattern rules map as: `allow` → `true` (auto-approve), `deny`
+* → `false` (VS Code then always prompts — note this is "never auto-approve",
+* not a hard block), and `ask` → the entry is OMITTED (VS Code falls through to
+* the same default prompt). A key whose canonical category is absent entirely
+* is left untouched, so authoring only `bash` rules never disturbs a
+* hand-written edits or urls map.
+* Only project scope is modeled: VS Code's user-scope settings.json lives at a
+* platform-dependent path outside rulesync's home-relative global model.
 */
 var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 	constructor(params) {
@@ -25697,11 +27099,13 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 		const paths = CopilotPermissions.getSettablePaths();
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
-		const rules = rulesyncPermissions.getJson().permission[TERMINAL_CATEGORY] ?? {};
-		const autoApprove = {};
-		for (const [pattern, action] of Object.entries(rules)) if (action === "allow") autoApprove[pattern] = true;
-		else if (action === "deny") autoApprove[pattern] = false;
-		const patchValue = Object.keys(autoApprove).length > 0 ? autoApprove : void 0;
+		const config = rulesyncPermissions.getJson();
+		const patch = {};
+		for (const [category, settingKey] of Object.entries(AUTO_APPROVE_KEYS)) {
+			const rules = config.permission[category];
+			if (rules === void 0) continue;
+			patch[settingKey] = buildAutoApproveValue(rules);
+		}
 		return new CopilotPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -25710,7 +27114,7 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "permissions",
 				existingContent,
-				patch: { [AUTO_APPROVE_KEY]: patchValue },
+				patch,
 				filePath
 			}),
 			validate: true
@@ -25729,10 +27133,13 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Copilot VS Code settings in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const autoApprove = asAutoApproveMap(settings[AUTO_APPROVE_KEY]);
-		const rules = {};
-		for (const [pattern, flag] of Object.entries(autoApprove)) rules[pattern] = flag ? "allow" : "deny";
-		const permission = Object.keys(rules).length > 0 ? { [TERMINAL_CATEGORY]: rules } : {};
+		const permission = {};
+		for (const [category, settingKey] of Object.entries(AUTO_APPROVE_KEYS)) {
+			const autoApprove = asAutoApproveMap(settings[settingKey]);
+			const rules = {};
+			for (const [pattern, flag] of Object.entries(autoApprove)) rules[pattern] = flag ? "allow" : "deny";
+			if (Object.keys(rules).length > 0) permission[category] = rules;
+		}
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
 	}
 	validate() {
@@ -27062,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,
@@ -27099,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({
@@ -27512,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
@@ -27569,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) {
@@ -27648,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 = {
@@ -27675,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,
@@ -27689,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) });
 	}
@@ -27932,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;
 	}
@@ -27946,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: {
@@ -28870,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
@@ -28934,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";
 			});
@@ -28986,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]);
@@ -29082,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 = {
@@ -29102,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.
 *
@@ -29122,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
@@ -29304,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 };
@@ -29328,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;
@@ -29358,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 = [];
@@ -29379,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 = {};
@@ -29389,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 ??= {};
@@ -30226,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
 		}];
 	}
@@ -31752,6 +33275,7 @@ const ClaudecodeSkillFrontmatterSchema = z.looseObject({
 	arguments: z.optional(z.union([z.string(), z.array(z.string())])),
 	context: z.optional(z.string()),
 	agent: z.optional(z.string()),
+	background: z.optional(z.boolean()),
 	hooks: z.optional(z.looseObject({})),
 	shell: z.optional(z.string()),
 	"disable-model-invocation": z.optional(z.boolean()),
@@ -31778,6 +33302,7 @@ function buildClaudecodeSkillFrontmatter({ rulesyncFrontmatter, resolvedDisableM
 		shell: section.shell
 	};
 	const definedFields = {
+		background: section.background,
 		arguments: section.arguments,
 		hooks: section.hooks,
 		"disable-model-invocation": resolvedDisableModelInvocation,
@@ -31855,6 +33380,7 @@ var ClaudecodeSkill = class extends ToolSkill {
 			...frontmatter.arguments !== void 0 && { arguments: frontmatter.arguments },
 			...frontmatter.context && { context: frontmatter.context },
 			...frontmatter.agent && { agent: frontmatter.agent },
+			...frontmatter.background !== void 0 && { background: frontmatter.background },
 			...frontmatter.hooks !== void 0 && { hooks: frontmatter.hooks },
 			...frontmatter.shell && { shell: frontmatter.shell },
 			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
@@ -32464,7 +33990,9 @@ const CopilotcliSkillFrontmatterSchema = z.looseObject({
 	description: z.string(),
 	license: z.optional(z.string()),
 	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
-	"argument-hint": z.optional(z.string())
+	"argument-hint": z.optional(z.string()),
+	"user-invocable": z.optional(z.boolean()),
+	"disable-model-invocation": z.optional(z.boolean())
 });
 /**
 * Represents a GitHub Copilot CLI skill directory.
@@ -32523,7 +34051,9 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		const copilotcliSection = {
 			...frontmatter.license !== void 0 && { license: frontmatter.license },
 			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] },
-			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] }
+			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] },
+			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
+			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -32550,7 +34080,9 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			description: rulesyncFrontmatter.description,
 			...rulesyncFrontmatter.copilotcli?.license !== void 0 && { license: rulesyncFrontmatter.copilotcli.license },
 			...rulesyncFrontmatter.copilotcli?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilotcli["allowed-tools"] },
-			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] }
+			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] },
+			...rulesyncFrontmatter.copilotcli?.["user-invocable"] !== void 0 && { "user-invocable": rulesyncFrontmatter.copilotcli["user-invocable"] },
+			...rulesyncFrontmatter.copilotcli?.["disable-model-invocation"] !== void 0 && { "disable-model-invocation": rulesyncFrontmatter.copilotcli["disable-model-invocation"] }
 		};
 		return new CopilotcliSkill({
 			outputRoot,
@@ -34220,6 +35752,37 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			alternativeSkillRoots: [global ? OPENCODE_GLOBAL_SKILL_DIR_PATH : OPENCODE_SKILL_DIR_PATH]
 		};
 	}
+	/**
+	* Extra skill roots the project configured in `opencode.json` /
+	* `opencode.jsonc` via `skills.paths` ("Additional paths to skill folders").
+	* Without these, skills a project keeps outside `.opencode/skills/` are
+	* invisible to `rulesync import` even though OpenCode loads them.
+	*
+	* Import-only: rulesync keeps writing to its own managed root, so a
+	* configured path is read but never generated into. `skills.urls` is a
+	* remote-fetch surface and is out of scope for a file-based generator.
+	*
+	* Absolute paths and paths escaping the output root are dropped — an import
+	* root is joined onto `outputRoot`, and reaching outside it is not something
+	* a project config should be able to ask for.
+	*
+	* @see https://opencode.ai/config.json
+	*/
+	static async getConfiguredImportRoots({ outputRoot, global = false }) {
+		const skills = asOpencodeEntries((await readOpencodeConfig({
+			outputRoot,
+			global
+		})).skills);
+		if (skills === null || !Array.isArray(skills.paths)) return [];
+		const configDir = getOpencodeConfigDir({
+			outputRoot,
+			global
+		});
+		return skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !isAbsolute(candidate) && !normalize(candidate).startsWith("..")).map((relativeDirPath) => ({
+			outputRoot: configDir,
+			relativeDirPath
+		}));
+	}
 	getFrontmatter() {
 		return OpenCodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
@@ -36153,12 +37716,19 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 	*/
 	async loadToolDirs() {
 		const factory = this.getFactory(this.toolTarget);
-		const roots = toolSkillImportRoots(factory.class.getSettablePaths({ global: this.global }));
+		const paths = factory.class.getSettablePaths({ global: this.global });
+		const configuredRoots = factory.class.getConfiguredImportRoots ? await factory.class.getConfiguredImportRoots({
+			outputRoot: this.outputRoot,
+			global: this.global
+		}) : [];
+		const configuredRootPaths = new Set(configuredRoots.map((root) => root.relativeDirPath));
+		const roots = [...toolSkillImportRoots(paths), ...configuredRoots];
 		const seenSkillNames = /* @__PURE__ */ new Set();
 		const toolSkills = [];
 		for (const root of roots) {
 			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
 			const relativeDirPath = typeof root === "string" ? root : root.relativeDirPath;
+			const isConfiguredRoot = configuredRootPaths.has(relativeDirPath);
 			const skillsDirPath = join(rootOutputRoot, relativeDirPath);
 			if (!await directoryExists(skillsDirPath)) continue;
 			const dirPaths = await findFilesByGlobs(join(skillsDirPath, "*"), { type: "dir" });
@@ -36173,12 +37743,20 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				})) continue;
 				ownedDirNames.push(dirName);
 			}
-			const directorySkills = await Promise.all(ownedDirNames.map((dirName) => factory.class.fromDir({
-				outputRoot: rootOutputRoot,
-				relativeDirPath,
-				dirName,
-				global: this.global
-			})));
+			const directorySkills = (await Promise.all(ownedDirNames.map(async (dirName) => {
+				try {
+					return await factory.class.fromDir({
+						outputRoot: rootOutputRoot,
+						relativeDirPath,
+						dirName,
+						global: this.global
+					});
+				} catch (error) {
+					if (!isConfiguredRoot) throw error;
+					this.logger.warn(`Skipping ${join(relativeDirPath, dirName)}: ${formatError(error)}`);
+					return null;
+				}
+			}))).filter((skill) => skill !== null);
 			for (const skill of directorySkills) {
 				const skillName = skill.getImportIdentity();
 				if (seenSkillNames.has(skillName)) continue;
@@ -36703,6 +38281,242 @@ var RovodevSubagent = class RovodevSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/antigravity-shared-subagent.ts
+/**
+* Frontmatter of an Antigravity custom agent (Markdown format, CLI v1.1.6+).
+*
+* `name` and `description` are required upstream; the rest are optional and
+* documented with defaults (`tools: []`, `mainAgent: true`, `subagent: true`,
+* `model: inherit`, `commandExecutionPolicy: sandbox`, `mcpServers: []`,
+* `skills`/`plugins`: `[]`). `hidden` and `inheritMcp` appear in the v1.1.6
+* release notes but not in the documented frontmatter table, so they are
+* accepted as verbatim passthrough without any behavior modeled around them.
+* `looseObject` keeps unknown future fields round-tripping.
+*
+* @see https://antigravity.google/docs/subagents
+*/
+const AntigravitySubagentFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.string().check(z.minLength(1)),
+	tools: z.optional(z.array(z.string())),
+	mainAgent: z.optional(z.boolean()),
+	subagent: z.optional(z.boolean()),
+	model: z.optional(z.string()),
+	commandExecutionPolicy: z.optional(z.string()),
+	mcpServers: z.optional(z.array(z.unknown())),
+	skills: z.optional(z.array(z.string())),
+	plugins: z.optional(z.array(z.string())),
+	hidden: z.optional(z.boolean()),
+	inheritMcp: z.optional(z.boolean())
+});
+/**
+* Shared custom-agent (subagent) implementation for Google Antigravity 2.0,
+* used by the IDE, the CLI and plugin bundles.
+*
+* Antigravity discovers agents at `.agents/agents/<name>.md` (project) and
+* `~/.gemini/config/agents/<name>.md` (global, shared by the IDE and the CLI
+* exactly like `~/.gemini/config/hooks.json`). The directory form
+* (`<name>/agent.md`) is an equivalent alternative upstream; rulesync emits and
+* imports the flat file form. The body after the frontmatter is the agent's
+* system prompt.
+*
+* Concrete subclasses only supply the rulesync target name they answer to via
+* {@link AntigravitySharedSubagent.getToolTarget} and, where the shared file is
+* not involved, the sections they read via
+* {@link AntigravitySharedSubagent.getReadSectionKeys}.
+*
+* @see https://antigravity.google/docs/subagents
+*/
+var AntigravitySharedSubagent = class extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = AntigravitySubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${join(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true })
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	/** The rulesync target name this subagent answers to. */
+	static getToolTarget() {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	/**
+	* Tool-specific sections this target reads, in increasing precedence order.
+	*
+	* `antigravity-ide` and `antigravity-cli` write the very same file, so a
+	* target that read only its own section would silently drop the other's keys
+	* — and which one survived would depend on `--targets` order. Every target
+	* therefore merges the shared `antigravity-ide` → `antigravity-cli` sections
+	* (the CLI block wins, matching the fixed order the MCP feature already uses
+	* for the same shared-output reason), and the plugin target layers its own
+	* section on top of that. Only `getToolTarget()` decides which section an
+	* import writes back into.
+	*/
+	static getReadSectionKeys() {
+		return ["antigravity-ide", "antigravity-cli"];
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { relativeDirPath: global ? ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH : ANTIGRAVITY_AGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, ...restFields } = this.frontmatter;
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name,
+				description,
+				...Object.keys(restFields).length > 0 && { [this.constructor.getToolTarget()]: restFields }
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const mergedSection = Object.assign({}, ...this.getReadSectionKeys().map((key) => rulesyncFrontmatter[key] ?? {}));
+		const toolSection = this.filterToolSpecificSection(mergedSection, ["name", "description"]);
+		const rawFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description || `${rulesyncFrontmatter.name} subagent`,
+			...toolSection
+		};
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(rawFrontmatter);
+		if (!result.success) throw new Error(`Invalid ${this.getToolTarget()} subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
+		const frontmatter = result.data;
+		const body = rulesyncSubagent.getBody();
+		const paths = this.getSettablePaths({ global });
+		return new this({
+			outputRoot,
+			frontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent: stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true }),
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${join(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: this.getToolTarget()
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new this({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new this({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-cli-subagent.ts
+/**
+* Google Antigravity CLI custom agent (subagent), shipped in CLI v1.1.6.
+*
+* Shares all behavior with {@link AntigravitySharedSubagent}; the CLI reads the
+* same `.agents/agents/` and `~/.gemini/config/agents/` roots as the IDE and
+* exposes them through the `agy agents` subcommand and the `--agent` flag. It
+* answers to the `antigravity-cli` target.
+*/
+var AntigravityCliSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-cli";
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-ide-subagent.ts
+/**
+* Google Antigravity IDE custom agent (subagent).
+*
+* Shares all behavior with {@link AntigravitySharedSubagent} — the subagents
+* documentation is product-wide and lists the same `.agents/agents/` and
+* `~/.gemini/config/agents/` roots for the IDE and the CLI. It answers to the
+* `antigravity-ide` target.
+*/
+var AntigravityIdeSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-ide";
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-plugin-subagent.ts
+/**
+* Custom agent inside an Antigravity plugin bundle
+* (`<plugin_name>/agents/<name>.md`). Plugin bundles are project-scope output
+* only; they are staged into `~/.gemini/antigravity-cli/plugins/` by the user.
+*
+* @see https://antigravity.google/docs/cli/plugins
+*/
+var AntigravityPluginSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-plugin";
+	}
+	static getReadSectionKeys() {
+		return [...super.getReadSectionKeys(), "antigravity-plugin"];
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: ANTIGRAVITY_PLUGIN_AGENTS_DIR };
+	}
+};
+//#endregion
 //#region src/features/subagents/augmentcode-subagent.ts
 const AugmentcodeSubagentFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -38516,7 +40330,7 @@ def register(ctx):
         _register_subagent(ctx, subagent)
 `;
 }
-function getEnabledPluginConfigContent(currentContent) {
+function getEnabledPluginConfigContent({ currentContent, global }) {
 	const config = parseSharedConfig({
 		format: "yaml",
 		fileContent: currentContent
@@ -38524,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: {
@@ -38575,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,
@@ -38583,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,
@@ -38636,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`)];
@@ -38676,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);
@@ -38684,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();
 	}
 };
@@ -40280,6 +42096,30 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["antigravity-cli", {
+		class: AntigravityCliSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
+	["antigravity-ide", {
+		class: AntigravityIdeSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: false,
+			filePattern: "*.md"
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeSubagent,
 		meta: {
@@ -42493,6 +44333,7 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 const CopilotRuleFrontmatterSchema = z.object({
 	description: z.optional(z.string()),
 	applyTo: z.optional(z.string()),
+	name: z.optional(z.string()),
 	excludeAgent: z.optional(z.union([
 		z.literal("code-review"),
 		z.literal("cloud-agent"),
@@ -42550,7 +44391,10 @@ var CopilotRule = class CopilotRule extends ToolRule {
 			root: this.isRoot(),
 			description: this.frontmatter.description,
 			globs,
-			...this.frontmatter.excludeAgent && { copilot: { excludeAgent: this.frontmatter.excludeAgent } }
+			...(this.frontmatter.excludeAgent || this.frontmatter.name) && { copilot: {
+				...this.frontmatter.excludeAgent && { excludeAgent: this.frontmatter.excludeAgent },
+				...this.frontmatter.name && { name: this.frontmatter.name }
+			} }
 		};
 		const relativeFilePath = this.getRelativeFilePath().replace(/\.instructions\.md$/, ".md");
 		return new RulesyncRule({
@@ -42569,7 +44413,8 @@ var CopilotRule = class CopilotRule extends ToolRule {
 		const copilotFrontmatter = {
 			description: rulesyncFrontmatter.description,
 			applyTo: rulesyncFrontmatter.globs?.length ? rulesyncFrontmatter.globs.join(",") : void 0,
-			excludeAgent: rulesyncFrontmatter.copilot?.excludeAgent
+			excludeAgent: rulesyncFrontmatter.copilot?.excludeAgent,
+			name: rulesyncFrontmatter.copilot?.name
 		};
 		const body = rulesyncRule.getBody();
 		if (root) return new CopilotRule({
@@ -43734,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: ".",
@@ -45322,6 +47170,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose",
 			additionalConventions: {
 				commands: { commandClass: AgentsmdCommand },
 				subagents: { subagentClass: AgentsmdSubagent },
@@ -45342,7 +47191,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose"
 		}
 	}],
 	["antigravity-cli", {
@@ -45419,7 +47269,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["copilot", {
@@ -45452,7 +47302,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["factorydroid", {
@@ -45460,7 +47310,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			collisionPolicy: "compose"
 		}
 	}],
 	["goose", {
@@ -45469,7 +47320,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["hermesagent", {
@@ -45478,7 +47329,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["grokcli", {
@@ -45495,7 +47346,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["kilo", {
@@ -45504,7 +47355,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			mcpInstructionsRegistrar: KiloMcp
+			mcpInstructionsRegistrar: KiloMcp,
+			collisionPolicy: "compose"
 		}
 	}],
 	["kimi-code", {
@@ -45513,7 +47365,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["kiro", {
@@ -45546,7 +47398,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "toon",
-			mcpInstructionsRegistrar: OpencodeMcp
+			mcpInstructionsRegistrar: OpencodeMcp,
+			collisionPolicy: "compose"
 		}
 	}],
 	["pi", {
@@ -45555,7 +47408,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["qwencode", {
@@ -45573,7 +47426,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["replit", {
@@ -45630,7 +47483,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: false,
 			ruleDiscoveryMode: "toon",
-			foldsNonRootIntoRoot: true
+			collisionPolicy: "fold"
 		}
 	}],
 	["devin", {
@@ -45699,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,
@@ -45726,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
@@ -45813,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);
 		}
 	}
 	/**
@@ -46005,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)}`);
@@ -46255,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
@@ -47663,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(),
@@ -48038,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-BT5KR_K-.js.map
+//# sourceMappingURL=import-CArKOPG_.js.map