rulesync 9.5.0 → 9.6.1

package/dist/{import-DngV1i49.cjs → import-DW-a1SJq.cjs}

@@ -31,11 +31,11 @@ node_os = __toESM(node_os, 1);
 let es_toolkit = require("es-toolkit");
 let globby = require("globby");
 let node_util = require("node:util");
-let js_yaml = require("js-yaml");
 let smol_toml = require("smol-toml");
 smol_toml = __toESM(smol_toml, 1);
 let gray_matter = require("gray-matter");
 gray_matter = __toESM(gray_matter, 1);
+let js_yaml = require("js-yaml");
 let es_toolkit_object = require("es-toolkit/object");
 let _toon_format_toon = require("@toon-format/toon");
 //#region src/types/features.ts
@@ -114,22 +114,22 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$247 } = node_path.posix;
+const { join: join$249 } = 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$247(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$249(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$247(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$247(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
@@ -167,6 +167,7 @@ const rulesProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -314,6 +315,7 @@ const skillsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -1317,7 +1319,8 @@ var ConfigResolver = class {
 		const validatedConfigPath = resolvePath(configPath, (0, node_path.resolve)(inputRoot ?? cwd));
 		const baseConfig = await loadConfigFromFile(validatedConfigPath);
 		const localConfigPath = (0, node_path.join)((0, node_path.dirname)(validatedConfigPath), RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
-		const configByFile = mergeConfigs(baseConfig, await loadConfigFromFile(localConfigPath));
+		const localConfig = await loadConfigFromFile(localConfigPath);
+		const configByFile = mergeConfigs(baseConfig, localConfig);
 		if (inputRoot === void 0 && configByFile.inputRoot !== void 0) validateOutputRoot(configByFile.inputRoot);
 		assertMergedTargetsFeaturesExclusive({
 			configByFile,
@@ -1450,7 +1453,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;
@@ -1462,11 +1465,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 (0, js_yaml.load)(content);
+	} catch (error) {
+		if (error instanceof js_yaml.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);
@@ -1489,7 +1524,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);
@@ -1512,7 +1547,7 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	const { avoidBlockScalars = false } = options ?? {};
 	const cleanFrontmatter = avoidBlockScalars ? deepFlattenStringsObject(frontmatter) : deepRemoveNullishObject(frontmatter);
 	if (avoidBlockScalars) return gray_matter.default.stringify(body, cleanFrontmatter, { engines: { yaml: {
-		parse: (input) => (0, js_yaml.load)(input) ?? {},
+		parse: (input) => loadYaml(input) ?? {},
 		stringify: (data) => (0, js_yaml.dump)(data, { lineWidth: -1 })
 	} } });
 	return gray_matter.default.stringify(body, cleanFrontmatter);
@@ -1551,7 +1586,7 @@ function tryJsonEquivalent(a, b) {
 }
 function tryYamlEquivalent(a, b) {
 	try {
-		return (0, node_util.isDeepStrictEqual)((0, js_yaml.load)(a), (0, js_yaml.load)(b));
+		return (0, node_util.isDeepStrictEqual)(loadYaml(a), loadYaml(b));
 	} catch {
 		return;
 	}
@@ -2373,14 +2408,17 @@ var AugmentcodeCommand = class AugmentcodeCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const augmentcodeFields = rulesyncFrontmatter.augmentcode ?? {};
+		const augmentcodeFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...augmentcodeFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new AugmentcodeCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...augmentcodeFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: augmentcodeFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -2514,14 +2552,17 @@ var ClaudecodeCommand = class ClaudecodeCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const claudecodeFields = rulesyncFrontmatter.claudecode ?? {};
+		const claudecodeFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...claudecodeFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new ClaudecodeCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...claudecodeFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: claudecodeFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -2722,12 +2763,13 @@ var CodexcliCommand = class CodexcliCommand extends ToolCommand {
 		const paths = this.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const codexcliFields = rulesyncFrontmatter.codexcli ?? {};
+		const codexcliFrontmatter = {
+			...rulesyncFrontmatter.description !== void 0 && { description: rulesyncFrontmatter.description },
+			...codexcliFields
+		};
 		return new CodexcliCommand({
 			outputRoot,
-			frontmatter: {
-				...rulesyncFrontmatter.description !== void 0 && { description: rulesyncFrontmatter.description },
-				...codexcliFields
-			},
+			frontmatter: codexcliFrontmatter,
 			body: rulesyncCommand.getBody(),
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
@@ -2989,14 +3031,17 @@ var CursorCommand = class CursorCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const cursorFields = rulesyncFrontmatter.cursor ?? {};
+		const cursorFrontmatter = {
+			...rulesyncFrontmatter.description && { description: rulesyncFrontmatter.description },
+			...cursorFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new CursorCommand({
 			outputRoot,
-			frontmatter: {
-				...rulesyncFrontmatter.description && { description: rulesyncFrontmatter.description },
-				...cursorFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: cursorFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -3120,14 +3165,17 @@ var DevinCommand = class DevinCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const devinFields = rulesyncFrontmatter.devin ?? {};
+		const devinFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...devinFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new DevinCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...devinFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: devinFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -3241,14 +3289,17 @@ var FactorydroidCommand = class FactorydroidCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const factorydroidFields = rulesyncFrontmatter.factorydroid ?? {};
+		const factorydroidFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...factorydroidFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new FactorydroidCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...factorydroidFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: factorydroidFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -3358,7 +3409,7 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		const where = (0, node_path.join)(this.relativeDirPath, this.relativeFilePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(content);
+			parsed = loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${where}): ${formatError(error)}`, { cause: error });
 		}
@@ -3409,9 +3460,10 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 			prompt,
 			...extraFields
 		};
+		const paths = this.getSettablePaths({ global });
 		return new GooseCommand({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
 			fileContent: (0, js_yaml.dump)(recipe, {
 				lineWidth: -1,
@@ -3452,19 +3504,20 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const placeholder = (0, js_yaml.dump)({
+			version: RECIPE_VERSION$1,
+			title: "",
+			description: "",
+			prompt: ""
+		}, {
+			lineWidth: -1,
+			noRefs: true
+		});
 		return new GooseCommand({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: (0, js_yaml.dump)({
-				version: RECIPE_VERSION$1,
-				title: "",
-				description: "",
-				prompt: ""
-			}, {
-				lineWidth: -1,
-				noRefs: true
-			}),
+			fileContent: placeholder,
 			validate: false
 		});
 	}
@@ -3622,14 +3675,17 @@ var JunieCommand = class JunieCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const junieFields = rulesyncFrontmatter.junie ?? {};
+		const junieFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...junieFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new JunieCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...junieFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: junieFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -3753,14 +3809,17 @@ var KiloCommand = class KiloCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const kiloFields = rulesyncFrontmatter.kilo ?? {};
+		const kiloFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...kiloFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new KiloCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...kiloFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: kiloFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -4012,7 +4071,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;
@@ -4028,14 +4087,14 @@ function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy =
 	const at = filePath === void 0 ? "" : ` at ${filePath}`;
 	let parsed;
 	try {
-		if (format === "yaml") parsed = (0, js_yaml.load)(fileContent);
+		if (format === "yaml") parsed = loadYaml(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
 		else parsed = (0, jsonc_parser.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 {};
 	}
@@ -4078,7 +4137,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
 		});
@@ -4348,14 +4407,17 @@ var OpenCodeCommand = class OpenCodeCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const opencodeFields = rulesyncFrontmatter.opencode ?? {};
+		const opencodeFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...opencodeFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new OpenCodeCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...opencodeFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: opencodeFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -4643,14 +4705,17 @@ var QwencodeCommand = class QwencodeCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const qwencodeFields = rulesyncFrontmatter.qwencode ?? {};
+		const qwencodeFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...qwencodeFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new QwencodeCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...qwencodeFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: qwencodeFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -4712,6 +4777,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 = (0, node_path.join)(REASONIX_DIR, "commands");
+const REASONIX_RULE_FILE_NAME = "REASONIX.md";
+const REASONIX_SKILLS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "skills");
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -4772,14 +4839,17 @@ var ReasonixCommand = class ReasonixCommand extends ToolCommand {
 	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
 		const reasonixFields = rulesyncFrontmatter.reasonix ?? {};
+		const reasonixFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...reasonixFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
 		return new ReasonixCommand({
 			outputRoot,
-			frontmatter: {
-				description: rulesyncFrontmatter.description,
-				...reasonixFields
-			},
-			body: rulesyncCommand.getBody(),
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			frontmatter: reasonixFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
 			validate
 		});
@@ -5077,14 +5147,15 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const paths = this.getSettablePaths({ global });
 		const body = (await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath))).trim();
 		const name = (0, node_path.basename)(relativeFilePath, ".md");
+		const description = await lookupPromptDescription({
+			outputRoot,
+			relativeFilePath,
+			name
+		});
 		return new RovodevCommand({
 			outputRoot,
 			name,
-			description: await lookupPromptDescription({
-				outputRoot,
-				relativeFilePath,
-				name
-			}),
+			description,
 			body,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
@@ -5117,8 +5188,8 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const existingContent = await readFileContentOrNull((0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
 		let existing = {};
 		if (existingContent) try {
-			const parsed = (0, js_yaml.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(),
@@ -5148,11 +5219,11 @@ async function lookupPromptDescription({ outputRoot, relativeFilePath, name }) {
 	if (!manifestContent) return "";
 	let parsed;
 	try {
-		parsed = (0, js_yaml.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((0, node_path.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 : "";
@@ -5283,14 +5354,15 @@ var TaktCommand = class TaktCommand extends ToolCommand {
 		});
 		const relativeFilePath = `${stem}.md`;
 		const paths = this.getSettablePaths({ global });
+		const body = prependTaktExtends({
+			extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
+			body: rulesyncCommand.getBody(),
+			featureLabel: "command",
+			sourceLabel
+		});
 		return new TaktCommand({
 			outputRoot,
-			body: prependTaktExtends({
-				extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
-				body: rulesyncCommand.getBody(),
-				featureLabel: "command",
-				sourceLabel
-			}),
+			body,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
 			validate
@@ -6190,18 +6262,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.
@@ -6637,14 +6716,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.
@@ -6693,6 +6776,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.
 */
@@ -6706,6 +6804,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 },
@@ -6793,6 +6895,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 }
 	};
 }
@@ -7087,7 +7193,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;
@@ -7131,14 +7237,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
@@ -7407,11 +7513,12 @@ var CodexcliConfigToml = class CodexcliConfigToml extends ToolFile {
 		};
 	}
 	static async fromOutputRoot({ outputRoot }) {
+		const fileContent = await buildCodexConfigTomlContent({ outputRoot });
 		return new CodexcliConfigToml({
 			outputRoot,
 			relativeDirPath: CODEXCLI_DIR,
 			relativeFilePath: CODEXCLI_MCP_FILE_NAME,
-			fileContent: await buildCodexConfigTomlContent({ outputRoot })
+			fileContent
 		});
 	}
 };
@@ -8702,15 +8809,16 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 	}
 	static fromRulesyncHooks({ outputRoot, rulesyncHooks, logger }) {
 		const config = rulesyncHooks.getJson();
+		const hermesHooks = canonicalToHermesHooks({
+			config,
+			toolOverrideHooks: config.hermesagent?.hooks,
+			logger
+		});
 		return new HermesagentHooks({
 			outputRoot,
 			fileContent: stringifySharedConfig({
 				format: "yaml",
-				document: { hooks: canonicalToHermesHooks({
-					config,
-					toolOverrideHooks: config.hermesagent?.hooks,
-					logger
-				}) }
+				document: { hooks: hermesHooks }
 			})
 		});
 	}
@@ -8723,7 +8831,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) {
@@ -9759,8 +9874,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 {
@@ -9977,11 +10093,12 @@ var VibeConfigToml = class VibeConfigToml extends ToolFile {
 		};
 	}
 	static async fromOutputRoot({ outputRoot }) {
+		const fileContent = await buildVibeConfigTomlContent({ outputRoot });
 		return new VibeConfigToml({
 			outputRoot,
 			relativeDirPath: VIBE_DIR,
 			relativeFilePath: VIBE_CONFIG_FILE_NAME,
-			fileContent: await buildVibeConfigTomlContent({ outputRoot })
+			fileContent
 		});
 	}
 };
@@ -10758,9 +10875,10 @@ var ClaudecodeIgnore = class ClaudecodeIgnore extends ToolIgnore {
 		this.patterns = jsonValue.permissions?.deny ?? [];
 	}
 	static getSettablePaths(params) {
+		const fileMode = resolveFileMode(params?.options);
 		return {
 			relativeDirPath: CLAUDECODE_DIR,
-			relativeFilePath: fileNameForMode(resolveFileMode(params?.options))
+			relativeFilePath: fileNameForMode(fileMode)
 		};
 	}
 	/**
@@ -10993,11 +11111,12 @@ var DevinIgnore = class DevinIgnore extends ToolIgnore {
 		const primaryPath = (0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath);
 		const legacyPath = (0, node_path.join)(outputRoot, relativeDirPath, DEVIN_LEGACY_IGNORE_FILE_NAME);
 		const resolvedFilePath = !await fileExists(primaryPath) && await fileExists(legacyPath) ? DEVIN_LEGACY_IGNORE_FILE_NAME : relativeFilePath;
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, resolvedFilePath));
 		return new DevinIgnore({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath: resolvedFilePath,
-			fileContent: await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, resolvedFilePath)),
+			fileContent,
 			validate
 		});
 	}
@@ -11839,7 +11958,7 @@ function parseAmpSettingsJsonc(fileContent) {
 		const details = errors.map((error) => `${(0, jsonc_parser.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) {
@@ -12161,7 +12280,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;
 }
 /**
@@ -12387,7 +12506,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;
 }
 /**
@@ -12658,7 +12777,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;
@@ -13299,12 +13418,12 @@ function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
 	let parsed;
 	try {
-		parsed = (0, js_yaml.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;
 }
 /**
@@ -13349,7 +13468,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.
@@ -13364,7 +13483,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);
@@ -13406,9 +13525,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;
@@ -13431,7 +13550,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;
 }
@@ -13731,7 +13850,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;
@@ -13793,10 +13912,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);
@@ -13841,9 +13960,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)) {
@@ -14780,7 +14899,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;
@@ -15012,7 +15133,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;
 }
 /**
@@ -16283,15 +16404,123 @@ const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 	enableTerminalSandbox: zod_mini.z.optional(zod_mini.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 = 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() })
+}))) });
+/**
+* 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 = 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()))
+	}))
+})) });
+/**
+* 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 = zod_mini.z.looseObject({
+	approval_policy: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
+	sandbox_mode: zod_mini.z.optional(zod_mini.z.string()),
+	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})]))
+});
+/**
 * 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
 * {
@@ -16315,7 +16544,10 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	junie: zod_mini.z.optional(JuniePermissionsOverrideSchema),
 	takt: zod_mini.z.optional(TaktPermissionsOverrideSchema),
 	amp: zod_mini.z.optional(AmpPermissionsOverrideSchema),
-	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema)
+	"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)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16467,7 +16699,7 @@ function parseAmpSettings(fileContent) {
 		const details = errors.map((error) => `${(0, jsonc_parser.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) {
@@ -16494,7 +16726,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;
@@ -16502,7 +16734,7 @@ function toPermissionsList(value) {
 			...raw,
 			tool,
 			action,
-			...isPlainObject(raw.matches) ? { matches: raw.matches } : {}
+			...isPlainObject$1(raw.matches) ? { matches: raw.matches } : {}
 		});
 	}
 	return entries;
@@ -17362,6 +17594,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.
 */
@@ -17492,12 +17773,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) => {
@@ -17508,7 +17795,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]
@@ -17532,11 +17823,14 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse AugmentCode permissions content in ${(0, node_path.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 {
@@ -17670,10 +17964,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);
@@ -18105,6 +18396,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 {
@@ -18146,6 +18444,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,
@@ -18170,7 +18473,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 {
@@ -18362,6 +18670,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 = {};
@@ -18529,7 +18861,11 @@ function toCursorPattern(canonical, pattern) {
 function toCanonicalCategory$1(cursorType, pattern) {
 	if (cursorType === "Mcp") {
 		const match = pattern.match(/^([^:()]+):([^:()]+)$/);
-		if (match) return `${MCP_CANONICAL_PREFIX$1}${match[1] ?? "*"}__${match[2] ?? "*"}`;
+		if (match) {
+			const server = match[1] ?? "*";
+			const tool = match[2] ?? "*";
+			return `${MCP_CANONICAL_PREFIX$1}${server}__${tool}`;
+		}
 		return CURSOR_TYPE_TO_CANONICAL[cursorType] ?? cursorType.toLowerCase();
 	}
 	return CURSOR_TYPE_TO_CANONICAL[cursorType] ?? cursorType.toLowerCase();
@@ -19276,7 +19612,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : (0, js_yaml.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 });
 		}
@@ -19298,7 +19634,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : (0, js_yaml.load)(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -20205,6 +20541,13 @@ const KiroAgentSchema = zod_mini.z.looseObject({
 	toolsSettings: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown()))
 });
 const UnknownRecordSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.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 {
@@ -20268,7 +20611,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 {
@@ -20318,19 +20664,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 ?? [],
@@ -20350,6 +20748,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") : [];
 }
@@ -21162,7 +21585,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : (0, js_yaml.load)(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Rovodev config at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -21188,7 +21611,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : (0, js_yaml.load)(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -21383,9 +21806,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,
@@ -21416,12 +21839,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;
@@ -21453,7 +21876,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];
 	}
@@ -22785,13 +23208,15 @@ var AgentsmdSkill = class AgentsmdSkill extends SimulatedSkill {
 		return { relativeDirPath: AGENTSMD_SKILLS_DIR_PATH };
 	}
 	static async fromDir(params) {
-		return new AgentsmdSkill(await this.fromDirDefault(params));
+		const baseParams = await this.fromDirDefault(params);
+		return new AgentsmdSkill(baseParams);
 	}
 	static fromRulesyncSkill(params) {
-		return new AgentsmdSkill({
+		const baseParams = {
 			...this.fromRulesyncSkillDefault(params),
 			relativeDirPath: this.getSettablePaths().relativeDirPath
-		});
+		};
+		return new AgentsmdSkill(baseParams);
 	}
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		return this.isTargetedByRulesyncSkillDefault({
@@ -22800,7 +23225,8 @@ var AgentsmdSkill = class AgentsmdSkill extends SimulatedSkill {
 		});
 	}
 	static forDeletion(params) {
-		return new AgentsmdSkill(this.forDeletionDefault(params));
+		const baseParams = this.forDeletionDefault(params);
+		return new AgentsmdSkill(baseParams);
 	}
 };
 const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
@@ -24207,9 +24633,10 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 			})
 		});
 		const settablePaths = ClaudecodeSkill.getSettablePaths({ global });
+		const relativeDirPath = rulesyncFrontmatter.claudecode?.["scheduled-task"] ? CLAUDECODE_SCHEDULED_TASKS_DIR_PATH : settablePaths.relativeDirPath;
 		return new ClaudecodeSkill({
 			outputRoot,
-			relativeDirPath: rulesyncFrontmatter.claudecode?.["scheduled-task"] ? CLAUDECODE_SCHEDULED_TASKS_DIR_PATH : settablePaths.relativeDirPath,
+			relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
 			frontmatter: claudecodeFrontmatter,
 			body: rulesyncSkill.getBody(),
@@ -24442,7 +24869,7 @@ function extractOpenaiYamlFile(otherFiles) {
 	const rest = [];
 	for (const file of otherFiles) {
 		if (toPosixPath(file.relativeFilePathToDirPath) === target) try {
-			const loaded = (0, js_yaml.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;
@@ -25998,9 +26425,10 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 			...kiloSection?.compatibility !== void 0 && { compatibility: kiloSection.compatibility },
 			...kiloSection?.metadata !== void 0 && { metadata: kiloSection.metadata }
 		};
+		const settablePaths = KiloSkill.getSettablePaths({ global });
 		return new KiloSkill({
 			outputRoot,
-			relativeDirPath: KiloSkill.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
 			frontmatter: kiloFrontmatter,
 			body: rulesyncSkill.getBody(),
@@ -26323,9 +26751,10 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			...metadata !== void 0 && { metadata },
 			...opencodeSection?.["allowed-tools"] !== void 0 && { "allowed-tools": opencodeSection["allowed-tools"] }
 		};
+		const settablePaths = OpenCodeSkill.getSettablePaths({ global });
 		return new OpenCodeSkill({
 			outputRoot,
-			relativeDirPath: OpenCodeSkill.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
 			frontmatter: opencodeFrontmatter,
 			body: rulesyncSkill.getBody(),
@@ -26640,9 +27069,10 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
+		const settablePaths = QwencodeSkill.getSettablePaths({ global });
 		return new QwencodeSkill({
 			outputRoot,
-			relativeDirPath: QwencodeSkill.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
 			frontmatter: qwencodeFrontmatter,
 			body: rulesyncSkill.getBody(),
@@ -26693,6 +27123,140 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/reasonix-skill.ts
+const ReasonixSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.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
+		};
+		const settablePaths = ReasonixSkill.getSettablePaths({ global });
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath: settablePaths.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 = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.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 = (0, node_path.join)(".agents", "skills");
@@ -27061,17 +27625,20 @@ var TaktSkill = class TaktSkill extends ToolSkill {
 			featureLabel: "skill",
 			sourceLabel
 		});
+		const fileName = `${stem}.md`;
+		const relativeDirPath = TAKT_SKILLS_DIR_PATH;
+		const body = prependTaktExtends({
+			extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
+			body: rulesyncSkill.getBody(),
+			featureLabel: "skill",
+			sourceLabel
+		});
 		return new TaktSkill({
 			outputRoot,
-			relativeDirPath: TAKT_SKILLS_DIR_PATH,
+			relativeDirPath,
 			dirName: stem,
-			fileName: `${stem}.md`,
-			body: prependTaktExtends({
-				extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
-				body: rulesyncSkill.getBody(),
-				featureLabel: "skill",
-				sourceLabel
-			}),
+			fileName,
+			body,
 			otherFiles: rulesyncSkill.getOtherFiles(),
 			validate,
 			global
@@ -27369,9 +27936,10 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description
 		};
+		const settablePaths = WarpSkill.getSettablePaths({ global });
 		return new WarpSkill({
 			outputRoot,
-			relativeDirPath: WarpSkill.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
 			frontmatter: warpFrontmatter,
 			body: rulesyncSkill.getBody(),
@@ -27787,6 +28355,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["replit", {
 		class: ReplitSkill,
 		meta: {
@@ -28180,10 +28756,12 @@ var AgentsmdSubagent = class AgentsmdSubagent extends SimulatedSubagent {
 		return { relativeDirPath: AGENTSMD_SUBAGENTS_DIR_PATH };
 	}
 	static async fromFile(params) {
-		return new AgentsmdSubagent(await this.fromFileDefault(params));
+		const baseParams = await this.fromFileDefault(params);
+		return new AgentsmdSubagent(baseParams);
 	}
 	static fromRulesyncSubagent(params) {
-		return new AgentsmdSubagent(this.fromRulesyncSubagentDefault(params));
+		const baseParams = this.fromRulesyncSubagentDefault(params);
+		return new AgentsmdSubagent(baseParams);
 	}
 	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
 		return this.isTargetedByRulesyncSubagentDefault({
@@ -28348,11 +28926,12 @@ var QwencodeSubagent = class QwencodeSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, qwencodeSubagentFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new QwencodeSubagent({
 			outputRoot,
 			frontmatter: qwencodeSubagentFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -28476,11 +29055,12 @@ var RovodevSubagent = class RovodevSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, rovodevFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new RovodevSubagent({
 			outputRoot,
 			frontmatter: rovodevFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -28611,11 +29191,12 @@ var AugmentcodeSubagent = class AugmentcodeSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, augmentcodeFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new AugmentcodeSubagent({
 			outputRoot,
 			frontmatter: augmentcodeFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -28750,11 +29331,12 @@ var ClaudecodeSubagent = class ClaudecodeSubagent extends ToolSubagent {
 		const claudecodeFrontmatter = result.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, claudecodeFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new ClaudecodeSubagent({
 			outputRoot,
 			frontmatter: claudecodeFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate
@@ -28880,11 +29462,12 @@ var ClineSubagent = class ClineSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, clineFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new ClineSubagent({
 			outputRoot,
 			frontmatter: clineFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath().replace(/\.md$/, ".yaml"),
 			fileContent,
 			validate,
@@ -29150,7 +29733,8 @@ var CopilotSubagent = class CopilotSubagent extends ToolSubagent {
 		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
 		const copilotSection = rulesyncFrontmatter.copilot ?? {};
 		const toolsField = copilotSection.tools;
-		const mergedTools = ensureRequiredTool(normalizeTools(Array.isArray(toolsField) || typeof toolsField === "string" ? toolsField : void 0));
+		const userTools = normalizeTools(Array.isArray(toolsField) || typeof toolsField === "string" ? toolsField : void 0);
+		const mergedTools = ensureRequiredTool(userTools);
 		const copilotFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
@@ -29159,11 +29743,12 @@ var CopilotSubagent = class CopilotSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new CopilotSubagent({
 			outputRoot,
 			frontmatter: copilotFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: toCopilotAgentFilePath(rulesyncSubagent.getRelativeFilePath()),
 			fileContent,
 			validate,
@@ -29336,11 +29921,12 @@ var CopilotcliSubagent = class CopilotcliSubagent extends ToolSubagent {
 		const copilotCliFrontmatter = result.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, copilotCliFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new CopilotcliSubagent({
 			outputRoot,
 			frontmatter: copilotCliFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: toCopilotCliAgentFilePath(rulesyncSubagent.getRelativeFilePath()),
 			fileContent,
 			validate,
@@ -29454,11 +30040,12 @@ var CursorSubagent = class CursorSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, cursorFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new CursorSubagent({
 			outputRoot,
 			frontmatter: cursorFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -29892,11 +30479,12 @@ var FactorydroidSubagent = class FactorydroidSubagent extends ToolSubagent {
 		const factorydroidFrontmatter = result.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, factorydroidFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new FactorydroidSubagent({
 			outputRoot,
 			frontmatter: factorydroidFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -30034,10 +30622,11 @@ var GooseSubagent = class GooseSubagent extends ToolSubagent {
 			instructions,
 			...extraFields
 		};
+		const paths = this.getSettablePaths({ global });
 		return new GooseSubagent({
 			outputRoot,
 			recipe,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
 			fileContent: (0, js_yaml.dump)(recipe, {
 				lineWidth: -1,
@@ -30070,7 +30659,7 @@ var GooseSubagent = class GooseSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -30172,11 +30761,12 @@ var GrokcliSubagent = class GrokcliSubagent extends ToolSubagent {
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, grokcliSubagentFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
 		return new GrokcliSubagent({
 			outputRoot,
 			frontmatter: grokcliSubagentFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -30412,9 +31002,10 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 	}
 	static fromRulesyncSubagent({ rulesyncSubagent, outputRoot }) {
 		const spec = getSubagentSpec(rulesyncSubagent);
+		const slug = String(spec.slug);
 		return new HermesagentSubagent({
 			relativeDirPath: HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH,
-			relativeFilePath: `${String(spec.slug)}.json`,
+			relativeFilePath: `${slug}.json`,
 			fileContent: `${JSON.stringify(spec, null, 2)}\n`,
 			outputRoot
 		});
@@ -30548,11 +31139,12 @@ var JunieSubagent = class JunieSubagent extends ToolSubagent {
 		const junieFrontmatter = result.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, junieFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new JunieSubagent({
 			outputRoot,
 			frontmatter: junieFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -30743,11 +31335,12 @@ var KiloSubagent = class KiloSubagent extends OpenCodeStyleSubagent {
 		const kiloFrontmatter = parseResult.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, kiloFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new KiloSubagent({
 			outputRoot,
 			frontmatter: kiloFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -31019,11 +31612,12 @@ var KiroIdeSubagent = class KiroIdeSubagent extends ToolSubagent {
 		const frontmatter = result.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, frontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new KiroIdeSubagent({
 			outputRoot,
 			frontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -31167,11 +31761,12 @@ var OpenCodeSubagent = class OpenCodeSubagent extends OpenCodeStyleSubagent {
 		const opencodeFrontmatter = parseResult.data;
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, opencodeFrontmatter);
+		const paths = this.getSettablePaths({ global });
 		return new OpenCodeSubagent({
 			outputRoot,
 			frontmatter: opencodeFrontmatter,
 			body,
-			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
 			fileContent,
 			validate,
@@ -31458,7 +32053,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse .roomodes (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -32460,11 +33055,12 @@ var AiassistantRule = class AiassistantRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
 		const relativeDirPath = this.getSettablePaths().nonRoot.relativeDirPath;
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
 		return new AiassistantRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: (await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath))).trim(),
+			fileContent: fileContent.trim(),
 			validate,
 			root: false
 		});
@@ -32565,13 +33161,14 @@ var AmpRule = class AmpRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new AmpRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -32654,13 +33251,14 @@ var AntigravityCliRule = class AntigravityCliRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new AntigravityCliRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -33074,13 +33672,14 @@ var AugmentcodeLegacyRule = class AugmentcodeLegacyRule extends ToolRule {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
 		return new AugmentcodeLegacyRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths().root.relativeFilePath
+			root: isRoot
 		});
 	}
 };
@@ -33316,13 +33915,14 @@ var ClaudecodeLegacyRule = class ClaudecodeLegacyRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new ClaudecodeLegacyRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -33421,6 +34021,7 @@ var ClaudecodeRule = class ClaudecodeRule extends ToolRule {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new ClaudecodeRule({
 			outputRoot,
 			relativeDirPath,
@@ -33428,7 +34029,7 @@ var ClaudecodeRule = class ClaudecodeRule extends ToolRule {
 			frontmatter: {},
 			body: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
@@ -33944,6 +34545,13 @@ var CopilotRule = class CopilotRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		const isRoot = sameRelativePath({
+			dir: relativeDirPath,
+			file: relativeFilePath
+		}, {
+			dir: paths.root.relativeDirPath,
+			file: paths.root.relativeFilePath
+		});
 		return new CopilotRule({
 			outputRoot,
 			relativeDirPath,
@@ -33951,13 +34559,7 @@ var CopilotRule = class CopilotRule extends ToolRule {
 			frontmatter: {},
 			body: "",
 			validate: false,
-			root: sameRelativePath({
-				dir: relativeDirPath,
-				file: relativeFilePath
-			}, {
-				dir: paths.root.relativeDirPath,
-				file: paths.root.relativeFilePath
-			})
+			root: isRoot
 		});
 	}
 	validate() {
@@ -34621,13 +35223,14 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath === paths.root.relativeDirPath;
 		return new FactorydroidRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === paths.root.relativeFilePath && relativeDirPath === paths.root.relativeDirPath
+			root: isRoot
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
@@ -34723,13 +35326,14 @@ var GooseRule = class GooseRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && (relativeDirPath === "." || relativeDirPath === paths.root.relativeDirPath);
 		return new GooseRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === paths.root.relativeFilePath && (relativeDirPath === "." || relativeDirPath === paths.root.relativeDirPath)
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -34933,11 +35537,12 @@ var JunieRule = class JunieRule extends ToolRule {
 		const settablePaths = this.getSettablePaths();
 		if (!settablePaths.nonRoot) throw new Error("JunieRule project settable paths must include a nonRoot path");
 		const relativeDirPath = isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath;
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(relativeDirPath, relativeFilePath)));
 		return new JunieRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(relativeDirPath, relativeFilePath))),
+			fileContent,
 			validate,
 			root: isRoot
 		});
@@ -34972,13 +35577,14 @@ var JunieRule = class JunieRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const isRoot = JunieRule.isRootRelativeFilePath(relativeFilePath);
 		return new JunieRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: JunieRule.isRootRelativeFilePath(relativeFilePath)
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -35052,13 +35658,14 @@ var KiloRule = class KiloRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new KiloRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -35147,11 +35754,12 @@ var KiroRule = class KiroRule extends ToolRule {
 		const paths = this.getSettablePaths({ global });
 		const isRoot = "root" in paths && relativeFilePath === paths.root.relativeFilePath;
 		const relativeDirPath = paths.nonRoot?.relativeDirPath ?? buildToolPath(".kiro", "steering");
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
 		return new KiroRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			root: isRoot
 		});
@@ -35326,13 +35934,14 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new OpenCodeRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -35417,13 +36026,14 @@ var PiRule = class PiRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		const { root } = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === root.relativeDirPath);
 		return new PiRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === root.relativeDirPath)
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -35651,6 +36261,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((0, node_path.join)(outputRoot, (0, node_path.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
@@ -35701,13 +36377,14 @@ var ReplitRule = class ReplitRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
 		return new ReplitRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths().root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -35858,11 +36535,12 @@ var RovodevRule = class RovodevRule extends ToolRule {
 	}
 	static async fromModularFile({ outputRoot, relativeFilePath, relativeDirPath, validate, global }) {
 		if (!this.isAllowedModularRulesRelativePath(relativeFilePath)) throw new Error(`Reserved Rovodev memory basename under modular-rules (not a modular rule): ${(0, node_path.join)(relativeDirPath, relativeFilePath)}`);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
 		return new RovodevRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			global,
 			root: false
@@ -35873,11 +36551,12 @@ var RovodevRule = class RovodevRule extends ToolRule {
 		const agentsMdExpectedLocationsDescription = "alternativeRoots" in paths && paths.alternativeRoots && paths.alternativeRoots.length > 0 ? `${(0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath)} or project root` : (0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath);
 		if (relativeFilePath !== "AGENTS.md") throw new Error(`Rovodev rules support only AGENTS.md at ${agentsMdExpectedLocationsDescription}, got: ${(0, node_path.join)(relativeDirPath, relativeFilePath)}`);
 		if (!(relativeDirPath === paths.root.relativeDirPath || "alternativeRoots" in paths && paths.alternativeRoots?.some((alt) => alt.relativeDirPath === relativeDirPath && alt.relativeFilePath === relativeFilePath))) throw new Error(`Rovodev AGENTS.md must be at ${agentsMdExpectedLocationsDescription}, got: ${(0, node_path.join)(relativeDirPath, relativeFilePath)}`);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
 		return new RovodevRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			global,
 			root: true
@@ -36068,16 +36747,18 @@ var TaktRule = class TaktRule extends ToolRule {
 			sourceLabel
 		});
 		const relativeFilePath = `${stem}.md`;
+		const relativeDirPath = resolveTaktRuleFacet(taktSection?.facet) === "output-contracts" ? TAKT_OUTPUT_CONTRACTS_DIR_PATH : TAKT_RULES_DIR_PATH;
+		const body = prependTaktExtends({
+			extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
+			body: rulesyncRule.getBody(),
+			featureLabel: "rule",
+			sourceLabel
+		});
 		return new TaktRule({
 			outputRoot,
-			relativeDirPath: resolveTaktRuleFacet(taktSection?.facet) === "output-contracts" ? TAKT_OUTPUT_CONTRACTS_DIR_PATH : TAKT_RULES_DIR_PATH,
+			relativeDirPath,
 			relativeFilePath,
-			body: prependTaktExtends({
-				extendsName: typeof taktSection?.extends === "string" ? taktSection.extends : void 0,
-				body: rulesyncRule.getBody(),
-				featureLabel: "rule",
-				sourceLabel
-			}),
+			body,
 			validate,
 			root: false
 		});
@@ -36145,13 +36826,14 @@ var VibeRule = class VibeRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new VibeRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -36213,13 +36895,14 @@ var WarpRule = class WarpRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
 		const { root } = this.getSettablePaths();
+		const isRoot = relativeFilePath === root.relativeFilePath && relativeDirPath === root.relativeDirPath;
 		return new WarpRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === root.relativeFilePath && relativeDirPath === root.relativeDirPath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -36284,13 +36967,14 @@ var ZedRule = class ZedRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
 		return new ZedRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -36563,6 +37247,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: {
@@ -37007,19 +37700,24 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const localRootToolRules = await (async () => {
 				if (!forDeletion || this.global || factory.meta.localRootMode !== "separate-local-file" || !factory.meta.localRootFileName) return [];
 				const fileName = factory.meta.localRootFileName;
-				if (factory.class.getLocalRootDeletionGlob) return buildDeletionRulesFromPaths(await findFilesByGlobs(factory.class.getLocalRootDeletionGlob({
-					outputRoot: this.outputRoot,
-					fileName
-				})));
+				if (factory.class.getLocalRootDeletionGlob) {
+					const filePaths = await findFilesByGlobs(factory.class.getLocalRootDeletionGlob({
+						outputRoot: this.outputRoot,
+						fileName
+					}));
+					return buildDeletionRulesFromPaths(filePaths);
+				}
 				if (!settablePaths.root) return [];
-				return buildDeletionRulesFromPaths(await findFilesWithFallback((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName)));
+				const filePaths = await findFilesWithFallback((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName));
+				return buildDeletionRulesFromPaths(filePaths);
 			})();
 			this.logger.debug(`Found ${localRootToolRules.length} local root tool rule files for deletion`);
 			const rootMirrorDeletionRules = await (async () => {
 				if (!forDeletion || this.global || !factory.meta.mirrorsRootToAgentsMd || !factory.class.getRootMirrorDeletionGlobs) return [];
 				const { primaryGlob, mirrorGlob } = factory.class.getRootMirrorDeletionGlobs({ outputRoot: this.outputRoot });
 				if ((await findFilesByGlobs(primaryGlob)).length === 0) return [];
-				return buildDeletionRulesFromPaths(await findFilesByGlobs(mirrorGlob));
+				const mirrorPaths = await findFilesByGlobs(mirrorGlob);
+				return buildDeletionRulesFromPaths(mirrorPaths);
 			})();
 			const nonRootToolRules = await (async () => {
 				if (!settablePaths.nonRoot) return [];
@@ -37448,7 +38146,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(/\/$/, "");
@@ -37471,7 +38168,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)];
@@ -37484,7 +38187,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;
@@ -38906,6 +39608,12 @@ Object.defineProperty(exports, "listDirectoryFiles", {
 		return listDirectoryFiles;
 	}
 });
+Object.defineProperty(exports, "loadYaml", {
+	enumerable: true,
+	get: function() {
+		return loadYaml;
+	}
+});
 Object.defineProperty(exports, "readFileContent", {
 	enumerable: true,
 	get: function() {