rulesync 9.8.0 → 10.1.0

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

@@ -114,28 +114,35 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$250 } = node_path.posix;
+const { join: join$251 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$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_RULES_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$250(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$250(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
 const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.json";
+const RULESYNC_MCP_JSONC_FILE_NAME = "mcp.jsonc";
+const RULESYNC_HOOKS_JSONC_FILE_NAME = "hooks.jsonc";
+const RULESYNC_PERMISSIONS_JSONC_FILE_NAME = "permissions.jsonc";
 const RULESYNC_CONFIG_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/config-schema.json";
 const RULESYNC_MCP_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/mcp-schema.json";
+const RULESYNC_PERMISSIONS_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/permissions-schema.json";
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 //#endregion
 //#region src/types/tool-target-tuples.ts
@@ -7343,12 +7350,55 @@ function toolHooksToCanonical({ hooks, converterConfig }) {
 	return canonical;
 }
 //#endregion
+//#region src/utils/jsonc.ts
+/**
+* Rebuild the parsed value from its own enumerable entries, dropping
+* prototype-pollution keys (`__proto__`, `constructor`, `prototype`).
+* `jsonc-parser` assigns keys with plain `obj[key] = value` semantics, so a
+* literal `__proto__` key would replace the containing object's prototype
+* instead of becoming an own property; rebuilding gives every object a clean
+* `Object.prototype` again and severs that path.
+*/
+function deepSanitize(value) {
+	if (Array.isArray(value)) return value.map((item) => deepSanitize(item));
+	if (value !== null && typeof value === "object") {
+		const sanitized = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			sanitized[key] = deepSanitize(entry);
+		}
+		return sanitized;
+	}
+	return value;
+}
+/**
+* Parse a JSONC (JSON with Comments) document strictly.
+*
+* Unlike `jsonc-parser`'s bare `parse` (which silently tolerates syntax
+* errors and returns a best-effort value), this throws on any parse error so
+* a malformed source file fails loudly instead of generating half-empty tool
+* configs. Plain JSON is valid JSONC, so this is a drop-in replacement for
+* `JSON.parse` on files that may contain comments or trailing commas.
+*/
+function parseJsonc$6(content) {
+	const errors = [];
+	const result = (0, jsonc_parser.parse)(content, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0) {
+		const details = errors.map((e) => `${(0, jsonc_parser.printParseErrorCode)(e.error)} at offset ${e.offset}`).join(", ");
+		throw new SyntaxError(`Failed to parse JSONC content: ${details}`);
+	}
+	return deepSanitize(result);
+}
+//#endregion
 //#region src/features/hooks/rulesync-hooks.ts
 var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	json;
 	constructor(params) {
 		super({ ...params });
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -7357,7 +7407,11 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	static getSettablePaths() {
 		return {
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: "hooks.json"
+			relativeFilePath: RULESYNC_HOOKS_FILE_NAME,
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_HOOKS_JSONC_FILE_NAME
+			}
 		};
 	}
 	validate() {
@@ -7373,16 +7427,23 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncHooks.getSettablePaths();
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
-		if (!await fileExists(filePath)) throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} found.`);
-		const fileContent = await readFileContent(filePath);
-		return new RulesyncHooks({
-			outputRoot,
+		const candidates = [paths.jsonc, {
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath,
-			fileContent,
-			validate
-		});
+			relativeFilePath: paths.relativeFilePath
+		}];
+		for (const candidate of candidates) {
+			const filePath = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			const fileContent = await readFileContent(filePath);
+			return new RulesyncHooks({
+				outputRoot,
+				relativeDirPath: candidate.relativeDirPath,
+				relativeFilePath: candidate.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
+		throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} or ${RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
@@ -12390,15 +12451,51 @@ const RulesyncMcpServerSchema = zod_mini.z.extend(McpServerSchema, {
 	exposed: zod_mini.z.optional(zod_mini.z.boolean())
 });
 const RulesyncMcpConfigSchema = zod_mini.z.object({ mcpServers: zod_mini.z.record(zod_mini.z.string(), RulesyncMcpServerSchema) });
+/**
+* Tool-scoped MCP block: servers that apply only to one tool. A named entry
+* replaces/adds the same-named shared server wholesale for that tool; `null`
+* removes the shared server for that tool. Mirrors `{toolname}.hooks` in
+* `.rulesync/hooks.json` and `{toolname}.permission` in
+* `.rulesync/permissions.json`.
+*/
+const toolScopedMcpSchema = zod_mini.z.looseObject({ mcpServers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.nullable(RulesyncMcpServerSchema))) });
 const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	$schema: zod_mini.z.optional(zod_mini.z.string()),
-	...RulesyncMcpConfigSchema.shape
+	...RulesyncMcpConfigSchema.shape,
+	amp: zod_mini.z.optional(toolScopedMcpSchema),
+	"antigravity-cli": zod_mini.z.optional(toolScopedMcpSchema),
+	"antigravity-ide": zod_mini.z.optional(toolScopedMcpSchema),
+	augmentcode: zod_mini.z.optional(toolScopedMcpSchema),
+	claudecode: zod_mini.z.optional(toolScopedMcpSchema),
+	cline: zod_mini.z.optional(toolScopedMcpSchema),
+	codexcli: zod_mini.z.optional(toolScopedMcpSchema),
+	copilot: zod_mini.z.optional(toolScopedMcpSchema),
+	copilotcli: zod_mini.z.optional(toolScopedMcpSchema),
+	cursor: zod_mini.z.optional(toolScopedMcpSchema),
+	deepagents: zod_mini.z.optional(toolScopedMcpSchema),
+	devin: zod_mini.z.optional(toolScopedMcpSchema),
+	factorydroid: zod_mini.z.optional(toolScopedMcpSchema),
+	goose: zod_mini.z.optional(toolScopedMcpSchema),
+	grokcli: zod_mini.z.optional(toolScopedMcpSchema),
+	hermesagent: zod_mini.z.optional(toolScopedMcpSchema),
+	junie: zod_mini.z.optional(toolScopedMcpSchema),
+	kilo: zod_mini.z.optional(toolScopedMcpSchema),
+	kiro: zod_mini.z.optional(toolScopedMcpSchema),
+	opencode: zod_mini.z.optional(toolScopedMcpSchema),
+	qwencode: zod_mini.z.optional(toolScopedMcpSchema),
+	reasonix: zod_mini.z.optional(toolScopedMcpSchema),
+	roo: zod_mini.z.optional(toolScopedMcpSchema),
+	rovodev: zod_mini.z.optional(toolScopedMcpSchema),
+	takt: zod_mini.z.optional(toolScopedMcpSchema),
+	vibe: zod_mini.z.optional(toolScopedMcpSchema),
+	warp: zod_mini.z.optional(toolScopedMcpSchema),
+	zed: zod_mini.z.optional(toolScopedMcpSchema)
 });
 var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	json;
 	constructor(params) {
 		super(params);
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -12408,7 +12505,11 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 		return {
 			recommended: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: "mcp.json"
+				relativeFilePath: RULESYNC_MCP_FILE_NAME
+			},
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_MCP_JSONC_FILE_NAME
 			},
 			legacy: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
@@ -12430,7 +12531,18 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	static async fromFile({ outputRoot = process.cwd(), validate = true, logger }) {
 		const paths = this.getSettablePaths();
 		const recommendedPath = (0, node_path.join)(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
+		const jsoncPath = (0, node_path.join)(outputRoot, paths.jsonc.relativeDirPath, paths.jsonc.relativeFilePath);
 		const legacyPath = (0, node_path.join)(outputRoot, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+		if (await fileExists(jsoncPath)) {
+			const fileContent = await readFileContent(jsoncPath);
+			return new RulesyncMcp({
+				outputRoot,
+				relativeDirPath: paths.jsonc.relativeDirPath,
+				relativeFilePath: paths.jsonc.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
 		if (await fileExists(recommendedPath)) {
 			const fileContent = await readFileContent(recommendedPath);
 			return new RulesyncMcp({
@@ -12490,7 +12602,141 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	getJson() {
 		return this.json;
 	}
-};
+	/**
+	* Build the effective MCP config for one tool target:
+	*
+	* 1. Filter shared servers by the DEPRECATED per-server `targets` field
+	*    (missing/`["*"]` means every tool). A deprecation warning points at
+	*    the tool-scoped blocks that replace it.
+	* 2. Overlay the tool-scoped `{toolname}.mcpServers` block(s): a named
+	*    entry replaces/adds the shared server wholesale for this tool; `null`
+	*    removes it.
+	*
+	* Targets that share one output file resolve identically so the shared
+	* file's content never depends on which of them generates last — see
+	* `resolveMcpTarget` for the alias groups (kiro trio, claudecode/-legacy,
+	* and the Antigravity pair).
+	*
+	* Returns the same instance when neither mechanism is used.
+	*/
+	forTarget({ toolTarget, logger }) {
+		const { blockKeys, acceptedTargetNames } = resolveMcpTarget({ toolTarget });
+		const json = this.json;
+		const sharedServers = this.json.mcpServers ?? {};
+		const serverNamesWithTargets = Object.entries(sharedServers).filter(([, serverConfig]) => serverConfig.targets !== void 0).map(([serverName]) => serverName);
+		if (serverNamesWithTargets.length > 0) this.warnTargetsDeprecationOnce({
+			serverNamesWithTargets,
+			logger
+		});
+		for (const ignoredKey of MCP_IGNORED_ALIAS_SOURCE_KEYS) {
+			if (!isRecord(json[ignoredKey])) continue;
+			this.warnOncePerFile(`alias:${ignoredKey}`, `The "${ignoredKey}" block in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is ignored. Author it under the "${MCP_BLOCK_KEY_ALIASES[ignoredKey]}" key instead.`, logger);
+		}
+		const toolBlockKeys = Object.keys(json).filter((key) => MCP_TOOL_BLOCK_KEYS.has(key));
+		if (serverNamesWithTargets.length === 0 && toolBlockKeys.length === 0) return this;
+		const effectiveServers = Object.fromEntries(Object.entries(sharedServers).filter(([, serverConfig]) => {
+			const targets = serverConfig.targets;
+			if (targets === void 0) return true;
+			return targets.some((target) => target === "*" || acceptedTargetNames.has(target));
+		}));
+		for (const blockKey of blockKeys) {
+			const toolBlock = json[blockKey];
+			const toolServers = isRecord(toolBlock) && isRecord(toolBlock.mcpServers) ? toolBlock.mcpServers : void 0;
+			for (const [serverName, serverConfig] of Object.entries(toolServers ?? {})) {
+				if (isPrototypePollutionKey(serverName)) continue;
+				if (serverConfig === null) delete effectiveServers[serverName];
+				else effectiveServers[serverName] = serverConfig;
+			}
+		}
+		const rest = Object.fromEntries(Object.entries(json).filter(([key]) => !MCP_TOOL_BLOCK_KEYS.has(key)));
+		return new RulesyncMcp({
+			outputRoot: this.outputRoot,
+			relativeDirPath: this.relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: JSON.stringify({
+				...rest,
+				mcpServers: effectiveServers
+			}, null, 2)
+		});
+	}
+	/**
+	* The deprecation warning would otherwise repeat once per generated tool
+	* target (a full `--targets "*"` run creates one RulesyncMcp per target),
+	* so it is deduplicated per source file path.
+	*/
+	warnTargetsDeprecationOnce({ serverNamesWithTargets, logger }) {
+		this.warnOncePerFile("targets-deprecation", `The per-server "targets" field in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is deprecated (servers: ${serverNamesWithTargets.join(", ")}). Author tool-scoped "{toolname}.mcpServers" blocks instead.`, logger);
+	}
+	warnOncePerFile(kind, message, logger) {
+		const dedupeKey = `${this.getFilePath()}#${kind}`;
+		if (warnedOnceKeys.has(dedupeKey)) return;
+		warnedOnceKeys.add(dedupeKey);
+		logger?.warn(message);
+	}
+};
+/**
+* All keys that may hold a tool-scoped `{toolname}.mcpServers` block. Derived
+* from the MCP processor's target tuple so a newly added MCP-capable tool is
+* covered automatically.
+*/
+const MCP_TOOL_BLOCK_KEYS = new Set(mcpProcessorToolTargetTuple);
+/**
+* Targets whose `{toolname}.mcpServers` block key is ALWAYS another target's
+* key (at every scope): `claudecode-legacy` is a deprecated alias of
+* `claudecode`, and the Kiro IDE/CLI targets share the `kiro` block because
+* all three write the same `.kiro/settings/mcp.json` at both scopes. Blocks
+* authored under these source names are never read (a warning is emitted).
+*/
+const MCP_BLOCK_KEY_ALIASES = {
+	"claudecode-legacy": "claudecode",
+	"kiro-cli": "kiro",
+	"kiro-ide": "kiro"
+};
+const MCP_IGNORED_ALIAS_SOURCE_KEYS = Object.keys(MCP_BLOCK_KEY_ALIASES);
+/**
+* Resolve which tool-scoped blocks a target reads and which deprecated
+* `targets` names match it. Targets that share one output file must resolve
+* identically, otherwise the shared file's content would depend on which
+* target happened to generate last:
+*
+* - `claudecode-legacy` aliases `claudecode`; the Kiro trio shares `kiro`
+*   (same output file at both scopes).
+* - `antigravity-ide` / `antigravity-cli` share their output file at BOTH
+*   scopes — `.agents/mcp_config.json` (project) and
+*   `~/.gemini/config/mcp_config.json` (global; both global subdirs are
+*   `config`) — so both targets always apply both blocks in a fixed order
+*   (`antigravity-ide` first, `antigravity-cli` second — the CLI block wins
+*   per server on conflict).
+*/
+function resolveMcpTarget({ toolTarget }) {
+	if (toolTarget === "claudecode" || toolTarget === "claudecode-legacy") return {
+		blockKeys: ["claudecode"],
+		acceptedTargetNames: /* @__PURE__ */ new Set(["claudecode", "claudecode-legacy"])
+	};
+	if (toolTarget === "kiro" || toolTarget === "kiro-cli" || toolTarget === "kiro-ide") return {
+		blockKeys: ["kiro"],
+		acceptedTargetNames: /* @__PURE__ */ new Set([
+			"kiro",
+			"kiro-cli",
+			"kiro-ide"
+		])
+	};
+	if (toolTarget === "antigravity-ide" || toolTarget === "antigravity-cli") return {
+		blockKeys: ["antigravity-ide", "antigravity-cli"],
+		acceptedTargetNames: /* @__PURE__ */ new Set(["antigravity-ide", "antigravity-cli"])
+	};
+	return {
+		blockKeys: [toolTarget],
+		acceptedTargetNames: /* @__PURE__ */ new Set([toolTarget])
+	};
+}
+/**
+* Deduplication set for once-per-source-file warnings, keyed by
+* `<absolute file path>#<warning kind>`. Never cleared: rulesync CLI runs
+* are one-shot processes, and in a long-lived embedding (the rulesync MCP
+* server) repeating the same warning per generate would only add noise.
+*/
+const warnedOnceKeys = /* @__PURE__ */ new Set();
 //#endregion
 //#region src/features/mcp/tool-mcp.ts
 var ToolMcp = class extends ToolFile {
@@ -16740,10 +16986,14 @@ var McpProcessor = class extends FeatureProcessor {
 		if (!rulesyncMcp) throw new Error(`No ${RULESYNC_MCP_RELATIVE_FILE_PATH} found.`);
 		const factory = this.getFactory(this.toolTarget);
 		return await Promise.all([rulesyncMcp].map(async (mcp) => {
+			const targetedRulesyncMcp = mcp.forTarget({
+				toolTarget: this.toolTarget,
+				logger: this.logger
+			});
 			const fieldsToStrip = [];
 			if (!factory.meta.supportsEnabledTools) fieldsToStrip.push("enabledTools");
 			if (!factory.meta.supportsDisabledTools) fieldsToStrip.push("disabledTools");
-			const filteredRulesyncMcp = mcp.stripMcpServerFields(fieldsToStrip);
+			const filteredRulesyncMcp = targetedRulesyncMcp.stripMcpServerFields(fieldsToStrip);
 			return await factory.class.fromRulesyncMcp({
 				outputRoot: this.outputRoot,
 				rulesyncMcp: filteredRulesyncMcp,
@@ -16793,6 +17043,25 @@ const PermissionActionSchema = zod_mini.z.enum([
 */
 const PermissionRulesSchema = zod_mini.z.record(zod_mini.z.string(), PermissionActionSchema);
 /**
+* Tool-scoped canonical `permission` block: the same shape as the shared
+* top-level `permission` record, but applied only to the tool whose override
+* key it appears under. During generation the categories placed here are
+* merged over the shared `permission` block per category (the tool-scoped
+* category replaces the shared one wholesale), mirroring how
+* `.rulesync/hooks.json` merges `{toolname}.hooks` per event.
+*
+* @example
+* { "claudecode": { "permission": { "bash": { "git push *": "deny" } } } }
+*/
+const ToolScopedPermissionSchema = zod_mini.z.record(zod_mini.z.string(), PermissionRulesSchema);
+/**
+* Generic tool-scoped override block for tools that have no tool-specific
+* override keys of their own; it carries only the canonical tool-scoped
+* `permission` block. Kept `looseObject` so future tool-specific keys can be
+* added without a schema break.
+*/
+const CanonicalPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(ToolScopedPermissionSchema) });
+/**
 * OpenCode-specific permission value. Unlike the shared canonical block, which
 * only accepts a pattern-to-action map, OpenCode also allows a bare action
 * string that applies to the whole category (e.g. `"external_directory": "deny"`).
@@ -16822,7 +17091,7 @@ const OpencodePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: z
 * @example
 * { "approvals": { "mode": "smart" }, "security": { "allow_private_urls": false } }
 */
-const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({});
+const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(ToolScopedPermissionSchema) });
 /**
 * Tool-scoped override block for Cline. Cline's `command-permissions.json`
 * carries a single global `allowRedirects` boolean (gates shell redirection
@@ -16834,7 +17103,10 @@ const HermesPermissionsOverrideSchema = zod_mini.z.looseObject({});
 * @example
 * { "allowRedirects": true }
 */
-const ClinePermissionsOverrideSchema = zod_mini.z.looseObject({ allowRedirects: zod_mini.z.optional(zod_mini.z.boolean()) });
+const ClinePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	allowRedirects: zod_mini.z.optional(zod_mini.z.boolean())
+});
 /**
 * Tool-scoped override block for Kilo Code (an OpenCode fork). Kilo's permission
 * object is a free-form record with tool-specific keys that have no canonical
@@ -16864,7 +17136,10 @@ const KiloPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 * @example
 * { "permissions": { "defaultMode": "acceptEdits", "additionalDirectories": ["../shared"] } }
 */
-const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({ permissions: zod_mini.z.optional(zod_mini.z.looseObject({})) });
+const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	permissions: zod_mini.z.optional(zod_mini.z.looseObject({}))
+});
 /**
 * Tool-scoped override block for Mistral Vibe. Vibe's per-tool `BaseToolConfig`
 * carries a `sensitive_patterns` list — patterns that escalate to ASK even when
@@ -16896,6 +17171,7 @@ const VibePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 * { "approvalMode": "auto-review" }
 */
 const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	approvalMode: zod_mini.z.optional(zod_mini.z.string()),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -16921,6 +17197,7 @@ const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
 * }
 */
 const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	tools: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	security: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	autoMode: zod_mini.z.optional(zod_mini.z.looseObject({}))
@@ -16942,6 +17219,7 @@ const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "sandbox": { "bash": "enforce", "network": false }, "agent": { "plan_mode_read_only_commands": ["gh pr diff"] } }
 */
 const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	agent: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -16961,7 +17239,10 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 * @example
 * { "commandBlocklist": ["rm -rf /*"], "sandbox": { "enabled": true } }
 */
-const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({ commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) });
+const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
 /**
 * Tool-scoped override block for Warp. Warp's `[agents.profiles]` table exposes
 * file-read/read-only autonomy keys with no canonical per-command allow/ask/deny
@@ -16978,6 +17259,7 @@ const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({ commandBl
 * { "agent_mode_coding_permissions": "always_allow_reading", "agent_mode_execute_readonly_commands": true }
 */
 const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	agent_mode_coding_permissions: zod_mini.z.optional(zod_mini.z.string()),
 	agent_mode_coding_file_read_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	agent_mode_execute_readonly_commands: zod_mini.z.optional(zod_mini.z.boolean())
@@ -16995,6 +17277,7 @@ const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "allowReadonlyCommands": true, "defaultBehavior": "ask" }
 */
 const JuniePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	allowReadonlyCommands: zod_mini.z.optional(zod_mini.z.boolean()),
 	defaultBehavior: zod_mini.z.optional(zod_mini.z.string())
 });
@@ -17022,6 +17305,7 @@ const JuniePermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "step_permission_overrides": { "ai_review": "readonly" }, "provider_options": { "codex": { "network_access": true } } }
 */
 const TaktPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	step_permission_overrides: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	provider_options: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
@@ -17049,6 +17333,7 @@ const TaktPermissionsOverrideSchema = zod_mini.z.looseObject({
 *   "permissions": [{ "tool": "Bash", "action": "delegate", "to": "approve.sh" }] }
 */
 const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	permissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
 		tool: zod_mini.z.string(),
 		action: zod_mini.z.string()
@@ -17077,6 +17362,7 @@ const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
 * { "toolPermission": "strict", "enableTerminalSandbox": true }
 */
 const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	toolPermission: zod_mini.z.optional(zod_mini.z.string()),
 	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -17102,10 +17388,13 @@ const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 *       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
 *     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
 */
-const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({ toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
-	toolName: zod_mini.z.string(),
-	permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
-}))) });
+const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
+		toolName: zod_mini.z.string(),
+		permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
+	})))
+});
 /**
 * Tool-scoped override block for Kiro. Kiro's agent config (`.kiro/agents/<name>.json`)
 * exposes per-tool `toolsSettings` knobs with no canonical allow/ask/deny
@@ -17131,21 +17420,24 @@ const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({ toolPermis
 *     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
 *     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
 */
-const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zod_mini.z.optional(zod_mini.z.looseObject({
-	shell: zod_mini.z.optional(zod_mini.z.looseObject({
-		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean()),
-		denyByDefault: zod_mini.z.optional(zod_mini.z.boolean())
-	})),
-	aws: zod_mini.z.optional(zod_mini.z.looseObject({
-		allowedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		deniedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean())
-	})),
-	web_fetch: zod_mini.z.optional(zod_mini.z.looseObject({
-		trusted: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-		blocked: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	toolsSettings: zod_mini.z.optional(zod_mini.z.looseObject({
+		shell: zod_mini.z.optional(zod_mini.z.looseObject({
+			autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean()),
+			denyByDefault: zod_mini.z.optional(zod_mini.z.boolean())
+		})),
+		aws: zod_mini.z.optional(zod_mini.z.looseObject({
+			allowedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			deniedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean())
+		})),
+		web_fetch: zod_mini.z.optional(zod_mini.z.looseObject({
+			trusted: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+			blocked: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+		}))
 	}))
-})) });
+});
 /**
 * Codex CLI's approval-workflow policy. Serialized as a kebab-case string in
 * `.codex/config.toml`. `on-failure` is a legacy alias for `on-request` that
@@ -17217,6 +17509,7 @@ const CodexApprovalsReviewerSchema = zod_mini.z.enum([
 *   "sandbox_workspace_write": { "network_access": true } }
 */
 const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	approval_policy: zod_mini.z.optional(zod_mini.z.union([CodexApprovalPolicySchema, zod_mini.z.looseObject({})])),
 	sandbox_mode: zod_mini.z.optional(CodexSandboxModeSchema),
 	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
@@ -17235,6 +17528,15 @@ const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
 * `*PermissionsOverrideSchema`); every other tool reads the shared `permission`
 * block and ignores them.
 *
+* Additionally, every permissions-capable tool accepts a canonical tool-scoped
+* `permission` block under its override key (`{toolname}.permission`, same
+* shape as the shared `permission` record). Its categories apply only to that
+* tool, merged over the shared block per category — see
+* `RulesyncPermissions.forTarget`. `kiro-cli`/`kiro-ide` alias to the `kiro`
+* key and `hermesagent` to `hermes` (matching the shared output file each
+* writes). OpenCode/Kilo/Vibe keep their existing tool-native `permission`
+* override semantics (handled by their translators, not the central merge).
+*
 * @example
 * {
 *   "bash": { "*": "ask", "git *": "allow", "rm *": "deny" },
@@ -17260,7 +17562,13 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema),
 	augmentcode: zod_mini.z.optional(AugmentcodePermissionsOverrideSchema),
 	kiro: zod_mini.z.optional(KiroPermissionsOverrideSchema),
-	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema)
+	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema),
+	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	devin: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	grokcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	rovodev: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	zed: zod_mini.z.optional(CanonicalPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -17275,7 +17583,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	json;
 	constructor(params) {
 		super({ ...params });
-		this.json = JSON.parse(this.fileContent);
+		this.json = parseJsonc$6(this.fileContent);
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -17284,7 +17592,11 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	static getSettablePaths() {
 		return {
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME
+			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
+			jsonc: {
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_PERMISSIONS_JSONC_FILE_NAME
+			}
 		};
 	}
 	validate() {
@@ -17300,20 +17612,85 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncPermissions.getSettablePaths();
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
-		if (!await fileExists(filePath)) throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
-		const fileContent = await readFileContent(filePath);
-		return new RulesyncPermissions({
-			outputRoot,
+		const candidates = [paths.jsonc, {
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath,
-			fileContent,
-			validate
-		});
+			relativeFilePath: paths.relativeFilePath
+		}];
+		for (const candidate of candidates) {
+			const filePath = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			const fileContent = await readFileContent(filePath);
+			return new RulesyncPermissions({
+				outputRoot,
+				relativeDirPath: candidate.relativeDirPath,
+				relativeFilePath: candidate.relativeFilePath,
+				fileContent,
+				validate
+			});
+		}
+		throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} or ${RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
 	}
+	/**
+	* Build the effective permissions config for one tool target by merging the
+	* tool-scoped `{toolname}.permission` block over the shared `permission`
+	* block, per category (the tool-scoped category replaces the shared one
+	* wholesale — mirroring how `{toolname}.hooks` merges per event in
+	* `.rulesync/hooks.json`). The consumed `permission` key is stripped from
+	* the override block so verbatim-passthrough translators (e.g. the Hermes
+	* deep merge or the Codex CLI top-level key whitelist) never see it.
+	*
+	* Returns the same instance when the target has no tool-scoped canonical
+	* `permission` block, or when the target's translator natively consumes its
+	* own `permission` override shape (OpenCode / Kilo / Vibe).
+	*/
+	forTarget({ toolTarget, logger }) {
+		if (NATIVE_PERMISSION_OVERRIDE_TARGETS.has(toolTarget)) return this;
+		const overrideKey = PERMISSION_OVERRIDE_KEY_ALIASES[toolTarget] ?? toolTarget;
+		const json = this.json;
+		if (overrideKey !== toolTarget && isRecord(json[toolTarget])) logger?.warn(`The "${toolTarget}" block in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)} is ignored. Author it under the "${overrideKey}" key instead (the ${toolTarget} target reads that block).`);
+		const overrideBlock = json[overrideKey];
+		if (!isRecord(overrideBlock) || !isRecord(overrideBlock.permission)) return this;
+		const { permission: toolScopedPermission, ...restOverride } = overrideBlock;
+		const merged = {
+			...json,
+			permission: {
+				...this.json.permission,
+				...toolScopedPermission
+			}
+		};
+		if (Object.keys(restOverride).length > 0) merged[overrideKey] = restOverride;
+		else delete merged[overrideKey];
+		return new RulesyncPermissions({
+			outputRoot: this.outputRoot,
+			relativeDirPath: this.relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: JSON.stringify(merged, null, 2)
+		});
+	}
+};
+/**
+* Targets whose tool-scoped `permission` override uses tool-native semantics
+* consumed directly by their translator (bare action strings / tool-only
+* categories for OpenCode and Kilo, `sensitive_patterns` objects for Vibe).
+* The central canonical merge must not touch those blocks.
+*/
+const NATIVE_PERMISSION_OVERRIDE_TARGETS = /* @__PURE__ */ new Set([
+	"opencode",
+	"kilo",
+	"vibe"
+]);
+/**
+* Targets that read their tool-scoped override from a differently named key:
+* Kiro IDE/CLI share the `kiro` block (they write the same agent config) and
+* Hermes Agent's established override key is `hermes`.
+*/
+const PERMISSION_OVERRIDE_KEY_ALIASES = {
+	"kiro-cli": "kiro",
+	"kiro-ide": "kiro",
+	hermesagent: "hermes"
 };
 //#endregion
 //#region src/features/permissions/tool-permissions.ts
@@ -19153,10 +19530,15 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			existingDomainsHadUnknown,
 			logger
 		});
-		permissionsTable[RULESYNC_PROFILE_NAME] = mergeWithExistingProfile({
+		const profile = mergeWithExistingProfile({
 			newProfile,
 			existingProfile
 		});
+		permissionsTable[RULESYNC_PROFILE_NAME] = preserveUnmanagedProfileKeys({
+			rawExistingProfile: permissionsTable[RULESYNC_PROFILE_NAME],
+			profile,
+			logger
+		});
 		const overridePatch = computeCodexcliOverridePatch({
 			existing,
 			override: rulesyncPermissions.getJson().codexcli,
@@ -19352,6 +19734,43 @@ function warnAboutPreservedProfileState({ existingProfile, newProfile, existingD
 	if (existingProfile?.network?.mode !== void 0) logger?.warn(`Preserving existing "network.mode" from config. Review this value manually as it may grant broader network access than the Rulesync-managed domain rules.`);
 	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
 }
+const MANAGED_PROFILE_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"extends",
+	"filesystem",
+	"network"
+]);
+const MANAGED_NETWORK_KEYS = /* @__PURE__ */ new Set([
+	"enabled",
+	"mode",
+	"domains",
+	"unix_sockets"
+]);
+/**
+* Re-attach the keys of the existing rulesync profile that rulesync does not
+* manage. The managed keys always come from `profile` (the freshly computed
+* merge result); unmanaged siblings — at the profile level and inside the
+* `network` table — are preserved verbatim from the existing config so a
+* regeneration never deletes user-authored Codex settings.
+*/
+function preserveUnmanagedProfileKeys({ rawExistingProfile, profile, logger }) {
+	const rawProfileTable = toMutableTable(rawExistingProfile);
+	const profileExtras = Object.fromEntries(Object.entries(rawProfileTable).filter(([key]) => !MANAGED_PROFILE_KEYS.has(key)));
+	const rawNetworkTable = toMutableTable(rawProfileTable.network);
+	const networkExtras = Object.fromEntries(Object.entries(rawNetworkTable).filter(([key]) => !MANAGED_NETWORK_KEYS.has(key)));
+	const preservedKeyNames = [...Object.keys(profileExtras), ...Object.keys(networkExtras).map((key) => `network.${key}`)];
+	if (preservedKeyNames.length > 0) logger?.warn(`Preserving unmanaged keys in the "${RULESYNC_PROFILE_NAME}" permissions profile: ${preservedKeyNames.join(", ")}. Review them manually; rulesync carries them forward verbatim.`);
+	const result = {
+		...profileExtras,
+		...profile
+	};
+	const mergedNetwork = {
+		...networkExtras,
+		...profile.network
+	};
+	if (Object.keys(mergedNetwork).length > 0) result.network = mergedNetwork;
+	return result;
+}
 function mergeWithExistingProfile({ newProfile, existingProfile }) {
 	if (!existingProfile) return newProfile;
 	const mergedNetwork = { ...newProfile.network };
@@ -23613,16 +24032,20 @@ var PermissionsProcessor = class extends FeatureProcessor {
 		if (!rulesyncPermissions) throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
 		const factory = toolPermissionsFactories.get(this.toolTarget);
 		if (!factory) throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+		const effectivePermissions = rulesyncPermissions.forTarget({
+			toolTarget: this.toolTarget,
+			logger: this.logger
+		});
 		const toolPermissions = await factory.class.fromRulesyncPermissions({
 			outputRoot: this.outputRoot,
-			rulesyncPermissions,
+			rulesyncPermissions: effectivePermissions,
 			logger: this.logger,
 			global: this.global
 		});
 		if (this.toolTarget !== "codexcli") return [toolPermissions];
 		return [toolPermissions, createCodexcliBashRulesFile({
 			outputRoot: this.outputRoot,
-			config: rulesyncPermissions.getJson()
+			config: effectivePermissions.getJson()
 		})];
 	}
 	async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -39718,6 +40141,16 @@ async function generatePermissionsCore(params) {
 //#endregion
 //#region src/lib/import.ts
 /**
+* Import always writes the `.json` variant of a fixed-path source file, but a
+* sibling `.jsonc` variant takes precedence at read time — so an import into a
+* project that authors the `.jsonc` variant would be silently shadowed. Warn
+* so the user merges (or removes) one of the two by hand.
+*/
+async function warnIfShadowedByJsonc(params) {
+	const { outputRoot, jsonRelativePath, jsoncRelativePath, logger } = params;
+	if (await fileExists((0, node_path.join)(outputRoot, jsoncRelativePath))) logger.warn(`${jsoncRelativePath} exists and takes precedence over the imported ${jsonRelativePath}. Merge the imported content into ${jsoncRelativePath} (or remove it) so the import takes effect.`);
+}
+/**
 * Import configuration files from AI tools.
 */
 async function importFromTool(params) {
@@ -39829,6 +40262,12 @@ async function importMcpCore(params) {
 	}
 	const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await mcpProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_MCP_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} MCP files`);
 	return writtenCount;
 }
@@ -39928,6 +40367,12 @@ async function importHooksCore(params) {
 	}
 	const rulesyncFiles = await hooksProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await hooksProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_HOOKS_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} hooks file(s)`);
 	return writtenCount;
 }
@@ -39957,6 +40402,12 @@ async function importPermissionsCore(params) {
 	}
 	const rulesyncFiles = await permissionsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await permissionsProcessor.writeAiFiles(rulesyncFiles);
+	if (writtenCount > 0) await warnIfShadowedByJsonc({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		jsonRelativePath: RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH,
+		jsoncRelativePath: RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH,
+		logger
+	});
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} permissions file(s)`);
 	return writtenCount;
 }
@@ -40021,6 +40472,12 @@ Object.defineProperty(exports, "CLIError", {
 		return CLIError;
 	}
 });
+Object.defineProperty(exports, "CODEXCLI_DIR", {
+	enumerable: true,
+	get: function() {
+		return CODEXCLI_DIR;
+	}
+});
 Object.defineProperty(exports, "CommandsProcessor", {
 	enumerable: true,
 	get: function() {
@@ -40117,6 +40574,12 @@ Object.defineProperty(exports, "RULESYNC_HOOKS_FILE_NAME", {
 		return RULESYNC_HOOKS_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_HOOKS_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_HOOKS_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_HOOKS_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
@@ -40141,6 +40604,12 @@ Object.defineProperty(exports, "RULESYNC_MCP_FILE_NAME", {
 		return RULESYNC_MCP_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_MCP_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_MCP_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_MCP_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
@@ -40165,12 +40634,24 @@ Object.defineProperty(exports, "RULESYNC_PERMISSIONS_FILE_NAME", {
 		return RULESYNC_PERMISSIONS_FILE_NAME;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_PERMISSIONS_JSONC_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_PERMISSIONS_JSONC_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH", {
 	enumerable: true,
 	get: function() {
 		return RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_PERMISSIONS_SCHEMA_URL", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_PERMISSIONS_SCHEMA_URL;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_RELATIVE_DIR_PATH", {
 	enumerable: true,
 	get: function() {