rulesync 9.5.0 → 9.6.1

package/dist/{import-BdJG1fyb.js → import-tTMN0WRi.js}

@@ -7,9 +7,9 @@ import os from "node:os";
 import { intersection, kebabCase, uniq } from "es-toolkit";
 import { globbySync } from "globby";
 import { isDeepStrictEqual } from "node:util";
-import { dump, load } from "js-yaml";
 import * as smolToml from "smol-toml";
 import matter from "gray-matter";
+import { YAMLException, dump, load } from "js-yaml";
 import { omit } from "es-toolkit/object";
 import { encode } from "@toon-format/toon";
 //#region src/types/features.ts
@@ -141,6 +141,7 @@ const rulesProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -288,6 +289,7 @@ const skillsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -1291,7 +1293,8 @@ var ConfigResolver = class {
 		const validatedConfigPath = resolvePath(configPath, resolve(inputRoot ?? cwd));
 		const baseConfig = await loadConfigFromFile(validatedConfigPath);
 		const localConfigPath = join(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,
@@ -1424,7 +1427,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;
@@ -1436,11 +1439,43 @@ function isStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 //#endregion
+//#region src/utils/yaml.ts
+/**
+* js-yaml v5's `reason` for an empty document. `load("")` — and any
+* whitespace/comment-only input — throws a `YAMLException` with this reason
+* instead of returning `undefined` the way v4 did.
+*/
+const EMPTY_INPUT_REASON = "expected a document, but the input is empty";
+/**
+* Load YAML content while preserving js-yaml v4's behavior of returning
+* `undefined` for empty documents (empty, whitespace-only, or comment-only
+* input).
+*
+* js-yaml v5 changed `load("")` to **throw** ("expected a document, but the
+* input is empty") instead of returning `undefined`. Many call sites here parse
+* config/lock/frontmatter files that can legitimately be empty and rely on the
+* old `undefined` sentinel (`load(input) ?? {}`, `if (loaded === undefined)`,
+* "an empty file parses to undefined/null"). Routing every load through this
+* wrapper keeps that contract in one place so a future js-yaml bump cannot
+* reintroduce the empty-input regression. Genuine parse errors still propagate.
+*
+* @see https://github.com/nodeca/js-yaml/blob/master/docs/migrate_v4_to_v5.md#empty-input-throws
+*/
+function loadYaml(content) {
+	if (content.trim() === "") return;
+	try {
+		return load(content);
+	} catch (error) {
+		if (error instanceof YAMLException && error.reason === EMPTY_INPUT_REASON) return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/utils/frontmatter.ts
 function deepRemoveNullishValue(value) {
 	if (value === null || value === void 0) return;
 	if (Array.isArray(value)) return value.map((item) => deepRemoveNullishValue(item)).filter((item) => item !== void 0);
-	if (isPlainObject(value)) {
+	if (isPlainObject$1(value)) {
 		const result = {};
 		for (const [key, val] of Object.entries(value)) {
 			const cleaned = deepRemoveNullishValue(val);
@@ -1463,7 +1498,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);
@@ -1486,7 +1521,7 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	const { avoidBlockScalars = false } = options ?? {};
 	const cleanFrontmatter = avoidBlockScalars ? deepFlattenStringsObject(frontmatter) : deepRemoveNullishObject(frontmatter);
 	if (avoidBlockScalars) return matter.stringify(body, cleanFrontmatter, { engines: { yaml: {
-		parse: (input) => load(input) ?? {},
+		parse: (input) => loadYaml(input) ?? {},
 		stringify: (data) => dump(data, { lineWidth: -1 })
 	} } });
 	return matter.stringify(body, cleanFrontmatter);
@@ -1525,7 +1560,7 @@ function tryJsonEquivalent(a, b) {
 }
 function tryYamlEquivalent(a, b) {
 	try {
-		return isDeepStrictEqual(load(a), load(b));
+		return isDeepStrictEqual(loadYaml(a), loadYaml(b));
 	} catch {
 		return;
 	}
@@ -2347,14 +2382,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
 		});
@@ -2488,14 +2526,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
 		});
@@ -2696,12 +2737,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(),
@@ -2963,14 +3005,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
 		});
@@ -3094,14 +3139,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
 		});
@@ -3215,14 +3263,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
 		});
@@ -3332,7 +3383,7 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		const where = join(this.relativeDirPath, this.relativeFilePath);
 		let parsed;
 		try {
-			parsed = load(content);
+			parsed = loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${where}): ${formatError(error)}`, { cause: error });
 		}
@@ -3383,9 +3434,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: dump(recipe, {
 				lineWidth: -1,
@@ -3426,19 +3478,20 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const placeholder = dump({
+			version: RECIPE_VERSION$1,
+			title: "",
+			description: "",
+			prompt: ""
+		}, {
+			lineWidth: -1,
+			noRefs: true
+		});
 		return new GooseCommand({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: dump({
-				version: RECIPE_VERSION$1,
-				title: "",
-				description: "",
-				prompt: ""
-			}, {
-				lineWidth: -1,
-				noRefs: true
-			}),
+			fileContent: placeholder,
 			validate: false
 		});
 	}
@@ -3595,14 +3648,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
 		});
@@ -3726,14 +3782,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
 		});
@@ -3985,7 +4044,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;
@@ -4001,14 +4060,14 @@ function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy =
 	const at = filePath === void 0 ? "" : ` at ${filePath}`;
 	let parsed;
 	try {
-		if (format === "yaml") parsed = load(fileContent);
+		if (format === "yaml") parsed = loadYaml(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
 		else parsed = parse(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse shared config${at}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) {
+	if (!isPlainObject$1(parsed)) {
 		if (invalidRootPolicy === "error") throw new Error(`Failed to parse shared config${at}: expected a mapping at the root`);
 		return {};
 	}
@@ -4051,7 +4110,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
 		});
@@ -4321,14 +4380,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
 		});
@@ -4616,14 +4678,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
 		});
@@ -4685,6 +4750,8 @@ const REASONIX_GLOBAL_PERMISSIONS_FILE_NAME = REASONIX_GLOBAL_MCP_FILE_NAME;
 const REASONIX_DIR = REASONIX_GLOBAL_DIR;
 const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = join(REASONIX_DIR, "commands");
+const REASONIX_RULE_FILE_NAME = "REASONIX.md";
+const REASONIX_SKILLS_DIR_PATH = join(REASONIX_DIR, "skills");
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -4745,14 +4812,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
 		});
@@ -5050,14 +5120,15 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const paths = this.getSettablePaths({ global });
 		const body = (await readFileContent(join(outputRoot, paths.relativeDirPath, relativeFilePath))).trim();
 		const name = 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,
@@ -5090,8 +5161,8 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const existingContent = await readFileContentOrNull(join(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
 		let existing = {};
 		if (existingContent) try {
-			const parsed = load(existingContent);
-			if (isPlainObject(parsed)) existing = parsed;
+			const parsed = loadYaml(existingContent);
+			if (isPlainObject$1(parsed)) existing = parsed;
 		} catch {}
 		const prompts = rovodevCommands.map((command) => ({
 			name: command.getName(),
@@ -5121,11 +5192,11 @@ async function lookupPromptDescription({ outputRoot, relativeFilePath, name }) {
 	if (!manifestContent) return "";
 	let parsed;
 	try {
-		parsed = load(manifestContent);
+		parsed = loadYaml(manifestContent);
 	} catch {
 		return "";
 	}
-	if (!isPlainObject(parsed) || !Array.isArray(parsed.prompts)) return "";
+	if (!isPlainObject$1(parsed) || !Array.isArray(parsed.prompts)) return "";
 	const expectedContentFile = toPosixPath(join("prompts", relativeFilePath));
 	const entry = parsed.prompts.find((candidate) => isRecord(candidate) && (candidate.content_file === expectedContentFile || candidate.name === name));
 	return isRecord(entry) && typeof entry.description === "string" ? entry.description : "";
@@ -5256,14 +5327,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
@@ -6163,18 +6235,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.
@@ -6610,14 +6689,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.
@@ -6666,6 +6749,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.
 */
@@ -6679,6 +6777,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 },
@@ -6766,6 +6868,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 }
 	};
 }
@@ -7060,7 +7166,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;
@@ -7104,14 +7210,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
@@ -7380,11 +7486,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
 		});
 	}
 };
@@ -8675,15 +8782,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 }
 			})
 		});
 	}
@@ -8696,7 +8804,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) {
@@ -9732,8 +9847,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 {
@@ -9950,11 +10066,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
 		});
 	}
 };
@@ -10731,9 +10848,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)
 		};
 	}
 	/**
@@ -10966,11 +11084,12 @@ var DevinIgnore = class DevinIgnore extends ToolIgnore {
 		const primaryPath = join(outputRoot, relativeDirPath, relativeFilePath);
 		const legacyPath = 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(join(outputRoot, relativeDirPath, resolvedFilePath));
 		return new DevinIgnore({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath: resolvedFilePath,
-			fileContent: await readFileContent(join(outputRoot, relativeDirPath, resolvedFilePath)),
+			fileContent,
 			validate
 		});
 	}
@@ -11812,7 +11931,7 @@ function parseAmpSettingsJsonc(fileContent) {
 		const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function filterMcpServers(mcpServers) {
@@ -12134,7 +12253,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;
 }
 /**
@@ -12360,7 +12479,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;
 }
 /**
@@ -12631,7 +12750,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;
@@ -13272,12 +13391,12 @@ function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = join(relativeDirPath, relativeFilePath);
 	let parsed;
 	try {
-		parsed = load(fileContent);
+		parsed = loadYaml(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse Goose config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
 	return parsed;
 }
 /**
@@ -13322,7 +13441,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.
@@ -13337,7 +13456,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);
@@ -13379,9 +13498,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;
@@ -13404,7 +13523,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;
 }
@@ -13704,7 +13823,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;
@@ -13766,10 +13885,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);
@@ -13814,9 +13933,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)) {
@@ -14753,7 +14872,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;
@@ -14985,7 +15106,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;
 }
 /**
@@ -16256,15 +16377,123 @@ const AntigravityCliPermissionsOverrideSchema = z.looseObject({
 	enableTerminalSandbox: z.optional(z.boolean())
 });
 /**
+* Tool-scoped override block for AugmentCode. AugmentCode's `toolPermissions[]`
+* array supports "custom policy" entries the canonical allow/ask/deny model
+* cannot express: `permission.type` of `webhook-policy` / `script-policy`
+* (delegating the decision to a `webhookUrl` / `script`) and an `eventType` of
+* `tool-response` (a post-execution check rather than the default pre-execution
+* `tool-call`). These are authored here as verbatim `toolPermissions` entries
+* and prepended — ahead of the canonical-generated basic rules — into the shared
+* `.augment/settings.json`, so a webhook/script gate or tool-response check is
+* never shadowed by a regenerated allow/deny/ask entry under AugmentCode's
+* first-match-wins evaluation. The shared `permission` block continues to drive
+* the basic `allow` / `deny` / `ask-user` entries. Kept `looseObject` (verbatim
+* passthrough) so `shellInputRegex`, `eventType`, `webhookUrl`, `script`, and
+* any future policy field survive untouched. Both project and global scope are
+* supported.
+*
+* @example
+* { "toolPermissions": [
+*     { "toolName": "github-api",
+*       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
+*     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
+*/
+const AugmentcodePermissionsOverrideSchema = z.looseObject({ toolPermissions: z.optional(z.array(z.looseObject({
+	toolName: z.string(),
+	permission: z.looseObject({ type: z.string() })
+}))) });
+/**
+* Tool-scoped override block for Kiro. Kiro's agent config (`.kiro/agents/<name>.json`)
+* exposes per-tool `toolsSettings` knobs with no canonical allow/ask/deny
+* category: the shell auto-trust flags `shell.autoAllowReadonly` /
+* `shell.denyByDefault`, the `aws` built-in tool's `allowedServices` /
+* `deniedServices` (+ `autoAllowReadonly`), and the `web_fetch` domain trust
+* arrays `trusted` / `blocked` (regex host patterns; documented for `web_fetch`
+* only — `web_search` has no such surface). Fields placed here are deep-merged
+* (per `toolsSettings` key, override wins at the leaf) into the shared agent
+* config, while the canonical `permission` block continues to drive
+* `shell.{allowed,denied}Commands`, `read`/`write`/`grep`/`glob` paths, and the
+* `web_fetch`/`web_search` `allowedTools` toggles. Kept `looseObject` at every
+* level (verbatim passthrough) so future Kiro `toolsSettings` fields survive.
+*
+* Kiro's MCP `autoApprove` / `disabledTools` lists are intentionally NOT modeled
+* here: they live in a SEPARATE file (`.kiro/settings/mcp.json`, under
+* `mcpServers.<name>`), not the agent config this permissions translator writes,
+* and reconciling them with the canonical `mcp__*` model is a distinct design
+* question left out of scope.
+*
+* @example
+* { "toolsSettings": { "shell": { "autoAllowReadonly": true },
+*     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
+*     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
+*/
+const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(z.looseObject({
+	shell: z.optional(z.looseObject({
+		autoAllowReadonly: z.optional(z.boolean()),
+		denyByDefault: z.optional(z.boolean())
+	})),
+	aws: z.optional(z.looseObject({
+		allowedServices: z.optional(z.array(z.string())),
+		deniedServices: z.optional(z.array(z.string())),
+		autoAllowReadonly: z.optional(z.boolean())
+	})),
+	web_fetch: z.optional(z.looseObject({
+		trusted: z.optional(z.array(z.string())),
+		blocked: z.optional(z.array(z.string()))
+	}))
+})) });
+/**
+* Codex CLI-scoped permission override.
+*
+* Codex CLI's permission surface is richer than the canonical allow/ask/deny
+* model: its approval workflow, classic sandbox system, and per-app tool gating
+* have no canonical category. Author them through a tool-scoped `codexcli`
+* override whose fields are written verbatim as top-level `.codex/config.toml`
+* keys (the override wins per key; existing sibling keys the user set directly
+* are preserved):
+* - `approval_policy` — `untrusted` | `on-request` | `never`, or a
+*   `{ granular = { … } }` table (kept verbatim; the granular schema has
+*   required fields that are brittle to model as typed keys).
+* - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
+*   with the sibling `sandbox_workspace_write` table (`network_access`,
+*   `writable_roots`, …).
+* - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
+*   `.enabled`, `apps.<id>.default_tools_approval_mode`).
+* - `approvals_reviewer` — the reviewer-approval surface.
+*
+* Two surfaces are deliberately NOT authorable here so the override can never
+* clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
+* MCP feature (`codexcli-mcp.ts` already writes the `mcp_servers` tables in the
+* same `config.toml`), and `permissions` / `default_permissions` are owned by
+* the canonical model. Any such key placed in the override is skipped with a
+* warning. Kept `looseObject` (verbatim passthrough) so future top-level Codex
+* config keys can be authored without Rulesync modeling each one.
+*
+* @see https://developers.openai.com/codex/config-reference
+* @see https://developers.openai.com/codex/permissions
+*
+* @example
+* { "approval_policy": "on-request", "sandbox_mode": "workspace-write",
+*   "sandbox_workspace_write": { "network_access": true } }
+*/
+const CodexcliPermissionsOverrideSchema = z.looseObject({
+	approval_policy: z.optional(z.union([z.string(), z.looseObject({})])),
+	sandbox_mode: z.optional(z.string()),
+	sandbox_workspace_write: z.optional(z.looseObject({})),
+	apps: z.optional(z.looseObject({})),
+	approvals_reviewer: z.optional(z.union([z.string(), z.looseObject({})]))
+});
+/**
 * Permissions configuration.
 * Keys are tool category names (e.g., "bash", "edit", "read", "webfetch").
 * Values are pattern-to-action mappings for that tool category.
 *
 * The optional `opencode`/`hermes`/`cline`/`kilo`/`claudecode`/`vibe`/`cursor`/
 * `qwencode`/`reasonix`/`factorydroid`/`warp`/`junie`/`takt`/`amp`/
-* `antigravity-cli` keys are tool-scoped overrides consumed only by their
-* respective translator (see the matching `*PermissionsOverrideSchema`); every
-* other tool reads the shared `permission` block and ignores them.
+* `antigravity-cli`/`augmentcode`/`kiro`/`codexcli` keys are tool-scoped
+* overrides consumed only by their respective translator (see the matching
+* `*PermissionsOverrideSchema`); every other tool reads the shared `permission`
+* block and ignores them.
 *
 * @example
 * {
@@ -16288,7 +16517,10 @@ const PermissionsConfigSchema = z.looseObject({
 	junie: z.optional(JuniePermissionsOverrideSchema),
 	takt: z.optional(TaktPermissionsOverrideSchema),
 	amp: z.optional(AmpPermissionsOverrideSchema),
-	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema)
+	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema),
+	augmentcode: z.optional(AugmentcodePermissionsOverrideSchema),
+	kiro: z.optional(KiroPermissionsOverrideSchema),
+	codexcli: z.optional(CodexcliPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16440,7 +16672,7 @@ function parseAmpSettings(fileContent) {
 		const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function toDisableList(value) {
@@ -16467,7 +16699,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;
@@ -16475,7 +16707,7 @@ function toPermissionsList(value) {
 			...raw,
 			tool,
 			action,
-			...isPlainObject(raw.matches) ? { matches: raw.matches } : {}
+			...isPlainObject$1(raw.matches) ? { matches: raw.matches } : {}
 		});
 	}
 	return entries;
@@ -17335,6 +17567,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.
 */
@@ -17465,12 +17746,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) => {
@@ -17481,7 +17768,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]
@@ -17505,11 +17796,14 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse AugmentCode permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const config = convertAugmentToRulesyncPermissions({
-			entries: settings.toolPermissions ?? [],
+		const allEntries = settings.toolPermissions ?? [];
+		const specialEntries = allEntries.filter((entry) => isSpecialEntry(entry));
+		const result = { ...convertAugmentToRulesyncPermissions({
+			entries: allEntries.filter((entry) => !isSpecialEntry(entry)),
 			logger: moduleLogger$1
-		});
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+		}) };
+		if (specialEntries.length > 0) result.augmentcode = { toolPermissions: specialEntries };
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		try {
@@ -17643,10 +17937,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);
@@ -18078,6 +18369,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 {
@@ -18119,6 +18417,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,
@@ -18143,7 +18446,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 {
@@ -18335,6 +18643,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 = {};
@@ -18502,7 +18834,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();
@@ -19249,7 +19585,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : load(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Goose permission.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -19271,7 +19607,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : load(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -20178,6 +20514,13 @@ const KiroAgentSchema = z.looseObject({
 	toolsSettings: z.optional(z.record(z.string(), z.unknown()))
 });
 const UnknownRecordSchema = z.record(z.string(), z.unknown());
+const CANONICAL_SHELL_KEYS = /* @__PURE__ */ new Set(["allowedCommands", "deniedCommands"]);
+const CANONICAL_TOOL_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+	"read",
+	"write",
+	"grep",
+	"glob"
+]);
 var KiroPermissions = class KiroPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
 		return {
@@ -20241,7 +20584,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 {
@@ -20291,19 +20637,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 ?? [],
@@ -20323,6 +20721,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") : [];
 }
@@ -21135,7 +21558,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : load(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Rovodev config at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -21161,7 +21584,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : load(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -21356,9 +21779,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,
@@ -21389,12 +21812,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;
@@ -21426,7 +21849,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];
 	}
@@ -22758,13 +23181,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({
@@ -22773,7 +23198,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 = z.looseObject({
@@ -24180,9 +24606,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(),
@@ -24415,7 +24842,7 @@ function extractOpenaiYamlFile(otherFiles) {
 	const rest = [];
 	for (const file of otherFiles) {
 		if (toPosixPath(file.relativeFilePathToDirPath) === target) try {
-			const loaded = load(file.fileBuffer.toString("utf-8"));
+			const loaded = loadYaml(file.fileBuffer.toString("utf-8"));
 			if (loaded !== null && typeof loaded === "object" && !Array.isArray(loaded)) {
 				parsed = loaded;
 				continue;
@@ -25971,9 +26398,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(),
@@ -26296,9 +26724,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(),
@@ -26613,9 +27042,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(),
@@ -26666,6 +27096,140 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/reasonix-skill.ts
+const ReasonixSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.string()
+});
+/**
+* Represents a DeepSeek-Reasonix skill directory.
+*
+* Reasonix discovers directory-layout skills (`<name>/SKILL.md`) under
+* `.reasonix/skills/` (project) and `~/.reasonix/skills/` (global); the global
+* scope is served by the processor supplying the home directory as outputRoot.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/GUIDE.md
+*/
+var ReasonixSkill = class ReasonixSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = REASONIX_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: REASONIX_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return ReasonixSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (this.mainFile === void 0) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = ReasonixSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const frontmatter = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			targets: ["*"]
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const reasonixFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		return new ReasonixSkill({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/constants/replit-paths.ts
 const REPLIT_RULE_FILE_NAME = "replit.md";
 const REPLIT_SKILLS_DIR_PATH = join(".agents", "skills");
@@ -27034,17 +27598,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
@@ -27342,9 +27909,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(),
@@ -27760,6 +28328,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["replit", {
 		class: ReplitSkill,
 		meta: {
@@ -28153,10 +28729,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({
@@ -28321,11 +28899,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,
@@ -28449,11 +29028,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,
@@ -28584,11 +29164,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,
@@ -28723,11 +29304,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
@@ -28853,11 +29435,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,
@@ -29123,7 +29706,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,
@@ -29132,11 +29716,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,
@@ -29309,11 +29894,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,
@@ -29427,11 +30013,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,
@@ -29865,11 +30452,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,
@@ -30007,10 +30595,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: dump(recipe, {
 				lineWidth: -1,
@@ -30043,7 +30632,7 @@ var GooseSubagent = class GooseSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = load(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -30145,11 +30734,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,
@@ -30385,9 +30975,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
 		});
@@ -30521,11 +31112,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,
@@ -30716,11 +31308,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,
@@ -30992,11 +31585,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,
@@ -31140,11 +31734,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,
@@ -31431,7 +32026,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = load(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse .roomodes (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -32433,11 +33028,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(join(outputRoot, relativeDirPath, relativeFilePath));
 		return new AiassistantRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: (await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath))).trim(),
+			fileContent: fileContent.trim(),
 			validate,
 			root: false
 		});
@@ -32538,13 +33134,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) {
@@ -32627,13 +33224,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) {
@@ -33047,13 +33645,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
 		});
 	}
 };
@@ -33289,13 +33888,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) {
@@ -33394,6 +33994,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,
@@ -33401,7 +34002,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 }) {
@@ -33917,6 +34518,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,
@@ -33924,13 +34532,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() {
@@ -34594,13 +35196,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 }) {
@@ -34696,13 +35299,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) {
@@ -34906,11 +35510,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(join(outputRoot, join(relativeDirPath, relativeFilePath)));
 		return new JunieRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent(join(outputRoot, join(relativeDirPath, relativeFilePath))),
+			fileContent,
 			validate,
 			root: isRoot
 		});
@@ -34945,13 +35550,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) {
@@ -35025,13 +35631,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) {
@@ -35120,11 +35727,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(join(outputRoot, relativeDirPath, relativeFilePath));
 		return new KiroRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			root: isRoot
 		});
@@ -35299,13 +35907,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) {
@@ -35390,13 +35999,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) {
@@ -35624,6 +36234,72 @@ var QwencodeRule = class QwencodeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/reasonix-rule.ts
+var ReasonixRule = class ReasonixRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { root: {
+			relativeDirPath: global ? REASONIX_GLOBAL_DIR : ".",
+			relativeFilePath: REASONIX_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent(join(outputRoot, join(root.relativeDirPath, root.relativeFilePath)));
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: isRoot
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "REASONIX.md" && (relativeDirPath === "." || relativeDirPath === ".reasonix")
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "reasonix"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/replit-rule.ts
 /**
 * Rule generator for Replit Agent
@@ -35674,13 +36350,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) {
@@ -35831,11 +36508,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): ${join(relativeDirPath, relativeFilePath)}`);
+		const fileContent = await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath));
 		return new RovodevRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			global,
 			root: false
@@ -35846,11 +36524,12 @@ var RovodevRule = class RovodevRule extends ToolRule {
 		const agentsMdExpectedLocationsDescription = "alternativeRoots" in paths && paths.alternativeRoots && paths.alternativeRoots.length > 0 ? `${join(paths.root.relativeDirPath, paths.root.relativeFilePath)} or project root` : join(paths.root.relativeDirPath, paths.root.relativeFilePath);
 		if (relativeFilePath !== "AGENTS.md") throw new Error(`Rovodev rules support only AGENTS.md at ${agentsMdExpectedLocationsDescription}, got: ${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: ${join(relativeDirPath, relativeFilePath)}`);
+		const fileContent = await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath));
 		return new RovodevRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath)),
+			fileContent,
 			validate,
 			global,
 			root: true
@@ -36041,16 +36720,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
 		});
@@ -36118,13 +36799,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) {
@@ -36186,13 +36868,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) {
@@ -36257,13 +36940,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) {
@@ -36536,6 +37220,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: {
@@ -36980,19 +37673,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(join(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => join(this.outputRoot, alt.relativeDirPath, fileName)));
+				const filePaths = await findFilesWithFallback(join(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => 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 [];
@@ -37421,7 +38119,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(/\/$/, "");
@@ -37444,7 +38141,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)];
@@ -37457,7 +38160,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;
@@ -38423,6 +39125,6 @@ async function importPermissionsCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { toPosixPath as $, RulesyncCommand as A, createTempDirectory as B, RulesyncHooks as C, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, ALL_FEATURES as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, formatError as Et, ConsoleLogger as F, getFileSize as G, ensureDir as H, JsonLogger as I, listDirectoryFiles as J, getHomeDirectory as K, CLIError as L, stringifyFrontmatter as M, ConfigResolver as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES_WITH_WILDCARD as Ot, findControlCharacter as P, removeTempDirectory as Q, ErrorCodes as R, HooksProcessor as S, RULESYNC_RULES_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Tt, fileExists as U, directoryExists as V, findFilesByGlobs as W, removeDirectory as X, readFileContent as Y, removeFile as Z, RulesyncPermissions as _, RULESYNC_MCP_SCHEMA_URL as _t, convertFromTool as a, RULESYNC_AIIGNORE_FILE_NAME as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_HOOKS_FILE_NAME as dt, writeFileContent as et, SkillsProcessor as f, RULESYNC_HOOKS_RELATIVE_FILE_PATH as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_RELATIVE_FILE_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_MCP_FILE_NAME as ht, getProcessorRegistryEntry as i, MAX_FILE_SIZE as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, SubagentsProcessor as l, RULESYNC_CONFIG_SCHEMA_URL as lt, RulesyncSkill as m, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS_WITH_WILDCARD as nt, RulesProcessor as o, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ot, getLocalSkillDirNames as p, RULESYNC_IGNORE_RELATIVE_FILE_PATH as pt, isSymlink as q, generate as r, ToolTargetSchema as rt, RulesyncRule as s, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as st, importFromTool as t, ALL_TOOL_TARGETS as tt, RulesyncSubagent as u, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ut, McpProcessor as v, RULESYNC_OVERVIEW_FILE_NAME as vt, CommandsProcessor as w, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as wt, RulesyncIgnore as x, RULESYNC_RELATIVE_DIR_PATH as xt, RulesyncMcp as y, RULESYNC_PERMISSIONS_FILE_NAME as yt, checkPathTraversal as z };
+export { removeTempDirectory as $, RulesyncCommand as A, checkPathTraversal as B, RulesyncHooks as C, RULESYNC_RULES_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, formatError as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Et, findControlCharacter as F, findFilesByGlobs as G, directoryExists as H, ConsoleLogger as I, isSymlink as J, getFileSize as K, JsonLogger as L, stringifyFrontmatter as M, loadYaml as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES as Ot, ConfigResolver as P, removeFile as Q, CLIError as R, HooksProcessor as S, RULESYNC_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Tt, ensureDir as U, createTempDirectory as V, fileExists as W, readFileContent as X, listDirectoryFiles as Y, removeDirectory as Z, RulesyncPermissions as _, RULESYNC_MCP_RELATIVE_FILE_PATH as _t, convertFromTool as a, MAX_FILE_SIZE as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_FILE_NAME as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as dt, toPosixPath as et, SkillsProcessor as f, RULESYNC_HOOKS_FILE_NAME as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_FILE_NAME as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ToolTargetSchema as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, ALL_FEATURES_WITH_WILDCARD as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as lt, RulesyncSkill as m, RULESYNC_IGNORE_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS as nt, RulesProcessor as o, RULESYNC_AIIGNORE_FILE_NAME as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_RELATIVE_FILE_PATH as pt, getHomeDirectory as q, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rt, RulesyncRule as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as st, importFromTool as t, writeFileContent as tt, RulesyncSubagent as u, RULESYNC_CONFIG_SCHEMA_URL as ut, McpProcessor as v, RULESYNC_MCP_SCHEMA_URL as vt, CommandsProcessor as w, RULESYNC_SKILLS_RELATIVE_DIR_PATH as wt, RulesyncIgnore as x, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as xt, RulesyncMcp as y, RULESYNC_OVERVIEW_FILE_NAME as yt, ErrorCodes as z };
 
-//# sourceMappingURL=import-BdJG1fyb.js.map
+//# sourceMappingURL=import-tTMN0WRi.js.map