rulesync 9.7.0 → 10.0.0

package/dist/{import-D5f_X4-A.cjs → import-Dcj5HiOE.cjs}

@@ -114,28 +114,35 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$249 } = node_path.posix;
+const { join: join$251 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
 const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.json";
+const RULESYNC_MCP_JSONC_FILE_NAME = "mcp.jsonc";
+const RULESYNC_HOOKS_JSONC_FILE_NAME = "hooks.jsonc";
+const RULESYNC_PERMISSIONS_JSONC_FILE_NAME = "permissions.jsonc";
 const RULESYNC_CONFIG_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/config-schema.json";
 const RULESYNC_MCP_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/mcp-schema.json";
+const RULESYNC_PERMISSIONS_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/permissions-schema.json";
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 //#endregion
 //#region src/types/tool-target-tuples.ts
@@ -347,7 +354,8 @@ const hooksProcessorToolTargetTuple = [
 	"junie",
 	"vibe",
 	"qwencode",
-	"reasonix"
+	"reasonix",
+	"grokcli"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -6295,10 +6303,13 @@ const CLAUDE_HOOK_EVENTS = [
 * Hook events supported by Devin Local (native `.devin/` hooks).
 *
 * Devin Local adopts a Claude-Code-style lifecycle hooks surface. It documents
-* seven events: `PreToolUse`, `PostToolUse`, `PermissionRequest`,
-* `UserPromptSubmit`, `Stop`, `SessionStart`, and `SessionEnd`. The
+* eight events: `PreToolUse`, `PostToolUse`, `PermissionRequest`,
+* `UserPromptSubmit`, `Stop`, `SessionStart`, `SessionEnd`, and
+* `PostCompaction` (fires after context compaction; added in the Devin CLI
+* stable changelog — https://docs.devin.ai/cli/changelog/stable). The
 * tool/permission events (`PreToolUse`/`PostToolUse`/`PermissionRequest`) carry
-* a `matcher` (regex against `tool_name`); the session/turn events do not.
+* a `matcher` (regex against `tool_name`); the session/turn/compaction events
+* do not.
 *
 * Hooks live in `.devin/hooks.v1.json` (project, standalone — the hooks object
 * is the entire file) or under the `"hooks"` key of `.devin/config.json` /
@@ -6313,7 +6324,8 @@ const DEVIN_HOOK_EVENTS = [
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"stop",
-	"permissionRequest"
+	"permissionRequest",
+	"postCompact"
 ];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
@@ -6507,7 +6519,7 @@ const ANTIGRAVITY_HOOK_EVENTS = [
 * Hook events supported by AugmentCode (Auggie CLI).
 * Auggie mirrors Claude Code's lifecycle hooks but exposes a smaller set:
 * PreToolUse / PostToolUse (tool events, matcher-aware) plus the
-* SessionStart / SessionEnd / Stop session events (no matcher).
+* SessionStart / SessionEnd / Stop / Notification session events (no matcher).
 * @see https://docs.augmentcode.com/cli/hooks
 */
 const AUGMENTCODE_HOOK_EVENTS = [
@@ -6515,7 +6527,8 @@ const AUGMENTCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"sessionStart",
 	"sessionEnd",
-	"stop"
+	"stop",
+	"notification"
 ];
 /**
 * Hook events supported by Mistral Vibe (mistral-vibe).
@@ -6567,6 +6580,10 @@ const JUNIE_HOOK_EVENTS = [
 * The Qwen-specific events
 * `TodoCreated`, `TodoCompleted`, and `StopFailure` map to the canonical
 * `todoCreated`, `todoCompleted`, and `stopFailure` events respectively.
+* Qwen's `HookEventName` enum (`packages/core/src/hooks/types.ts`) also documents
+* `PostToolBatch`, `UserPromptExpansion`, `PermissionDenied`, and
+* `InstructionsLoaded`, which map to the canonical `postToolBatch`,
+* `userPromptExpansion`, `permissionDenied`, and `instructionsLoaded` events.
 * @see https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/hooks.md
 */
 const QWENCODE_HOOK_EVENTS = [
@@ -6575,7 +6592,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"postToolUseFailure",
+	"postToolBatch",
 	"beforeSubmitPrompt",
+	"userPromptExpansion",
 	"stop",
 	"stopFailure",
 	"subagentStart",
@@ -6583,7 +6602,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preCompact",
 	"postCompact",
 	"permissionRequest",
+	"permissionDenied",
 	"notification",
+	"instructionsLoaded",
 	"todoCreated",
 	"todoCompleted"
 ];
@@ -6593,11 +6614,11 @@ const QWENCODE_HOOK_EVENTS = [
 * Reasonix's `.reasonix/settings.json` (project) / `~/.reasonix/settings.json`
 * (global) documents a ten-event surface (`PreToolUse`, `PostToolUse`,
 * `UserPromptSubmit`, `Stop`, `PostLLMCall`, `SessionStart`, `SessionEnd`,
-* `SubagentStop`, `Notification`, `PreCompact`). The eight events with a clean
-* canonical equivalent are mapped: `PreToolUse`, `PostToolUse`,
+* `SubagentStop`, `Notification`, `PreCompact`). All ten have a clean canonical
+* equivalent and are mapped: `PreToolUse`, `PostToolUse`,
 * `UserPromptSubmit` ← `beforeSubmitPrompt`, `Stop`, `SessionStart`,
-* `SessionEnd`, `SubagentStop`, and `PostLLMCall` ← `postModelInvocation`.
-* (`Notification` and `PreCompact` have no canonical event and are left out.)
+* `SessionEnd`, `SubagentStop`, `PostLLMCall` ← `postModelInvocation`,
+* `Notification` ← `notification`, and `PreCompact` ← `preCompact`.
 * `match` (Reasonix's matcher field name) is honored only on
 * `PreToolUse`/`PostToolUse`, matching the canonical `matcher` field's
 * tool-event scoping used by other adapters.
@@ -6611,7 +6632,39 @@ const REASONIX_HOOK_EVENTS = [
 	"sessionStart",
 	"sessionEnd",
 	"subagentStop",
-	"postModelInvocation"
+	"postModelInvocation",
+	"notification",
+	"preCompact"
+];
+/**
+* Hook events supported by Grok CLI (xAI Grok Build).
+*
+* Grok Build documents a Claude-Code-compatible hooks surface with fourteen
+* PascalCase events, all of which map 1:1 onto an existing canonical arm:
+* `SessionStart`, `SessionEnd`, `UserPromptSubmit` ← `beforeSubmitPrompt`,
+* `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, `PermissionDenied`,
+* `Stop`, `StopFailure`, `Notification`, `SubagentStart`, `SubagentStop`,
+* `PreCompact`, `PostCompact`. A `matcher` (a regex tested against the tool
+* name) is meaningful only on the tool-name events (`PreToolUse`, `PostToolUse`,
+* `PostToolUseFailure`, `PermissionDenied`), matching Claude Code's semantics;
+* the remaining lifecycle events are matcher-less.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const GROKCLI_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionDenied",
+	"stop",
+	"stopFailure",
+	"notification",
+	"subagentStart",
+	"subagentStop",
+	"preCompact",
+	"postCompact"
 ];
 /**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
@@ -6685,6 +6738,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	junie: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -6743,7 +6797,8 @@ const CANONICAL_TO_DEVIN_EVENT_NAMES = {
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
 	stop: "Stop",
-	permissionRequest: "PermissionRequest"
+	permissionRequest: "PermissionRequest",
+	postCompact: "PostCompaction"
 };
 /**
 * Map Devin Local PascalCase event names to canonical camelCase.
@@ -6758,7 +6813,8 @@ const CANONICAL_TO_AUGMENTCODE_EVENT_NAMES = {
 	postToolUse: "PostToolUse",
 	sessionStart: "SessionStart",
 	sessionEnd: "SessionEnd",
-	stop: "Stop"
+	stop: "Stop",
+	notification: "Notification"
 };
 /**
 * Map AugmentCode PascalCase event names to canonical camelCase.
@@ -7028,7 +7084,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	postToolUseFailure: "PostToolUseFailure",
+	postToolBatch: "PostToolBatch",
 	beforeSubmitPrompt: "UserPromptSubmit",
+	userPromptExpansion: "UserPromptExpansion",
 	stop: "Stop",
 	subagentStart: "SubagentStart",
 	subagentStop: "SubagentStop",
@@ -7036,7 +7094,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preCompact: "PreCompact",
 	postCompact: "PostCompact",
 	permissionRequest: "PermissionRequest",
+	permissionDenied: "PermissionDenied",
 	notification: "Notification",
+	instructionsLoaded: "InstructionsLoaded",
 	todoCreated: "TodoCreated",
 	todoCompleted: "TodoCompleted"
 };
@@ -7058,12 +7118,40 @@ const CANONICAL_TO_REASONIX_EVENT_NAMES = {
 	sessionStart: "SessionStart",
 	sessionEnd: "SessionEnd",
 	subagentStop: "SubagentStop",
-	postModelInvocation: "PostLLMCall"
+	postModelInvocation: "PostLLMCall",
+	notification: "Notification",
+	preCompact: "PreCompact"
 };
 /**
 * Map Reasonix PascalCase event names to canonical camelCase.
 */
 const REASONIX_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_REASONIX_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
+* Map canonical camelCase event names to Grok CLI PascalCase.
+* Grok Build reuses the same Claude-style PascalCase event names, so each
+* canonical arm maps to its PascalCase equivalent.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const CANONICAL_TO_GROKCLI_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionDenied: "PermissionDenied",
+	stop: "Stop",
+	stopFailure: "StopFailure",
+	notification: "Notification",
+	subagentStart: "SubagentStart",
+	subagentStop: "SubagentStop",
+	preCompact: "PreCompact",
+	postCompact: "PostCompact"
+};
+/**
+* Map Grok CLI PascalCase event names to canonical camelCase.
+*/
+const GROKCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_GROKCLI_EVENT_NAMES).map(([k, v]) => [v, k]));
 //#endregion
 //#region src/features/hooks/tool-hooks-converter.ts
 function isToolMatcherEntry(x) {
@@ -7262,12 +7350,55 @@ function toolHooksToCanonical({ hooks, converterConfig }) {
 	return canonical;
 }
 //#endregion
+//#region src/utils/jsonc.ts
+/**
+* Rebuild the parsed value from its own enumerable entries, dropping
+* prototype-pollution keys (`__proto__`, `constructor`, `prototype`).
+* `jsonc-parser` assigns keys with plain `obj[key] = value` semantics, so a
+* literal `__proto__` key would replace the containing object's prototype
+* instead of becoming an own property; rebuilding gives every object a clean
+* `Object.prototype` again and severs that path.
+*/
+function deepSanitize(value) {
+	if (Array.isArray(value)) return value.map((item) => deepSanitize(item));
+	if (value !== null && typeof value === "object") {
+		const sanitized = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			sanitized[key] = deepSanitize(entry);
+		}
+		return sanitized;
+	}
+	return value;
+}
+/**
+* Parse a JSONC (JSON with Comments) document strictly.
+*
+* Unlike `jsonc-parser`'s bare `parse` (which silently tolerates syntax
+* errors and returns a best-effort value), this throws on any parse error so
+* a malformed source file fails loudly instead of generating half-empty tool
+* configs. Plain JSON is valid JSONC, so this is a drop-in replacement for
+* `JSON.parse` on files that may contain comments or trailing commas.
+*/
+function parseJsonc$6(content) {
+	const errors = [];
+	const result = (0, jsonc_parser.parse)(content, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0) {
+		const details = errors.map((e) => `${(0, jsonc_parser.printParseErrorCode)(e.error)} at offset ${e.offset}`).join(", ");
+		throw new SyntaxError(`Failed to parse JSONC content: ${details}`);
+	}
+	return deepSanitize(result);
+}
+//#endregion
 //#region src/features/hooks/rulesync-hooks.ts
 var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	json;
 	constructor(params) {
 		super({ ...params });
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -7276,7 +7407,11 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	static getSettablePaths() {
 		return {
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: "hooks.json"
+			relativeFilePath: RULESYNC_HOOKS_FILE_NAME,
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_HOOKS_JSONC_FILE_NAME
+			}
 		};
 	}
 	validate() {
@@ -7292,16 +7427,23 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncHooks.getSettablePaths();
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
-		if (!await fileExists(filePath)) throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} found.`);
-		const fileContent = await readFileContent(filePath);
-		return new RulesyncHooks({
-			outputRoot,
+		const candidates = [paths.jsonc, {
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath,
-			fileContent,
-			validate
-		});
+			relativeFilePath: paths.relativeFilePath
+		}];
+		for (const candidate of candidates) {
+			const filePath = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			const fileContent = await readFileContent(filePath);
+			return new RulesyncHooks({
+				outputRoot,
+				relativeDirPath: candidate.relativeDirPath,
+				relativeFilePath: candidate.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
+		throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} or ${RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
@@ -7588,7 +7730,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
-		"stop"
+		"stop",
+		"notification"
 	])
 };
 /**
@@ -8687,7 +8830,8 @@ const DEVIN_CONVERTER_CONFIG = {
 		"sessionStart",
 		"sessionEnd",
 		"stop",
-		"beforeSubmitPrompt"
+		"beforeSubmitPrompt",
+		"postCompact"
 	])
 };
 /**
@@ -8996,6 +9140,167 @@ 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 = (0, node_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 = (0, node_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 = (0, node_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";
+//#endregion
+//#region src/features/hooks/grokcli-hooks.ts
+const GROKCLI_CONVERTER_CONFIG = {
+	supportedEvents: GROKCLI_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_GROKCLI_EVENT_NAMES,
+	toolToCanonicalEventNames: GROKCLI_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"sessionStart",
+		"sessionEnd",
+		"beforeSubmitPrompt",
+		"stop",
+		"stopFailure",
+		"notification",
+		"subagentStart",
+		"subagentStop",
+		"preCompact",
+		"postCompact"
+	])
+};
+/**
+* Hooks generator for Grok CLI (xAI Grok Build).
+*
+* Grok Build adopts a Claude-Code-compatible lifecycle hooks model: each event
+* maps to an array of `{ matcher?, hooks: [{ type, command, timeout? }] }`
+* matcher groups under a top-level `hooks` key. rulesync writes all its hooks
+* into a single standalone `rulesync.json` file discovered from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global). The file
+* is dedicated to hooks and owned wholesale by rulesync, so it may be deleted
+* as an orphan.
+*
+* @see https://docs.x.ai/build/features/hooks
+*/
+var GrokcliHooks = class GrokcliHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: GROKCLI_HOOKS_DIR_PATH,
+			relativeFilePath: GROKCLI_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const config = rulesyncHooks.getJson();
+		const grokHooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.grokcli?.hooks,
+			converterConfig: GROKCLI_CONVERTER_CONFIG,
+			logger
+		});
+		await readOrInitializeFileContent(filePath, JSON.stringify({ hooks: {} }, null, 2));
+		const fileContent = JSON.stringify({ hooks: grokHooks }, null, 2);
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		let parsed;
+		try {
+			parsed = JSON.parse(this.getFileContent());
+		} catch (error) {
+			throw new Error(`Failed to parse Grok hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			hooks: isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {},
+			converterConfig: GROKCLI_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/hermesagent-hooks.ts
 /**
 * Canonical events that map to a Hermes tool-call event (`pre_tool_call` /
@@ -10202,9 +10507,9 @@ function reasonixHooksToCanonical(hooks) {
 * Reasonix hooks live in a Claude-Code-style but standalone JSON file —
 * `.reasonix/settings.json` (project) or `~/.reasonix/settings.json`
 * (global) — separate from the `[permissions]`/`[[plugins]]` TOML config.
-* The eight upstream events with a clean canonical equivalent are mapped:
+* All ten upstream events have a clean canonical equivalent and are mapped:
 * PreToolUse/PostToolUse/UserPromptSubmit/Stop plus SessionStart/SessionEnd/
-* SubagentStop/PostLLMCall (see REASONIX_HOOK_EVENTS).
+* SubagentStop/PostLLMCall/Notification/PreCompact (see REASONIX_HOOK_EVENTS).
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 var ReasonixHooks = class ReasonixHooks extends ToolHooks {
@@ -10792,6 +11097,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedEvents: REASONIX_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
+	}],
+	["grokcli", {
+		class: GrokcliHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: GROKCLI_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
 	}]
 ]);
 const hooksProcessorToolTargets = [...toolHooksFactories.entries()].filter(([, f]) => f.meta.supportsProject).map(([t]) => t);
@@ -12135,15 +12451,51 @@ const RulesyncMcpServerSchema = zod_mini.z.extend(McpServerSchema, {
 	exposed: zod_mini.z.optional(zod_mini.z.boolean())
 });
 const RulesyncMcpConfigSchema = zod_mini.z.object({ mcpServers: zod_mini.z.record(zod_mini.z.string(), RulesyncMcpServerSchema) });
+/**
+* Tool-scoped MCP block: servers that apply only to one tool. A named entry
+* replaces/adds the same-named shared server wholesale for that tool; `null`
+* removes the shared server for that tool. Mirrors `{toolname}.hooks` in
+* `.rulesync/hooks.json` and `{toolname}.permission` in
+* `.rulesync/permissions.json`.
+*/
+const toolScopedMcpSchema = zod_mini.z.looseObject({ mcpServers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.nullable(RulesyncMcpServerSchema))) });
 const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	$schema: zod_mini.z.optional(zod_mini.z.string()),
-	...RulesyncMcpConfigSchema.shape
+	...RulesyncMcpConfigSchema.shape,
+	amp: zod_mini.z.optional(toolScopedMcpSchema),
+	"antigravity-cli": zod_mini.z.optional(toolScopedMcpSchema),
+	"antigravity-ide": zod_mini.z.optional(toolScopedMcpSchema),
+	augmentcode: zod_mini.z.optional(toolScopedMcpSchema),
+	claudecode: zod_mini.z.optional(toolScopedMcpSchema),
+	cline: zod_mini.z.optional(toolScopedMcpSchema),
+	codexcli: zod_mini.z.optional(toolScopedMcpSchema),
+	copilot: zod_mini.z.optional(toolScopedMcpSchema),
+	copilotcli: zod_mini.z.optional(toolScopedMcpSchema),
+	cursor: zod_mini.z.optional(toolScopedMcpSchema),
+	deepagents: zod_mini.z.optional(toolScopedMcpSchema),
+	devin: zod_mini.z.optional(toolScopedMcpSchema),
+	factorydroid: zod_mini.z.optional(toolScopedMcpSchema),
+	goose: zod_mini.z.optional(toolScopedMcpSchema),
+	grokcli: zod_mini.z.optional(toolScopedMcpSchema),
+	hermesagent: zod_mini.z.optional(toolScopedMcpSchema),
+	junie: zod_mini.z.optional(toolScopedMcpSchema),
+	kilo: zod_mini.z.optional(toolScopedMcpSchema),
+	kiro: zod_mini.z.optional(toolScopedMcpSchema),
+	opencode: zod_mini.z.optional(toolScopedMcpSchema),
+	qwencode: zod_mini.z.optional(toolScopedMcpSchema),
+	reasonix: zod_mini.z.optional(toolScopedMcpSchema),
+	roo: zod_mini.z.optional(toolScopedMcpSchema),
+	rovodev: zod_mini.z.optional(toolScopedMcpSchema),
+	takt: zod_mini.z.optional(toolScopedMcpSchema),
+	vibe: zod_mini.z.optional(toolScopedMcpSchema),
+	warp: zod_mini.z.optional(toolScopedMcpSchema),
+	zed: zod_mini.z.optional(toolScopedMcpSchema)
 });
 var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	json;
 	constructor(params) {
 		super(params);
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -12153,7 +12505,11 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 		return {
 			recommended: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: "mcp.json"
+				relativeFilePath: RULESYNC_MCP_FILE_NAME
+			},
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_MCP_JSONC_FILE_NAME
 			},
 			legacy: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
@@ -12175,7 +12531,18 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	static async fromFile({ outputRoot = process.cwd(), validate = true, logger }) {
 		const paths = this.getSettablePaths();
 		const recommendedPath = (0, node_path.join)(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
+		const jsoncPath = (0, node_path.join)(outputRoot, paths.jsonc.relativeDirPath, paths.jsonc.relativeFilePath);
 		const legacyPath = (0, node_path.join)(outputRoot, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+		if (await fileExists(jsoncPath)) {
+			const fileContent = await readFileContent(jsoncPath);
+			return new RulesyncMcp({
+				outputRoot,
+				relativeDirPath: paths.jsonc.relativeDirPath,
+				relativeFilePath: paths.jsonc.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
 		if (await fileExists(recommendedPath)) {
 			const fileContent = await readFileContent(recommendedPath);
 			return new RulesyncMcp({
@@ -12235,7 +12602,141 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	getJson() {
 		return this.json;
 	}
-};
+	/**
+	* Build the effective MCP config for one tool target:
+	*
+	* 1. Filter shared servers by the DEPRECATED per-server `targets` field
+	*    (missing/`["*"]` means every tool). A deprecation warning points at
+	*    the tool-scoped blocks that replace it.
+	* 2. Overlay the tool-scoped `{toolname}.mcpServers` block(s): a named
+	*    entry replaces/adds the shared server wholesale for this tool; `null`
+	*    removes it.
+	*
+	* Targets that share one output file resolve identically so the shared
+	* file's content never depends on which of them generates last — see
+	* `resolveMcpTarget` for the alias groups (kiro trio, claudecode/-legacy,
+	* and the Antigravity pair).
+	*
+	* Returns the same instance when neither mechanism is used.
+	*/
+	forTarget({ toolTarget, logger }) {
+		const { blockKeys, acceptedTargetNames } = resolveMcpTarget({ toolTarget });
+		const json = this.json;
+		const sharedServers = this.json.mcpServers ?? {};
+		const serverNamesWithTargets = Object.entries(sharedServers).filter(([, serverConfig]) => serverConfig.targets !== void 0).map(([serverName]) => serverName);
+		if (serverNamesWithTargets.length > 0) this.warnTargetsDeprecationOnce({
+			serverNamesWithTargets,
+			logger
+		});
+		for (const ignoredKey of MCP_IGNORED_ALIAS_SOURCE_KEYS) {
+			if (!isRecord(json[ignoredKey])) continue;
+			this.warnOncePerFile(`alias:${ignoredKey}`, `The "${ignoredKey}" block in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is ignored. Author it under the "${MCP_BLOCK_KEY_ALIASES[ignoredKey]}" key instead.`, logger);
+		}
+		const toolBlockKeys = Object.keys(json).filter((key) => MCP_TOOL_BLOCK_KEYS.has(key));
+		if (serverNamesWithTargets.length === 0 && toolBlockKeys.length === 0) return this;
+		const effectiveServers = Object.fromEntries(Object.entries(sharedServers).filter(([, serverConfig]) => {
+			const targets = serverConfig.targets;
+			if (targets === void 0) return true;
+			return targets.some((target) => target === "*" || acceptedTargetNames.has(target));
+		}));
+		for (const blockKey of blockKeys) {
+			const toolBlock = json[blockKey];
+			const toolServers = isRecord(toolBlock) && isRecord(toolBlock.mcpServers) ? toolBlock.mcpServers : void 0;
+			for (const [serverName, serverConfig] of Object.entries(toolServers ?? {})) {
+				if (isPrototypePollutionKey(serverName)) continue;
+				if (serverConfig === null) delete effectiveServers[serverName];
+				else effectiveServers[serverName] = serverConfig;
+			}
+		}
+		const rest = Object.fromEntries(Object.entries(json).filter(([key]) => !MCP_TOOL_BLOCK_KEYS.has(key)));
+		return new RulesyncMcp({
+			outputRoot: this.outputRoot,
+			relativeDirPath: this.relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: JSON.stringify({
+				...rest,
+				mcpServers: effectiveServers
+			}, null, 2)
+		});
+	}
+	/**
+	* The deprecation warning would otherwise repeat once per generated tool
+	* target (a full `--targets "*"` run creates one RulesyncMcp per target),
+	* so it is deduplicated per source file path.
+	*/
+	warnTargetsDeprecationOnce({ serverNamesWithTargets, logger }) {
+		this.warnOncePerFile("targets-deprecation", `The per-server "targets" field in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is deprecated (servers: ${serverNamesWithTargets.join(", ")}). Author tool-scoped "{toolname}.mcpServers" blocks instead.`, logger);
+	}
+	warnOncePerFile(kind, message, logger) {
+		const dedupeKey = `${this.getFilePath()}#${kind}`;
+		if (warnedOnceKeys.has(dedupeKey)) return;
+		warnedOnceKeys.add(dedupeKey);
+		logger?.warn(message);
+	}
+};
+/**
+* All keys that may hold a tool-scoped `{toolname}.mcpServers` block. Derived
+* from the MCP processor's target tuple so a newly added MCP-capable tool is
+* covered automatically.
+*/
+const MCP_TOOL_BLOCK_KEYS = new Set(mcpProcessorToolTargetTuple);
+/**
+* Targets whose `{toolname}.mcpServers` block key is ALWAYS another target's
+* key (at every scope): `claudecode-legacy` is a deprecated alias of
+* `claudecode`, and the Kiro IDE/CLI targets share the `kiro` block because
+* all three write the same `.kiro/settings/mcp.json` at both scopes. Blocks
+* authored under these source names are never read (a warning is emitted).
+*/
+const MCP_BLOCK_KEY_ALIASES = {
+	"claudecode-legacy": "claudecode",
+	"kiro-cli": "kiro",
+	"kiro-ide": "kiro"
+};
+const MCP_IGNORED_ALIAS_SOURCE_KEYS = Object.keys(MCP_BLOCK_KEY_ALIASES);
+/**
+* Resolve which tool-scoped blocks a target reads and which deprecated
+* `targets` names match it. Targets that share one output file must resolve
+* identically, otherwise the shared file's content would depend on which
+* target happened to generate last:
+*
+* - `claudecode-legacy` aliases `claudecode`; the Kiro trio shares `kiro`
+*   (same output file at both scopes).
+* - `antigravity-ide` / `antigravity-cli` share their output file at BOTH
+*   scopes — `.agents/mcp_config.json` (project) and
+*   `~/.gemini/config/mcp_config.json` (global; both global subdirs are
+*   `config`) — so both targets always apply both blocks in a fixed order
+*   (`antigravity-ide` first, `antigravity-cli` second — the CLI block wins
+*   per server on conflict).
+*/
+function resolveMcpTarget({ toolTarget }) {
+	if (toolTarget === "claudecode" || toolTarget === "claudecode-legacy") return {
+		blockKeys: ["claudecode"],
+		acceptedTargetNames: /* @__PURE__ */ new Set(["claudecode", "claudecode-legacy"])
+	};
+	if (toolTarget === "kiro" || toolTarget === "kiro-cli" || toolTarget === "kiro-ide") return {
+		blockKeys: ["kiro"],
+		acceptedTargetNames: /* @__PURE__ */ new Set([
+			"kiro",
+			"kiro-cli",
+			"kiro-ide"
+		])
+	};
+	if (toolTarget === "antigravity-ide" || toolTarget === "antigravity-cli") return {
+		blockKeys: ["antigravity-ide", "antigravity-cli"],
+		acceptedTargetNames: /* @__PURE__ */ new Set(["antigravity-ide", "antigravity-cli"])
+	};
+	return {
+		blockKeys: [toolTarget],
+		acceptedTargetNames: /* @__PURE__ */ new Set([toolTarget])
+	};
+}
+/**
+* Deduplication set for once-per-source-file warnings, keyed by
+* `<absolute file path>#<warning kind>`. Never cleared: rulesync CLI runs
+* are one-shot processes, and in a long-lived embedding (the rulesync MCP
+* server) repeating the same warning per generate would only add noise.
+*/
+const warnedOnceKeys = /* @__PURE__ */ new Set();
 //#endregion
 //#region src/features/mcp/tool-mcp.ts
 var ToolMcp = class extends ToolFile {
@@ -13047,7 +13548,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			...rest,
 			validate: false
 		});
-		this.toml = smol_toml.parse(this.fileContent);
+		let toml;
+		try {
+			toml = smol_toml.parse(this.fileContent);
+		} catch (error) {
+			throw new Error(`Failed to parse Codex CLI config at ${this.getFilePath()}: ${formatError(error)}`, { cause: error });
+		}
+		this.toml = toml;
 		if (rest.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -13083,7 +13590,12 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		const paths = this.getSettablePaths({ global });
 		const configTomlFilePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
-		const configToml = smol_toml.parse(configTomlFileContent || smol_toml.stringify({}));
+		let configToml;
+		try {
+			configToml = smol_toml.parse(configTomlFileContent || smol_toml.stringify({}));
+		} catch (error) {
+			throw new Error(`Failed to parse existing Codex CLI config at ${configTomlFilePath}: ${formatError(error)}`, { cause: error });
+		}
 		const strippedMcpServers = rulesyncMcp.getMcpServers();
 		const rawMcpServers = rulesyncMcp.getJson().mcpServers;
 		const converted = convertToCodexFormat(Object.fromEntries(Object.entries(strippedMcpServers).map(([serverName, serverConfig]) => {
@@ -14057,47 +14569,6 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 	}
 };
 //#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 = (0, node_path.join)(GROKCLI_DIR, "skills");
-/**
-* 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 = (0, node_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";
-//#endregion
 //#region src/features/mcp/grokcli-mcp.ts
 const MAX_REMOVE_EMPTY_ENTRIES_DEPTH = 32;
 /**
@@ -14257,6 +14728,54 @@ function resolveHermesTimeout(config) {
 	if (typeof config.networkTimeout === "number") return config.networkTimeout;
 }
 /**
+* Copies the advanced Hermes-recognized per-server fields that have no canonical
+* alias — `auth` (`oauth` for OAuth 2.1/PKCE), mTLS `client_cert` (string PEM
+* path, or `[cert, key]`/`[cert, key, password]` list) and `client_key`,
+* `connect_timeout` (seconds), and `supports_parallel_tool_calls` — verbatim
+* from `source` to `target`. Field names are identical on both sides (the
+* canonical `McpServerSchema` is a `looseObject`), so this serves export and
+* import alike. See the Hermes mcp-config-reference.
+*/
+function copyHermesAdvancedFields(source, target) {
+	if (typeof source.auth === "string") target.auth = source.auth;
+	if (typeof source.client_cert === "string" || isStringArray(source.client_cert)) target.client_cert = source.client_cert;
+	if (typeof source.client_key === "string") target.client_key = source.client_key;
+	if (typeof source.connect_timeout === "number") target.connect_timeout = source.connect_timeout;
+	if (typeof source.supports_parallel_tool_calls === "boolean") target.supports_parallel_tool_calls = source.supports_parallel_tool_calls;
+}
+/**
+* Builds Hermes's per-server `tools` block from a canonical server config. The
+* canonical `enabledTools`/`disabledTools` arrays become `include`/`exclude`,
+* and the boolean `promptsEnabled`/`resourcesEnabled` toggles become Hermes's
+* `prompts`/`resources` capability flags. Returns an empty object when the
+* server has no tool scoping (the caller omits the block in that case).
+*
+* Note: `promptsEnabled`/`resourcesEnabled` are canonical top-level keys rather
+* than a nested canonical `tools` object, because canonical `McpServerSchema.tools`
+* is reserved as a `string[]` (used by other tools) — reusing it for an object
+* would fail validation on the next `generate`.
+*/
+function buildHermesToolsBlock(config) {
+	const tools = {};
+	if (isStringArray(config.enabledTools)) tools.include = config.enabledTools;
+	if (isStringArray(config.disabledTools)) tools.exclude = config.disabledTools;
+	if (typeof config.promptsEnabled === "boolean") tools.prompts = config.promptsEnabled;
+	if (typeof config.resourcesEnabled === "boolean") tools.resources = config.resourcesEnabled;
+	return tools;
+}
+/**
+* Applies a Hermes per-server `tools` block back onto a canonical server config
+* (inverse of {@link buildHermesToolsBlock}): `include`/`exclude` become
+* `enabledTools`/`disabledTools`, and `prompts`/`resources` become the boolean
+* `promptsEnabled`/`resourcesEnabled` top-level toggles.
+*/
+function applyHermesToolsBlock(hermesTools, server) {
+	if (isStringArray(hermesTools.include)) server.enabledTools = hermesTools.include;
+	if (isStringArray(hermesTools.exclude)) server.disabledTools = hermesTools.exclude;
+	if (typeof hermesTools.prompts === "boolean") server.promptsEnabled = hermesTools.prompts;
+	if (typeof hermesTools.resources === "boolean") server.resourcesEnabled = hermesTools.resources;
+}
+/**
 * Converts a single rulesync canonical MCP server into a Hermes `mcp_servers:` entry.
 *
 * Hermes is close to the MCP spec but not identical: `command` must be a single
@@ -14290,9 +14809,8 @@ function convertServerToHermes(config) {
 	if (config.disabled === true) out.enabled = false;
 	const timeout = resolveHermesTimeout(config);
 	if (timeout !== void 0) out.timeout = timeout;
-	const tools = {};
-	if (isStringArray(config.enabledTools)) tools.include = config.enabledTools;
-	if (isStringArray(config.disabledTools)) tools.exclude = config.disabledTools;
+	copyHermesAdvancedFields(config, out);
+	const tools = buildHermesToolsBlock(config);
 	if (Object.keys(tools).length > 0) out.tools = tools;
 	return out;
 }
@@ -14335,10 +14853,8 @@ function convertFromHermesFormat(mcpServers) {
 		if (isPlainObject$1(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
 		if (config.enabled === false) server.disabled = true;
 		if (typeof config.timeout === "number") server.networkTimeout = config.timeout;
-		if (isRecord(config.tools)) {
-			if (isStringArray(config.tools.include)) server.enabledTools = config.tools.include;
-			if (isStringArray(config.tools.exclude)) server.disabledTools = config.tools.exclude;
-		}
+		copyHermesAdvancedFields(config, server);
+		if (isRecord(config.tools)) applyHermesToolsBlock(config.tools, server);
 		result[name] = server;
 	}
 	return result;
@@ -16470,10 +16986,14 @@ var McpProcessor = class extends FeatureProcessor {
 		if (!rulesyncMcp) throw new Error(`No ${RULESYNC_MCP_RELATIVE_FILE_PATH} found.`);
 		const factory = this.getFactory(this.toolTarget);
 		return await Promise.all([rulesyncMcp].map(async (mcp) => {
+			const targetedRulesyncMcp = mcp.forTarget({
+				toolTarget: this.toolTarget,
+				logger: this.logger
+			});
 			const fieldsToStrip = [];
 			if (!factory.meta.supportsEnabledTools) fieldsToStrip.push("enabledTools");
 			if (!factory.meta.supportsDisabledTools) fieldsToStrip.push("disabledTools");
-			const filteredRulesyncMcp = mcp.stripMcpServerFields(fieldsToStrip);
+			const filteredRulesyncMcp = targetedRulesyncMcp.stripMcpServerFields(fieldsToStrip);
 			return await factory.class.fromRulesyncMcp({
 				outputRoot: this.outputRoot,
 				rulesyncMcp: filteredRulesyncMcp,
@@ -16523,6 +17043,25 @@ const PermissionActionSchema = zod_mini.z.enum([
 */
 const PermissionRulesSchema = zod_mini.z.record(zod_mini.z.string(), PermissionActionSchema);
 /**
+* Tool-scoped canonical `permission` block: the same shape as the shared
+* top-level `permission` record, but applied only to the tool whose override
+* key it appears under. During generation the categories placed here are
+* merged over the shared `permission` block per category (the tool-scoped
+* category replaces the shared one wholesale), mirroring how
+* `.rulesync/hooks.json` merges `{toolname}.hooks` per event.
+*
+* @example
+* { "claudecode": { "permission": { "bash": { "git push *": "deny" } } } }
+*/
+const ToolScopedPermissionSchema = zod_mini.z.record(zod_mini.z.string(), PermissionRulesSchema);
+/**
+* Generic tool-scoped override block for tools that have no tool-specific
+* override keys of their own; it carries only the canonical tool-scoped
+* `permission` block. Kept `looseObject` so future tool-specific keys can be
+* added without a schema break.
+*/
+const CanonicalPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(ToolScopedPermissionSchema) });
+/**
 * OpenCode-specific permission value. Unlike the shared canonical block, which
 * only accepts a pattern-to-action map, OpenCode also allows a bare action
 * string that applies to the whole category (e.g. `"external_directory": "deny"`).
@@ -16552,7 +17091,7 @@ const OpencodePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: z
 * @example
 * { "approvals": { "mode": "smart" }, "security": { "allow_private_urls": false } }
 */
-const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({});
+const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(ToolScopedPermissionSchema) });
 /**
 * Tool-scoped override block for Cline. Cline's `command-permissions.json`
 * carries a single global `allowRedirects` boolean (gates shell redirection
@@ -16564,7 +17103,10 @@ const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({});
 * @example
 * { "allowRedirects": true }
 */
-const ClinePermissionsOverrideSchema = zod_mini.z.looseObject({ allowRedirects: zod_mini.z.optional(zod_mini.z.boolean()) });
+const ClinePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	allowRedirects: zod_mini.z.optional(zod_mini.z.boolean())
+});
 /**
 * Tool-scoped override block for Kilo Code (an OpenCode fork). Kilo's permission
 * object is a free-form record with tool-specific keys that have no canonical
@@ -16594,7 +17136,10 @@ const KiloPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 * @example
 * { "permissions": { "defaultMode": "acceptEdits", "additionalDirectories": ["../shared"] } }
 */
-const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({ permissions: zod_mini.z.optional(zod_mini.z.looseObject({})) });
+const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	permissions: zod_mini.z.optional(zod_mini.z.looseObject({}))
+});
 /**
 * Tool-scoped override block for Mistral Vibe. Vibe's per-tool `BaseToolConfig`
 * carries a `sensitive_patterns` list — patterns that escalate to ASK even when
@@ -16626,6 +17171,7 @@ const VibePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 * { "approvalMode": "auto-review" }
 */
 const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	approvalMode: zod_mini.z.optional(zod_mini.z.string()),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -16633,18 +17179,28 @@ const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
 * Tool-scoped override block for Qwen Code. Qwen's `settings.json` exposes
 * autonomy/sandbox controls with no canonical permission category — under
 * `tools` (`approvalMode` = plan/default/auto-edit/auto/yolo, `autoAccept`,
-* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). Fields
-* placed here are merged into the matching `settings.json` group and emitted
-* only for Qwen, while the shared `permission` block continues to drive the
-* `permissions.allow`/`ask`/`deny` arrays. Kept `looseObject` (verbatim
-* passthrough) so any current or future `tools`/`security` key can be authored.
+* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). It also
+* exposes `permissions.autoMode` (the Auto Mode classifier config:
+* `hints.{allow,softDeny,hardDeny}`, `environment`, `classifyAllShell` — see
+* https://qwenlm.github.io/qwen-code-docs/en/users/features/auto-mode/), which
+* likewise has no canonical category. Fields placed here are merged into the
+* matching `settings.json` group and emitted only for Qwen, while the shared
+* `permission` block continues to drive the `permissions.allow`/`ask`/`deny`
+* arrays. Kept `looseObject` (verbatim passthrough) so any current or future
+* `tools`/`security`/`autoMode` key can be authored.
 *
 * @example
-* { "tools": { "approvalMode": "auto-edit" }, "security": { "folderTrust": { "enabled": true } } }
+* {
+*   "tools": { "approvalMode": "auto-edit" },
+*   "security": { "folderTrust": { "enabled": true } },
+*   "autoMode": { "hints": { "allow": ["Running tests"] }, "classifyAllShell": true }
+* }
 */
 const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	tools: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	security: zod_mini.z.optional(zod_mini.z.looseObject({}))
+	security: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	autoMode: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Reasonix. Reasonix has security axes orthogonal
@@ -16663,6 +17219,7 @@ const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "sandbox": { "bash": "enforce", "network": false }, "agent": { "plan_mode_read_only_commands": ["gh pr diff"] } }
 */
 const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	agent: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -16671,16 +17228,21 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 * exposes security controls with no canonical per-command allow/ask/deny slot —
 * `commandBlocklist` (a hard-block tier that can never be approved, distinct from
 * an approvable `deny`), `networkPolicy` (`allowedIps`), `sandbox`
-* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`, `enableDroidShield`,
+* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`,
+* `mcpAutonomyOverrides` (per-MCP-tool autonomy levels), `enableDroidShield`,
 * and autonomy settings (`sessionDefaultSettings`, `maxAutonomyLevel`,
-* `interactionMode`). Fields placed here are merged into `settings.json` and
+* `subagentAutonomyLevel`, `interactionMode`). Fields placed here are merged
+* into `settings.json` and
 * emitted only for Factory Droid, while the shared `permission` block continues
 * to drive `commandAllowlist`/`commandDenylist`. Kept `looseObject` passthrough.
 *
 * @example
 * { "commandBlocklist": ["rm -rf /*"], "sandbox": { "enabled": true } }
 */
-const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({ commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) });
+const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
 /**
 * Tool-scoped override block for Warp. Warp's `[agents.profiles]` table exposes
 * file-read/read-only autonomy keys with no canonical per-command allow/ask/deny
@@ -16697,6 +17259,7 @@ const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({ commandBl
 * { "agent_mode_coding_permissions": "always_allow_reading", "agent_mode_execute_readonly_commands": true }
 */
 const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	agent_mode_coding_permissions: zod_mini.z.optional(zod_mini.z.string()),
 	agent_mode_coding_file_read_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	agent_mode_execute_readonly_commands: zod_mini.z.optional(zod_mini.z.boolean())
@@ -16714,6 +17277,7 @@ const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "allowReadonlyCommands": true, "defaultBehavior": "ask" }
 */
 const JuniePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	allowReadonlyCommands: zod_mini.z.optional(zod_mini.z.boolean()),
 	defaultBehavior: zod_mini.z.optional(zod_mini.z.string())
 });
@@ -16741,6 +17305,7 @@ const JuniePermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "step_permission_overrides": { "ai_review": "readonly" }, "provider_options": { "codex": { "network_access": true } } }
 */
 const TaktPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	step_permission_overrides: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	provider_options: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -16768,6 +17333,7 @@ const TaktPermissionsOverrideSchema = zod_mini.z.looseObject({
 *   "permissions": [{ "tool": "Bash", "action": "delegate", "to": "approve.sh" }] }
 */
 const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	permissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
 		tool: zod_mini.z.string(),
 		action: zod_mini.z.string()
@@ -16796,6 +17362,7 @@ const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "toolPermission": "strict", "enableTerminalSandbox": true }
 */
 const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	toolPermission: zod_mini.z.optional(zod_mini.z.string()),
 	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -16821,10 +17388,13 @@ const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 *       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
 *     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
 */
-const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({ toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
-	toolName: zod_mini.z.string(),
-	permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
-}))) });
+const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
+		toolName: zod_mini.z.string(),
+		permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
+	})))
+});
 /**
 * Tool-scoped override block for Kiro. Kiro's agent config (`.kiro/agents/<name>.json`)
 * exposes per-tool `toolsSettings` knobs with no canonical allow/ask/deny
@@ -16850,21 +17420,59 @@ const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({ toolPermis
 *     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
 *     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
 */
-const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zod_mini.z.optional(zod_mini.z.looseObject({
-	shell: zod_mini.z.optional(zod_mini.z.looseObject({
-		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean()),
-		denyByDefault: zod_mini.z.optional(zod_mini.z.boolean())
-	})),
-	aws: zod_mini.z.optional(zod_mini.z.looseObject({
-		allowedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		deniedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean())
-	})),
-	web_fetch: zod_mini.z.optional(zod_mini.z.looseObject({
-		trusted: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		blocked: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	toolsSettings: zod_mini.z.optional(zod_mini.z.looseObject({
+		shell: zod_mini.z.optional(zod_mini.z.looseObject({
+			autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean()),
+			denyByDefault: zod_mini.z.optional(zod_mini.z.boolean())
+		})),
+		aws: zod_mini.z.optional(zod_mini.z.looseObject({
+			allowedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			deniedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean())
+		})),
+		web_fetch: zod_mini.z.optional(zod_mini.z.looseObject({
+			trusted: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			blocked: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+		}))
 	}))
-})) });
+});
+/**
+* Codex CLI's approval-workflow policy. Serialized as a kebab-case string in
+* `.codex/config.toml`. `on-failure` is a legacy alias for `on-request` that
+* Codex still accepts, so it is included so existing configs round-trip. The
+* granular table form (`{ granular = { … } }`) is modeled separately in the
+* override union.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalPolicySchema = zod_mini.z.enum([
+	"untrusted",
+	"on-request",
+	"on-failure",
+	"never"
+]);
+/**
+* Codex CLI's classic sandbox mode. Serialized as a kebab-case string in
+* `.codex/config.toml`.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexSandboxModeSchema = zod_mini.z.enum([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+/**
+* Codex CLI's reviewer for approval requests. `guardian_subagent` is a legacy
+* value Codex still accepts for backward compatibility, so it is included so
+* existing configs round-trip through the rulesync model.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalsReviewerSchema = zod_mini.z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
 /**
 * Codex CLI-scoped permission override.
 *
@@ -16874,15 +17482,16 @@ const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zo
 * override whose fields are written verbatim as top-level `.codex/config.toml`
 * keys (the override wins per key; existing sibling keys the user set directly
 * are preserved):
-* - `approval_policy` — `untrusted` | `on-request` | `never`, or a
-*   `{ granular = { … } }` table (kept verbatim; the granular schema has
-*   required fields that are brittle to model as typed keys).
+* - `approval_policy` — `untrusted` | `on-request` (legacy alias `on-failure`) |
+*   `never`, or a `{ granular = { … } }` table (kept verbatim; the granular
+*   schema has required fields that are brittle to model as typed keys).
 * - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
 *   with the sibling `sandbox_workspace_write` table (`network_access`,
 *   `writable_roots`, …).
 * - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
 *   `.enabled`, `apps.<id>.default_tools_approval_mode`).
-* - `approvals_reviewer` — the reviewer-approval surface.
+* - `approvals_reviewer` — the reviewer-approval surface (`user` | `auto_review`
+*   | `guardian_subagent`), or a table for the richer reviewer config.
 *
 * Two surfaces are deliberately NOT authorable here so the override can never
 * clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
@@ -16900,11 +17509,12 @@ const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zo
 *   "sandbox_workspace_write": { "network_access": true } }
 */
 const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
-	approval_policy: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
-	sandbox_mode: zod_mini.z.optional(zod_mini.z.string()),
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	approval_policy: zod_mini.z.optional(zod_mini.z.union([CodexApprovalPolicySchema, zod_mini.z.looseObject({})])),
+	sandbox_mode: zod_mini.z.optional(CodexSandboxModeSchema),
 	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})]))
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})]))
 });
 /**
 * Permissions configuration.
@@ -16918,6 +17528,15 @@ const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
 * `*PermissionsOverrideSchema`); every other tool reads the shared `permission`
 * block and ignores them.
 *
+* Additionally, every permissions-capable tool accepts a canonical tool-scoped
+* `permission` block under its override key (`{toolname}.permission`, same
+* shape as the shared `permission` record). Its categories apply only to that
+* tool, merged over the shared block per category — see
+* `RulesyncPermissions.forTarget`. `kiro-cli`/`kiro-ide` alias to the `kiro`
+* key and `hermesagent` to `hermes` (matching the shared output file each
+* writes). OpenCode/Kilo/Vibe keep their existing tool-native `permission`
+* override semantics (handled by their translators, not the central merge).
+*
 * @example
 * {
 *   "bash": { "*": "ask", "git *": "allow", "rm *": "deny" },
@@ -16943,7 +17562,13 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema),
 	augmentcode: zod_mini.z.optional(AugmentcodePermissionsOverrideSchema),
 	kiro: zod_mini.z.optional(KiroPermissionsOverrideSchema),
-	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema)
+	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema),
+	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	devin: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	grokcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	rovodev: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	zed: zod_mini.z.optional(CanonicalPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16958,7 +17583,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	json;
 	constructor(params) {
 		super({ ...params });
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -16967,7 +17592,11 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	static getSettablePaths() {
 		return {
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME
+			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_PERMISSIONS_JSONC_FILE_NAME
+			}
 		};
 	}
 	validate() {
@@ -16983,20 +17612,85 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncPermissions.getSettablePaths();
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
-		if (!await fileExists(filePath)) throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
-		const fileContent = await readFileContent(filePath);
-		return new RulesyncPermissions({
-			outputRoot,
+		const candidates = [paths.jsonc, {
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath,
-			fileContent,
-			validate
-		});
+			relativeFilePath: paths.relativeFilePath
+		}];
+		for (const candidate of candidates) {
+			const filePath = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			const fileContent = await readFileContent(filePath);
+			return new RulesyncPermissions({
+				outputRoot,
+				relativeDirPath: candidate.relativeDirPath,
+				relativeFilePath: candidate.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
+		throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} or ${RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
 	}
+	/**
+	* Build the effective permissions config for one tool target by merging the
+	* tool-scoped `{toolname}.permission` block over the shared `permission`
+	* block, per category (the tool-scoped category replaces the shared one
+	* wholesale — mirroring how `{toolname}.hooks` merges per event in
+	* `.rulesync/hooks.json`). The consumed `permission` key is stripped from
+	* the override block so verbatim-passthrough translators (e.g. the Hermes
+	* deep merge or the Codex CLI top-level key whitelist) never see it.
+	*
+	* Returns the same instance when the target has no tool-scoped canonical
+	* `permission` block, or when the target's translator natively consumes its
+	* own `permission` override shape (OpenCode / Kilo / Vibe).
+	*/
+	forTarget({ toolTarget, logger }) {
+		if (NATIVE_PERMISSION_OVERRIDE_TARGETS.has(toolTarget)) return this;
+		const overrideKey = PERMISSION_OVERRIDE_KEY_ALIASES[toolTarget] ?? toolTarget;
+		const json = this.json;
+		if (overrideKey !== toolTarget && isRecord(json[toolTarget])) logger?.warn(`The "${toolTarget}" block in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is ignored. Author it under the "${overrideKey}" key instead (the ${toolTarget} target reads that block).`);
+		const overrideBlock = json[overrideKey];
+		if (!isRecord(overrideBlock) || !isRecord(overrideBlock.permission)) return this;
+		const { permission: toolScopedPermission, ...restOverride } = overrideBlock;
+		const merged = {
+			...json,
+			permission: {
+				...this.json.permission,
+				...toolScopedPermission
+			}
+		};
+		if (Object.keys(restOverride).length > 0) merged[overrideKey] = restOverride;
+		else delete merged[overrideKey];
+		return new RulesyncPermissions({
+			outputRoot: this.outputRoot,
+			relativeDirPath: this.relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: JSON.stringify(merged, null, 2)
+		});
+	}
+};
+/**
+* Targets whose tool-scoped `permission` override uses tool-native semantics
+* consumed directly by their translator (bare action strings / tool-only
+* categories for OpenCode and Kilo, `sensitive_patterns` objects for Vibe).
+* The central canonical merge must not touch those blocks.
+*/
+const NATIVE_PERMISSION_OVERRIDE_TARGETS = /* @__PURE__ */ new Set([
+	"opencode",
+	"kilo",
+	"vibe"
+]);
+/**
+* Targets that read their tool-scoped override from a differently named key:
+* Kiro IDE/CLI share the `kiro` block (they write the same agent config) and
+* Hermes Agent's established override key is `hermes`.
+*/
+const PERMISSION_OVERRIDE_KEY_ALIASES = {
+	"kiro-cli": "kiro",
+	"kiro-ide": "kiro",
+	hermesagent: "hermes"
 };
 //#endregion
 //#region src/features/permissions/tool-permissions.ts
@@ -18836,10 +19530,15 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			existingDomainsHadUnknown,
 			logger
 		});
-		permissionsTable[RULESYNC_PROFILE_NAME] = mergeWithExistingProfile({
+		const profile = mergeWithExistingProfile({
 			newProfile,
 			existingProfile
 		});
+		permissionsTable[RULESYNC_PROFILE_NAME] = preserveUnmanagedProfileKeys({
+			rawExistingProfile: permissionsTable[RULESYNC_PROFILE_NAME],
+			profile,
+			logger
+		});
 		const overridePatch = computeCodexcliOverridePatch({
 			existing,
 			override: rulesyncPermissions.getJson().codexcli,
@@ -19035,6 +19734,43 @@ function warnAboutPreservedProfileState({ existingProfile, newProfile, existingD
 	if (existingProfile?.network?.mode !== void 0) logger?.warn(`Preserving existing "network.mode" from config. Review this value manually as it may grant broader network access than the Rulesync-managed domain rules.`);
 	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
 }
+const MANAGED_PROFILE_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"extends",
+	"filesystem",
+	"network"
+]);
+const MANAGED_NETWORK_KEYS = /* @__PURE__ */ new Set([
+	"enabled",
+	"mode",
+	"domains",
+	"unix_sockets"
+]);
+/**
+* Re-attach the keys of the existing rulesync profile that rulesync does not
+* manage. The managed keys always come from `profile` (the freshly computed
+* merge result); unmanaged siblings — at the profile level and inside the
+* `network` table — are preserved verbatim from the existing config so a
+* regeneration never deletes user-authored Codex settings.
+*/
+function preserveUnmanagedProfileKeys({ rawExistingProfile, profile, logger }) {
+	const rawProfileTable = toMutableTable(rawExistingProfile);
+	const profileExtras = Object.fromEntries(Object.entries(rawProfileTable).filter(([key]) => !MANAGED_PROFILE_KEYS.has(key)));
+	const rawNetworkTable = toMutableTable(rawProfileTable.network);
+	const networkExtras = Object.fromEntries(Object.entries(rawNetworkTable).filter(([key]) => !MANAGED_NETWORK_KEYS.has(key)));
+	const preservedKeyNames = [...Object.keys(profileExtras), ...Object.keys(networkExtras).map((key) => `network.${key}`)];
+	if (preservedKeyNames.length > 0) logger?.warn(`Preserving unmanaged keys in the "${RULESYNC_PROFILE_NAME}" permissions profile: ${preservedKeyNames.join(", ")}. Review them manually; rulesync carries them forward verbatim.`);
+	const result = {
+		...profileExtras,
+		...profile
+	};
+	const mergedNetwork = {
+		...networkExtras,
+		...profile.network
+	};
+	if (Object.keys(mergedNetwork).length > 0) result.network = mergedNetwork;
+	return result;
+}
 function mergeWithExistingProfile({ newProfile, existingProfile }) {
 	if (!existingProfile) return newProfile;
 	const mergedNetwork = { ...newProfile.network };
@@ -19765,9 +20501,11 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"networkPolicy",
 	"sandbox",
 	"mcpPolicy",
+	"mcpAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
+	"subagentAutonomyLevel",
 	"interactionMode"
 ];
 /**
@@ -20125,7 +20863,6 @@ function convertGoosePermissionConfigToRulesync(userPermission) {
 }
 //#endregion
 //#region src/features/permissions/grokcli-permissions.ts
-const GROKCLI_GLOBAL_ONLY_MESSAGE = "Grok CLI permissions are global-only; use --global to sync ~/.grok/config.toml";
 const GROKCLI_UI_KEY = "ui";
 const GROKCLI_PERMISSION_MODE_KEY = "permission_mode";
 const GROKCLI_PERMISSION_KEY = "permission";
@@ -20227,13 +20964,19 @@ function parseGrokEntry(entry) {
 * compatibility with older Grok versions: `always-approve` when the config is
 * pure-`allow`, otherwise `ask` (conservative — it is never `always-approve`
 * while any `deny`/`ask` rule exists, so it never contradicts the fine-grained
-* arrays).
-*
-* This surface is **global only** — the adapter syncs the user-level
-* `~/.grok/config.toml`. (Grok also supports a project-scoped `[permission]`
-* file; project scope is not modeled here.) The shared config is merged in
+* arrays). It is a user-level UI setting, so it is only written in global scope
+* (see below).
+*
+* Both scopes are supported: the adapter syncs the project-level
+* `./.grok/config.toml` (default) and the user-level `~/.grok/config.toml`
+* (with `--global`). Grok documents that "Project configs are limited to MCP
+* servers, plugins, and permission rules, not full user configs"
+* (https://docs.x.ai/build/settings), so the project config carries only the
+* fine-grained `[permission]` rules; the coarse `[ui] permission_mode` UI toggle
+* is written in global scope only. The shared config is merged in
 * place: rulesync owns the `[permission]` `allow`/`deny`/`ask` entries for the
-* tools it models and the `[ui] permission_mode` value, while every other key
+* tools it models and (in global scope) the `[ui] permission_mode` value, while
+* every other key
 * (e.g. `[mcp_servers]`, `[permission] rules`, `[sandbox]`) and any user-authored
 * entries for tools rulesync cannot model (e.g. `WebSearch`) are preserved. The
 * file is never deleted.
@@ -20255,7 +20998,6 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		return new GrokcliPermissions({
@@ -20264,11 +21006,10 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
 			validate,
-			global: true
+			global
 		});
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
@@ -20287,11 +21028,10 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			deny: buckets.deny,
 			ask: buckets.ask
 		};
-		const mode = deriveGrokPermissionMode(config);
-		const ui = {
+		const uiPatch = global ? { [GROKCLI_UI_KEY]: {
 			...isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {},
-			[GROKCLI_PERMISSION_MODE_KEY]: mode
-		};
+			[GROKCLI_PERMISSION_MODE_KEY]: deriveGrokPermissionMode(config)
+		} } : {};
 		return new GrokcliPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -20302,12 +21042,12 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 				existingContent,
 				patch: {
 					[GROKCLI_PERMISSION_KEY]: permission,
-					[GROKCLI_UI_KEY]: ui
+					...uiPatch
 				},
 				filePath
 			}),
 			validate: true,
-			global: true
+			global
 		});
 	}
 	toRulesyncPermissions() {
@@ -20328,14 +21068,14 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			error: null
 		};
 	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		return new GrokcliPermissions({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			global: true
+			global
 		});
 	}
 };
@@ -21250,6 +21990,22 @@ const CANONICAL_PERMISSION_CATEGORIES = /* @__PURE__ */ new Set([
 	"notebookedit",
 	"agent"
 ]);
+/**
+* Translate between rulesync's canonical permission category names and
+* OpenCode's native permission keys. OpenCode has no `agent` key — subagent
+* launches are gated by the `task` key (see the documented key list at
+* https://opencode.ai/docs/permissions/). Without this translation a canonical
+* `agent: deny` would be written verbatim into `opencode.json` and silently
+* ignored by OpenCode. Unknown names pass through unchanged.
+*/
+const CANONICAL_TO_OPENCODE_PERMISSION_KEYS = { agent: "task" };
+const OPENCODE_TO_CANONICAL_PERMISSION_KEYS = Object.fromEntries(Object.entries(CANONICAL_TO_OPENCODE_PERMISSION_KEYS).map(([canonical, opencode]) => [opencode, canonical]));
+function toOpencodePermissionKey(canonical) {
+	return CANONICAL_TO_OPENCODE_PERMISSION_KEYS[canonical] ?? canonical;
+}
+function toCanonicalPermissionKey(opencodeKey) {
+	return OPENCODE_TO_CANONICAL_PERMISSION_KEYS[opencodeKey] ?? opencodeKey;
+}
 function isSharedPermissionCategory(category) {
 	return category === "*" || CANONICAL_PERMISSION_CATEGORIES.has(category) || category.startsWith("mcp__");
 }
@@ -21316,6 +22072,8 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 		}
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const overridePermission = rulesyncJson.opencode?.permission ?? {};
+		const sharedPermission = {};
+		for (const [category, value] of Object.entries(rulesyncJson.permission ?? {})) sharedPermission[toOpencodePermissionKey(category)] = value;
 		return new OpencodePermissions({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -21325,7 +22083,7 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch: { permission: {
-					...rulesyncJson.permission,
+					...sharedPermission,
 					...overridePermission
 				} },
 				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
@@ -21341,8 +22099,11 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 		}
 		const shared = {};
 		const overrideOnly = {};
-		for (const [category, value] of Object.entries(rawPermission)) if (isSharedPermissionCategory(category)) shared[category] = typeof value === "string" ? { "*": value } : value;
-		else overrideOnly[category] = value;
+		for (const [category, value] of Object.entries(rawPermission)) {
+			const canonicalCategory = toCanonicalPermissionKey(category);
+			if (isSharedPermissionCategory(canonicalCategory)) shared[canonicalCategory] = typeof value === "string" ? { "*": value } : value;
+			else overrideOnly[category] = value;
+		}
 		const json = Object.keys(overrideOnly).length > 0 ? {
 			permission: shared,
 			opencode: { permission: overrideOnly }
@@ -21467,6 +22228,7 @@ const QWEN_OVERRIDE_TOOLS_KEYS = [
 	"disabled"
 ];
 const QWEN_OVERRIDE_SECURITY_KEYS = ["folderTrust"];
+const QWEN_OVERRIDE_PERMISSIONS_KEYS = ["autoMode"];
 function asPlainRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -21538,8 +22300,9 @@ var QwencodePermissions = class QwencodePermissions extends ToolPermissions {
 		else delete mergedPermissions.ask;
 		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
 		else delete mergedPermissions.deny;
-		const patch = { permissions: mergedPermissions };
 		const override = config.qwencode;
+		if (override?.autoMode !== void 0) mergedPermissions.autoMode = override.autoMode;
+		const patch = { permissions: mergedPermissions };
 		if (override?.tools !== void 0) patch.tools = {
 			...asPlainRecord(settings.tools),
 			...asPlainRecord(override.tools)
@@ -21581,9 +22344,11 @@ var QwencodePermissions = class QwencodePermissions extends ToolPermissions {
 		});
 		const overrideTools = pickQwenOverrideKeys(settings.tools, QWEN_OVERRIDE_TOOLS_KEYS);
 		const overrideSecurity = pickQwenOverrideKeys(settings.security, QWEN_OVERRIDE_SECURITY_KEYS);
+		const overridePermissions = pickQwenOverrideKeys(settings.permissions, QWEN_OVERRIDE_PERMISSIONS_KEYS);
 		const qwencodeOverride = {};
 		if (Object.keys(overrideTools).length > 0) qwencodeOverride.tools = overrideTools;
 		if (Object.keys(overrideSecurity).length > 0) qwencodeOverride.security = overrideSecurity;
+		if (overridePermissions.autoMode !== void 0) qwencodeOverride.autoMode = overridePermissions.autoMode;
 		const result = { ...config };
 		if (Object.keys(qwencodeOverride).length > 0) result.qwencode = qwencodeOverride;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -23092,7 +23857,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["grokcli", {
 		class: GrokcliPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -23267,16 +24032,20 @@ var PermissionsProcessor = class extends FeatureProcessor {
 		if (!rulesyncPermissions) throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
 		const factory = toolPermissionsFactories.get(this.toolTarget);
 		if (!factory) throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+		const effectivePermissions = rulesyncPermissions.forTarget({
+			toolTarget: this.toolTarget,
+			logger: this.logger
+		});
 		const toolPermissions = await factory.class.fromRulesyncPermissions({
 			outputRoot: this.outputRoot,
-			rulesyncPermissions,
+			rulesyncPermissions: effectivePermissions,
 			logger: this.logger,
 			global: this.global
 		});
 		if (this.toolTarget !== "codexcli") return [toolPermissions];
 		return [toolPermissions, createCodexcliBashRulesFile({
 			outputRoot: this.outputRoot,
-			config: rulesyncPermissions.getJson()
+			config: effectivePermissions.getJson()
 		})];
 	}
 	async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -39372,6 +40141,16 @@ async function generatePermissionsCore(params) {
 //#endregion
 //#region src/lib/import.ts
 /**
+* Import always writes the `.json` variant of a fixed-path source file, but a
+* sibling `.jsonc` variant takes precedence at read time — so an import into a
+* project that authors the `.jsonc` variant would be silently shadowed. Warn
+* so the user merges (or removes) one of the two by hand.
+*/
+async function warnIfShadowedByJsonc(params) {
+	const { outputRoot, jsonRelativePath, jsoncRelativePath, logger } = params;
+	if (await fileExists((0, node_path.join)(outputRoot, jsoncRelativePath))) logger.warn(`${jsoncRelativePath} exists and takes precedence over the imported ${jsonRelativePath}. Merge the imported content into ${jsoncRelativePath} (or remove it) so the import takes effect.`);
+}
+/**
 * Import configuration files from AI tools.
 */
 async function importFromTool(params) {
@@ -39483,6 +40262,12 @@ async function importMcpCore(params) {
 	}
 	const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await mcpProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_MCP_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} MCP files`);
 	return writtenCount;
 }
@@ -39582,6 +40367,12 @@ async function importHooksCore(params) {
 	}
 	const rulesyncFiles = await hooksProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await hooksProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_HOOKS_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} hooks file(s)`);
 	return writtenCount;
 }
@@ -39611,6 +40402,12 @@ async function importPermissionsCore(params) {
 	}
 	const rulesyncFiles = await permissionsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await permissionsProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} permissions file(s)`);
 	return writtenCount;
 }
@@ -39675,6 +40472,12 @@ Object.defineProperty(exports, "CLIError", {
 		return CLIError;
 	}
 });
+Object.defineProperty(exports, "CODEXCLI_DIR", {
+	enumerable: true,
+	get: function() {
+		return CODEXCLI_DIR;
+	}
+});
 Object.defineProperty(exports, "CommandsProcessor", {
 	enumerable: true,
 	get: function() {
@@ -39771,6 +40574,12 @@ Object.defineProperty(exports, "RULESYNC_HOOKS_FILE_NAME", {
 		return RULESYNC_HOOKS_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_HOOKS_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_HOOKS_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_HOOKS_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
@@ -39795,6 +40604,12 @@ Object.defineProperty(exports, "RULESYNC_MCP_FILE_NAME", {
 		return RULESYNC_MCP_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_MCP_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_MCP_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_MCP_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
@@ -39819,12 +40634,24 @@ Object.defineProperty(exports, "RULESYNC_PERMISSIONS_FILE_NAME", {
 		return RULESYNC_PERMISSIONS_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_PERMISSIONS_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_PERMISSIONS_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
 		return RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_PERMISSIONS_SCHEMA_URL", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_PERMISSIONS_SCHEMA_URL;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_RELATIVE_DIR_PATH", {
 	enumerable: true,
 	get: function() {