rulesync 9.6.3 → 9.8.0

package/dist/{import-A1yGuzwv.js → import-Dioh9ca8.js}

@@ -8,6 +8,7 @@ import { intersection, kebabCase, uniq } from "es-toolkit";
 import { globbySync } from "globby";
 import { isDeepStrictEqual } from "node:util";
 import * as smolToml from "smol-toml";
+import { parse as parse$1, stringify } from "smol-toml";
 import matter from "gray-matter";
 import { YAMLException, dump, load } from "js-yaml";
 import { omit } from "es-toolkit/object";
@@ -321,7 +322,8 @@ const hooksProcessorToolTargetTuple = [
 	"junie",
 	"vibe",
 	"qwencode",
-	"reasonix"
+	"reasonix",
+	"grokcli"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -2677,6 +2679,13 @@ const CODEXCLI_MCP_FILE_NAME = "config.toml";
 const CODEXCLI_RULE_FILE_NAME = "AGENTS.md";
 const CODEXCLI_BASH_RULES_FILE_NAME = "rulesync.rules";
 const CODEXCLI_OPENAI_YAML_RELATIVE_PATH = join("agents", "openai.yaml");
+const CODEXCLI_OVERRIDE_KEYS = [
+	"approval_policy",
+	"sandbox_mode",
+	"sandbox_workspace_write",
+	"apps",
+	"approvals_reviewer"
+];
 //#endregion
 //#region src/features/commands/codexcli-command.ts
 const CodexcliCommandFrontmatterSchema = z.looseObject({
@@ -4055,14 +4064,22 @@ function sanitizeSharedConfigValue(value) {
 * root follows `invalidRootPolicy`. Syntax errors are wrapped with the file
 * path when one is given.
 */
-function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy = "coerce-empty" }) {
+function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy = "coerce-empty", jsoncParseErrors = "tolerate" }) {
 	if (fileContent.trim() === "") return {};
 	const at = filePath === void 0 ? "" : ` at ${filePath}`;
 	let parsed;
 	try {
 		if (format === "yaml") parsed = loadYaml(fileContent);
+		else if (format === "toml") parsed = parse$1(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
-		else parsed = parse(fileContent);
+		else if (jsoncParseErrors === "error") {
+			const errors = [];
+			parsed = parse(fileContent, errors, { allowTrailingComma: true });
+			if (errors.length > 0) {
+				const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
+				throw new Error(details);
+			}
+		} else parsed = parse(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse shared config${at}: ${formatError(error)}`, { cause: error });
 	}
@@ -4076,13 +4093,15 @@ function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy =
 /**
 * Serialize a shared config document. YAML output always ends with exactly one
 * newline; JSON output matches the 2-space `JSON.stringify` shape the JSON
-* writers have always emitted (no trailing newline).
+* writers have always emitted (no trailing newline); TOML output matches the
+* `smol-toml` `stringify` shape the TOML writers have always emitted.
 */
 function stringifySharedConfig({ format, document }) {
 	if (format === "yaml") return dump(document, {
 		noRefs: true,
 		sortKeys: false
 	}).trimEnd() + "\n";
+	if (format === "toml") return stringify(document);
 	return JSON.stringify(document, null, 2);
 }
 /**
@@ -4121,6 +4140,25 @@ function mergeSharedConfigDeep({ base, patch }) {
 const CLAUDE_SETTINGS_SHARED_FILE_KEY = ".claude/settings.json";
 const HERMES_CONFIG_SHARED_FILE_KEY = ".hermes/config.yaml";
 const TAKT_CONFIG_SHARED_FILE_KEY = ".takt/config.yaml";
+const CODEXCLI_CONFIG_SHARED_FILE_KEY = ".codex/config.toml";
+const GROKCLI_CONFIG_SHARED_FILE_KEY = ".grok/config.toml";
+const VIBE_CONFIG_SHARED_FILE_KEY = ".vibe/config.toml";
+const REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY = "reasonix.toml";
+const REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY = ".reasonix/config.toml";
+/**
+* Build the `SHARED_CONFIG_OWNERSHIP` lookup key from a tool's settable paths.
+* Mirrors `sharedFileKey` in `src/lib/shared-file-derive.ts` (kept separate so
+* feature classes don't pull the processor registry through this module and
+* create an import cycle); the ownership lock-step test keeps the two aligned.
+* Lets a tool whose file lives at a scope-dependent path (`.zed/settings.json`
+* vs `.config/zed/settings.json`) resolve its declaration from the settable
+* paths it already holds.
+*/
+const sharedConfigFileKey = ({ relativeDirPath, relativeFilePath }) => {
+	const dir = relativeDirPath.replace(/\\/g, "/").replace(/\/$/, "");
+	const file = relativeFilePath.replace(/\\/g, "/");
+	return dir === "" || dir === "." ? file : `${dir}/${file}`;
+};
 /**
 * Who owns what in each gateway-managed shared config file, and which policy
 * resolves conflicts. Keys are `dir/file` tokens matching
@@ -4177,6 +4215,298 @@ const SHARED_CONFIG_OWNERSHIP = {
 			},
 			permissions: { kind: "deep-merge" }
 		}
+	},
+	".zed/settings.json": {
+		format: "json",
+		features: {
+			ignore: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["private_files"]
+			},
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["context_servers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["agent"]
+			}
+		}
+	},
+	".config/zed/settings.json": {
+		format: "json",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["context_servers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["agent"]
+			}
+		}
+	},
+	".qwen/settings.json": {
+		format: "json",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcpServers"]
+			},
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks", "disableAllHooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"permissions",
+					"tools",
+					"security"
+				]
+			}
+		}
+	},
+	".augment/settings.json": {
+		format: "json",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcpServers"]
+			},
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["toolPermissions"]
+			}
+		}
+	},
+	".devin/config.json": {
+		format: "json",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcpServers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permissions"]
+			}
+		}
+	},
+	".config/devin/config.json": {
+		format: "json",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcpServers"]
+			},
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permissions"]
+			}
+		}
+	},
+	".kiro/agents/default.json": {
+		format: "json",
+		features: {
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["allowedTools", "toolsSettings"]
+			}
+		}
+	},
+	".amp/settings.json": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["amp.mcpServers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"amp.tools.disable",
+					"amp.permissions",
+					"amp.guardedFiles.allowlist",
+					"amp.dangerouslyAllowAll",
+					"amp.mcpPermissions"
+				]
+			}
+		}
+	},
+	".config/amp/settings.json": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["amp.mcpServers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"amp.tools.disable",
+					"amp.permissions",
+					"amp.guardedFiles.allowlist",
+					"amp.dangerouslyAllowAll",
+					"amp.mcpPermissions"
+				]
+			}
+		}
+	},
+	"opencode.json": {
+		format: "jsonc",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp", "tools"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permission"]
+			},
+			rules: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["instructions"]
+			}
+		}
+	},
+	".config/opencode/opencode.json": {
+		format: "jsonc",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp", "tools"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permission"]
+			}
+		}
+	},
+	"kilo.json": {
+		format: "jsonc",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp", "tools"]
+			},
+			rules: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["instructions"]
+			}
+		}
+	},
+	".config/kilo/kilo.json": {
+		format: "jsonc",
+		features: { mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["mcp", "tools"]
+		} }
+	},
+	[CODEXCLI_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		features: {
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["features"]
+			},
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp_servers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"permissions",
+					"default_permissions",
+					...CODEXCLI_OVERRIDE_KEYS
+				]
+			}
+		}
+	},
+	[GROKCLI_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp_servers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permission", "ui"]
+			}
+		}
+	},
+	[VIBE_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		features: {
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["enable_experimental_hooks"]
+			},
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp_servers"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"tools",
+					"enabled_tools",
+					"disabled_tools"
+				]
+			}
+		}
+	},
+	[REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["plugins"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"permissions",
+					"sandbox",
+					"agent"
+				]
+			}
+		}
+	},
+	[REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["plugins"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: [
+					"permissions",
+					"sandbox",
+					"agent"
+				]
+			}
+		}
 	}
 };
 /**
@@ -4197,17 +4527,20 @@ function applySharedConfigPatch({ fileKey, feature, existingContent, patch, file
 		format: declaration.format,
 		fileContent: existingContent,
 		filePath,
-		...declaration.invalidRootPolicy !== void 0 && { invalidRootPolicy: declaration.invalidRootPolicy }
+		...declaration.invalidRootPolicy !== void 0 && { invalidRootPolicy: declaration.invalidRootPolicy },
+		...declaration.jsoncParseErrors !== void 0 && { jsoncParseErrors: declaration.jsoncParseErrors }
 	});
 	if (policy.kind === "replace-owned-keys") {
 		const unowned = Object.keys(patch).filter((key) => !policy.ownedKeys.includes(key));
 		if (unowned.length > 0) throw new Error(`Feature '${feature}' tried to write undeclared keys [${unowned.join(", ")}] to '${fileKey}'; extend its ownedKeys declaration if that ownership is intended.`);
+		const document = mergeSharedConfigShallow({
+			base,
+			patch
+		});
+		for (const [key, value] of Object.entries(patch)) if (value === void 0) delete document[key];
 		return stringifySharedConfig({
 			format: declaration.format,
-			document: mergeSharedConfigShallow({
-				base,
-				patch
-			})
+			document
 		});
 	}
 	const merged = mergeSharedConfigDeep({
@@ -5937,10 +6270,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` /
@@ -5955,7 +6291,8 @@ const DEVIN_HOOK_EVENTS = [
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"stop",
-	"permissionRequest"
+	"permissionRequest",
+	"postCompact"
 ];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
@@ -6149,7 +6486,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 = [
@@ -6157,7 +6494,8 @@ const AUGMENTCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"sessionStart",
 	"sessionEnd",
-	"stop"
+	"stop",
+	"notification"
 ];
 /**
 * Hook events supported by Mistral Vibe (mistral-vibe).
@@ -6209,6 +6547,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 = [
@@ -6217,7 +6559,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"postToolUseFailure",
+	"postToolBatch",
 	"beforeSubmitPrompt",
+	"userPromptExpansion",
 	"stop",
 	"stopFailure",
 	"subagentStart",
@@ -6225,7 +6569,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preCompact",
 	"postCompact",
 	"permissionRequest",
+	"permissionDenied",
 	"notification",
+	"instructionsLoaded",
 	"todoCreated",
 	"todoCompleted"
 ];
@@ -6235,11 +6581,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.
@@ -6253,7 +6599,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.
@@ -6327,6 +6705,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())
@@ -6385,7 +6764,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.
@@ -6400,7 +6780,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.
@@ -6670,7 +7051,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",
@@ -6678,7 +7061,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preCompact: "PreCompact",
 	postCompact: "PostCompact",
 	permissionRequest: "PermissionRequest",
+	permissionDenied: "PermissionDenied",
 	notification: "Notification",
+	instructionsLoaded: "InstructionsLoaded",
 	todoCreated: "TodoCreated",
 	todoCompleted: "TodoCompleted"
 };
@@ -6700,12 +7085,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) {
@@ -7230,7 +7643,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
-		"stop"
+		"stop",
+		"notification"
 	])
 };
 /**
@@ -7280,12 +7694,6 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 		const paths = AugmentcodeHooks.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
-		let settings;
-		try {
-			settings = JSON.parse(existingContent);
-		} catch (error) {
-			throw new Error(`Failed to parse existing AugmentCode settings at ${filePath}: ${formatError(error)}`, { cause: error });
-		}
 		const config = rulesyncHooks.getJson();
 		const augmentHooks = canonicalToToolHooks({
 			config,
@@ -7293,11 +7701,13 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 			converterConfig: AUGMENTCODE_CONVERTER_CONFIG,
 			logger
 		});
-		const merged = {
-			...settings,
-			hooks: augmentHooks
-		};
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks: augmentHooks },
+			filePath
+		});
 		return new AugmentcodeHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -7464,15 +7874,28 @@ const CODEXCLI_CONVERTER_CONFIG = {
 */
 async function buildCodexConfigTomlContent({ outputRoot }) {
 	const configPath = join(outputRoot, CODEXCLI_DIR, CODEXCLI_MCP_FILE_NAME);
-	const existingContent = await readFileContentOrNull(configPath) ?? smolToml.stringify({});
+	const existingContent = await readFileContentOrNull(configPath) ?? "";
 	let configToml;
 	try {
-		configToml = smolToml.parse(existingContent);
+		configToml = smolToml.parse(existingContent || smolToml.stringify({}));
 	} catch (error) {
 		throw new Error(`Failed to parse existing Codex CLI config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (typeof configToml.features === "object" && configToml.features !== null) delete configToml.features.codex_hooks;
-	return smolToml.stringify(configToml);
+	let features;
+	if (typeof configToml.features === "object" && configToml.features !== null) {
+		features = { ...configToml.features };
+		delete features.codex_hooks;
+	}
+	return applySharedConfigPatch({
+		fileKey: sharedConfigFileKey({
+			relativeDirPath: CODEXCLI_DIR,
+			relativeFilePath: CODEXCLI_MCP_FILE_NAME
+		}),
+		feature: "hooks",
+		existingContent,
+		patch: { features },
+		filePath: configPath
+	});
 }
 /**
 * Represents the `.codex/config.toml` file as a generated ToolFile,
@@ -8320,7 +8743,8 @@ const DEVIN_CONVERTER_CONFIG = {
 		"sessionStart",
 		"sessionEnd",
 		"stop",
-		"beforeSubmitPrompt"
+		"beforeSubmitPrompt",
+		"postCompact"
 	])
 };
 /**
@@ -8388,17 +8812,13 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 		let fileContent;
 		if (global) {
 			const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
-			let parsedSettings;
-			try {
-				parsedSettings = JSON.parse(existingContent);
-			} catch (error) {
-				throw new Error(`Failed to parse existing Devin config at ${filePath}: ${formatError(error)}`, { cause: error });
-			}
-			const merged = {
-				...isRecord(parsedSettings) ? parsedSettings : {},
-				hooks: devinHooks
-			};
-			fileContent = JSON.stringify(merged, null, 2);
+			fileContent = applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "hooks",
+				existingContent,
+				patch: { hooks: devinHooks },
+				filePath
+			});
 		} else {
 			await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
 			fileContent = JSON.stringify(devinHooks, null, 2);
@@ -8633,6 +9053,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` /
@@ -9210,18 +9791,14 @@ var KiroHooks = class KiroHooks extends ToolHooks {
 		const paths = KiroHooks.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
-		let agentConfig;
-		try {
-			agentConfig = JSON.parse(existingContent);
-		} catch (error) {
-			throw new Error(`Failed to parse existing Kiro agent config at ${filePath}: ${formatError(error)}`, { cause: error });
-		}
 		const kiroHooks = canonicalToKiroHooks(rulesyncHooks.getJson(), this.getOverrideKey());
-		const merged = {
-			...agentConfig,
-			hooks: kiroHooks
-		};
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks: kiroHooks },
+			filePath
+		});
 		return new KiroHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -9716,21 +10293,17 @@ var QwencodeHooks = class QwencodeHooks extends ToolHooks {
 		const paths = QwencodeHooks.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
-		let settings;
-		try {
-			settings = JSON.parse(existingContent);
-		} catch (error) {
-			throw new Error(`Failed to parse existing Qwen Code settings at ${filePath}: ${formatError(error)}`, { cause: error });
-		}
 		const config = rulesyncHooks.getJson();
-		const qwencodeHooks = canonicalToQwencodeHooks(config);
-		const merged = {
-			...settings,
-			hooks: qwencodeHooks
-		};
+		const patch = { hooks: canonicalToQwencodeHooks(config) };
 		const disableAllHooks = config.qwencode?.disableAllHooks;
-		if (typeof disableAllHooks === "boolean") merged.disableAllHooks = disableAllHooks;
-		const fileContent = JSON.stringify(merged, null, 2);
+		if (typeof disableAllHooks === "boolean") patch.disableAllHooks = disableAllHooks;
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch,
+			filePath
+		});
 		return new QwencodeHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -9847,9 +10420,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 {
@@ -9989,10 +10562,6 @@ function canonicalToVibeHooks(config, toolOverride) {
 	}
 	return { hooks };
 }
-/**
-* Reverse {@link canonicalToVibeHooks}: parse the flat `[[hooks]]` array back
-* into a canonical event → definition[] record.
-*/
 /** Convert one raw `[[hooks]]` entry to a canonical definition, or null to skip. */
 function vibeEntryToCanonicalDef(raw) {
 	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
@@ -10012,6 +10581,10 @@ function vibeEntryToCanonicalDef(raw) {
 		def
 	};
 }
+/**
+* Reverse {@link canonicalToVibeHooks}: parse the flat `[[hooks]]` array back
+* into a canonical event → definition[] record.
+*/
 function vibeHooksToCanonical(parsed) {
 	const canonical = {};
 	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return canonical;
@@ -10040,15 +10613,22 @@ function parseVibeToml(fileContent) {
 */
 async function buildVibeConfigTomlContent({ outputRoot }) {
 	const configPath = join(outputRoot, VIBE_DIR, VIBE_CONFIG_FILE_NAME);
-	const existingContent = await readFileContentOrNull(configPath) ?? smolToml.stringify({});
-	let config;
+	const existingContent = await readFileContentOrNull(configPath) ?? "";
 	try {
-		config = parseVibeToml(existingContent);
+		parseVibeToml(existingContent);
 	} catch (error) {
 		throw new Error(`Failed to parse existing Vibe config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	config.enable_experimental_hooks = true;
-	return smolToml.stringify(config);
+	return applySharedConfigPatch({
+		fileKey: sharedConfigFileKey({
+			relativeDirPath: VIBE_DIR,
+			relativeFilePath: VIBE_CONFIG_FILE_NAME
+		}),
+		feature: "hooks",
+		existingContent,
+		patch: { enable_experimental_hooks: true },
+		filePath: configPath
+	});
 }
 /**
 * Represents the `.vibe/config.toml` file as a generated ToolFile so it goes
@@ -10430,6 +11010,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);
@@ -11548,17 +12139,18 @@ var ZedIgnore = class ZedIgnore extends ToolIgnore {
 		const patterns = rulesyncIgnore.getFileContent().split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 		const filePath = join(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath);
 		const existingFileContent = await fileExists(filePath) ? await readFileContent(filePath) : "{}";
-		const existingJsonValue = JSON.parse(existingFileContent);
-		const mergedPatterns = uniq([...existingJsonValue.private_files ?? [], ...patterns].toSorted());
-		const jsonValue = {
-			...existingJsonValue,
-			private_files: mergedPatterns
-		};
+		const mergedPatterns = uniq([...JSON.parse(existingFileContent).private_files ?? [], ...patterns].toSorted());
 		return new ZedIgnore({
 			outputRoot,
 			relativeDirPath: this.getSettablePaths().relativeDirPath,
 			relativeFilePath: this.getSettablePaths().relativeFilePath,
-			fileContent: JSON.stringify(jsonValue, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(this.getSettablePaths()),
+				feature: "ignore",
+				existingContent: existingFileContent,
+				patch: { private_files: mergedPatterns },
+				filePath
+			}),
 			validate: true
 		});
 	}
@@ -12015,17 +12607,17 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = join(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
-		const json = fileContent ? parseAmpSettingsJsonc(fileContent) : { [AMP_MCP_SERVERS_KEY]: {} };
-		const filteredMcpServers = filterMcpServers(rulesyncMcp.getMcpServers());
-		const newJson = {
-			...json,
-			[AMP_MCP_SERVERS_KEY]: filteredMcpServers
-		};
 		return new AmpMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "mcp",
+				existingContent: fileContent ?? "",
+				patch: { [AMP_MCP_SERVERS_KEY]: filterMcpServers(rulesyncMcp.getMcpServers()) },
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate,
 			global
 		});
@@ -12312,15 +12904,19 @@ var AugmentcodeMcp = class AugmentcodeMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const merged = {
-			...parseAugmentcodeSettings(await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({}, null, 2)), paths.relativeDirPath, paths.relativeFilePath),
-			mcpServers: rulesyncMcp.getMcpServers()
-		};
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
 		return new AugmentcodeMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(merged, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcpServers: rulesyncMcp.getMcpServers() },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -12680,7 +13276,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;
@@ -12714,8 +13316,14 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const configTomlFileContent = await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), smolToml.stringify({}));
-		const configToml = smolToml.parse(configTomlFileContent);
+		const configTomlFilePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
+		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]) => {
@@ -12728,7 +13336,7 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		const filteredMcpServers = this.removeEmptyEntries(converted);
 		for (const name of Object.keys(converted)) if (!Object.hasOwn(filteredMcpServers, name)) warnWithFallback(void 0, `MCP server "${name}" had no non-empty configuration and was dropped from the codex CLI config`);
 		const existingMcpServers = isRecord(configToml["mcp_servers"]) ? configToml["mcp_servers"] : {};
-		configToml["mcp_servers"] = Object.fromEntries(Object.entries(filteredMcpServers).map(([name, serverConfig]) => {
+		const mergedMcpServers = Object.fromEntries(Object.entries(filteredMcpServers).map(([name, serverConfig]) => {
 			const existingServer = isRecord(existingMcpServers[name]) ? existingMcpServers[name] : void 0;
 			const serverRecord = serverConfig;
 			if (existingServer && isRecord(existingServer["tools"]) && !("tools" in serverRecord)) return [name, {
@@ -12741,7 +13349,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(configToml),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent: configTomlFileContent,
+				patch: { mcp_servers: mergedMcpServers },
+				filePath: configTomlFilePath
+			}),
 			validate
 		});
 	}
@@ -13308,16 +13922,19 @@ var DevinMcp = class DevinMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const fileContent = await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({ mcpServers: {} }, null, 2));
-		const devinConfig = {
-			...this.parseJsonOrThrow(fileContent, paths.relativeDirPath, paths.relativeFilePath),
-			mcpServers: rulesyncMcp.getMcpServers()
-		};
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({ mcpServers: {} }, null, 2));
 		return new DevinMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(devinConfig, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcpServers: rulesyncMcp.getMcpServers() },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -13680,47 +14297,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;
 /**
@@ -13804,17 +14380,22 @@ var GrokcliMcp = class GrokcliMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const configTomlFileContent = await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), smolToml.stringify({}));
-		const configToml = smolToml.parse(configTomlFileContent);
+		const configTomlFilePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
 		const converted = convertToGrokFormat(rulesyncMcp.getMcpServers());
 		const filteredMcpServers = this.removeEmptyEntries(converted);
 		for (const name of Object.keys(converted)) if (!Object.hasOwn(filteredMcpServers, name)) warnWithFallback(void 0, `MCP server "${name}" had no non-empty configuration and was dropped from the grok CLI config`);
-		configToml["mcp_servers"] = filteredMcpServers;
 		return new GrokcliMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(configToml),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent: configTomlFileContent,
+				patch: { mcp_servers: filteredMcpServers },
+				filePath: configTomlFilePath
+			}),
 			validate
 		});
 	}
@@ -13875,6 +14456,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
@@ -13908,9 +14537,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;
 }
@@ -13953,10 +14581,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;
@@ -14347,20 +14973,21 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = KILO_JSON_FILE_NAME;
 		}
-		if (!fileContent) fileContent = JSON.stringify({ mcp: {} }, null, 2);
-		const json = parse(fileContent);
 		const { mcp: convertedMcp, tools: mcpTools } = convertToKiloFormat(rulesyncMcp.getMcpServers());
-		const { tools: _existingTools, ...jsonWithoutTools } = json;
-		const newJson = {
-			...jsonWithoutTools,
-			mcp: convertedMcp,
-			...Object.keys(mcpTools).length > 0 && { tools: mcpTools }
-		};
 		return new KiloMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "mcp",
+				existingContent: fileContent ?? "",
+				patch: {
+					mcp: convertedMcp,
+					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
+				},
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14389,15 +15016,17 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 		const json = fileContent ? parse(fileContent) : {};
 		const existingInstructions = Array.isArray(json.instructions) ? json.instructions.filter((entry) => typeof entry === "string") : [];
 		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...existingInstructions, ...instructions])).toSorted();
-		const newJson = {
-			...json,
-			instructions: mergedInstructions
-		};
 		return new KiloMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "rules",
+				existingContent: fileContent ?? "",
+				patch: { instructions: mergedInstructions },
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14669,23 +15298,24 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
-		if (!fileContent) fileContent = JSON.stringify({ mcp: {} }, null, 2);
-		const json = parse(fileContent);
 		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(convertEnvVarRefsToToolFormat({
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
 		}));
-		const { tools: _existingTools, ...jsonWithoutTools } = json;
-		const newJson = {
-			...jsonWithoutTools,
-			mcp: convertedMcp,
-			...Object.keys(mcpTools).length > 0 && { tools: mcpTools }
-		};
 		return new OpencodeMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "mcp",
+				existingContent: fileContent ?? "",
+				patch: {
+					mcp: convertedMcp,
+					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
+				},
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14720,15 +15350,17 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 		const json = fileContent ? parse(fileContent) : {};
 		const existingInstructions = Array.isArray(json.instructions) ? json.instructions.filter((entry) => typeof entry === "string") : [];
 		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...existingInstructions, ...instructions])).toSorted();
-		const newJson = {
-			...json,
-			instructions: mergedInstructions
-		};
 		return new OpencodeMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "rules",
+				existingContent: fileContent ?? "",
+				patch: { instructions: mergedInstructions },
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14838,16 +15470,19 @@ var QwencodeMcp = class QwencodeMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const fileContent = await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({ mcpServers: {} }, null, 2));
-		const newJson = {
-			...JSON.parse(fileContent),
-			mcpServers: convertToQwencodeFormat(rulesyncMcp.getMcpServers())
-		};
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({ mcpServers: {} }, null, 2));
 		return new QwencodeMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcpServers: convertToQwencodeFormat(rulesyncMcp.getMcpServers()) },
+				filePath
+			}),
 			validate
 		});
 	}
@@ -14932,13 +15567,20 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const config = parseReasonixConfig$1(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
-		config.plugins = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToReasonix(name, server));
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const plugins = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToReasonix(name, server));
 		return new ReasonixMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(config),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { plugins },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -15413,13 +16055,20 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const config = parseVibeConfig$1(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
-		config.mcp_servers = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToVibe(name, server));
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const mcpServers = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToVibe(name, server));
 		return new VibeMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(config),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcp_servers: mcpServers },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -15650,16 +16299,19 @@ var ZedMcp = class ZedMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const fileContent = await readOrInitializeFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), "{}");
-		const newJson = {
-			...JSON.parse(fileContent),
-			context_servers: rulesyncMcp.getMcpServers()
-		};
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, "{}");
 		return new ZedMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { context_servers: rulesyncMcp.getMcpServers() },
+				filePath
+			}),
 			validate
 		});
 	}
@@ -16225,18 +16877,27 @@ 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({
 	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
@@ -16263,9 +16924,11 @@ 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.
 *
@@ -16458,6 +17121,41 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 	}))
 })) });
 /**
+* 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.
 *
 * Codex CLI's permission surface is richer than the canonical allow/ask/deny
@@ -16466,15 +17164,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
@@ -16492,11 +17191,11 @@ 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()),
+	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.
@@ -16828,25 +17527,29 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 		const override = config.amp;
 		const authoredExtras = override?.permissions ? toPermissionsList(override.permissions) : [];
 		const preservedDelegates = override?.permissions ? [] : toPermissionsList(json[AMP_PERMISSIONS_KEY]).filter((entry) => entry.action === "delegate");
-		const newJson = {
-			...json,
-			[AMP_TOOLS_DISABLE_KEY]: disable
-		};
 		const mergedPermissions = mergeAmpPermissions([
 			...permissions,
 			...authoredExtras,
 			...preservedDelegates
 		]);
-		if (mergedPermissions.length > 0) newJson[AMP_PERMISSIONS_KEY] = mergedPermissions;
-		else delete newJson[AMP_PERMISSIONS_KEY];
-		if (override?.guardedFiles?.allowlist !== void 0) newJson[AMP_GUARDED_FILES_ALLOWLIST_KEY] = override.guardedFiles.allowlist;
-		if (override?.dangerouslyAllowAll !== void 0) newJson[AMP_DANGEROUSLY_ALLOW_ALL_KEY] = override.dangerouslyAllowAll;
-		if (override?.mcpPermissions !== void 0) newJson[AMP_MCP_PERMISSIONS_KEY] = override.mcpPermissions;
+		const patch = {
+			[AMP_TOOLS_DISABLE_KEY]: disable,
+			[AMP_PERMISSIONS_KEY]: mergedPermissions.length > 0 ? mergedPermissions : void 0
+		};
+		if (override?.guardedFiles?.allowlist !== void 0) patch[AMP_GUARDED_FILES_ALLOWLIST_KEY] = override.guardedFiles.allowlist;
+		if (override?.dangerouslyAllowAll !== void 0) patch[AMP_DANGEROUSLY_ALLOW_ALL_KEY] = override.dangerouslyAllowAll;
+		if (override?.mcpPermissions !== void 0) patch[AMP_MCP_PERMISSIONS_KEY] = override.mcpPermissions;
 		return new AmpPermissions({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(newJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "permissions",
+				existingContent: fileContent ?? "",
+				patch,
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate: true
 		});
 	}
@@ -17788,11 +18491,13 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 			...preservedBasicEntries,
 			...authoredBasics
 		]);
-		const merged = {
-			...settings,
-			toolPermissions: [...specialEntries, ...sortedBasic]
-		};
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "permissions",
+			existingContent,
+			patch: { toolPermissions: [...specialEntries, ...sortedBasic] },
+			filePath
+		});
 		return new AugmentcodePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -18384,13 +19089,6 @@ const WORKSPACE_WIDE_WRITE_PATTERNS = /* @__PURE__ */ new Set([
 ]);
 const CODEX_MINIMAL_KEY = ":minimal";
 const GLOBAL_WILDCARD_DOMAIN = "*";
-const CODEXCLI_OVERRIDE_KEYS = [
-	"approval_policy",
-	"sandbox_mode",
-	"sandbox_workspace_write",
-	"apps",
-	"approvals_reviewer"
-];
 var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
 		return {
@@ -18414,26 +19112,27 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, validate = true, logger, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const existingContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({});
-		const parsed = toMutableTable(smolToml.parse(existingContent));
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const existing = toMutableTable(smolToml.parse(existingContent || smolToml.stringify({})));
 		const newProfile = convertRulesyncToCodexProfile({
 			config: rulesyncPermissions.getJson(),
 			logger
 		});
-		const permissionsTable = toMutableTable(parsed.permissions);
+		const permissionsTable = toMutableTable(existing.permissions);
 		const { profile: existingProfile, domainsHadUnknown: existingDomainsHadUnknown } = toCodexProfile(permissionsTable[RULESYNC_PROFILE_NAME]);
-		if (existingProfile?.extends !== void 0 && existingProfile.extends !== newProfile.extends) logger?.warn(`Existing "extends" value "${existingProfile.extends}" will be replaced by Rulesync-managed "${newProfile.extends ?? "(none)"}".`);
-		if (existingProfile?.network?.unix_sockets !== void 0) logger?.warn(`Preserving existing "network.unix_sockets" from config. Review these entries manually as they may grant broad system access.`);
-		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.`);
+		warnAboutPreservedProfileState({
+			existingProfile,
+			newProfile,
+			existingDomainsHadUnknown,
+			logger
+		});
 		permissionsTable[RULESYNC_PROFILE_NAME] = mergeWithExistingProfile({
 			newProfile,
 			existingProfile
 		});
-		parsed.permissions = permissionsTable;
-		parsed.default_permissions = RULESYNC_PROFILE_NAME;
-		applyCodexcliOverride({
-			parsed,
+		const overridePatch = computeCodexcliOverridePatch({
+			existing,
 			override: rulesyncPermissions.getJson().codexcli,
 			logger
 		});
@@ -18441,7 +19140,17 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(parsed),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					permissions: permissionsTable,
+					default_permissions: RULESYNC_PROFILE_NAME,
+					...overridePatch
+				},
+				filePath
+			}),
 			validate
 		});
 	}
@@ -18611,6 +19320,12 @@ function toCodexProfile(value) {
 		domainsHadUnknown
 	};
 }
+function warnAboutPreservedProfileState({ existingProfile, newProfile, existingDomainsHadUnknown, logger }) {
+	if (existingProfile?.extends !== void 0 && existingProfile.extends !== newProfile.extends) logger?.warn(`Existing "extends" value "${existingProfile.extends}" will be replaced by Rulesync-managed "${newProfile.extends ?? "(none)"}".`);
+	if (existingProfile?.network?.unix_sockets !== void 0) logger?.warn(`Preserving existing "network.unix_sockets" from config. Review these entries manually as they may grant broad system access.`);
+	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.`);
+}
 function mergeWithExistingProfile({ newProfile, existingProfile }) {
 	if (!existingProfile) return newProfile;
 	const mergedNetwork = { ...newProfile.network };
@@ -18661,8 +19376,9 @@ function toMutableTable(value) {
 function isPlainObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function applyCodexcliOverride({ parsed, override, logger }) {
-	if (!override) return;
+function computeCodexcliOverridePatch({ existing, override, logger }) {
+	const patch = {};
+	if (!override) return patch;
 	const allowed = new Set(CODEXCLI_OVERRIDE_KEYS);
 	for (const [key, value] of Object.entries(override)) {
 		if (!allowed.has(key)) {
@@ -18670,12 +19386,13 @@ function applyCodexcliOverride({ parsed, override, logger }) {
 			continue;
 		}
 		if (value === void 0) continue;
-		const existing = parsed[key];
-		parsed[key] = isPlainObject(existing) && isPlainObject(value) ? {
-			...existing,
+		const existingValue = existing[key];
+		patch[key] = isPlainObject(existingValue) && isPlainObject(value) ? {
+			...existingValue,
 			...value
 		} : value;
 	}
+	return patch;
 }
 function extractCodexcliOverride(table) {
 	const override = {};
@@ -19236,15 +19953,17 @@ var DevinPermissions = class DevinPermissions extends ToolPermissions {
 		else delete mergedPermissions.ask;
 		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
 		else delete mergedPermissions.deny;
-		const merged = {
-			...settings,
-			permissions: mergedPermissions
-		};
 		return new DevinPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(merged, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: { permissions: mergedPermissions },
+				filePath
+			}),
 			validate
 		});
 	}
@@ -19337,9 +20056,11 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"networkPolicy",
 	"sandbox",
 	"mcpPolicy",
+	"mcpAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
+	"subagentAutonomyLevel",
 	"interactionMode"
 ];
 /**
@@ -19697,7 +20418,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";
@@ -19799,13 +20519,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.
@@ -19827,7 +20553,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({
@@ -19836,11 +20561,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) ?? "";
@@ -19853,25 +20577,32 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		const config = rulesyncPermissions.getJson();
 		const existingPermission = isRecord(parsed[GROKCLI_PERMISSION_KEY]) ? parsed[GROKCLI_PERMISSION_KEY] : {};
 		const buckets = buildGrokPermissionArrays(config, existingPermission, logger);
-		parsed[GROKCLI_PERMISSION_KEY] = {
+		const permission = {
 			...existingPermission,
 			allow: buckets.allow,
 			deny: buckets.deny,
 			ask: buckets.ask
 		};
-		const mode = deriveGrokPermissionMode(config);
-		const existingUi = isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {};
-		parsed[GROKCLI_UI_KEY] = {
-			...existingUi,
-			[GROKCLI_PERMISSION_MODE_KEY]: mode
-		};
+		const uiPatch = global ? { [GROKCLI_UI_KEY]: {
+			...isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {},
+			[GROKCLI_PERMISSION_MODE_KEY]: deriveGrokPermissionMode(config)
+		} } : {};
 		return new GrokcliPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(parsed),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					[GROKCLI_PERMISSION_KEY]: permission,
+					...uiPatch
+				},
+				filePath
+			}),
 			validate: true,
-			global: true
+			global
 		});
 	}
 	toRulesyncPermissions() {
@@ -19892,14 +20623,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
 		});
 	}
 };
@@ -20572,7 +21303,16 @@ var KiroPermissions = class KiroPermissions extends ToolPermissions {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(next, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					allowedTools: next.allowedTools,
+					toolsSettings: next.toolsSettings
+				},
+				filePath
+			}),
 			validate
 		});
 	}
@@ -20805,6 +21545,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__");
 }
@@ -20869,21 +21625,24 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
-		const parsed = parse(fileContent ?? "{}");
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const overridePermission = rulesyncJson.opencode?.permission ?? {};
-		const nextJson = {
-			...parsed,
-			permission: {
-				...rulesyncJson.permission,
-				...overridePermission
-			}
-		};
+		const sharedPermission = {};
+		for (const [category, value] of Object.entries(rulesyncJson.permission ?? {})) sharedPermission[toOpencodePermissionKey(category)] = value;
 		return new OpencodePermissions({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify(nextJson, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(basePaths),
+				feature: "permissions",
+				existingContent: fileContent ?? "",
+				patch: { permission: {
+					...sharedPermission,
+					...overridePermission
+				} },
+				filePath: join(jsonDir, relativeFilePath)
+			}),
 			validate: true
 		});
 	}
@@ -20895,8 +21654,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 }
@@ -21021,6 +21783,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 : {};
 }
@@ -21092,20 +21855,24 @@ var QwencodePermissions = class QwencodePermissions extends ToolPermissions {
 		else delete mergedPermissions.ask;
 		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
 		else delete mergedPermissions.deny;
-		const merged = {
-			...settings,
-			permissions: mergedPermissions
-		};
 		const override = config.qwencode;
-		if (override?.tools !== void 0) merged.tools = {
+		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)
 		};
-		if (override?.security !== void 0) merged.security = {
+		if (override?.security !== void 0) patch.security = {
 			...asPlainRecord(settings.security),
 			...asPlainRecord(override.security)
 		};
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "permissions",
+			existingContent,
+			patch,
+			filePath
+		});
 		return new QwencodePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -21132,9 +21899,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) });
@@ -21340,7 +22109,9 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, validate = true, logger, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const parsed = parseReasonixConfig(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const parsed = parseReasonixConfig(existingContent);
 		const config = rulesyncPermissions.getJson();
 		const { allow, ask, deny } = convertRulesyncToReasonixPermissions(config);
 		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toReasonixToolName(category)));
@@ -21365,25 +22136,27 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 		else delete mergedPermissions.ask;
 		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
 		else delete mergedPermissions.deny;
-		const merged = {
-			...parsed,
-			permissions: mergedPermissions
-		};
+		const patch = { permissions: mergedPermissions };
 		const override = config.reasonix;
-		if (override?.sandbox !== void 0) merged.sandbox = {
+		if (override?.sandbox !== void 0) patch.sandbox = {
 			...asReasonixRecord(parsed.sandbox),
 			...asReasonixRecord(override.sandbox)
 		};
-		if (override?.agent !== void 0) merged.agent = {
+		if (override?.agent !== void 0) patch.agent = {
 			...asReasonixRecord(parsed.agent),
 			...asReasonixRecord(override.agent)
 		};
-		const fileContent = smolToml.stringify(merged);
 		return new ReasonixPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch,
+				filePath
+			}),
 			validate
 		});
 	}
@@ -21954,7 +22727,9 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, validate = true, logger, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const config = parseVibeConfig(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const config = parseVibeConfig(existingContent);
 		const permission = rulesyncPermissions.getJson().permission;
 		const tools = toVibeToolsRecord(config.tools);
 		const enabledTools = new Set(toStringArray(config.enabled_tools));
@@ -21999,16 +22774,21 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 			tools[vibeToolName] = nextTool;
 		}
 		applyVibeSensitivePatterns(tools, rulesyncPermissions.getJson().vibe);
-		config.tools = tools;
-		if (enabledTools.size > 0) config.enabled_tools = [...enabledTools].toSorted();
-		else delete config.enabled_tools;
-		if (disabledTools.size > 0) config.disabled_tools = [...disabledTools].toSorted();
-		else delete config.disabled_tools;
 		return new VibePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smolToml.stringify(config),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					tools,
+					enabled_tools: enabledTools.size > 0 ? [...enabledTools].toSorted() : void 0,
+					disabled_tools: disabledTools.size > 0 ? [...disabledTools].toSorted() : void 0
+				},
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -22471,24 +23251,26 @@ var ZedPermissions = class ZedPermissions extends ToolPermissions {
 		}
 		const managedToolNames = new Set(Object.keys(managedTools));
 		const preservedTools = Object.fromEntries(Object.entries(existingTools).filter(([toolName]) => !managedToolNames.has(toolName)));
-		const mergedSettings = {
-			...settings,
-			agent: {
-				...agent,
-				tool_permissions: {
-					...toolPermissions,
-					tools: {
-						...preservedTools,
-						...managedTools
-					}
-				}
-			}
-		};
 		return new ZedPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(mergedSettings, null, 2),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: { agent: {
+					...agent,
+					tool_permissions: {
+						...toolPermissions,
+						tools: {
+							...preservedTools,
+							...managedTools
+						}
+					}
+				} },
+				filePath
+			}),
 			validate: true
 		});
 	}
@@ -22630,7 +23412,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["grokcli", {
 		class: GrokcliPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -38178,8 +38960,13 @@ const collectFactoryPaths = (factory) => [...settablePathsForScope({
 * Derive, from the processor registry, every on-disk file that two or more
 * features read-modify-write. Source of truth the generation step graph's
 * `writesSharedFile` declarations must match.
+*
+* `minWriters: 1` widens the result to single-feature files as well — used to
+* validate `SHARED_CONFIG_OWNERSHIP` declarations for files that route through
+* the gateway without being cross-feature shared (e.g. a global-scope twin
+* only one feature writes).
 */
-const deriveSharedFileWriters = () => {
+const deriveSharedFileWriters = ({ minWriters = 2 } = {}) => {
 	const byKey = /* @__PURE__ */ new Map();
 	const pathByKey = /* @__PURE__ */ new Map();
 	for (const entry of PROCESSOR_REGISTRY) {
@@ -38205,7 +38992,7 @@ const deriveSharedFileWriters = () => {
 	}
 	const writers = [];
 	for (const [key, features] of byKey) {
-		if (features.size < 2) continue;
+		if (features.size < minWriters) continue;
 		const path = pathByKey.get(key);
 		const toolsByFeature = /* @__PURE__ */ new Map();
 		for (const [feature, tools] of features) toolsByFeature.set(feature, [...tools].toSorted());
@@ -39150,4 +39937,4 @@ async function importPermissionsCore(params) {
 //#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 };
 
-//# sourceMappingURL=import-A1yGuzwv.js.map
+//# sourceMappingURL=import-Dioh9ca8.js.map