rulesync 9.7.0 → 10.0.0

package/dist/{import-DC9T1JlQ.js → import-B02AyWkQ.js}

@@ -99,6 +99,9 @@ const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH,
 const RULESYNC_MCP_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
 const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
 const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
 const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
@@ -109,8 +112,12 @@ 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
@@ -322,7 +329,8 @@ const hooksProcessorToolTargetTuple = [
 	"junie",
 	"vibe",
 	"qwencode",
-	"reasonix"
+	"reasonix",
+	"grokcli"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -6269,10 +6277,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` /
@@ -6287,7 +6298,8 @@ const DEVIN_HOOK_EVENTS = [
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"stop",
-	"permissionRequest"
+	"permissionRequest",
+	"postCompact"
 ];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
@@ -6481,7 +6493,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 = [
@@ -6489,7 +6501,8 @@ const AUGMENTCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"sessionStart",
 	"sessionEnd",
-	"stop"
+	"stop",
+	"notification"
 ];
 /**
 * Hook events supported by Mistral Vibe (mistral-vibe).
@@ -6541,6 +6554,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 = [
@@ -6549,7 +6566,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"postToolUseFailure",
+	"postToolBatch",
 	"beforeSubmitPrompt",
+	"userPromptExpansion",
 	"stop",
 	"stopFailure",
 	"subagentStart",
@@ -6557,7 +6576,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preCompact",
 	"postCompact",
 	"permissionRequest",
+	"permissionDenied",
 	"notification",
+	"instructionsLoaded",
 	"todoCreated",
 	"todoCompleted"
 ];
@@ -6567,11 +6588,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.
@@ -6585,7 +6606,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.
@@ -6659,6 +6712,7 @@ const HooksConfigSchema = z.looseObject({
 	junie: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	vibe: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	reasonix: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	grokcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -6717,7 +6771,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.
@@ -6732,7 +6787,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.
@@ -7002,7 +7058,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",
@@ -7010,7 +7068,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preCompact: "PreCompact",
 	postCompact: "PostCompact",
 	permissionRequest: "PermissionRequest",
+	permissionDenied: "PermissionDenied",
 	notification: "Notification",
+	instructionsLoaded: "InstructionsLoaded",
 	todoCreated: "TodoCreated",
 	todoCompleted: "TodoCompleted"
 };
@@ -7032,12 +7092,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) {
@@ -7236,12 +7324,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(content) {
+	const errors = [];
+	const result = parse(content, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0) {
+		const details = errors.map((e) => `${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(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -7250,7 +7381,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() {
@@ -7266,16 +7401,23 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncHooks.getSettablePaths();
-		const filePath = 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 = 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;
@@ -7562,7 +7704,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
-		"stop"
+		"stop",
+		"notification"
 	])
 };
 /**
@@ -8661,7 +8804,8 @@ const DEVIN_CONVERTER_CONFIG = {
 		"sessionStart",
 		"sessionEnd",
 		"stop",
-		"beforeSubmitPrompt"
+		"beforeSubmitPrompt",
+		"postCompact"
 	])
 };
 /**
@@ -8970,6 +9114,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 = 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";
+//#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(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 = 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 ${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` /
@@ -10176,9 +10481,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 {
@@ -10766,6 +11071,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);
@@ -12109,15 +12425,51 @@ const RulesyncMcpServerSchema = z.extend(McpServerSchema, {
 	exposed: z.optional(z.boolean())
 });
 const RulesyncMcpConfigSchema = z.object({ mcpServers: z.record(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 = z.looseObject({ mcpServers: z.optional(z.record(z.string(), z.nullable(RulesyncMcpServerSchema))) });
 const RulesyncMcpFileSchema = z.looseObject({
 	$schema: z.optional(z.string()),
-	...RulesyncMcpConfigSchema.shape
+	...RulesyncMcpConfigSchema.shape,
+	amp: z.optional(toolScopedMcpSchema),
+	"antigravity-cli": z.optional(toolScopedMcpSchema),
+	"antigravity-ide": z.optional(toolScopedMcpSchema),
+	augmentcode: z.optional(toolScopedMcpSchema),
+	claudecode: z.optional(toolScopedMcpSchema),
+	cline: z.optional(toolScopedMcpSchema),
+	codexcli: z.optional(toolScopedMcpSchema),
+	copilot: z.optional(toolScopedMcpSchema),
+	copilotcli: z.optional(toolScopedMcpSchema),
+	cursor: z.optional(toolScopedMcpSchema),
+	deepagents: z.optional(toolScopedMcpSchema),
+	devin: z.optional(toolScopedMcpSchema),
+	factorydroid: z.optional(toolScopedMcpSchema),
+	goose: z.optional(toolScopedMcpSchema),
+	grokcli: z.optional(toolScopedMcpSchema),
+	hermesagent: z.optional(toolScopedMcpSchema),
+	junie: z.optional(toolScopedMcpSchema),
+	kilo: z.optional(toolScopedMcpSchema),
+	kiro: z.optional(toolScopedMcpSchema),
+	opencode: z.optional(toolScopedMcpSchema),
+	qwencode: z.optional(toolScopedMcpSchema),
+	reasonix: z.optional(toolScopedMcpSchema),
+	roo: z.optional(toolScopedMcpSchema),
+	rovodev: z.optional(toolScopedMcpSchema),
+	takt: z.optional(toolScopedMcpSchema),
+	vibe: z.optional(toolScopedMcpSchema),
+	warp: z.optional(toolScopedMcpSchema),
+	zed: z.optional(toolScopedMcpSchema)
 });
 var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	json;
 	constructor(params) {
 		super(params);
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -12127,7 +12479,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,
@@ -12149,7 +12505,18 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	static async fromFile({ outputRoot = process.cwd(), validate = true, logger }) {
 		const paths = this.getSettablePaths();
 		const recommendedPath = join(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
+		const jsoncPath = join(outputRoot, paths.jsonc.relativeDirPath, paths.jsonc.relativeFilePath);
 		const legacyPath = 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({
@@ -12209,7 +12576,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 ${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 ${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 {
@@ -13021,7 +13522,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			...rest,
 			validate: false
 		});
-		this.toml = smolToml.parse(this.fileContent);
+		let toml;
+		try {
+			toml = smolToml.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;
@@ -13057,7 +13564,12 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		const paths = this.getSettablePaths({ global });
 		const configTomlFilePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
-		const configToml = smolToml.parse(configTomlFileContent || smolToml.stringify({}));
+		let configToml;
+		try {
+			configToml = smolToml.parse(configTomlFileContent || smolToml.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]) => {
@@ -14031,47 +14543,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 = 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 = 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;
 /**
@@ -14231,6 +14702,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
@@ -14264,9 +14783,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;
 }
@@ -14309,10 +14827,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;
@@ -16444,10 +16960,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,
@@ -16497,6 +17017,25 @@ const PermissionActionSchema = z.enum([
 */
 const PermissionRulesSchema = z.record(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 = z.record(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 = z.looseObject({ permission: 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"`).
@@ -16526,7 +17065,7 @@ const OpencodePermissionsOverrideSchema = z.looseObject({ permission: z.optional
 * @example
 * { "approvals": { "mode": "smart" }, "security": { "allow_private_urls": false } }
 */
-const HermesPermissionsOverrideSchema = z.looseObject({});
+const HermesPermissionsOverrideSchema = z.looseObject({ permission: z.optional(ToolScopedPermissionSchema) });
 /**
 * Tool-scoped override block for Cline. Cline's `command-permissions.json`
 * carries a single global `allowRedirects` boolean (gates shell redirection
@@ -16538,7 +17077,10 @@ const HermesPermissionsOverrideSchema = z.looseObject({});
 * @example
 * { "allowRedirects": true }
 */
-const ClinePermissionsOverrideSchema = z.looseObject({ allowRedirects: z.optional(z.boolean()) });
+const ClinePermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	allowRedirects: z.optional(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
@@ -16568,7 +17110,10 @@ const KiloPermissionsOverrideSchema = z.looseObject({ permission: z.optional(z.r
 * @example
 * { "permissions": { "defaultMode": "acceptEdits", "additionalDirectories": ["../shared"] } }
 */
-const ClaudecodePermissionsOverrideSchema = z.looseObject({ permissions: z.optional(z.looseObject({})) });
+const ClaudecodePermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	permissions: z.optional(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
@@ -16600,6 +17145,7 @@ const VibePermissionsOverrideSchema = z.looseObject({ permission: z.optional(z.r
 * { "approvalMode": "auto-review" }
 */
 const CursorPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	approvalMode: z.optional(z.string()),
 	sandbox: z.optional(z.looseObject({}))
 });
@@ -16607,18 +17153,28 @@ const CursorPermissionsOverrideSchema = 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 = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	tools: z.optional(z.looseObject({})),
-	security: z.optional(z.looseObject({}))
+	security: z.optional(z.looseObject({})),
+	autoMode: z.optional(z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Reasonix. Reasonix has security axes orthogonal
@@ -16637,6 +17193,7 @@ const QwencodePermissionsOverrideSchema = z.looseObject({
 * { "sandbox": { "bash": "enforce", "network": false }, "agent": { "plan_mode_read_only_commands": ["gh pr diff"] } }
 */
 const ReasonixPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	sandbox: z.optional(z.looseObject({})),
 	agent: z.optional(z.looseObject({}))
 });
@@ -16645,16 +17202,21 @@ const ReasonixPermissionsOverrideSchema = 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 = z.looseObject({ commandBlocklist: z.optional(z.array(z.string())) });
+const FactorydroidPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	commandBlocklist: z.optional(z.array(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
@@ -16671,6 +17233,7 @@ const FactorydroidPermissionsOverrideSchema = z.looseObject({ commandBlocklist:
 * { "agent_mode_coding_permissions": "always_allow_reading", "agent_mode_execute_readonly_commands": true }
 */
 const WarpPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	agent_mode_coding_permissions: z.optional(z.string()),
 	agent_mode_coding_file_read_allowlist: z.optional(z.array(z.string())),
 	agent_mode_execute_readonly_commands: z.optional(z.boolean())
@@ -16688,6 +17251,7 @@ const WarpPermissionsOverrideSchema = z.looseObject({
 * { "allowReadonlyCommands": true, "defaultBehavior": "ask" }
 */
 const JuniePermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	allowReadonlyCommands: z.optional(z.boolean()),
 	defaultBehavior: z.optional(z.string())
 });
@@ -16715,6 +17279,7 @@ const JuniePermissionsOverrideSchema = z.looseObject({
 * { "step_permission_overrides": { "ai_review": "readonly" }, "provider_options": { "codex": { "network_access": true } } }
 */
 const TaktPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	step_permission_overrides: z.optional(z.record(z.string(), z.string())),
 	provider_options: z.optional(z.looseObject({}))
 });
@@ -16742,6 +17307,7 @@ const TaktPermissionsOverrideSchema = z.looseObject({
 *   "permissions": [{ "tool": "Bash", "action": "delegate", "to": "approve.sh" }] }
 */
 const AmpPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	permissions: z.optional(z.array(z.looseObject({
 		tool: z.string(),
 		action: z.string()
@@ -16770,6 +17336,7 @@ const AmpPermissionsOverrideSchema = z.looseObject({
 * { "toolPermission": "strict", "enableTerminalSandbox": true }
 */
 const AntigravityCliPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
 	toolPermission: z.optional(z.string()),
 	enableTerminalSandbox: z.optional(z.boolean())
 });
@@ -16795,10 +17362,13 @@ const AntigravityCliPermissionsOverrideSchema = z.looseObject({
 *       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
 *     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
 */
-const AugmentcodePermissionsOverrideSchema = z.looseObject({ toolPermissions: z.optional(z.array(z.looseObject({
-	toolName: z.string(),
-	permission: z.looseObject({ type: z.string() })
-}))) });
+const AugmentcodePermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	toolPermissions: z.optional(z.array(z.looseObject({
+		toolName: z.string(),
+		permission: z.looseObject({ type: 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
@@ -16824,21 +17394,59 @@ const AugmentcodePermissionsOverrideSchema = z.looseObject({ toolPermissions: z.
 *     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
 *     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
 */
-const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(z.looseObject({
-	shell: z.optional(z.looseObject({
-		autoAllowReadonly: z.optional(z.boolean()),
-		denyByDefault: z.optional(z.boolean())
-	})),
-	aws: z.optional(z.looseObject({
-		allowedServices: z.optional(z.array(z.string())),
-		deniedServices: z.optional(z.array(z.string())),
-		autoAllowReadonly: z.optional(z.boolean())
-	})),
-	web_fetch: z.optional(z.looseObject({
-		trusted: z.optional(z.array(z.string())),
-		blocked: z.optional(z.array(z.string()))
+const KiroPermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	toolsSettings: z.optional(z.looseObject({
+		shell: z.optional(z.looseObject({
+			autoAllowReadonly: z.optional(z.boolean()),
+			denyByDefault: z.optional(z.boolean())
+		})),
+		aws: z.optional(z.looseObject({
+			allowedServices: z.optional(z.array(z.string())),
+			deniedServices: z.optional(z.array(z.string())),
+			autoAllowReadonly: z.optional(z.boolean())
+		})),
+		web_fetch: z.optional(z.looseObject({
+			trusted: z.optional(z.array(z.string())),
+			blocked: z.optional(z.array(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 = 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 = 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 = z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
 /**
 * Codex CLI-scoped permission override.
 *
@@ -16848,15 +17456,16 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 * 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
@@ -16874,11 +17483,12 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 *   "sandbox_workspace_write": { "network_access": true } }
 */
 const CodexcliPermissionsOverrideSchema = z.looseObject({
-	approval_policy: z.optional(z.union([z.string(), z.looseObject({})])),
-	sandbox_mode: z.optional(z.string()),
+	permission: z.optional(ToolScopedPermissionSchema),
+	approval_policy: z.optional(z.union([CodexApprovalPolicySchema, z.looseObject({})])),
+	sandbox_mode: z.optional(CodexSandboxModeSchema),
 	sandbox_workspace_write: z.optional(z.looseObject({})),
 	apps: z.optional(z.looseObject({})),
-	approvals_reviewer: z.optional(z.union([z.string(), z.looseObject({})]))
+	approvals_reviewer: z.optional(z.union([CodexApprovalsReviewerSchema, z.looseObject({})]))
 });
 /**
 * Permissions configuration.
@@ -16892,6 +17502,15 @@ const CodexcliPermissionsOverrideSchema = 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" },
@@ -16917,7 +17536,13 @@ const PermissionsConfigSchema = z.looseObject({
 	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema),
 	augmentcode: z.optional(AugmentcodePermissionsOverrideSchema),
 	kiro: z.optional(KiroPermissionsOverrideSchema),
-	codexcli: z.optional(CodexcliPermissionsOverrideSchema)
+	codexcli: z.optional(CodexcliPermissionsOverrideSchema),
+	"antigravity-ide": z.optional(CanonicalPermissionsOverrideSchema),
+	devin: z.optional(CanonicalPermissionsOverrideSchema),
+	goose: z.optional(CanonicalPermissionsOverrideSchema),
+	grokcli: z.optional(CanonicalPermissionsOverrideSchema),
+	rovodev: z.optional(CanonicalPermissionsOverrideSchema),
+	zed: z.optional(CanonicalPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16932,7 +17557,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	json;
 	constructor(params) {
 		super({ ...params });
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -16941,7 +17566,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() {
@@ -16957,20 +17586,85 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncPermissions.getSettablePaths();
-		const filePath = 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 = 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 ${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
@@ -18810,10 +19504,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,
@@ -19009,6 +19708,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 };
@@ -19739,9 +20475,11 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"networkPolicy",
 	"sandbox",
 	"mcpPolicy",
+	"mcpAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
+	"subagentAutonomyLevel",
 	"interactionMode"
 ];
 /**
@@ -20099,7 +20837,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";
@@ -20201,13 +20938,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.
@@ -20229,7 +20972,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		return new GrokcliPermissions({
@@ -20238,11 +20980,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 = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
@@ -20261,11 +21002,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,
@@ -20276,12 +21016,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() {
@@ -20302,14 +21042,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
 		});
 	}
 };
@@ -21224,6 +21964,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__");
 }
@@ -21290,6 +22046,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,
@@ -21299,7 +22057,7 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch: { permission: {
-					...rulesyncJson.permission,
+					...sharedPermission,
 					...overridePermission
 				} },
 				filePath: join(jsonDir, relativeFilePath)
@@ -21315,8 +22073,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 }
@@ -21441,6 +22202,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 : {};
 }
@@ -21512,8 +22274,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)
@@ -21555,9 +22318,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) });
@@ -23066,7 +23831,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["grokcli", {
 		class: GrokcliPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -23241,16 +24006,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) {
@@ -39346,6 +40115,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(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) {
@@ -39457,6 +40236,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;
 }
@@ -39556,6 +40341,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;
 }
@@ -39585,10 +40376,16 @@ 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;
 }
 //#endregion
-export { removeTempDirectory as $, RulesyncCommand as A, checkPathTraversal as B, RulesyncHooks as C, RULESYNC_RULES_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, formatError as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Et, findControlCharacter as F, findFilesByGlobs as G, directoryExists as H, ConsoleLogger as I, isSymlink as J, getFileSize as K, JsonLogger as L, stringifyFrontmatter as M, loadYaml as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES as Ot, ConfigResolver as P, removeFile as Q, CLIError as R, HooksProcessor as S, RULESYNC_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Tt, ensureDir as U, createTempDirectory as V, fileExists as W, readFileContent as X, listDirectoryFiles as Y, removeDirectory as Z, RulesyncPermissions as _, RULESYNC_MCP_RELATIVE_FILE_PATH as _t, convertFromTool as a, MAX_FILE_SIZE as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_FILE_NAME as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as dt, toPosixPath as et, SkillsProcessor as f, RULESYNC_HOOKS_FILE_NAME as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_FILE_NAME as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ToolTargetSchema as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, ALL_FEATURES_WITH_WILDCARD as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as lt, RulesyncSkill as m, RULESYNC_IGNORE_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS as nt, RulesProcessor as o, RULESYNC_AIIGNORE_FILE_NAME as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_RELATIVE_FILE_PATH as pt, getHomeDirectory as q, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rt, RulesyncRule as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as st, importFromTool as t, writeFileContent as tt, RulesyncSubagent as u, RULESYNC_CONFIG_SCHEMA_URL as ut, McpProcessor as v, RULESYNC_MCP_SCHEMA_URL as vt, CommandsProcessor as w, RULESYNC_SKILLS_RELATIVE_DIR_PATH as wt, RulesyncIgnore as x, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as xt, RulesyncMcp as y, RULESYNC_OVERVIEW_FILE_NAME as yt, ErrorCodes as z };
+export { removeFile as $, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as At, ErrorCodes as B, RulesyncHooks as C, RULESYNC_PERMISSIONS_FILE_NAME as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_RELATIVE_DIR_PATH as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_SCHEMA_URL as Et, ConfigResolver as F, fileExists as G, createTempDirectory as H, findControlCharacter as I, getHomeDirectory as J, findFilesByGlobs as K, ConsoleLogger as L, RulesyncCommandFrontmatterSchema as M, formatError as Mt, stringifyFrontmatter as N, ALL_FEATURES as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RULES_RELATIVE_DIR_PATH as Ot, loadYaml as P, ALL_FEATURES_WITH_WILDCARD as Pt, removeDirectory as Q, JsonLogger as R, HooksProcessor as S, RULESYNC_OVERVIEW_FILE_NAME as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Tt, directoryExists as U, checkPathTraversal as V, ensureDir as W, listDirectoryFiles as X, isSymlink as Y, readFileContent as Z, RulesyncPermissions as _, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as _t, convertFromTool as a, ToolTargetSchema as at, IgnoreProcessor as b, RULESYNC_MCP_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CONFIG_SCHEMA_URL as dt, removeTempDirectory as et, SkillsProcessor as f, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ft, SKILL_FILE_NAME as g, RULESYNC_IGNORE_RELATIVE_FILE_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_HOOKS_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ALL_TOOL_TARGETS_WITH_WILDCARD as it, RulesyncCommand as j, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_SKILLS_RELATIVE_DIR_PATH as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as lt, RulesyncSkill as m, RULESYNC_HOOKS_JSONC_FILE_NAME as mt, checkRulesyncDirExists as n, writeFileContent as nt, RulesProcessor as o, MAX_FILE_SIZE as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_FILE_NAME as pt, getFileSize as q, generate as r, ALL_TOOL_TARGETS as rt, RulesyncRule as s, RULESYNC_AIIGNORE_FILE_NAME as st, importFromTool as t, toPosixPath as tt, RulesyncSubagent as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ut, McpProcessor as v, RULESYNC_MCP_FILE_NAME as vt, CommandsProcessor as w, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as wt, RulesyncIgnore as x, RULESYNC_MCP_SCHEMA_URL as xt, RulesyncMcp as y, RULESYNC_MCP_JSONC_FILE_NAME as yt, CLIError as z };
 
-//# sourceMappingURL=import-DC9T1JlQ.js.map
+//# sourceMappingURL=import-B02AyWkQ.js.map