rulesync 9.5.0 → 9.6.0

package/dist/{import-DngV1i49.cjs → import-CiS5ckUo.cjs}

@@ -31,11 +31,11 @@ node_os = __toESM(node_os, 1);
 let es_toolkit = require("es-toolkit");
 let globby = require("globby");
 let node_util = require("node:util");
-let js_yaml = require("js-yaml");
 let smol_toml = require("smol-toml");
 smol_toml = __toESM(smol_toml, 1);
 let gray_matter = require("gray-matter");
 gray_matter = __toESM(gray_matter, 1);
+let js_yaml = require("js-yaml");
 let es_toolkit_object = require("es-toolkit/object");
 let _toon_format_toon = require("@toon-format/toon");
 //#region src/types/features.ts
@@ -114,22 +114,22 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$247 } = node_path.posix;
+const { join: join$249 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$247(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$247(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$249(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
@@ -167,6 +167,7 @@ const rulesProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -314,6 +315,7 @@ const skillsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"replit",
 	"roo",
 	"rovodev",
@@ -1450,7 +1452,7 @@ function isRecord(value) {
 * conversion, etc.) should reject inputs whose prototype could carry
 * malicious accessor descriptors.
 */
-function isPlainObject(value) {
+function isPlainObject$1(value) {
 	if (!isRecord(value)) return false;
 	const proto = Object.getPrototypeOf(value);
 	return proto === null || proto === Object.prototype;
@@ -1462,11 +1464,43 @@ function isStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 //#endregion
+//#region src/utils/yaml.ts
+/**
+* js-yaml v5's `reason` for an empty document. `load("")` — and any
+* whitespace/comment-only input — throws a `YAMLException` with this reason
+* instead of returning `undefined` the way v4 did.
+*/
+const EMPTY_INPUT_REASON = "expected a document, but the input is empty";
+/**
+* Load YAML content while preserving js-yaml v4's behavior of returning
+* `undefined` for empty documents (empty, whitespace-only, or comment-only
+* input).
+*
+* js-yaml v5 changed `load("")` to **throw** ("expected a document, but the
+* input is empty") instead of returning `undefined`. Many call sites here parse
+* config/lock/frontmatter files that can legitimately be empty and rely on the
+* old `undefined` sentinel (`load(input) ?? {}`, `if (loaded === undefined)`,
+* "an empty file parses to undefined/null"). Routing every load through this
+* wrapper keeps that contract in one place so a future js-yaml bump cannot
+* reintroduce the empty-input regression. Genuine parse errors still propagate.
+*
+* @see https://github.com/nodeca/js-yaml/blob/master/docs/migrate_v4_to_v5.md#empty-input-throws
+*/
+function loadYaml(content) {
+	if (content.trim() === "") return;
+	try {
+		return (0, js_yaml.load)(content);
+	} catch (error) {
+		if (error instanceof js_yaml.YAMLException && error.reason === EMPTY_INPUT_REASON) return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/utils/frontmatter.ts
 function deepRemoveNullishValue(value) {
 	if (value === null || value === void 0) return;
 	if (Array.isArray(value)) return value.map((item) => deepRemoveNullishValue(item)).filter((item) => item !== void 0);
-	if (isPlainObject(value)) {
+	if (isPlainObject$1(value)) {
 		const result = {};
 		for (const [key, val] of Object.entries(value)) {
 			const cleaned = deepRemoveNullishValue(val);
@@ -1489,7 +1523,7 @@ function deepFlattenStringsValue(value) {
 	if (value === null || value === void 0) return;
 	if (typeof value === "string") return value.replace(/\n+/g, " ").trim();
 	if (Array.isArray(value)) return value.map((item) => deepFlattenStringsValue(item)).filter((item) => item !== void 0);
-	if (isPlainObject(value)) {
+	if (isPlainObject$1(value)) {
 		const result = {};
 		for (const [key, val] of Object.entries(value)) {
 			const cleaned = deepFlattenStringsValue(val);
@@ -1512,7 +1546,7 @@ function stringifyFrontmatter(body, frontmatter, options) {
 	const { avoidBlockScalars = false } = options ?? {};
 	const cleanFrontmatter = avoidBlockScalars ? deepFlattenStringsObject(frontmatter) : deepRemoveNullishObject(frontmatter);
 	if (avoidBlockScalars) return gray_matter.default.stringify(body, cleanFrontmatter, { engines: { yaml: {
-		parse: (input) => (0, js_yaml.load)(input) ?? {},
+		parse: (input) => loadYaml(input) ?? {},
 		stringify: (data) => (0, js_yaml.dump)(data, { lineWidth: -1 })
 	} } });
 	return gray_matter.default.stringify(body, cleanFrontmatter);
@@ -1551,7 +1585,7 @@ function tryJsonEquivalent(a, b) {
 }
 function tryYamlEquivalent(a, b) {
 	try {
-		return (0, node_util.isDeepStrictEqual)((0, js_yaml.load)(a), (0, js_yaml.load)(b));
+		return (0, node_util.isDeepStrictEqual)(loadYaml(a), loadYaml(b));
 	} catch {
 		return;
 	}
@@ -3358,7 +3392,7 @@ var GooseCommand = class GooseCommand extends ToolCommand {
 		const where = (0, node_path.join)(this.relativeDirPath, this.relativeFilePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(content);
+			parsed = loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${where}): ${formatError(error)}`, { cause: error });
 		}
@@ -4012,7 +4046,7 @@ function omitPrototypePollutionKeys(record) {
 //#region src/features/shared/shared-config-gateway.ts
 function sanitizeSharedConfigValue(value) {
 	if (Array.isArray(value)) return value.map(sanitizeSharedConfigValue);
-	if (!isPlainObject(value)) return value;
+	if (!isPlainObject$1(value)) return value;
 	const result = {};
 	for (const [key, nested] of Object.entries(omitPrototypePollutionKeys(value))) result[key] = sanitizeSharedConfigValue(nested);
 	return result;
@@ -4028,14 +4062,14 @@ function parseSharedConfig({ format, fileContent, filePath, invalidRootPolicy =
 	const at = filePath === void 0 ? "" : ` at ${filePath}`;
 	let parsed;
 	try {
-		if (format === "yaml") parsed = (0, js_yaml.load)(fileContent);
+		if (format === "yaml") parsed = loadYaml(fileContent);
 		else if (format === "json") parsed = JSON.parse(fileContent);
 		else parsed = (0, jsonc_parser.parse)(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse shared config${at}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) {
+	if (!isPlainObject$1(parsed)) {
 		if (invalidRootPolicy === "error") throw new Error(`Failed to parse shared config${at}: expected a mapping at the root`);
 		return {};
 	}
@@ -4078,7 +4112,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
 		});
@@ -4712,6 +4746,8 @@ const REASONIX_GLOBAL_PERMISSIONS_FILE_NAME = REASONIX_GLOBAL_MCP_FILE_NAME;
 const REASONIX_DIR = REASONIX_GLOBAL_DIR;
 const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "commands");
+const REASONIX_RULE_FILE_NAME = "REASONIX.md";
+const REASONIX_SKILLS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "skills");
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -5117,8 +5153,8 @@ var RovodevCommand = class RovodevCommand extends ToolCommand {
 		const existingContent = await readFileContentOrNull((0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
 		let existing = {};
 		if (existingContent) try {
-			const parsed = (0, js_yaml.load)(existingContent);
-			if (isPlainObject(parsed)) existing = parsed;
+			const parsed = loadYaml(existingContent);
+			if (isPlainObject$1(parsed)) existing = parsed;
 		} catch {}
 		const prompts = rovodevCommands.map((command) => ({
 			name: command.getName(),
@@ -5148,11 +5184,11 @@ async function lookupPromptDescription({ outputRoot, relativeFilePath, name }) {
 	if (!manifestContent) return "";
 	let parsed;
 	try {
-		parsed = (0, js_yaml.load)(manifestContent);
+		parsed = loadYaml(manifestContent);
 	} catch {
 		return "";
 	}
-	if (!isPlainObject(parsed) || !Array.isArray(parsed.prompts)) return "";
+	if (!isPlainObject$1(parsed) || !Array.isArray(parsed.prompts)) return "";
 	const expectedContentFile = toPosixPath((0, node_path.join)("prompts", relativeFilePath));
 	const entry = parsed.prompts.find((candidate) => isRecord(candidate) && (candidate.content_file === expectedContentFile || candidate.name === name));
 	return isRecord(entry) && typeof entry.description === "string" ? entry.description : "";
@@ -6190,18 +6226,25 @@ const QWENCODE_HOOK_EVENTS = [
 * Reasonix's `.reasonix/settings.json` (project) / `~/.reasonix/settings.json`
 * (global) documents a ten-event surface (`PreToolUse`, `PostToolUse`,
 * `UserPromptSubmit`, `Stop`, `PostLLMCall`, `SessionStart`, `SessionEnd`,
-* `SubagentStop`, `Notification`, `PreCompact`), but only the four events the
-* upstream issue scoped in are mapped here: `PreToolUse`, `PostToolUse`,
-* `UserPromptSubmit` ← `beforeSubmitPrompt`, and `Stop`. `match` (Reasonix's
-* matcher field name) is honored only on `PreToolUse`/`PostToolUse`, matching
-* the canonical `matcher` field's tool-event scoping used by other adapters.
+* `SubagentStop`, `Notification`, `PreCompact`). The eight events with a clean
+* canonical equivalent are mapped: `PreToolUse`, `PostToolUse`,
+* `UserPromptSubmit` ← `beforeSubmitPrompt`, `Stop`, `SessionStart`,
+* `SessionEnd`, `SubagentStop`, and `PostLLMCall` ← `postModelInvocation`.
+* (`Notification` and `PreCompact` have no canonical event and are left out.)
+* `match` (Reasonix's matcher field name) is honored only on
+* `PreToolUse`/`PostToolUse`, matching the canonical `matcher` field's
+* tool-event scoping used by other adapters.
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 const REASONIX_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"beforeSubmitPrompt",
-	"stop"
+	"stop",
+	"sessionStart",
+	"sessionEnd",
+	"subagentStop",
+	"postModelInvocation"
 ];
 /**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
@@ -6637,14 +6680,18 @@ const QWENCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANO
 /**
 * Map canonical camelCase event names to Reasonix PascalCase.
 * Reasonix explicitly mirrors Claude Code's hooks model, so it reuses the same
-* PascalCase names for the four events rulesync maps.
+* PascalCase names for the events rulesync maps.
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 const CANONICAL_TO_REASONIX_EVENT_NAMES = {
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
-	stop: "Stop"
+	stop: "Stop",
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	subagentStop: "SubagentStop",
+	postModelInvocation: "PostLLMCall"
 };
 /**
 * Map Reasonix PascalCase event names to canonical camelCase.
@@ -6693,6 +6740,21 @@ function applyCommandPrefix({ def, converterConfig }) {
 	return converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith(".")) && typeof trimmedCommand === "string" ? `"${converterConfig.projectDirVar}"/${trimmedCommand.replace(/^\.\//, "")}` : def.command;
 }
 /**
+* Emit the configured boolean passthrough fields on the tool side, mapping each
+* canonical field name to its (possibly renamed) tool field name. Only boolean
+* values are carried through.
+*/
+function emitBooleanPassthroughFields({ def, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "boolean").map(({ canonical, tool }) => [tool, def[canonical]]));
+}
+/**
+* Import the configured boolean passthrough fields back into canonical fields,
+* reversing {@link emitBooleanPassthroughFields}. Only boolean values are read.
+*/
+function importBooleanPassthroughFields({ h, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "boolean").map(({ canonical, tool }) => [canonical, h[tool]]));
+}
+/**
 * Convert the definitions of a single matcher group into tool hook entries,
 * honoring supported hook types and passthrough fields.
 */
@@ -6706,6 +6768,10 @@ function buildToolHooks({ defs, converterConfig }) {
 			converterConfig
 		});
 		hooks.push({
+			...emitBooleanPassthroughFields({
+				def,
+				converterConfig
+			}),
 			type: hookType,
 			...command !== void 0 && command !== null && { command },
 			...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
@@ -6793,6 +6859,10 @@ function toolHookToCanonical({ h, rawEntry, converterConfig }) {
 		...prompt !== void 0 && prompt !== null && { prompt },
 		...converterConfig.passthroughFields?.includes("name") && typeof h.name === "string" && { name: h.name },
 		...converterConfig.passthroughFields?.includes("description") && typeof h.description === "string" && { description: h.description },
+		...importBooleanPassthroughFields({
+			h,
+			converterConfig
+		}),
 		...rawEntry.matcher !== void 0 && rawEntry.matcher !== null && rawEntry.matcher !== "" && { matcher: rawEntry.matcher }
 	};
 }
@@ -7087,7 +7157,7 @@ function combineAugmentSettings(base, local) {
 		const baseValue = result[key];
 		if (AUGMENTCODE_REPLACE_KEYS.has(key)) result[key] = localValue;
 		else if (Array.isArray(localValue) && Array.isArray(baseValue)) result[key] = [...localValue, ...baseValue];
-		else if (isPlainObject(localValue) && isPlainObject(baseValue)) result[key] = combineAugmentSettings(baseValue, localValue);
+		else if (isPlainObject$1(localValue) && isPlainObject$1(baseValue)) result[key] = combineAugmentSettings(baseValue, localValue);
 		else result[key] = localValue;
 	}
 	return result;
@@ -7131,14 +7201,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
@@ -8723,7 +8793,14 @@ const JUNIE_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: JUNIE_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
-	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"])
+	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+	booleanPassthroughFields: [{
+		canonical: "failClosed",
+		tool: "blockOnError"
+	}, {
+		canonical: "async",
+		tool: "async"
+	}]
 };
 var JunieHooks = class JunieHooks extends ToolHooks {
 	constructor(params) {
@@ -9759,8 +9836,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 {
@@ -11839,7 +11917,7 @@ function parseAmpSettingsJsonc(fileContent) {
 		const details = errors.map((error) => `${(0, jsonc_parser.printParseErrorCode)(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function filterMcpServers(mcpServers) {
@@ -12161,7 +12239,7 @@ function parseAugmentcodeSettings(fileContent, relativeDirPath, relativeFilePath
 	} catch (error) {
 		throw new Error(`Failed to parse AugmentCode settings at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse AugmentCode settings at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -12387,7 +12465,7 @@ function parseClineSettings(fileContent, relativeDirPath, relativeFilePath) {
 	} catch (error) {
 		throw new Error(`Failed to parse Cline MCP settings at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Cline MCP settings at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Cline MCP settings at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -12658,7 +12736,7 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		for (const [key, value] of Object.entries(obj)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 			if (value === null) continue;
-			if (isPlainObject(value)) {
+			if (isPlainObject$1(value)) {
 				const cleaned = this.removeEmptyEntries(value, depth + 1);
 				if (Object.keys(cleaned).length === 0) continue;
 				filtered[key] = cleaned;
@@ -13299,12 +13377,12 @@ function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
 	let parsed;
 	try {
-		parsed = (0, js_yaml.load)(fileContent);
+		parsed = loadYaml(fileContent);
 	} catch (error) {
 		throw new Error(`Failed to parse Goose config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
 	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Goose config at ${configPath}: expected a YAML mapping`);
 	return parsed;
 }
 /**
@@ -13349,7 +13427,7 @@ function applyGooseStdioFields(ext, config) {
 		ext.cmd = command;
 		if (isStringArray(config.args)) ext.args = config.args;
 	}
-	if (isPlainObject(config.env)) ext.envs = omitPrototypePollutionKeys(config.env);
+	if (isPlainObject$1(config.env)) ext.envs = omitPrototypePollutionKeys(config.env);
 }
 /**
 * Converts a single rulesync canonical MCP server into a Goose `extensions:` entry.
@@ -13364,7 +13442,7 @@ function convertServerToGooseExtension(name, config) {
 	if (gooseType === "stdio") applyGooseStdioFields(ext, config);
 	else if (gooseType === "sse" || gooseType === "streamable_http") {
 		if (url !== void 0) ext.uri = url;
-		if (isPlainObject(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
+		if (isPlainObject$1(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
 	}
 	ext.enabled = config.disabled !== true;
 	const timeout = resolveGooseTimeout(config);
@@ -13406,9 +13484,9 @@ function convertFromGooseFormat(extensions) {
 		else if (type === "stdio") server.type = "stdio";
 		if (typeof ext.cmd === "string") server.command = ext.cmd;
 		if (isStringArray(ext.args)) server.args = ext.args;
-		if (isPlainObject(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
+		if (isPlainObject$1(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
 		if (typeof ext.uri === "string") server.url = ext.uri;
-		if (isPlainObject(ext.headers)) server.headers = omitPrototypePollutionKeys(ext.headers);
+		if (isPlainObject$1(ext.headers)) server.headers = omitPrototypePollutionKeys(ext.headers);
 		if (ext.enabled === false) server.disabled = true;
 		if (typeof ext.timeout === "number") server.timeout = ext.timeout;
 		result[name] = server;
@@ -13431,7 +13509,7 @@ function buildGoosePluginStdioServer(config) {
 		server.command = command;
 		if (isStringArray(config.args)) server.args = config.args;
 	}
-	if (isPlainObject(config.env)) server.env = omitPrototypePollutionKeys(config.env);
+	if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 	if (typeof config.cwd === "string") server.cwd = config.cwd;
 	return server;
 }
@@ -13731,7 +13809,7 @@ var GrokcliMcp = class GrokcliMcp extends ToolMcp {
 		for (const [key, value] of Object.entries(obj)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 			if (value === null) continue;
-			if (isPlainObject(value)) {
+			if (isPlainObject$1(value)) {
 				const cleaned = this.removeEmptyEntries(value, depth + 1);
 				if (Object.keys(cleaned).length === 0) continue;
 				filtered[key] = cleaned;
@@ -13793,10 +13871,10 @@ function convertServerToHermes(config) {
 			out.command = command;
 			if (isStringArray(config.args)) out.args = config.args;
 		}
-		if (isPlainObject(config.env)) out.env = omitPrototypePollutionKeys(config.env);
+		if (isPlainObject$1(config.env)) out.env = omitPrototypePollutionKeys(config.env);
 	} else if (url !== void 0) {
 		out.url = url;
-		if (isPlainObject(config.headers)) out.headers = omitPrototypePollutionKeys(config.headers);
+		if (isPlainObject$1(config.headers)) out.headers = omitPrototypePollutionKeys(config.headers);
 	}
 	if (config.disabled === true) out.enabled = false;
 	const timeout = resolveHermesTimeout(config);
@@ -13841,9 +13919,9 @@ function convertFromHermesFormat(mcpServers) {
 		const server = {};
 		if (typeof config.command === "string") server.command = config.command;
 		if (isStringArray(config.args)) server.args = config.args;
-		if (isPlainObject(config.env)) server.env = omitPrototypePollutionKeys(config.env);
+		if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 		if (typeof config.url === "string") server.url = config.url;
-		if (isPlainObject(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
+		if (isPlainObject$1(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
 		if (config.enabled === false) server.disabled = true;
 		if (typeof config.timeout === "number") server.networkTimeout = config.timeout;
 		if (isRecord(config.tools)) {
@@ -14780,7 +14858,9 @@ const REASONIX_PLUGIN_FIELDS = [
 	"env",
 	"url",
 	"headers",
-	"trusted_read_only_tools"
+	"trusted_read_only_tools",
+	"call_timeout_seconds",
+	"tool_timeout_seconds"
 ];
 var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	toml;
@@ -15012,7 +15092,7 @@ function parseRovodevMcpJson(fileContent, relativeDirPath, relativeFilePath) {
 	} catch (error) {
 		throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: expected a JSON object`);
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Rovodev MCP config at ${configPath}: expected a JSON object`);
 	return parsed;
 }
 /**
@@ -16283,15 +16363,123 @@ const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
+* Tool-scoped override block for AugmentCode. AugmentCode's `toolPermissions[]`
+* array supports "custom policy" entries the canonical allow/ask/deny model
+* cannot express: `permission.type` of `webhook-policy` / `script-policy`
+* (delegating the decision to a `webhookUrl` / `script`) and an `eventType` of
+* `tool-response` (a post-execution check rather than the default pre-execution
+* `tool-call`). These are authored here as verbatim `toolPermissions` entries
+* and prepended — ahead of the canonical-generated basic rules — into the shared
+* `.augment/settings.json`, so a webhook/script gate or tool-response check is
+* never shadowed by a regenerated allow/deny/ask entry under AugmentCode's
+* first-match-wins evaluation. The shared `permission` block continues to drive
+* the basic `allow` / `deny` / `ask-user` entries. Kept `looseObject` (verbatim
+* passthrough) so `shellInputRegex`, `eventType`, `webhookUrl`, `script`, and
+* any future policy field survive untouched. Both project and global scope are
+* supported.
+*
+* @example
+* { "toolPermissions": [
+*     { "toolName": "github-api",
+*       "permission": { "type": "webhook-policy", "webhookUrl": "https://api.example.com/validate" } },
+*     { "toolName": "view", "eventType": "tool-response", "permission": { "type": "allow" } } ] }
+*/
+const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({ toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
+	toolName: zod_mini.z.string(),
+	permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
+}))) });
+/**
+* Tool-scoped override block for Kiro. Kiro's agent config (`.kiro/agents/<name>.json`)
+* exposes per-tool `toolsSettings` knobs with no canonical allow/ask/deny
+* category: the shell auto-trust flags `shell.autoAllowReadonly` /
+* `shell.denyByDefault`, the `aws` built-in tool's `allowedServices` /
+* `deniedServices` (+ `autoAllowReadonly`), and the `web_fetch` domain trust
+* arrays `trusted` / `blocked` (regex host patterns; documented for `web_fetch`
+* only — `web_search` has no such surface). Fields placed here are deep-merged
+* (per `toolsSettings` key, override wins at the leaf) into the shared agent
+* config, while the canonical `permission` block continues to drive
+* `shell.{allowed,denied}Commands`, `read`/`write`/`grep`/`glob` paths, and the
+* `web_fetch`/`web_search` `allowedTools` toggles. Kept `looseObject` at every
+* level (verbatim passthrough) so future Kiro `toolsSettings` fields survive.
+*
+* Kiro's MCP `autoApprove` / `disabledTools` lists are intentionally NOT modeled
+* here: they live in a SEPARATE file (`.kiro/settings/mcp.json`, under
+* `mcpServers.<name>`), not the agent config this permissions translator writes,
+* and reconciling them with the canonical `mcp__*` model is a distinct design
+* question left out of scope.
+*
+* @example
+* { "toolsSettings": { "shell": { "autoAllowReadonly": true },
+*     "aws": { "allowedServices": ["s3"], "deniedServices": ["eks"] },
+*     "web_fetch": { "trusted": [".*github\\.com.*"] } } }
+*/
+const KiroPermissionsOverrideSchema = zod_mini.z.looseObject({ toolsSettings: zod_mini.z.optional(zod_mini.z.looseObject({
+	shell: zod_mini.z.optional(zod_mini.z.looseObject({
+		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean()),
+		denyByDefault: zod_mini.z.optional(zod_mini.z.boolean())
+	})),
+	aws: zod_mini.z.optional(zod_mini.z.looseObject({
+		allowedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+		deniedServices: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+		autoAllowReadonly: zod_mini.z.optional(zod_mini.z.boolean())
+	})),
+	web_fetch: zod_mini.z.optional(zod_mini.z.looseObject({
+		trusted: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+		blocked: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+	}))
+})) });
+/**
+* Codex CLI-scoped permission override.
+*
+* Codex CLI's permission surface is richer than the canonical allow/ask/deny
+* model: its approval workflow, classic sandbox system, and per-app tool gating
+* have no canonical category. Author them through a tool-scoped `codexcli`
+* override whose fields are written verbatim as top-level `.codex/config.toml`
+* keys (the override wins per key; existing sibling keys the user set directly
+* are preserved):
+* - `approval_policy` — `untrusted` | `on-request` | `never`, or a
+*   `{ granular = { … } }` table (kept verbatim; the granular schema has
+*   required fields that are brittle to model as typed keys).
+* - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
+*   with the sibling `sandbox_workspace_write` table (`network_access`,
+*   `writable_roots`, …).
+* - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
+*   `.enabled`, `apps.<id>.default_tools_approval_mode`).
+* - `approvals_reviewer` — the reviewer-approval surface.
+*
+* Two surfaces are deliberately NOT authorable here so the override can never
+* clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
+* MCP feature (`codexcli-mcp.ts` already writes the `mcp_servers` tables in the
+* same `config.toml`), and `permissions` / `default_permissions` are owned by
+* the canonical model. Any such key placed in the override is skipped with a
+* warning. Kept `looseObject` (verbatim passthrough) so future top-level Codex
+* config keys can be authored without Rulesync modeling each one.
+*
+* @see https://developers.openai.com/codex/config-reference
+* @see https://developers.openai.com/codex/permissions
+*
+* @example
+* { "approval_policy": "on-request", "sandbox_mode": "workspace-write",
+*   "sandbox_workspace_write": { "network_access": true } }
+*/
+const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
+	approval_policy: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
+	sandbox_mode: zod_mini.z.optional(zod_mini.z.string()),
+	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})]))
+});
+/**
 * Permissions configuration.
 * Keys are tool category names (e.g., "bash", "edit", "read", "webfetch").
 * Values are pattern-to-action mappings for that tool category.
 *
 * The optional `opencode`/`hermes`/`cline`/`kilo`/`claudecode`/`vibe`/`cursor`/
 * `qwencode`/`reasonix`/`factorydroid`/`warp`/`junie`/`takt`/`amp`/
-* `antigravity-cli` keys are tool-scoped overrides consumed only by their
-* respective translator (see the matching `*PermissionsOverrideSchema`); every
-* other tool reads the shared `permission` block and ignores them.
+* `antigravity-cli`/`augmentcode`/`kiro`/`codexcli` keys are tool-scoped
+* overrides consumed only by their respective translator (see the matching
+* `*PermissionsOverrideSchema`); every other tool reads the shared `permission`
+* block and ignores them.
 *
 * @example
 * {
@@ -16315,7 +16503,10 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	junie: zod_mini.z.optional(JuniePermissionsOverrideSchema),
 	takt: zod_mini.z.optional(TaktPermissionsOverrideSchema),
 	amp: zod_mini.z.optional(AmpPermissionsOverrideSchema),
-	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema)
+	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema),
+	augmentcode: zod_mini.z.optional(AugmentcodePermissionsOverrideSchema),
+	kiro: zod_mini.z.optional(KiroPermissionsOverrideSchema),
+	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema)
 });
 /**
 * Full permissions file schema including optional $schema field.
@@ -16467,7 +16658,7 @@ function parseAmpSettings(fileContent) {
 		const details = errors.map((error) => `${(0, jsonc_parser.printParseErrorCode)(error.error)} at offset ${error.offset}`).join(", ");
 		throw new Error(`Failed to parse Amp settings: ${details}`);
 	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
 function toDisableList(value) {
@@ -16494,7 +16685,7 @@ function toPermissionsList(value) {
 	if (!Array.isArray(value)) return [];
 	const entries = [];
 	for (const raw of value) {
-		if (!isPlainObject(raw)) continue;
+		if (!isPlainObject$1(raw)) continue;
 		const { tool, action } = raw;
 		if (typeof tool !== "string" || typeof action !== "string") continue;
 		if (action !== "allow" && action !== "reject" && action !== "ask" && action !== "delegate") continue;
@@ -16502,7 +16693,7 @@ function toPermissionsList(value) {
 			...raw,
 			tool,
 			action,
-			...isPlainObject(raw.matches) ? { matches: raw.matches } : {}
+			...isPlainObject$1(raw.matches) ? { matches: raw.matches } : {}
 		});
 	}
 	return entries;
@@ -17362,6 +17553,55 @@ function isSpecialEntry(entry) {
 	return false;
 }
 /**
+* A composite identity for a special entry, used to de-duplicate authored
+* (`augmentcode` override) and preserved (existing-file) special entries so the
+* same policy is not emitted twice into `toolPermissions`. Every field that can
+* distinguish two special entries is included.
+*/
+function specialEntryKey(entry) {
+	return JSON.stringify([
+		entry.toolName,
+		entry.shellInputRegex ?? "",
+		entry.eventType ?? "",
+		entry.permission.type,
+		entry.permission.webhookUrl ?? "",
+		entry.permission.script ?? ""
+	]);
+}
+/**
+* Stable de-duplication of special entries by {@link specialEntryKey}, keeping
+* the first occurrence (authored entries lead, so an authored policy wins over
+* an identical preserved one).
+*/
+function dedupeSpecialEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const entry of entries) {
+		const key = specialEntryKey(entry);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(entry);
+	}
+	return out;
+}
+/**
+* Validate/normalize the `augmentcode` override's `toolPermissions` array into
+* typed `AugmentToolPermission` entries, dropping any malformed item (with a
+* warning so a typo is not lost silently). The override schema is intentionally
+* loose (verbatim passthrough), so entries are re-parsed through the full entry
+* schema here to guarantee shape before they are written into the shared
+* settings file.
+*/
+function coerceAuthoredEntries(entries, logger) {
+	const out = [];
+	for (const item of entries) {
+		const parsed = AugmentToolPermissionSchema.safeParse(item);
+		if (parsed.success) out.push(parsed.data);
+		else logger?.warn(`AugmentCode permissions: dropping malformed 'augmentcode.toolPermissions' override entry: ${formatError(parsed.error)}.`);
+	}
+	return out;
+}
+/**
 * Convert a glob-like pattern into a regex string for AugmentCode's `shellInputRegex`.
 * Maps glob `*` to `.*`, `?` to `.`, escapes other regex metacharacters, and anchors at both ends.
 */
@@ -17492,12 +17732,18 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse existing AugmentCode settings at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
+		const config = rulesyncPermissions.getJson();
 		const generated = convertRulesyncToAugmentEntries({
-			config: rulesyncPermissions.getJson(),
+			config,
 			logger
 		});
 		const existingEntries = settings.toolPermissions ?? [];
-		const specialEntries = existingEntries.filter((entry) => isSpecialEntry(entry));
+		const override = config.augmentcode;
+		const authoredEntries = override?.toolPermissions ? coerceAuthoredEntries(override.toolPermissions, logger) : [];
+		const authoredSpecials = authoredEntries.filter((entry) => isSpecialEntry(entry));
+		const authoredBasics = authoredEntries.filter((entry) => !isSpecialEntry(entry));
+		const preservedSpecials = override?.toolPermissions ? [] : existingEntries.filter((entry) => isSpecialEntry(entry));
+		const specialEntries = dedupeSpecialEntries([...authoredSpecials, ...preservedSpecials]);
 		const basicExistingEntries = existingEntries.filter((entry) => !isSpecialEntry(entry));
 		const generatedKeys = new Set(generated.map((e) => `${e.toolName}|${e.shellInputRegex ?? ""}|${e.permission.type}`));
 		const preservedBasicEntries = basicExistingEntries.filter((entry) => {
@@ -17508,7 +17754,11 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 			}
 			return false;
 		});
-		const sortedBasic = sortAugmentEntries([...generated, ...preservedBasicEntries]);
+		const sortedBasic = sortAugmentEntries([
+			...generated,
+			...preservedBasicEntries,
+			...authoredBasics
+		]);
 		const merged = {
 			...settings,
 			toolPermissions: [...specialEntries, ...sortedBasic]
@@ -17532,11 +17782,14 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		} catch (error) {
 			throw new Error(`Failed to parse AugmentCode permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const config = convertAugmentToRulesyncPermissions({
-			entries: settings.toolPermissions ?? [],
+		const allEntries = settings.toolPermissions ?? [];
+		const specialEntries = allEntries.filter((entry) => isSpecialEntry(entry));
+		const result = { ...convertAugmentToRulesyncPermissions({
+			entries: allEntries.filter((entry) => !isSpecialEntry(entry)),
 			logger: moduleLogger$1
-		});
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+		}) };
+		if (specialEntries.length > 0) result.augmentcode = { toolPermissions: specialEntries };
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		try {
@@ -17670,10 +17923,7 @@ function convertAugmentToRulesyncPermissions({ entries, logger }) {
 	]);
 	const permission = {};
 	for (const entry of entries) {
-		if (isSpecialEntry(entry)) {
-			logger?.warn(`AugmentCode permissions: skipping advanced entry for tool '${entry.toolName}' (type '${entry.permission.type}'${entry.eventType !== void 0 ? `, eventType '${entry.eventType}'` : ""}) on import; rulesync's permission model cannot represent custom policies, eventType, webhookUrl, or script. Such entries are preserved on generate but not imported.`);
-			continue;
-		}
+		if (isSpecialEntry(entry)) continue;
 		const type = entry.permission.type;
 		if (!isBasicAugmentType(type)) continue;
 		const canonical = toCanonicalToolName$5(entry.toolName);
@@ -18105,6 +18355,13 @@ const WORKSPACE_WIDE_WRITE_PATTERNS = /* @__PURE__ */ new Set([
 ]);
 const CODEX_MINIMAL_KEY = ":minimal";
 const GLOBAL_WILDCARD_DOMAIN = "*";
+const CODEXCLI_OVERRIDE_KEYS = [
+	"approval_policy",
+	"sandbox_mode",
+	"sandbox_workspace_write",
+	"apps",
+	"approvals_reviewer"
+];
 var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
 		return {
@@ -18146,6 +18403,11 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 		});
 		parsed.permissions = permissionsTable;
 		parsed.default_permissions = RULESYNC_PROFILE_NAME;
+		applyCodexcliOverride({
+			parsed,
+			override: rulesyncPermissions.getJson().codexcli,
+			logger
+		});
 		return new CodexcliPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -18170,7 +18432,12 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			profile,
 			domainsHadUnknown
 		});
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+		const override = extractCodexcliOverride(table);
+		const result = Object.keys(override).length > 0 ? {
+			...config,
+			codexcli: override
+		} : config;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		return {
@@ -18362,6 +18629,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 = {};
@@ -19276,7 +19567,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : (0, js_yaml.load)(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Goose permission.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -19298,7 +19589,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : (0, js_yaml.load)(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -20205,6 +20496,13 @@ const KiroAgentSchema = zod_mini.z.looseObject({
 	toolsSettings: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown()))
 });
 const UnknownRecordSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown());
+const CANONICAL_SHELL_KEYS = /* @__PURE__ */ new Set(["allowedCommands", "deniedCommands"]);
+const CANONICAL_TOOL_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+	"read",
+	"write",
+	"grep",
+	"glob"
+]);
 var KiroPermissions = class KiroPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
 		return {
@@ -20268,7 +20566,10 @@ var KiroPermissions = class KiroPermissions extends ToolPermissions {
 		const allowedTools = new Set(parsed.allowedTools ?? []);
 		if (allowedTools.has("web_fetch")) permission.webfetch = { "*": "allow" };
 		if (allowedTools.has("web_search")) permission.websearch = { "*": "allow" };
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
+		const kiroOverride = extractKiroOverride(toolsSettings);
+		const result = { permission };
+		if (kiroOverride !== void 0) result.kiro = kiroOverride;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
 		return {
@@ -20318,19 +20619,71 @@ function buildKiroPermissionsFromRulesync({ config, logger, existing }) {
 		});
 		else logger?.warn(`Kiro permissions do not support category: ${category}. Skipping.`);
 	}
-	nextToolsSettings.shell = shell;
+	nextToolsSettings.shell = {
+		...preservedShellFlags(existing),
+		...shell
+	};
 	nextToolsSettings.read = pathTable(pathBuckets.read);
 	nextToolsSettings.write = pathTable(pathBuckets.write);
 	for (const key of ["grep", "glob"]) {
 		const bucket = pathBuckets[key];
 		if (bucket && (bucket.allow.length > 0 || bucket.deny.length > 0)) nextToolsSettings[key] = pathTable(bucket);
 	}
+	applyKiroOverride({
+		override: config.kiro,
+		nextToolsSettings,
+		logger
+	});
 	return {
 		...existing,
 		allowedTools: [...nextAllowedTools].toSorted(),
 		toolsSettings: nextToolsSettings
 	};
 }
+/**
+* Non-canonical `toolsSettings.shell` keys already present in the existing agent
+* config (everything except the canonical `allowed`/`deniedCommands`), so a
+* regenerate does not silently drop a hand-set `autoAllowReadonly` /
+* `denyByDefault` when no `kiro` override re-authors it.
+*/
+function preservedShellFlags(existing) {
+	const existingShell = asRecord$1(asRecord$1(existing.toolsSettings).shell);
+	const flags = {};
+	for (const [key, value] of Object.entries(existingShell)) if (!CANONICAL_SHELL_KEYS.has(key)) flags[key] = value;
+	return flags;
+}
+/**
+* Deep-merge the `kiro` override's `toolsSettings` block into the generated
+* settings, one `toolsSettings` key at a time so the override's leaf fields win
+* without clobbering canonical-generated siblings.
+*
+* Guards, so the override can only author the non-canonical surfaces it is meant
+* for and can never weaken a canonical-generated deny:
+* - prototype-pollution keys are skipped before being used as object keys;
+* - fully-canonical `toolsSettings` keys (`read`/`write`/`grep`/`glob`) are
+*   rejected outright with a warning (their paths are owned by the canonical
+*   `permission` block);
+* - for `shell` (partly canonical), the canonical command-list leaves
+*   (`allowed`/`deniedCommands`) are stripped from the override value so only the
+*   auto-trust flags merge.
+*/
+function applyKiroOverride({ override, nextToolsSettings, logger }) {
+	const overrideToolsSettings = override?.toolsSettings;
+	if (!isPlainObject$1(overrideToolsSettings)) return;
+	for (const [key, value] of Object.entries(overrideToolsSettings)) {
+		if (isPrototypePollutionKey(key)) continue;
+		if (!isPlainObject$1(value)) continue;
+		if (CANONICAL_TOOL_SETTINGS_KEYS.has(key)) {
+			logger?.warn(`Kiro permissions: ignoring 'kiro.toolsSettings.${key}' override; '${key}' paths are driven by the canonical permission block.`);
+			continue;
+		}
+		const mergeValue = key === "shell" ? Object.fromEntries(Object.entries(value).filter(([leaf]) => !CANONICAL_SHELL_KEYS.has(leaf))) : value;
+		nextToolsSettings[key] = {
+			...asRecord$1(nextToolsSettings[key]),
+			...mergeValue
+		};
+	}
+}
 function pathTable(bucket) {
 	return {
 		allowedPaths: bucket?.allow ?? [],
@@ -20350,6 +20703,31 @@ function asRecord$1(value) {
 	const result = UnknownRecordSchema.safeParse(value);
 	return result.success ? result.data : {};
 }
+/**
+* Build the `kiro` permissions override from a parsed agent config's
+* `toolsSettings`, lifting the Kiro-specific knobs with no canonical category:
+* - `shell.*` flags other than the canonical `allowed`/`deniedCommands`
+*   (e.g. `autoAllowReadonly`, `denyByDefault`), verbatim.
+* - the whole `aws` object (`allowedServices` / `deniedServices` / …), verbatim.
+* - the whole `web_fetch` object (`trusted` / `blocked`), verbatim.
+*
+* Returns `undefined` when none are present so the override key is omitted.
+*/
+function extractKiroOverride(toolsSettings) {
+	const overrideToolsSettings = {};
+	const shellFlags = {};
+	for (const [key, value] of Object.entries(asRecord$1(toolsSettings.shell))) {
+		if (isPrototypePollutionKey(key)) continue;
+		if (!CANONICAL_SHELL_KEYS.has(key)) shellFlags[key] = value;
+	}
+	if (Object.keys(shellFlags).length > 0) overrideToolsSettings.shell = shellFlags;
+	const aws = asRecord$1(toolsSettings.aws);
+	if (Object.keys(aws).length > 0) overrideToolsSettings.aws = aws;
+	const webFetch = asRecord$1(toolsSettings.web_fetch);
+	if (Object.keys(webFetch).length > 0) overrideToolsSettings.web_fetch = webFetch;
+	if (Object.keys(overrideToolsSettings).length === 0) return void 0;
+	return { toolsSettings: overrideToolsSettings };
+}
 function asStringArray(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -21162,7 +21540,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		let parsed;
 		try {
-			parsed = existingContent.trim() === "" ? {} : (0, js_yaml.load)(existingContent);
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
 		} catch (error) {
 			throw new Error(`Failed to parse existing Rovodev config at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
@@ -21188,7 +21566,7 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		let parsed;
 		try {
 			const content = this.getFileContent();
-			parsed = content.trim() === "" ? {} : (0, js_yaml.load)(content);
+			parsed = content.trim() === "" ? {} : loadYaml(content);
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
@@ -21383,9 +21761,9 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const provider = resolveActiveProvider(config);
 		const mode = deriveTaktPermissionMode(rulesyncJson);
-		const override = isPlainObject(rulesyncJson.takt) ? rulesyncJson.takt : void 0;
-		const stepOverrides = isPlainObject(override?.[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? override[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
-		const overrideProviderOptions = isPlainObject(override?.[TAKT_PROVIDER_OPTIONS_KEY]) ? override[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
+		const override = isPlainObject$1(rulesyncJson.takt) ? rulesyncJson.takt : void 0;
+		const stepOverrides = isPlainObject$1(override?.[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? override[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
+		const overrideProviderOptions = isPlainObject$1(override?.[TAKT_PROVIDER_OPTIONS_KEY]) ? override[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
 		const patch = {
 			[TAKT_PROVIDER_PROFILES_KEY]: { [provider]: {
 				[TAKT_DEFAULT_PERMISSION_MODE_KEY]: mode,
@@ -21416,12 +21794,12 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 			invalidRootPolicy: "error"
 		});
 		const provider = resolveActiveProvider(config);
-		const profiles = isPlainObject(config[TAKT_PROVIDER_PROFILES_KEY]) ? config[TAKT_PROVIDER_PROFILES_KEY] : {};
-		const profile = isPlainObject(profiles[provider]) ? profiles[provider] : {};
+		const profiles = isPlainObject$1(config[TAKT_PROVIDER_PROFILES_KEY]) ? config[TAKT_PROVIDER_PROFILES_KEY] : {};
+		const profile = isPlainObject$1(profiles[provider]) ? profiles[provider] : {};
 		const mode = profile[TAKT_DEFAULT_PERMISSION_MODE_KEY];
 		const rulesyncConfig = taktModeToRulesyncConfig(mode);
-		const stepOverrides = isPlainObject(profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
-		const providerOptions = isPlainObject(config[TAKT_PROVIDER_OPTIONS_KEY]) ? config[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
+		const stepOverrides = isPlainObject$1(profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY]) ? profile[TAKT_STEP_PERMISSION_OVERRIDES_KEY] : void 0;
+		const providerOptions = isPlainObject$1(config[TAKT_PROVIDER_OPTIONS_KEY]) ? config[TAKT_PROVIDER_OPTIONS_KEY] : void 0;
 		const taktOverride = {};
 		if (stepOverrides && Object.keys(stepOverrides).length > 0) taktOverride[TAKT_STEP_PERMISSION_OVERRIDES_KEY] = stepOverrides;
 		if (providerOptions && Object.keys(providerOptions).length > 0) taktOverride[TAKT_PROVIDER_OPTIONS_KEY] = providerOptions;
@@ -21453,7 +21831,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];
 	}
@@ -24442,7 +24820,7 @@ function extractOpenaiYamlFile(otherFiles) {
 	const rest = [];
 	for (const file of otherFiles) {
 		if (toPosixPath(file.relativeFilePathToDirPath) === target) try {
-			const loaded = (0, js_yaml.load)(file.fileBuffer.toString("utf-8"));
+			const loaded = loadYaml(file.fileBuffer.toString("utf-8"));
 			if (loaded !== null && typeof loaded === "object" && !Array.isArray(loaded)) {
 				parsed = loaded;
 				continue;
@@ -26693,6 +27071,139 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/reasonix-skill.ts
+const ReasonixSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string()
+});
+/**
+* Represents a DeepSeek-Reasonix skill directory.
+*
+* Reasonix discovers directory-layout skills (`<name>/SKILL.md`) under
+* `.reasonix/skills/` (project) and `~/.reasonix/skills/` (global); the global
+* scope is served by the processor supplying the home directory as outputRoot.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/GUIDE.md
+*/
+var ReasonixSkill = class ReasonixSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = REASONIX_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: REASONIX_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return ReasonixSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (this.mainFile === void 0) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = ReasonixSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const frontmatter = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			targets: ["*"]
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const reasonixFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath: ReasonixSkill.getSettablePaths({ global }).relativeDirPath,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: reasonixFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("reasonix");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: ReasonixSkill.getSettablePaths
+		});
+		const result = ReasonixSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) {
+			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		return new ReasonixSkill({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new ReasonixSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/constants/replit-paths.ts
 const REPLIT_RULE_FILE_NAME = "replit.md";
 const REPLIT_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
@@ -27787,6 +28298,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["replit", {
 		class: ReplitSkill,
 		meta: {
@@ -30070,7 +30589,7 @@ var GooseSubagent = class GooseSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse Goose recipe (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -31458,7 +31977,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		const fileContent = await readFileContent(filePath);
 		let parsed;
 		try {
-			parsed = (0, js_yaml.load)(fileContent);
+			parsed = loadYaml(fileContent);
 		} catch (error) {
 			throw new Error(`Failed to parse .roomodes (${filePath}): ${formatError(error)}`, { cause: error });
 		}
@@ -35651,6 +36170,72 @@ var QwencodeRule = class QwencodeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/reasonix-rule.ts
+var ReasonixRule = class ReasonixRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { root: {
+			relativeDirPath: global ? REASONIX_GLOBAL_DIR : ".",
+			relativeFilePath: REASONIX_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: isRoot
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "REASONIX.md" && (relativeDirPath === "." || relativeDirPath === ".reasonix")
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "reasonix"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/replit-rule.ts
 /**
 * Rule generator for Replit Agent
@@ -36563,6 +37148,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: {
@@ -37448,7 +38042,6 @@ const SHARED_WRITE_FEATURE_ORDER = [
 	"permissions",
 	"rules"
 ];
-const SHARED_WRITE_FEATURES = new Set(SHARED_WRITE_FEATURE_ORDER);
 const TARGETS_NOT_DERIVED = /* @__PURE__ */ new Set(["augmentcode-legacy", "claudecode-legacy"]);
 const sharedFileKey = (path) => {
 	const dir = path.relativeDirPath.replace(/\\/g, "/").replace(/\/$/, "");
@@ -37471,7 +38064,13 @@ const settablePathsForScope = (cls, global) => {
 		paths.push(settable.root);
 		for (const alt of settable.alternativeRoots ?? []) paths.push(alt);
 	}
-	for (const path of cls.getExtraSharedWritePaths?.({ global }) ?? []) if (path.relativeFilePath) paths.push(path);
+	let extra;
+	try {
+		extra = cls.getExtraSharedWritePaths?.({ global }) ?? [];
+	} catch {
+		return paths;
+	}
+	for (const path of extra) if (path.relativeFilePath) paths.push(path);
 	return paths;
 };
 const collectFactoryPaths = (factory) => [...settablePathsForScope(factory.class, false), ...settablePathsForScope(factory.class, true)];
@@ -37484,7 +38083,6 @@ const deriveSharedFileWriters = () => {
 	const byKey = /* @__PURE__ */ new Map();
 	const pathByKey = /* @__PURE__ */ new Map();
 	for (const entry of PROCESSOR_REGISTRY) {
-		if (!SHARED_WRITE_FEATURES.has(entry.feature)) continue;
 		const factories = entry.factory;
 		for (const [tool, factory] of factories) {
 			if (TARGETS_NOT_DERIVED.has(tool)) continue;
@@ -38906,6 +39504,12 @@ Object.defineProperty(exports, "listDirectoryFiles", {
 		return listDirectoryFiles;
 	}
 });
+Object.defineProperty(exports, "loadYaml", {
+	enumerable: true,
+	get: function() {
+		return loadYaml;
+	}
+});
 Object.defineProperty(exports, "readFileContent", {
 	enumerable: true,
 	get: function() {