rulesync 9.6.3 → 9.8.0

package/dist/{import-DnpMhZOY.cjs → import-l0o1jVdc.cjs}

@@ -114,22 +114,22 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$249 } = node_path.posix;
+const { join: join$250 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$250(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
@@ -347,7 +347,8 @@ const hooksProcessorToolTargetTuple = [
 	"junie",
 	"vibe",
 	"qwencode",
-	"reasonix"
+	"reasonix",
+	"grokcli"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -2703,6 +2704,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 = (0, node_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 = zod_mini.z.looseObject({
@@ -4082,14 +4090,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 = (0, smol_toml.parse)(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
-		else parsed = (0, jsonc_parser.parse)(fileContent);
+		else if (jsoncParseErrors === "error") {
+			const errors = [];
+			parsed = (0, jsonc_parser.parse)(fileContent, errors, { allowTrailingComma: true });
+			if (errors.length > 0) {
+				const details = errors.map((error) => `${(0, jsonc_parser.printParseErrorCode)(error.error)} at offset ${error.offset}`).join(", ");
+				throw new Error(details);
+			}
+		} else parsed = (0, jsonc_parser.parse)(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse shared config${at}: ${formatError(error)}`, { cause: error });
 	}
@@ -4103,13 +4119,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 (0, js_yaml.dump)(document, {
 		noRefs: true,
 		sortKeys: false
 	}).trimEnd() + "\n";
+	if (format === "toml") return (0, smol_toml.stringify)(document);
 	return JSON.stringify(document, null, 2);
 }
 /**
@@ -4148,6 +4166,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
@@ -4204,6 +4241,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"
+				]
+			}
+		}
 	}
 };
 /**
@@ -4224,17 +4553,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({
@@ -5964,10 +6296,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` /
@@ -5982,7 +6317,8 @@ const DEVIN_HOOK_EVENTS = [
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"stop",
-	"permissionRequest"
+	"permissionRequest",
+	"postCompact"
 ];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
@@ -6176,7 +6512,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 = [
@@ -6184,7 +6520,8 @@ const AUGMENTCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"sessionStart",
 	"sessionEnd",
-	"stop"
+	"stop",
+	"notification"
 ];
 /**
 * Hook events supported by Mistral Vibe (mistral-vibe).
@@ -6236,6 +6573,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 = [
@@ -6244,7 +6585,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"postToolUseFailure",
+	"postToolBatch",
 	"beforeSubmitPrompt",
+	"userPromptExpansion",
 	"stop",
 	"stopFailure",
 	"subagentStart",
@@ -6252,7 +6595,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preCompact",
 	"postCompact",
 	"permissionRequest",
+	"permissionDenied",
 	"notification",
+	"instructionsLoaded",
 	"todoCreated",
 	"todoCompleted"
 ];
@@ -6262,11 +6607,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.
@@ -6280,7 +6625,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.
@@ -6354,6 +6731,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	junie: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -6412,7 +6790,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.
@@ -6427,7 +6806,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.
@@ -6697,7 +7077,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",
@@ -6705,7 +7087,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preCompact: "PreCompact",
 	postCompact: "PostCompact",
 	permissionRequest: "PermissionRequest",
+	permissionDenied: "PermissionDenied",
 	notification: "Notification",
+	instructionsLoaded: "InstructionsLoaded",
 	todoCreated: "TodoCreated",
 	todoCompleted: "TodoCompleted"
 };
@@ -6727,12 +7111,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) {
@@ -7257,7 +7669,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
-		"stop"
+		"stop",
+		"notification"
 	])
 };
 /**
@@ -7307,12 +7720,6 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 		const paths = AugmentcodeHooks.getSettablePaths({ global });
 		const filePath = (0, node_path.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,
@@ -7320,11 +7727,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,
@@ -7491,15 +7900,28 @@ const CODEXCLI_CONVERTER_CONFIG = {
 */
 async function buildCodexConfigTomlContent({ outputRoot }) {
 	const configPath = (0, node_path.join)(outputRoot, CODEXCLI_DIR, CODEXCLI_MCP_FILE_NAME);
-	const existingContent = await readFileContentOrNull(configPath) ?? smol_toml.stringify({});
+	const existingContent = await readFileContentOrNull(configPath) ?? "";
 	let configToml;
 	try {
-		configToml = smol_toml.parse(existingContent);
+		configToml = smol_toml.parse(existingContent || smol_toml.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 smol_toml.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,
@@ -8347,7 +8769,8 @@ const DEVIN_CONVERTER_CONFIG = {
 		"sessionStart",
 		"sessionEnd",
 		"stop",
-		"beforeSubmitPrompt"
+		"beforeSubmitPrompt",
+		"postCompact"
 	])
 };
 /**
@@ -8415,17 +8838,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);
@@ -8660,6 +9079,167 @@ var GooseHooks = class GooseHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/constants/grokcli-paths.ts
+/**
+* Grok Build CLI (xAI) configuration-layout conventions.
+*
+* Single source of truth for where Grok Build expects its files. Grok Build
+* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
+* with project/global scopes resolved by the directory the CLI runs in
+* (`./.grok/config.toml` vs `~/.grok/config.toml`).
+*
+* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
+* `-s project` writes `./.grok/config.toml`, `-s user` writes
+* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
+* @see https://docs.x.ai/build/overview
+*/
+/** Root directory for Grok Build configuration, relative to the scope root. */
+const GROKCLI_DIR = ".grok";
+/** MCP servers and other settings live in `config.toml` under `.grok/`. */
+const GROKCLI_MCP_FILE_NAME = "config.toml";
+/**
+* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
+* permission mode, and other settings all live here; permissions reuse the same
+* file name as MCP since Grok consolidates everything into one config.
+*/
+const GROKCLI_CONFIG_FILE_NAME = "config.toml";
+/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
+const GROKCLI_SKILLS_DIR_PATH = (0, node_path.join)(GROKCLI_DIR, "skills");
+/**
+* Hooks directory under `.grok/`. Grok Build discovers hook config files from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global), each a
+* standalone JSON file using the Claude-Code-compatible nested `{ hooks: { … } }`
+* shape. rulesync writes all its hooks into a single `rulesync.json`.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const GROKCLI_HOOKS_DIR_PATH = (0, node_path.join)(GROKCLI_DIR, "hooks");
+/** rulesync-managed Grok hooks file under `.grok/hooks/`. */
+const GROKCLI_HOOKS_FILE_NAME = "rulesync.json";
+/**
+* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
+* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
+* (global), each a Markdown file with YAML frontmatter (verified via
+* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
+*/
+const GROKCLI_AGENTS_DIR_PATH = (0, node_path.join)(GROKCLI_DIR, "agents");
+/**
+* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
+* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
+* `grok inspect`, consistent with the `.grok/` global discovery used by the
+* MCP/skills/subagents adapters).
+*/
+const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
+//#endregion
+//#region src/features/hooks/grokcli-hooks.ts
+const GROKCLI_CONVERTER_CONFIG = {
+	supportedEvents: GROKCLI_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_GROKCLI_EVENT_NAMES,
+	toolToCanonicalEventNames: GROKCLI_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"sessionStart",
+		"sessionEnd",
+		"beforeSubmitPrompt",
+		"stop",
+		"stopFailure",
+		"notification",
+		"subagentStart",
+		"subagentStop",
+		"preCompact",
+		"postCompact"
+	])
+};
+/**
+* Hooks generator for Grok CLI (xAI Grok Build).
+*
+* Grok Build adopts a Claude-Code-compatible lifecycle hooks model: each event
+* maps to an array of `{ matcher?, hooks: [{ type, command, timeout? }] }`
+* matcher groups under a top-level `hooks` key. rulesync writes all its hooks
+* into a single standalone `rulesync.json` file discovered from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global). The file
+* is dedicated to hooks and owned wholesale by rulesync, so it may be deleted
+* as an orphan.
+*
+* @see https://docs.x.ai/build/features/hooks
+*/
+var GrokcliHooks = class GrokcliHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: GROKCLI_HOOKS_DIR_PATH,
+			relativeFilePath: GROKCLI_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const config = rulesyncHooks.getJson();
+		const grokHooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.grokcli?.hooks,
+			converterConfig: GROKCLI_CONVERTER_CONFIG,
+			logger
+		});
+		await readOrInitializeFileContent(filePath, JSON.stringify({ hooks: {} }, null, 2));
+		const fileContent = JSON.stringify({ hooks: grokHooks }, null, 2);
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		let parsed;
+		try {
+			parsed = JSON.parse(this.getFileContent());
+		} catch (error) {
+			throw new Error(`Failed to parse Grok hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			hooks: isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {},
+			converterConfig: GROKCLI_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/hermesagent-hooks.ts
 /**
 * Canonical events that map to a Hermes tool-call event (`pre_tool_call` /
@@ -9237,18 +9817,14 @@ var KiroHooks = class KiroHooks extends ToolHooks {
 		const paths = KiroHooks.getSettablePaths({ global });
 		const filePath = (0, node_path.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,
@@ -9743,21 +10319,17 @@ var QwencodeHooks = class QwencodeHooks extends ToolHooks {
 		const paths = QwencodeHooks.getSettablePaths({ global });
 		const filePath = (0, node_path.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,
@@ -9874,9 +10446,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 {
@@ -10016,10 +10588,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;
@@ -10039,6 +10607,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;
@@ -10067,15 +10639,22 @@ function parseVibeToml(fileContent) {
 */
 async function buildVibeConfigTomlContent({ outputRoot }) {
 	const configPath = (0, node_path.join)(outputRoot, VIBE_DIR, VIBE_CONFIG_FILE_NAME);
-	const existingContent = await readFileContentOrNull(configPath) ?? smol_toml.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 smol_toml.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
@@ -10457,6 +11036,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);
@@ -11575,17 +12165,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 = (0, node_path.join)(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath);
 		const existingFileContent = await fileExists(filePath) ? await readFileContent(filePath) : "{}";
-		const existingJsonValue = JSON.parse(existingFileContent);
-		const mergedPatterns = (0, es_toolkit.uniq)([...existingJsonValue.private_files ?? [], ...patterns].toSorted());
-		const jsonValue = {
-			...existingJsonValue,
-			private_files: mergedPatterns
-		};
+		const mergedPatterns = (0, es_toolkit.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
 		});
 	}
@@ -12042,17 +12633,17 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate,
 			global
 		});
@@ -12339,15 +12930,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({}, null, 2)), paths.relativeDirPath, paths.relativeFilePath),
-			mcpServers: rulesyncMcp.getMcpServers()
-		};
+		const filePath = (0, node_path.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
 		});
@@ -12707,7 +13302,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			...rest,
 			validate: false
 		});
-		this.toml = smol_toml.parse(this.fileContent);
+		let toml;
+		try {
+			toml = smol_toml.parse(this.fileContent);
+		} catch (error) {
+			throw new Error(`Failed to parse Codex CLI config at ${this.getFilePath()}: ${formatError(error)}`, { cause: error });
+		}
+		this.toml = toml;
 		if (rest.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -12741,8 +13342,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), smol_toml.stringify({}));
-		const configToml = smol_toml.parse(configTomlFileContent);
+		const configTomlFilePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
+		let configToml;
+		try {
+			configToml = smol_toml.parse(configTomlFileContent || smol_toml.stringify({}));
+		} catch (error) {
+			throw new Error(`Failed to parse existing Codex CLI config at ${configTomlFilePath}: ${formatError(error)}`, { cause: error });
+		}
 		const strippedMcpServers = rulesyncMcp.getMcpServers();
 		const rawMcpServers = rulesyncMcp.getJson().mcpServers;
 		const converted = convertToCodexFormat(Object.fromEntries(Object.entries(strippedMcpServers).map(([serverName, serverConfig]) => {
@@ -12755,7 +13362,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, {
@@ -12768,7 +13375,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smol_toml.stringify(configToml),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent: configTomlFileContent,
+				patch: { mcp_servers: mergedMcpServers },
+				filePath: configTomlFilePath
+			}),
 			validate
 		});
 	}
@@ -13335,16 +13948,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((0, node_path.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 = (0, node_path.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
 		});
@@ -13707,47 +14323,6 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/constants/grokcli-paths.ts
-/**
-* Grok Build CLI (xAI) configuration-layout conventions.
-*
-* Single source of truth for where Grok Build expects its files. Grok Build
-* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
-* with project/global scopes resolved by the directory the CLI runs in
-* (`./.grok/config.toml` vs `~/.grok/config.toml`).
-*
-* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
-* `-s project` writes `./.grok/config.toml`, `-s user` writes
-* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
-* @see https://docs.x.ai/build/overview
-*/
-/** Root directory for Grok Build configuration, relative to the scope root. */
-const GROKCLI_DIR = ".grok";
-/** MCP servers and other settings live in `config.toml` under `.grok/`. */
-const GROKCLI_MCP_FILE_NAME = "config.toml";
-/**
-* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
-* permission mode, and other settings all live here; permissions reuse the same
-* file name as MCP since Grok consolidates everything into one config.
-*/
-const GROKCLI_CONFIG_FILE_NAME = "config.toml";
-/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
-const GROKCLI_SKILLS_DIR_PATH = (0, node_path.join)(GROKCLI_DIR, "skills");
-/**
-* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
-* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
-* (global), each a Markdown file with YAML frontmatter (verified via
-* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
-*/
-const GROKCLI_AGENTS_DIR_PATH = (0, node_path.join)(GROKCLI_DIR, "agents");
-/**
-* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
-* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
-* `grok inspect`, consistent with the `.grok/` global discovery used by the
-* MCP/skills/subagents adapters).
-*/
-const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
-//#endregion
 //#region src/features/mcp/grokcli-mcp.ts
 const MAX_REMOVE_EMPTY_ENTRIES_DEPTH = 32;
 /**
@@ -13831,17 +14406,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), smol_toml.stringify({}));
-		const configToml = smol_toml.parse(configTomlFileContent);
+		const configTomlFilePath = (0, node_path.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: smol_toml.stringify(configToml),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent: configTomlFileContent,
+				patch: { mcp_servers: filteredMcpServers },
+				filePath: configTomlFilePath
+			}),
 			validate
 		});
 	}
@@ -13902,6 +14482,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
@@ -13935,9 +14563,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;
 }
@@ -13980,10 +14607,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;
@@ -14374,20 +14999,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 = (0, jsonc_parser.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14416,15 +15042,17 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 		const json = fileContent ? (0, jsonc_parser.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14696,23 +15324,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 = (0, jsonc_parser.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14747,15 +15376,17 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 		const json = fileContent ? (0, jsonc_parser.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate
 		});
 	}
@@ -14865,16 +15496,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({ mcpServers: {} }, null, 2));
-		const newJson = {
-			...JSON.parse(fileContent),
-			mcpServers: convertToQwencodeFormat(rulesyncMcp.getMcpServers())
-		};
+		const filePath = (0, node_path.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
 		});
 	}
@@ -14959,13 +15593,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
-		config.plugins = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToReasonix(name, server));
+		const filePath = (0, node_path.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: smol_toml.stringify(config),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { plugins },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -15440,13 +16081,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
-		config.mcp_servers = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToVibe(name, server));
+		const filePath = (0, node_path.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: smol_toml.stringify(config),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcp_servers: mcpServers },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -15677,16 +16325,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), "{}");
-		const newJson = {
-			...JSON.parse(fileContent),
-			context_servers: rulesyncMcp.getMcpServers()
-		};
+		const filePath = (0, node_path.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
 		});
 	}
@@ -16252,18 +16903,27 @@ const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
 * Tool-scoped override block for Qwen Code. Qwen's `settings.json` exposes
 * autonomy/sandbox controls with no canonical permission category — under
 * `tools` (`approvalMode` = plan/default/auto-edit/auto/yolo, `autoAccept`,
-* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). Fields
-* placed here are merged into the matching `settings.json` group and emitted
-* only for Qwen, while the shared `permission` block continues to drive the
-* `permissions.allow`/`ask`/`deny` arrays. Kept `looseObject` (verbatim
-* passthrough) so any current or future `tools`/`security` key can be authored.
+* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). It also
+* exposes `permissions.autoMode` (the Auto Mode classifier config:
+* `hints.{allow,softDeny,hardDeny}`, `environment`, `classifyAllShell` — see
+* https://qwenlm.github.io/qwen-code-docs/en/users/features/auto-mode/), which
+* likewise has no canonical category. Fields placed here are merged into the
+* matching `settings.json` group and emitted only for Qwen, while the shared
+* `permission` block continues to drive the `permissions.allow`/`ask`/`deny`
+* arrays. Kept `looseObject` (verbatim passthrough) so any current or future
+* `tools`/`security`/`autoMode` key can be authored.
 *
 * @example
-* { "tools": { "approvalMode": "auto-edit" }, "security": { "folderTrust": { "enabled": true } } }
+* {
+*   "tools": { "approvalMode": "auto-edit" },
+*   "security": { "folderTrust": { "enabled": true } },
+*   "autoMode": { "hints": { "allow": ["Running tests"] }, "classifyAllShell": true }
+* }
 */
 const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
 	tools: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	security: zod_mini.z.optional(zod_mini.z.looseObject({}))
+	security: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	autoMode: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Reasonix. Reasonix has security axes orthogonal
@@ -16290,9 +16950,11 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 * exposes security controls with no canonical per-command allow/ask/deny slot —
 * `commandBlocklist` (a hard-block tier that can never be approved, distinct from
 * an approvable `deny`), `networkPolicy` (`allowedIps`), `sandbox`
-* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`, `enableDroidShield`,
+* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`,
+* `mcpAutonomyOverrides` (per-MCP-tool autonomy levels), `enableDroidShield`,
 * and autonomy settings (`sessionDefaultSettings`, `maxAutonomyLevel`,
-* `interactionMode`). Fields placed here are merged into `settings.json` and
+* `subagentAutonomyLevel`, `interactionMode`). Fields placed here are merged
+* into `settings.json` and
 * emitted only for Factory Droid, while the shared `permission` block continues
 * to drive `commandAllowlist`/`commandDenylist`. Kept `looseObject` passthrough.
 *
@@ -16485,6 +17147,41 @@ const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zo
 	}))
 })) });
 /**
+* Codex CLI's approval-workflow policy. Serialized as a kebab-case string in
+* `.codex/config.toml`. `on-failure` is a legacy alias for `on-request` that
+* Codex still accepts, so it is included so existing configs round-trip. The
+* granular table form (`{ granular = { … } }`) is modeled separately in the
+* override union.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalPolicySchema = zod_mini.z.enum([
+	"untrusted",
+	"on-request",
+	"on-failure",
+	"never"
+]);
+/**
+* Codex CLI's classic sandbox mode. Serialized as a kebab-case string in
+* `.codex/config.toml`.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexSandboxModeSchema = zod_mini.z.enum([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+/**
+* Codex CLI's reviewer for approval requests. `guardian_subagent` is a legacy
+* value Codex still accepts for backward compatibility, so it is included so
+* existing configs round-trip through the rulesync model.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalsReviewerSchema = zod_mini.z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
+/**
 * Codex CLI-scoped permission override.
 *
 * Codex CLI's permission surface is richer than the canonical allow/ask/deny
@@ -16493,15 +17190,16 @@ const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zo
 * override whose fields are written verbatim as top-level `.codex/config.toml`
 * keys (the override wins per key; existing sibling keys the user set directly
 * are preserved):
-* - `approval_policy` — `untrusted` | `on-request` | `never`, or a
-*   `{ granular = { … } }` table (kept verbatim; the granular schema has
-*   required fields that are brittle to model as typed keys).
+* - `approval_policy` — `untrusted` | `on-request` (legacy alias `on-failure`) |
+*   `never`, or a `{ granular = { … } }` table (kept verbatim; the granular
+*   schema has required fields that are brittle to model as typed keys).
 * - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
 *   with the sibling `sandbox_workspace_write` table (`network_access`,
 *   `writable_roots`, …).
 * - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
 *   `.enabled`, `apps.<id>.default_tools_approval_mode`).
-* - `approvals_reviewer` — the reviewer-approval surface.
+* - `approvals_reviewer` — the reviewer-approval surface (`user` | `auto_review`
+*   | `guardian_subagent`), or a table for the richer reviewer config.
 *
 * Two surfaces are deliberately NOT authorable here so the override can never
 * clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
@@ -16519,11 +17217,11 @@ const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zo
 *   "sandbox_workspace_write": { "network_access": true } }
 */
 const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
-	approval_policy: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
-	sandbox_mode: zod_mini.z.optional(zod_mini.z.string()),
+	approval_policy: zod_mini.z.optional(zod_mini.z.union([CodexApprovalPolicySchema, zod_mini.z.looseObject({})])),
+	sandbox_mode: zod_mini.z.optional(CodexSandboxModeSchema),
 	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})]))
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})]))
 });
 /**
 * Permissions configuration.
@@ -16855,25 +17553,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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate: true
 		});
 	}
@@ -17815,11 +18517,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,
@@ -18411,13 +19115,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 {
@@ -18441,26 +19138,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({});
-		const parsed = toMutableTable(smol_toml.parse(existingContent));
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const existing = toMutableTable(smol_toml.parse(existingContent || smol_toml.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
 		});
@@ -18468,7 +19166,17 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: smol_toml.stringify(parsed),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					permissions: permissionsTable,
+					default_permissions: RULESYNC_PROFILE_NAME,
+					...overridePatch
+				},
+				filePath
+			}),
 			validate
 		});
 	}
@@ -18638,6 +19346,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 };
@@ -18688,8 +19402,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)) {
@@ -18697,12 +19412,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 = {};
@@ -19263,15 +19979,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
 		});
 	}
@@ -19364,9 +20082,11 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"networkPolicy",
 	"sandbox",
 	"mcpPolicy",
+	"mcpAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
+	"subagentAutonomyLevel",
 	"interactionMode"
 ];
 /**
@@ -19724,7 +20444,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";
@@ -19826,13 +20545,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.
@@ -19854,7 +20579,6 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		return new GrokcliPermissions({
@@ -19863,11 +20587,10 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
 			validate,
-			global: true
+			global
 		});
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
@@ -19880,25 +20603,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: smol_toml.stringify(parsed),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: {
+					[GROKCLI_PERMISSION_KEY]: permission,
+					...uiPatch
+				},
+				filePath
+			}),
 			validate: true,
-			global: true
+			global
 		});
 	}
 	toRulesyncPermissions() {
@@ -19919,14 +20649,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
 		});
 	}
 };
@@ -20599,7 +21329,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
 		});
 	}
@@ -20832,6 +21571,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__");
 }
@@ -20896,21 +21651,24 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
-		const parsed = (0, jsonc_parser.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: (0, node_path.join)(jsonDir, relativeFilePath)
+			}),
 			validate: true
 		});
 	}
@@ -20922,8 +21680,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 }
@@ -21048,6 +21809,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 : {};
 }
@@ -21119,20 +21881,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,
@@ -21159,9 +21925,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) });
@@ -21367,7 +22135,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
+		const filePath = (0, node_path.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)));
@@ -21392,25 +22162,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 = smol_toml.stringify(merged);
 		return new ReasonixPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch,
+				filePath
+			}),
 			validate
 		});
 	}
@@ -21981,7 +22753,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
+		const filePath = (0, node_path.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));
@@ -22026,16 +22800,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: smol_toml.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
 		});
@@ -22498,24 +23277,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
 		});
 	}
@@ -22657,7 +23438,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["grokcli", {
 		class: GrokcliPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -38205,8 +38986,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) {
@@ -38232,7 +39018,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());