rulesync 9.4.0 → 9.6.0

package/dist/{import-BxqZVTKb.js → import-B6nwZmGl.js}

@@ -7,9 +7,9 @@ import os from "node:os";
 import { intersection, kebabCase, uniq } from "es-toolkit";
 import { globbySync } from "globby";
 import { isDeepStrictEqual } from "node:util";
-import { dump, load } from "js-yaml";
 import * as smolToml from "smol-toml";
 import matter from "gray-matter";
+import { YAMLException, dump, load } from "js-yaml";
 import { omit } from "es-toolkit/object";
 import { encode } from "@toon-format/toon";
 //#region src/types/features.ts
@@ -141,6 +141,7 @@ const rulesProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -288,6 +289,7 @@ const skillsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -852,7 +854,7 @@ const SourceEntrySchema = z.object({
 	scope: optional(z.enum(["project", "user"]))
 });
 const ConfigParamsSchema = z.object({
-	outputRoots: z.array(z.string()),
+	outputRoots: z.union([z.array(z.string()), z.record(z.string(), z.union([z.string(), z.array(z.string())]))]),
 	targets: RulesyncConfigTargetsSchema,
 	features: RulesyncFeaturesSchema,
 	verbose: z.boolean(),
@@ -957,6 +959,7 @@ var Config = class Config {
 		const resolvedTargets = targets ?? [];
 		const resolvedFeatures = features ?? [];
 		this.validateObjectFormTargetKeys(resolvedTargets);
+		this.validateObjectFormOutputRootKeys(outputRoots);
 		this.validateConflictingTargets(resolvedTargets);
 		if (dryRun && check) throw new Error("--dry-run and --check cannot be used together");
 		this.outputRoots = outputRoots;
@@ -994,6 +997,11 @@ var Config = class Config {
 			if (!validTargets.has(key)) throw new Error(`Unknown target '${key}'. Valid targets: ${ALL_TOOL_TARGETS.join(", ")}.`);
 		}
 	}
+	validateObjectFormOutputRootKeys(outputRoots) {
+		if (Array.isArray(outputRoots)) return;
+		const validTargets = new Set(ALL_TOOL_TARGETS);
+		for (const key of Object.keys(outputRoots)) if (!validTargets.has(key)) throw new Error(`Unknown outputRoots target '${key}'. Valid targets: ${ALL_TOOL_TARGETS.join(", ")}.`);
+	}
 	validateConflictingTargets(targets) {
 		const has = (target) => {
 			if (Array.isArray(targets)) return targets.includes(target);
@@ -1001,8 +1009,19 @@ var Config = class Config {
 		};
 		for (const [target1, target2] of CONFLICTING_TARGET_PAIRS) if (has(target1) && has(target2)) throw new Error(`Conflicting targets: '${target1}' and '${target2}' cannot be used together. Please choose one.`);
 	}
-	getOutputRoots() {
-		return this.outputRoots;
+	getOutputRoots(target) {
+		if (Array.isArray(this.outputRoots)) return this.outputRoots;
+		if (target) {
+			const targetOutputRoots = this.outputRoots[target];
+			if (targetOutputRoots === void 0) return [];
+			return Array.isArray(targetOutputRoots) ? targetOutputRoots : [targetOutputRoots];
+		}
+		const allRoots = [];
+		for (const value of Object.values(this.outputRoots)) {
+			if (value === void 0) continue;
+			allRoots.push(...Array.isArray(value) ? value : [value]);
+		}
+		return [...new Set(allRoots)];
 	}
 	/**
 	* Filter an arbitrary string-key list down to the known `ToolTarget` set,
@@ -1364,10 +1383,21 @@ var ConfigResolver = class {
 };
 function getOutputRootsInLightOfGlobal({ outputRoots, global }) {
 	if (global) return [getHomeDirectory()];
-	outputRoots.forEach((outputRoot) => {
-		validateOutputRoot(outputRoot);
-	});
-	return outputRoots.map((outputRoot) => resolve(outputRoot));
+	if (Array.isArray(outputRoots)) {
+		outputRoots.forEach((outputRoot) => {
+			validateOutputRoot(outputRoot);
+		});
+		return outputRoots.map((outputRoot) => resolve(outputRoot));
+	}
+	const resolvedOutputRoots = {};
+	for (const [target, targetOutputRoots] of Object.entries(outputRoots)) {
+		const roots = Array.isArray(targetOutputRoots) ? targetOutputRoots : [targetOutputRoots];
+		roots.forEach((outputRoot) => {
+			validateOutputRoot(outputRoot);
+		});
+		resolvedOutputRoots[target] = Array.isArray(targetOutputRoots) ? roots.map((outputRoot) => resolve(outputRoot)) : resolve(targetOutputRoots);
+	}
+	return resolvedOutputRoots;
 }
 function extractConfigFileTargets(targets) {
 	if (targets === void 0) return void 0;
@@ -1396,7 +1426,7 @@ function isRecord(value) {
 * conversion, etc.) should reject inputs whose prototype could carry
 * malicious accessor descriptors.
 */
-function isPlainObject(value) {
+function isPlainObject$1(value) {
 	if (!isRecord(value)) return false;
 	const proto = Object.getPrototypeOf(value);
 	return proto === null || proto === Object.prototype;
@@ -1408,11 +1438,43 @@ function isStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 //#endregion
+//#region src/utils/yaml.ts
+/**
+* js-yaml v5's `reason` for an empty document. `load("")` — and any
+* whitespace/comment-only input — throws a `YAMLException` with this reason
+* instead of returning `undefined` the way v4 did.
+*/
+const EMPTY_INPUT_REASON = "expected a document, but the input is empty";
+/**
+* Load YAML content while preserving js-yaml v4's behavior of returning
+* `undefined` for empty documents (empty, whitespace-only, or comment-only
+* input).
+*
+* js-yaml v5 changed `load("")` to **throw** ("expected a document, but the
+* input is empty") instead of returning `undefined`. Many call sites here parse
+* config/lock/frontmatter files that can legitimately be empty and rely on the
+* old `undefined` sentinel (`load(input) ?? {}`, `if (loaded === undefined)`,
+* "an empty file parses to undefined/null"). Routing every load through this
+* wrapper keeps that contract in one place so a future js-yaml bump cannot
+* reintroduce the empty-input regression. Genuine parse errors still propagate.
+*
+* @see https://github.com/nodeca/js-yaml/blob/master/docs/migrate_v4_to_v5.md#empty-input-throws
+*/
+function loadYaml(content) {
+	if (content.trim() === "") return;
+	try {
+		return load(content);
+	} catch (error) {
+		if (error instanceof YAMLException && error.reason === EMPTY_INPUT_REASON) return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/utils/frontmatter.ts
 function deepRemoveNullishValue(value) {
 	if (value === null || value === void 0) return;
 	if (Array.isArray(value)) return value.map((item) => deepRemoveNullishValue(item)).filter((item) => item !== void 0);
-	if (isPlainObject(value)) {
+	if (isPlainObject$1(value)) {
 		const result = {};
 		for (const [key, val] of Object.entries(value)) {
 			const cleaned = deepRemoveNullishValue(val);
@@ -1435,7 +1497,7 @@ function deepFlattenStringsValue(value) {
 	if (value === null || value === void 0) return;
 	if (typeof value === "string") return value.replace(/\n+/g, " ").trim();
 	if (Array.isArray(value)) return value.map((item) => deepFlattenStringsValue(item)).filter((item) => item !== void 0);
-	if (isPlainObject(value)) {
+	if (isPlainObject$1(value)) {
 		const result = {};
 		for (const [key, val] of Object.entries(value)) {
 			const cleaned = deepFlattenStringsValue(val);
@@ -1458,7 +1520,7 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	const { avoidBlockScalars = false } = options ?? {};
 	const cleanFrontmatter = avoidBlockScalars ? deepFlattenStringsObject(frontmatter) : deepRemoveNullishObject(frontmatter);
 	if (avoidBlockScalars) return matter.stringify(body, cleanFrontmatter, { engines: { yaml: {
-		parse: (input) => load(input) ?? {},
+		parse: (input) => loadYaml(input) ?? {},
 		stringify: (data) => dump(data, { lineWidth: -1 })
 	} } });
 	return matter.stringify(body, cleanFrontmatter);
@@ -1497,7 +1559,7 @@ function tryJsonEquivalent(a, b) {
 }
 function tryYamlEquivalent(a, b) {
 	try {
-		return isDeepStrictEqual(load(a), load(b));
+		return isDeepStrictEqual(loadYaml(a), loadYaml(b));
 	} catch {
 		return;
 	}
@@ -3304,7 +3366,7 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		const where = join(this.relativeDirPath, this.relativeFilePath);
 		let parsed;
 		try {
-			parsed = load(content);
+			parsed = loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${where}): ${formatError(error)}`, { cause: error });
 		}
@@ -3957,7 +4019,7 @@ function omitPrototypePollutionKeys(record) {
 //#region src/features/shared/shared-config-gateway.ts
 function sanitizeSharedConfigValue(value) {
 	if (Array.isArray(value)) return value.map(sanitizeSharedConfigValue);
-	if (!isPlainObject(value)) return value;
+	if (!isPlainObject$1(value)) return value;
 	const result = {};
 	for (const [key, nested] of Object.entries(omitPrototypePollutionKeys(value))) result[key] = sanitizeSharedConfigValue(nested);
 	return result;
@@ -3973,14 +4035,14 @@ function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy =
 	const at = filePath === void 0 ? "" : ` at ${filePath}`;
 	let parsed;
 	try {
-		if (format === "yaml") parsed = load(fileContent);
+		if (format === "yaml") parsed = loadYaml(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
 		else parsed = parse(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse shared config${at}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) {
+	if (!isPlainObject$1(parsed)) {
 		if (invalidRootPolicy === "error") throw new Error(`Failed to parse shared config${at}: expected a mapping at the root`);
 		return {};
 	}
@@ -4023,7 +4085,7 @@ function mergeSharedConfigDeep({ base, patch }) {
 	for (const [key, patchValue] of Object.entries(patch)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 		const baseValue = result[key];
-		if (isPlainObject(baseValue) && isPlainObject(patchValue)) result[key] = mergeSharedConfigDeep({
+		if (isPlainObject$1(baseValue) && isPlainObject$1(patchValue)) result[key] = mergeSharedConfigDeep({
 			base: baseValue,
 			patch: patchValue
 		});
@@ -4657,6 +4719,8 @@ const REASONIX_GLOBAL_PERMISSIONS_FILE_NAME = REASONIX_GLOBAL_MCP_FILE_NAME;
 const REASONIX_DIR = REASONIX_GLOBAL_DIR;
 const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = join(REASONIX_DIR, "commands");
+const REASONIX_RULE_FILE_NAME = "REASONIX.md";
+const REASONIX_SKILLS_DIR_PATH = join(REASONIX_DIR, "skills");
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -5062,8 +5126,8 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const existingContent = await readFileContentOrNull(join(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
 		let existing = {};
 		if (existingContent) try {
-			const parsed = load(existingContent);
-			if (isPlainObject(parsed)) existing = parsed;
+			const parsed = loadYaml(existingContent);
+			if (isPlainObject$1(parsed)) existing = parsed;
 		} catch {}
 		const prompts = rovodevCommands.map((command) => ({
 			name: command.getName(),
@@ -5093,11 +5157,11 @@ async function lookupPromptDescription({ outputRoot, relativeFilePath, name }) {
 	if (!manifestContent) return "";
 	let parsed;
 	try {
-		parsed = load(manifestContent);
+		parsed = loadYaml(manifestContent);
 	} catch {
 		return "";
 	}
-	if (!isPlainObject(parsed) || !Array.isArray(parsed.prompts)) return "";
+	if (!isPlainObject$1(parsed) || !Array.isArray(parsed.prompts)) return "";
 	const expectedContentFile = toPosixPath(join("prompts", relativeFilePath));
 	const entry = parsed.prompts.find((candidate) => isRecord(candidate) && (candidate.content_file === expectedContentFile || candidate.name === name));
 	return isRecord(entry) && typeof entry.description === "string" ? entry.description : "";
@@ -6135,18 +6199,25 @@ 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`), but only the four events the
-* upstream issue scoped in are mapped here: `PreToolUse`, `PostToolUse`,
-* `UserPromptSubmit` ← `beforeSubmitPrompt`, and `Stop`. `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.
+* `SubagentStop`, `Notification`, `PreCompact`). The eight events with a clean
+* canonical equivalent are mapped: `PreToolUse`, `PostToolUse`,
+* `UserPromptSubmit` ← `beforeSubmitPrompt`, `Stop`, `SessionStart`,
+* `SessionEnd`, `SubagentStop`, and `PostLLMCall` ← `postModelInvocation`.
+* (`Notification` and `PreCompact` have no canonical event and are left out.)
+* `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.
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 const REASONIX_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"beforeSubmitPrompt",
-	"stop"
+	"stop",
+	"sessionStart",
+	"sessionEnd",
+	"subagentStop",
+	"postModelInvocation"
 ];
 /**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
@@ -6582,14 +6653,18 @@ const QWENCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANO
 /**
 * Map canonical camelCase event names to Reasonix PascalCase.
 * Reasonix explicitly mirrors Claude Code's hooks model, so it reuses the same
-* PascalCase names for the four events rulesync maps.
+* PascalCase names for the events rulesync maps.
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 const CANONICAL_TO_REASONIX_EVENT_NAMES = {
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
-	stop: "Stop"
+	stop: "Stop",
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	subagentStop: "SubagentStop",
+	postModelInvocation: "PostLLMCall"
 };
 /**
 * Map Reasonix PascalCase event names to canonical camelCase.
@@ -6638,6 +6713,21 @@ function applyCommandPrefix({ def, converterConfig }) {
 	return converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith(".")) && typeof trimmedCommand === "string" ? `"${converterConfig.projectDirVar}"/${trimmedCommand.replace(/^\.\//, "")}` : def.command;
 }
 /**
+* Emit the configured boolean passthrough fields on the tool side, mapping each
+* canonical field name to its (possibly renamed) tool field name. Only boolean
+* values are carried through.
+*/
+function emitBooleanPassthroughFields({ def, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "boolean").map(({ canonical, tool }) => [tool, def[canonical]]));
+}
+/**
+* Import the configured boolean passthrough fields back into canonical fields,
+* reversing {@link emitBooleanPassthroughFields}. Only boolean values are read.
+*/
+function importBooleanPassthroughFields({ h, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "boolean").map(({ canonical, tool }) => [canonical, h[tool]]));
+}
+/**
 * Convert the definitions of a single matcher group into tool hook entries,
 * honoring supported hook types and passthrough fields.
 */
@@ -6651,6 +6741,10 @@ function buildToolHooks({ defs, converterConfig }) {
 			converterConfig
 		});
 		hooks.push({
+			...emitBooleanPassthroughFields({
+				def,
+				converterConfig
+			}),
 			type: hookType,
 			...command !== void 0 && command !== null && { command },
 			...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
@@ -6738,6 +6832,10 @@ function toolHookToCanonical({ h, rawEntry, converterConfig }) {
 		...prompt !== void 0 && prompt !== null && { prompt },
 		...converterConfig.passthroughFields?.includes("name") && typeof h.name === "string" && { name: h.name },
 		...converterConfig.passthroughFields?.includes("description") && typeof h.description === "string" && { description: h.description },
+		...importBooleanPassthroughFields({
+			h,
+			converterConfig
+		}),
 		...rawEntry.matcher !== void 0 && rawEntry.matcher !== null && rawEntry.matcher !== "" && { matcher: rawEntry.matcher }
 	};
 }
@@ -7032,7 +7130,7 @@ function combineAugmentSettings(base, local) {
 		const baseValue = result[key];
 		if (AUGMENTCODE_REPLACE_KEYS.has(key)) result[key] = localValue;
 		else if (Array.isArray(localValue) && Array.isArray(baseValue)) result[key] = [...localValue, ...baseValue];
-		else if (isPlainObject(localValue) && isPlainObject(baseValue)) result[key] = combineAugmentSettings(baseValue, localValue);
+		else if (isPlainObject$1(localValue) && isPlainObject$1(baseValue)) result[key] = combineAugmentSettings(baseValue, localValue);
 		else result[key] = localValue;
 	}
 	return result;
@@ -7076,14 +7174,14 @@ async function readAugmentcodeSettingsWithLocalOverlay({ outputRoot, relativeDir
 	} catch (error) {
 		throw new Error(`Failed to parse AugmentCode settings at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(localParsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(localParsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
 	let baseParsed;
 	try {
 		baseParsed = JSON.parse(baseContent);
 	} catch {
 		return baseContent;
 	}
-	const merged = combineAugmentSettings(isPlainObject(baseParsed) ? baseParsed : {}, localParsed);
+	const merged = combineAugmentSettings(isPlainObject$1(baseParsed) ? baseParsed : {}, localParsed);
 	return JSON.stringify(merged, null, 2);
 }
 //#endregion
@@ -8668,7 +8766,14 @@ const JUNIE_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: JUNIE_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
-	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"])
+	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+	booleanPassthroughFields: [{
+		canonical: "failClosed",
+		tool: "blockOnError"
+	}, {
+		canonical: "async",
+		tool: "async"
+	}]
 };
 var JunieHooks = class JunieHooks extends ToolHooks {
 	constructor(params) {
@@ -9704,8 +9809,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.
-* Only the four events documented in the upstream issue are mapped:
-* PreToolUse/PostToolUse/UserPromptSubmit/Stop (see REASONIX_HOOK_EVENTS).
+* The eight upstream events with a clean canonical equivalent are mapped:
+* PreToolUse/PostToolUse/UserPromptSubmit/Stop plus SessionStart/SessionEnd/
+* SubagentStop/PostLLMCall (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 {
@@ -11784,7 +11890,7 @@ function parseAmpSettingsJsonc(fileContent) {
 		const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function filterMcpServers(mcpServers) {
@@ -12106,7 +12212,7 @@ function parseAugmentcodeSettings(fileContent, relativeDirPath, relativeFilePath
 	} catch (error) {
 		throw new Error(`Failed to parse AugmentCode settings at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -12332,7 +12438,7 @@ function parseClineSettings(fileContent, relativeDirPath, relativeFilePath) {
 	} catch (error) {
 		throw new Error(`Failed to parse Cline MCP settings at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Cline MCP settings at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Cline MCP settings at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -12603,7 +12709,7 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		for (const [key, value] of Object.entries(obj)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 			if (value === null) continue;
-			if (isPlainObject(value)) {
+			if (isPlainObject$1(value)) {
 				const cleaned = this.removeEmptyEntries(value, depth + 1);
 				if (Object.keys(cleaned).length === 0) continue;
 				filtered[key] = cleaned;
@@ -13244,12 +13350,12 @@ function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = join(relativeDirPath, relativeFilePath);
 	let parsed;
 	try {
-		parsed = load(fileContent);
+		parsed = loadYaml(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse Goose config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
 	return parsed;
 }
 /**
@@ -13294,7 +13400,7 @@ function applyGooseStdioFields(ext, config) {
 		ext.cmd = command;
 		if (isStringArray(config.args)) ext.args = config.args;
 	}
-	if (isPlainObject(config.env)) ext.envs = omitPrototypePollutionKeys(config.env);
+	if (isPlainObject$1(config.env)) ext.envs = omitPrototypePollutionKeys(config.env);
 }
 /**
 * Converts a single rulesync canonical MCP server into a Goose `extensions:` entry.
@@ -13309,7 +13415,7 @@ function convertServerToGooseExtension(name, config) {
 	if (gooseType === "stdio") applyGooseStdioFields(ext, config);
 	else if (gooseType === "sse" || gooseType === "streamable_http") {
 		if (url !== void 0) ext.uri = url;
-		if (isPlainObject(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
+		if (isPlainObject$1(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
 	}
 	ext.enabled = config.disabled !== true;
 	const timeout = resolveGooseTimeout(config);
@@ -13351,9 +13457,9 @@ function convertFromGooseFormat(extensions) {
 		else if (type === "stdio") server.type = "stdio";
 		if (typeof ext.cmd === "string") server.command = ext.cmd;
 		if (isStringArray(ext.args)) server.args = ext.args;
-		if (isPlainObject(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
+		if (isPlainObject$1(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
 		if (typeof ext.uri === "string") server.url = ext.uri;
-		if (isPlainObject(ext.headers)) server.headers = omitPrototypePollutionKeys(ext.headers);
+		if (isPlainObject$1(ext.headers)) server.headers = omitPrototypePollutionKeys(ext.headers);
 		if (ext.enabled === false) server.disabled = true;
 		if (typeof ext.timeout === "number") server.timeout = ext.timeout;
 		result[name] = server;
@@ -13376,7 +13482,7 @@ function buildGoosePluginStdioServer(config) {
 		server.command = command;
 		if (isStringArray(config.args)) server.args = config.args;
 	}
-	if (isPlainObject(config.env)) server.env = omitPrototypePollutionKeys(config.env);
+	if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 	if (typeof config.cwd === "string") server.cwd = config.cwd;
 	return server;
 }
@@ -13676,7 +13782,7 @@ var GrokcliMcp = class GrokcliMcp extends ToolMcp {
 		for (const [key, value] of Object.entries(obj)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 			if (value === null) continue;
-			if (isPlainObject(value)) {
+			if (isPlainObject$1(value)) {
 				const cleaned = this.removeEmptyEntries(value, depth + 1);
 				if (Object.keys(cleaned).length === 0) continue;
 				filtered[key] = cleaned;
@@ -13738,10 +13844,10 @@ function convertServerToHermes(config) {
 			out.command = command;
 			if (isStringArray(config.args)) out.args = config.args;
 		}
-		if (isPlainObject(config.env)) out.env = omitPrototypePollutionKeys(config.env);
+		if (isPlainObject$1(config.env)) out.env = omitPrototypePollutionKeys(config.env);
 	} else if (url !== void 0) {
 		out.url = url;
-		if (isPlainObject(config.headers)) out.headers = omitPrototypePollutionKeys(config.headers);
+		if (isPlainObject$1(config.headers)) out.headers = omitPrototypePollutionKeys(config.headers);
 	}
 	if (config.disabled === true) out.enabled = false;
 	const timeout = resolveHermesTimeout(config);
@@ -13786,9 +13892,9 @@ function convertFromHermesFormat(mcpServers) {
 		const server = {};
 		if (typeof config.command === "string") server.command = config.command;
 		if (isStringArray(config.args)) server.args = config.args;
-		if (isPlainObject(config.env)) server.env = omitPrototypePollutionKeys(config.env);
+		if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 		if (typeof config.url === "string") server.url = config.url;
-		if (isPlainObject(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
+		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)) {
@@ -14725,7 +14831,9 @@ const REASONIX_PLUGIN_FIELDS = [
 	"env",
 	"url",
 	"headers",
-	"trusted_read_only_tools"
+	"trusted_read_only_tools",
+	"call_timeout_seconds",
+	"tool_timeout_seconds"
 ];
 var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	toml;
@@ -14957,7 +15065,7 @@ function parseRovodevMcpJson(fileContent, relativeDirPath, relativeFilePath) {
 	} catch (error) {
 		throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -16228,15 +16336,123 @@ const AntigravityCliPermissionsOverrideSchema = z.looseObject({
 	enableTerminalSandbox: z.optional(z.boolean())
 });
 /**
+* Tool-scoped override block for AugmentCode. AugmentCode's `toolPermissions[]`
+* array supports "custom policy" entries the canonical allow/ask/deny model
+* cannot express: `permission.type` of `webhook-policy` / `script-policy`
+* (delegating the decision to a `webhookUrl` / `script`) and an `eventType` of
+* `tool-response` (a post-execution check rather than the default pre-execution
+* `tool-call`). These are authored here as verbatim `toolPermissions` entries
+* and prepended — ahead of the canonical-generated basic rules — into the shared
+* `.augment/settings.json`, so a webhook/script gate or tool-response check is
+* never shadowed by a regenerated allow/deny/ask entry under AugmentCode's
+* first-match-wins evaluation. The shared `permission` block continues to drive
+* the basic `allow` / `deny` / `ask-user` entries. Kept `looseObject` (verbatim
+* passthrough) so `shellInputRegex`, `eventType`, `webhookUrl`, `script`, and
+* any future policy field survive untouched. Both project and global scope are
+* supported.
+*
+* @example
+* { "toolPermissions": [
+*     { "toolName": "github-api",
+*       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
+*     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
+*/
+const AugmentcodePermissionsOverrideSchema = z.looseObject({ toolPermissions: z.optional(z.array(z.looseObject({
+	toolName: z.string(),
+	permission: z.looseObject({ type: z.string() })
+}))) });
+/**
+* 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
+* category: the shell auto-trust flags `shell.autoAllowReadonly` /
+* `shell.denyByDefault`, the `aws` built-in tool's `allowedServices` /
+* `deniedServices` (+ `autoAllowReadonly`), and the `web_fetch` domain trust
+* arrays `trusted` / `blocked` (regex host patterns; documented for `web_fetch`
+* only — `web_search` has no such surface). Fields placed here are deep-merged
+* (per `toolsSettings` key, override wins at the leaf) into the shared agent
+* config, while the canonical `permission` block continues to drive
+* `shell.{allowed,denied}Commands`, `read`/`write`/`grep`/`glob` paths, and the
+* `web_fetch`/`web_search` `allowedTools` toggles. Kept `looseObject` at every
+* level (verbatim passthrough) so future Kiro `toolsSettings` fields survive.
+*
+* Kiro's MCP `autoApprove` / `disabledTools` lists are intentionally NOT modeled
+* here: they live in a SEPARATE file (`.kiro/settings/mcp.json`, under
+* `mcpServers.<name>`), not the agent config this permissions translator writes,
+* and reconciling them with the canonical `mcp__*` model is a distinct design
+* question left out of scope.
+*
+* @example
+* { "toolsSettings": { "shell": { "autoAllowReadonly": true },
+*     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
+*     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
+*/
+const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(z.looseObject({
+	shell: z.optional(z.looseObject({
+		autoAllowReadonly: z.optional(z.boolean()),
+		denyByDefault: z.optional(z.boolean())
+	})),
+	aws: z.optional(z.looseObject({
+		allowedServices: z.optional(z.array(z.string())),
+		deniedServices: z.optional(z.array(z.string())),
+		autoAllowReadonly: z.optional(z.boolean())
+	})),
+	web_fetch: z.optional(z.looseObject({
+		trusted: z.optional(z.array(z.string())),
+		blocked: z.optional(z.array(z.string()))
+	}))
+})) });
+/**
+* Codex CLI-scoped permission override.
+*
+* Codex CLI's permission surface is richer than the canonical allow/ask/deny
+* model: its approval workflow, classic sandbox system, and per-app tool gating
+* have no canonical category. Author them through a tool-scoped `codexcli`
+* 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).
+* - `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.
+*
+* 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
+* MCP feature (`codexcli-mcp.ts` already writes the `mcp_servers` tables in the
+* same `config.toml`), and `permissions` / `default_permissions` are owned by
+* the canonical model. Any such key placed in the override is skipped with a
+* warning. Kept `looseObject` (verbatim passthrough) so future top-level Codex
+* config keys can be authored without Rulesync modeling each one.
+*
+* @see https://developers.openai.com/codex/config-reference
+* @see https://developers.openai.com/codex/permissions
+*
+* @example
+* { "approval_policy": "on-request", "sandbox_mode": "workspace-write",
+*   "sandbox_workspace_write": { "network_access": true } }
+*/
+const CodexcliPermissionsOverrideSchema = z.looseObject({
+	approval_policy: z.optional(z.union([z.string(), z.looseObject({})])),
+	sandbox_mode: z.optional(z.string()),
+	sandbox_workspace_write: z.optional(z.looseObject({})),
+	apps: z.optional(z.looseObject({})),
+	approvals_reviewer: z.optional(z.union([z.string(), z.looseObject({})]))
+});
+/**
 * Permissions configuration.
 * Keys are tool category names (e.g., "bash", "edit", "read", "webfetch").
 * Values are pattern-to-action mappings for that tool category.
 *
 * The optional `opencode`/`hermes`/`cline`/`kilo`/`claudecode`/`vibe`/`cursor`/
 * `qwencode`/`reasonix`/`factorydroid`/`warp`/`junie`/`takt`/`amp`/
-* `antigravity-cli` keys are tool-scoped overrides consumed only by their
-* respective translator (see the matching `*PermissionsOverrideSchema`); every
-* other tool reads the shared `permission` block and ignores them.
+* `antigravity-cli`/`augmentcode`/`kiro`/`codexcli` keys are tool-scoped
+* overrides consumed only by their respective translator (see the matching
+* `*PermissionsOverrideSchema`); every other tool reads the shared `permission`
+* block and ignores them.
 *
 * @example
 * {
@@ -16260,7 +16476,10 @@ const PermissionsConfigSchema = z.looseObject({
 	junie: z.optional(JuniePermissionsOverrideSchema),
 	takt: z.optional(TaktPermissionsOverrideSchema),
 	amp: z.optional(AmpPermissionsOverrideSchema),
-	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema)
+	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema),
+	augmentcode: z.optional(AugmentcodePermissionsOverrideSchema),
+	kiro: z.optional(KiroPermissionsOverrideSchema),
+	codexcli: z.optional(CodexcliPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16412,7 +16631,7 @@ function parseAmpSettings(fileContent) {
 		const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function toDisableList(value) {
@@ -16439,7 +16658,7 @@ function toPermissionsList(value) {
 	if (!Array.isArray(value)) return [];
 	const entries = [];
 	for (const raw of value) {
-		if (!isPlainObject(raw)) continue;
+		if (!isPlainObject$1(raw)) continue;
 		const { tool, action } = raw;
 		if (typeof tool !== "string" || typeof action !== "string") continue;
 		if (action !== "allow" && action !== "reject" && action !== "ask" && action !== "delegate") continue;
@@ -16447,7 +16666,7 @@ function toPermissionsList(value) {
 			...raw,
 			tool,
 			action,
-			...isPlainObject(raw.matches) ? { matches: raw.matches } : {}
+			...isPlainObject$1(raw.matches) ? { matches: raw.matches } : {}
 		});
 	}
 	return entries;
@@ -17307,6 +17526,55 @@ function isSpecialEntry(entry) {
 	return false;
 }
 /**
+* A composite identity for a special entry, used to de-duplicate authored
+* (`augmentcode` override) and preserved (existing-file) special entries so the
+* same policy is not emitted twice into `toolPermissions`. Every field that can
+* distinguish two special entries is included.
+*/
+function specialEntryKey(entry) {
+	return JSON.stringify([
+		entry.toolName,
+		entry.shellInputRegex ?? "",
+		entry.eventType ?? "",
+		entry.permission.type,
+		entry.permission.webhookUrl ?? "",
+		entry.permission.script ?? ""
+	]);
+}
+/**
+* Stable de-duplication of special entries by {@link specialEntryKey}, keeping
+* the first occurrence (authored entries lead, so an authored policy wins over
+* an identical preserved one).
+*/
+function dedupeSpecialEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const entry of entries) {
+		const key = specialEntryKey(entry);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(entry);
+	}
+	return out;
+}
+/**
+* Validate/normalize the `augmentcode` override's `toolPermissions` array into
+* typed `AugmentToolPermission` entries, dropping any malformed item (with a
+* warning so a typo is not lost silently). The override schema is intentionally
+* loose (verbatim passthrough), so entries are re-parsed through the full entry
+* schema here to guarantee shape before they are written into the shared
+* settings file.
+*/
+function coerceAuthoredEntries(entries, logger) {
+	const out = [];
+	for (const item of entries) {
+		const parsed = AugmentToolPermissionSchema.safeParse(item);
+		if (parsed.success) out.push(parsed.data);
+		else logger?.warn(`AugmentCode permissions: dropping malformed 'augmentcode.toolPermissions' override entry: ${formatError(parsed.error)}.`);
+	}
+	return out;
+}
+/**
 * Convert a glob-like pattern into a regex string for AugmentCode's `shellInputRegex`.
 * Maps glob `*` to `.*`, `?` to `.`, escapes other regex metacharacters, and anchors at both ends.
 */
@@ -17437,12 +17705,18 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse existing AugmentCode settings at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
+		const config = rulesyncPermissions.getJson();
 		const generated = convertRulesyncToAugmentEntries({
-			config: rulesyncPermissions.getJson(),
+			config,
 			logger
 		});
 		const existingEntries = settings.toolPermissions ?? [];
-		const specialEntries = existingEntries.filter((entry) => isSpecialEntry(entry));
+		const override = config.augmentcode;
+		const authoredEntries = override?.toolPermissions ? coerceAuthoredEntries(override.toolPermissions, logger) : [];
+		const authoredSpecials = authoredEntries.filter((entry) => isSpecialEntry(entry));
+		const authoredBasics = authoredEntries.filter((entry) => !isSpecialEntry(entry));
+		const preservedSpecials = override?.toolPermissions ? [] : existingEntries.filter((entry) => isSpecialEntry(entry));
+		const specialEntries = dedupeSpecialEntries([...authoredSpecials, ...preservedSpecials]);
 		const basicExistingEntries = existingEntries.filter((entry) => !isSpecialEntry(entry));
 		const generatedKeys = new Set(generated.map((e) => `${e.toolName}|${e.shellInputRegex ?? ""}|${e.permission.type}`));
 		const preservedBasicEntries = basicExistingEntries.filter((entry) => {
@@ -17453,7 +17727,11 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 			}
 			return false;
 		});
-		const sortedBasic = sortAugmentEntries([...generated, ...preservedBasicEntries]);
+		const sortedBasic = sortAugmentEntries([
+			...generated,
+			...preservedBasicEntries,
+			...authoredBasics
+		]);
 		const merged = {
 			...settings,
 			toolPermissions: [...specialEntries, ...sortedBasic]
@@ -17477,11 +17755,14 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse AugmentCode permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const config = convertAugmentToRulesyncPermissions({
-			entries: settings.toolPermissions ?? [],
+		const allEntries = settings.toolPermissions ?? [];
+		const specialEntries = allEntries.filter((entry) => isSpecialEntry(entry));
+		const result = { ...convertAugmentToRulesyncPermissions({
+			entries: allEntries.filter((entry) => !isSpecialEntry(entry)),
 			logger: moduleLogger$1
-		});
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+		}) };
+		if (specialEntries.length > 0) result.augmentcode = { toolPermissions: specialEntries };
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		try {
@@ -17615,10 +17896,7 @@ function convertAugmentToRulesyncPermissions({ entries, logger }) {
 	]);
 	const permission = {};
 	for (const entry of entries) {
-		if (isSpecialEntry(entry)) {
-			logger?.warn(`AugmentCode permissions: skipping advanced entry for tool '${entry.toolName}' (type '${entry.permission.type}'${entry.eventType !== void 0 ? `, eventType '${entry.eventType}'` : ""}) on import; rulesync's permission model cannot represent custom policies, eventType, webhookUrl, or script. Such entries are preserved on generate but not imported.`);
-			continue;
-		}
+		if (isSpecialEntry(entry)) continue;
 		const type = entry.permission.type;
 		if (!isBasicAugmentType(type)) continue;
 		const canonical = toCanonicalToolName$5(entry.toolName);
@@ -18050,6 +18328,13 @@ 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 {
@@ -18091,6 +18376,11 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 		});
 		parsed.permissions = permissionsTable;
 		parsed.default_permissions = RULESYNC_PROFILE_NAME;
+		applyCodexcliOverride({
+			parsed,
+			override: rulesyncPermissions.getJson().codexcli,
+			logger
+		});
 		return new CodexcliPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -18115,7 +18405,12 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			profile,
 			domainsHadUnknown
 		});
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+		const override = extractCodexcliOverride(table);
+		const result = Object.keys(override).length > 0 ? {
+			...config,
+			codexcli: override
+		} : config;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		return {
@@ -18307,6 +18602,30 @@ function toMutableTable(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
 	return { ...value };
 }
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function applyCodexcliOverride({ parsed, override, logger }) {
+	if (!override) return;
+	const allowed = new Set(CODEXCLI_OVERRIDE_KEYS);
+	for (const [key, value] of Object.entries(override)) {
+		if (!allowed.has(key)) {
+			logger?.warn(`Codex CLI permission override key "${key}" is not managed and was skipped. "permissions"/"default_permissions" are owned by the canonical permission model and "mcp_servers" gating by the MCP feature.`);
+			continue;
+		}
+		if (value === void 0) continue;
+		const existing = parsed[key];
+		parsed[key] = isPlainObject(existing) && isPlainObject(value) ? {
+			...existing,
+			...value
+		} : value;
+	}
+}
+function extractCodexcliOverride(table) {
+	const override = {};
+	for (const key of CODEXCLI_OVERRIDE_KEYS) if (table[key] !== void 0) override[key] = table[key];
+	return override;
+}
 function toFilesystemRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
 	const result = {};
@@ -19221,7 +19540,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : load(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Goose permission.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -19243,7 +19562,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : load(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -20150,6 +20469,13 @@ const KiroAgentSchema = z.looseObject({
 	toolsSettings: z.optional(z.record(z.string(), z.unknown()))
 });
 const UnknownRecordSchema = z.record(z.string(), z.unknown());
+const CANONICAL_SHELL_KEYS = /* @__PURE__ */ new Set(["allowedCommands", "deniedCommands"]);
+const CANONICAL_TOOL_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+	"read",
+	"write",
+	"grep",
+	"glob"
+]);
 var KiroPermissions = class KiroPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
 		return {
@@ -20213,7 +20539,10 @@ var KiroPermissions = class KiroPermissions extends ToolPermissions {
 		const allowedTools = new Set(parsed.allowedTools ?? []);
 		if (allowedTools.has("web_fetch")) permission.webfetch = { "*": "allow" };
 		if (allowedTools.has("web_search")) permission.websearch = { "*": "allow" };
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
+		const kiroOverride = extractKiroOverride(toolsSettings);
+		const result = { permission };
+		if (kiroOverride !== void 0) result.kiro = kiroOverride;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		return {
@@ -20263,19 +20592,71 @@ function buildKiroPermissionsFromRulesync({ config, logger, existing }) {
 		});
 		else logger?.warn(`Kiro permissions do not support category: ${category}. Skipping.`);
 	}
-	nextToolsSettings.shell = shell;
+	nextToolsSettings.shell = {
+		...preservedShellFlags(existing),
+		...shell
+	};
 	nextToolsSettings.read = pathTable(pathBuckets.read);
 	nextToolsSettings.write = pathTable(pathBuckets.write);
 	for (const key of ["grep", "glob"]) {
 		const bucket = pathBuckets[key];
 		if (bucket && (bucket.allow.length > 0 || bucket.deny.length > 0)) nextToolsSettings[key] = pathTable(bucket);
 	}
+	applyKiroOverride({
+		override: config.kiro,
+		nextToolsSettings,
+		logger
+	});
 	return {
 		...existing,
 		allowedTools: [...nextAllowedTools].toSorted(),
 		toolsSettings: nextToolsSettings
 	};
 }
+/**
+* Non-canonical `toolsSettings.shell` keys already present in the existing agent
+* config (everything except the canonical `allowed`/`deniedCommands`), so a
+* regenerate does not silently drop a hand-set `autoAllowReadonly` /
+* `denyByDefault` when no `kiro` override re-authors it.
+*/
+function preservedShellFlags(existing) {
+	const existingShell = asRecord$1(asRecord$1(existing.toolsSettings).shell);
+	const flags = {};
+	for (const [key, value] of Object.entries(existingShell)) if (!CANONICAL_SHELL_KEYS.has(key)) flags[key] = value;
+	return flags;
+}
+/**
+* Deep-merge the `kiro` override's `toolsSettings` block into the generated
+* settings, one `toolsSettings` key at a time so the override's leaf fields win
+* without clobbering canonical-generated siblings.
+*
+* Guards, so the override can only author the non-canonical surfaces it is meant
+* for and can never weaken a canonical-generated deny:
+* - prototype-pollution keys are skipped before being used as object keys;
+* - fully-canonical `toolsSettings` keys (`read`/`write`/`grep`/`glob`) are
+*   rejected outright with a warning (their paths are owned by the canonical
+*   `permission` block);
+* - for `shell` (partly canonical), the canonical command-list leaves
+*   (`allowed`/`deniedCommands`) are stripped from the override value so only the
+*   auto-trust flags merge.
+*/
+function applyKiroOverride({ override, nextToolsSettings, logger }) {
+	const overrideToolsSettings = override?.toolsSettings;
+	if (!isPlainObject$1(overrideToolsSettings)) return;
+	for (const [key, value] of Object.entries(overrideToolsSettings)) {
+		if (isPrototypePollutionKey(key)) continue;
+		if (!isPlainObject$1(value)) continue;
+		if (CANONICAL_TOOL_SETTINGS_KEYS.has(key)) {
+			logger?.warn(`Kiro permissions: ignoring 'kiro.toolsSettings.${key}' override; '${key}' paths are driven by the canonical permission block.`);
+			continue;
+		}
+		const mergeValue = key === "shell" ? Object.fromEntries(Object.entries(value).filter(([leaf]) => !CANONICAL_SHELL_KEYS.has(leaf))) : value;
+		nextToolsSettings[key] = {
+			...asRecord$1(nextToolsSettings[key]),
+			...mergeValue
+		};
+	}
+}
 function pathTable(bucket) {
 	return {
 		allowedPaths: bucket?.allow ?? [],
@@ -20295,6 +20676,31 @@ function asRecord$1(value) {
 	const result = UnknownRecordSchema.safeParse(value);
 	return result.success ? result.data : {};
 }
+/**
+* Build the `kiro` permissions override from a parsed agent config's
+* `toolsSettings`, lifting the Kiro-specific knobs with no canonical category:
+* - `shell.*` flags other than the canonical `allowed`/`deniedCommands`
+*   (e.g. `autoAllowReadonly`, `denyByDefault`), verbatim.
+* - the whole `aws` object (`allowedServices` / `deniedServices` / …), verbatim.
+* - the whole `web_fetch` object (`trusted` / `blocked`), verbatim.
+*
+* Returns `undefined` when none are present so the override key is omitted.
+*/
+function extractKiroOverride(toolsSettings) {
+	const overrideToolsSettings = {};
+	const shellFlags = {};
+	for (const [key, value] of Object.entries(asRecord$1(toolsSettings.shell))) {
+		if (isPrototypePollutionKey(key)) continue;
+		if (!CANONICAL_SHELL_KEYS.has(key)) shellFlags[key] = value;
+	}
+	if (Object.keys(shellFlags).length > 0) overrideToolsSettings.shell = shellFlags;
+	const aws = asRecord$1(toolsSettings.aws);
+	if (Object.keys(aws).length > 0) overrideToolsSettings.aws = aws;
+	const webFetch = asRecord$1(toolsSettings.web_fetch);
+	if (Object.keys(webFetch).length > 0) overrideToolsSettings.web_fetch = webFetch;
+	if (Object.keys(overrideToolsSettings).length === 0) return void 0;
+	return { toolsSettings: overrideToolsSettings };
+}
 function asStringArray(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -21107,7 +21513,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : load(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Rovodev config at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -21133,7 +21539,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : load(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -21328,9 +21734,9 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const provider = resolveActiveProvider(config);
 		const mode = deriveTaktPermissionMode(rulesyncJson);
-		const override = isPlainObject(rulesyncJson.takt) ? rulesyncJson.takt : void 0;
-		const stepOverrides = isPlainObject(override?.[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? override[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
-		const overrideProviderOptions = isPlainObject(override?.[TAKT_PROVIDER_OPTIONS_KEY]) ? override[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
+		const override = isPlainObject$1(rulesyncJson.takt) ? rulesyncJson.takt : void 0;
+		const stepOverrides = isPlainObject$1(override?.[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? override[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
+		const overrideProviderOptions = isPlainObject$1(override?.[TAKT_PROVIDER_OPTIONS_KEY]) ? override[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
 		const patch = {
 			[TAKT_PROVIDER_PROFILES_KEY]: { [provider]: {
 				[TAKT_DEFAULT_PERMISSION_MODE_KEY]: mode,
@@ -21361,12 +21767,12 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 			invalidRootPolicy: "error"
 		});
 		const provider = resolveActiveProvider(config);
-		const profiles = isPlainObject(config[TAKT_PROVIDER_PROFILES_KEY]) ? config[TAKT_PROVIDER_PROFILES_KEY] : {};
-		const profile = isPlainObject(profiles[provider]) ? profiles[provider] : {};
+		const profiles = isPlainObject$1(config[TAKT_PROVIDER_PROFILES_KEY]) ? config[TAKT_PROVIDER_PROFILES_KEY] : {};
+		const profile = isPlainObject$1(profiles[provider]) ? profiles[provider] : {};
 		const mode = profile[TAKT_DEFAULT_PERMISSION_MODE_KEY];
 		const rulesyncConfig = taktModeToRulesyncConfig(mode);
-		const stepOverrides = isPlainObject(profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
-		const providerOptions = isPlainObject(config[TAKT_PROVIDER_OPTIONS_KEY]) ? config[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
+		const stepOverrides = isPlainObject$1(profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
+		const providerOptions = isPlainObject$1(config[TAKT_PROVIDER_OPTIONS_KEY]) ? config[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
 		const taktOverride = {};
 		if (stepOverrides && Object.keys(stepOverrides).length > 0) taktOverride[TAKT_STEP_PERMISSION_OVERRIDES_KEY] = stepOverrides;
 		if (providerOptions && Object.keys(providerOptions).length > 0) taktOverride[TAKT_PROVIDER_OPTIONS_KEY] = providerOptions;
@@ -21398,7 +21804,7 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 function resolveActiveProvider(config) {
 	if (typeof config[TAKT_PROVIDER_KEY] === "string" && config[TAKT_PROVIDER_KEY].trim() !== "") return config[TAKT_PROVIDER_KEY];
 	const profiles = config[TAKT_PROVIDER_PROFILES_KEY];
-	if (isPlainObject(profiles)) {
+	if (isPlainObject$1(profiles)) {
 		const keys = Object.keys(profiles);
 		if (keys.length === 1) return keys[0];
 	}
@@ -24387,7 +24793,7 @@ function extractOpenaiYamlFile(otherFiles) {
 	const rest = [];
 	for (const file of otherFiles) {
 		if (toPosixPath(file.relativeFilePathToDirPath) === target) try {
-			const loaded = load(file.fileBuffer.toString("utf-8"));
+			const loaded = loadYaml(file.fileBuffer.toString("utf-8"));
 			if (loaded !== null && typeof loaded === "object" && !Array.isArray(loaded)) {
 				parsed = loaded;
 				continue;
@@ -26638,6 +27044,139 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/reasonix-skill.ts
+const ReasonixSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.string()
+});
+/**
+* Represents a DeepSeek-Reasonix skill directory.
+*
+* Reasonix discovers directory-layout skills (`<name>/SKILL.md`) under
+* `.reasonix/skills/` (project) and `~/.reasonix/skills/` (global); the global
+* scope is served by the processor supplying the home directory as outputRoot.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/GUIDE.md
+*/
+var ReasonixSkill = class ReasonixSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = REASONIX_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: REASONIX_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return ReasonixSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (this.mainFile === void 0) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = ReasonixSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const frontmatter = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			targets: ["*"]
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const reasonixFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath: ReasonixSkill.getSettablePaths({ global }).relativeDirPath,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: reasonixFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("reasonix");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: ReasonixSkill.getSettablePaths
+		});
+		const result = ReasonixSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) {
+			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		return new ReasonixSkill({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/constants/replit-paths.ts
 const REPLIT_RULE_FILE_NAME = "replit.md";
 const REPLIT_SKILLS_DIR_PATH = join(".agents", "skills");
@@ -27732,6 +28271,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["replit", {
 		class: ReplitSkill,
 		meta: {
@@ -30015,7 +30562,7 @@ var GooseSubagent = class GooseSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = load(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -31403,7 +31950,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = load(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse .roomodes (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -35596,6 +36143,72 @@ var QwencodeRule = class QwencodeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/reasonix-rule.ts
+var ReasonixRule = class ReasonixRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { root: {
+			relativeDirPath: global ? REASONIX_GLOBAL_DIR : ".",
+			relativeFilePath: REASONIX_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent(join(outputRoot, join(root.relativeDirPath, root.relativeFilePath)));
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: isRoot
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "REASONIX.md" && (relativeDirPath === "." || relativeDirPath === ".reasonix")
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "reasonix"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/replit-rule.ts
 /**
 * Rule generator for Replit Agent
@@ -36508,6 +37121,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			additionalConventions: { subagents: { subagentClass: QwencodeSubagent } }
 		}
 	}],
+	["reasonix", {
+		class: ReasonixRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			foldsNonRootIntoRoot: true
+		}
+	}],
 	["replit", {
 		class: ReplitRule,
 		meta: {
@@ -37393,7 +38015,6 @@ const SHARED_WRITE_FEATURE_ORDER = [
 	"permissions",
 	"rules"
 ];
-const SHARED_WRITE_FEATURES = new Set(SHARED_WRITE_FEATURE_ORDER);
 const TARGETS_NOT_DERIVED = /* @__PURE__ */ new Set(["augmentcode-legacy", "claudecode-legacy"]);
 const sharedFileKey = (path) => {
 	const dir = path.relativeDirPath.replace(/\\/g, "/").replace(/\/$/, "");
@@ -37416,7 +38037,13 @@ const settablePathsForScope = (cls, global) => {
 		paths.push(settable.root);
 		for (const alt of settable.alternativeRoots ?? []) paths.push(alt);
 	}
-	for (const path of cls.getExtraSharedWritePaths?.({ global }) ?? []) if (path.relativeFilePath) paths.push(path);
+	let extra;
+	try {
+		extra = cls.getExtraSharedWritePaths?.({ global }) ?? [];
+	} catch {
+		return paths;
+	}
+	for (const path of extra) if (path.relativeFilePath) paths.push(path);
 	return paths;
 };
 const collectFactoryPaths = (factory) => [...settablePathsForScope(factory.class, false), ...settablePathsForScope(factory.class, true)];
@@ -37429,7 +38056,6 @@ const deriveSharedFileWriters = () => {
 	const byKey = /* @__PURE__ */ new Map();
 	const pathByKey = /* @__PURE__ */ new Map();
 	for (const entry of PROCESSOR_REGISTRY) {
-		if (!SHARED_WRITE_FEATURES.has(entry.feature)) continue;
 		const factories = entry.factory;
 		for (const [tool, factory] of factories) {
 			if (TARGETS_NOT_DERIVED.has(tool)) continue;
@@ -37818,7 +38444,7 @@ async function generateRulesCore(params) {
 		targets: config.getConfigFileTargets(),
 		global: config.getGlobal()
 	}) : /* @__PURE__ */ new Map();
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("rules")) continue;
 		const processor = new RulesProcessor({
 			outputRoot,
@@ -37873,7 +38499,7 @@ async function generateIgnoreCore(params) {
 	let hasDiff = false;
 	for (const toolTarget of intersection(config.getTargets(), supportedIgnoreTargets)) {
 		if (!config.getFeatures(toolTarget).includes("ignore")) continue;
-		for (const outputRoot of config.getOutputRoots()) try {
+		for (const outputRoot of config.getOutputRoots(toolTarget)) try {
 			const processor = new IgnoreProcessor({
 				outputRoot,
 				inputRoot: config.getInputRoot(),
@@ -37914,7 +38540,7 @@ async function generateMcpCore(params) {
 		featureName: "mcp",
 		logger
 	});
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("mcp")) continue;
 		const processor = new McpProcessor({
 			outputRoot,
@@ -37956,7 +38582,7 @@ async function generateCommandsCore(params) {
 		featureName: "commands",
 		logger
 	});
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("commands")) continue;
 		const processor = new CommandsProcessor({
 			outputRoot,
@@ -37998,7 +38624,7 @@ async function generateSubagentsCore(params) {
 		featureName: "subagents",
 		logger
 	});
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("subagents")) continue;
 		const processor = new SubagentsProcessor({
 			outputRoot,
@@ -38041,7 +38667,7 @@ async function generateSkillsCore(params) {
 		featureName: "skills",
 		logger
 	});
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("skills")) continue;
 		const processor = new SkillsProcessor({
 			outputRoot,
@@ -38082,7 +38708,7 @@ async function generateHooksCore(params) {
 		featureName: "hooks",
 		logger
 	});
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of toolTargets) {
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("hooks")) continue;
 		const processor = new HooksProcessor({
 			outputRoot,
@@ -38119,7 +38745,7 @@ async function generatePermissionsCore(params) {
 	let totalCount = 0;
 	const allPaths = [];
 	let hasDiff = false;
-	for (const outputRoot of config.getOutputRoots()) for (const toolTarget of intersection(config.getTargets(), supportedPermissionsTargets)) {
+	for (const toolTarget of intersection(config.getTargets(), supportedPermissionsTargets)) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("permissions")) continue;
 		try {
 			const processor = new PermissionsProcessor({
@@ -38395,6 +39021,6 @@ async function importPermissionsCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { toPosixPath as $, RulesyncCommand as A, createTempDirectory as B, RulesyncHooks as C, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, ALL_FEATURES as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, formatError as Et, ConsoleLogger as F, getFileSize as G, ensureDir as H, JsonLogger as I, listDirectoryFiles as J, getHomeDirectory as K, CLIError as L, stringifyFrontmatter as M, ConfigResolver as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES_WITH_WILDCARD as Ot, findControlCharacter as P, removeTempDirectory as Q, ErrorCodes as R, HooksProcessor as S, RULESYNC_RULES_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Tt, fileExists as U, directoryExists as V, findFilesByGlobs as W, removeDirectory as X, readFileContent as Y, removeFile as Z, RulesyncPermissions as _, RULESYNC_MCP_SCHEMA_URL as _t, convertFromTool as a, RULESYNC_AIIGNORE_FILE_NAME as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_HOOKS_FILE_NAME as dt, writeFileContent as et, SkillsProcessor as f, RULESYNC_HOOKS_RELATIVE_FILE_PATH as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_RELATIVE_FILE_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_MCP_FILE_NAME as ht, getProcessorRegistryEntry as i, MAX_FILE_SIZE as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, SubagentsProcessor as l, RULESYNC_CONFIG_SCHEMA_URL as lt, RulesyncSkill as m, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS_WITH_WILDCARD as nt, RulesProcessor as o, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ot, getLocalSkillDirNames as p, RULESYNC_IGNORE_RELATIVE_FILE_PATH as pt, isSymlink as q, generate as r, ToolTargetSchema as rt, RulesyncRule as s, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as st, importFromTool as t, ALL_TOOL_TARGETS as tt, RulesyncSubagent as u, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ut, McpProcessor as v, RULESYNC_OVERVIEW_FILE_NAME as vt, CommandsProcessor as w, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as wt, RulesyncIgnore as x, RULESYNC_RELATIVE_DIR_PATH as xt, RulesyncMcp as y, RULESYNC_PERMISSIONS_FILE_NAME as yt, checkPathTraversal as z };
+export { removeTempDirectory as $, RulesyncCommand as A, checkPathTraversal as B, RulesyncHooks as C, RULESYNC_RULES_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, formatError as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Et, findControlCharacter as F, findFilesByGlobs as G, directoryExists as H, ConsoleLogger as I, isSymlink as J, getFileSize as K, JsonLogger as L, stringifyFrontmatter as M, loadYaml as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES as Ot, ConfigResolver as P, removeFile as Q, CLIError as R, HooksProcessor as S, RULESYNC_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Tt, ensureDir as U, createTempDirectory as V, fileExists as W, readFileContent as X, listDirectoryFiles as Y, removeDirectory as Z, RulesyncPermissions as _, RULESYNC_MCP_RELATIVE_FILE_PATH as _t, convertFromTool as a, MAX_FILE_SIZE as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_FILE_NAME as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as dt, toPosixPath as et, SkillsProcessor as f, RULESYNC_HOOKS_FILE_NAME as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_FILE_NAME as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ToolTargetSchema as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, ALL_FEATURES_WITH_WILDCARD as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as lt, RulesyncSkill as m, RULESYNC_IGNORE_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS as nt, RulesProcessor as o, RULESYNC_AIIGNORE_FILE_NAME as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_RELATIVE_FILE_PATH as pt, getHomeDirectory as q, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rt, RulesyncRule as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as st, importFromTool as t, writeFileContent as tt, RulesyncSubagent as u, RULESYNC_CONFIG_SCHEMA_URL as ut, McpProcessor as v, RULESYNC_MCP_SCHEMA_URL as vt, CommandsProcessor as w, RULESYNC_SKILLS_RELATIVE_DIR_PATH as wt, RulesyncIgnore as x, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as xt, RulesyncMcp as y, RULESYNC_OVERVIEW_FILE_NAME as yt, ErrorCodes as z };
 
-//# sourceMappingURL=import-BxqZVTKb.js.map
+//# sourceMappingURL=import-B6nwZmGl.js.map