rulesync 9.0.2 → 9.1.1

package/dist/{import-BhqQwWah.cjs → import-cNqo0ZxT.cjs}

@@ -114,22 +114,22 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$238 } = node_path.posix;
+const { join: join$248 } = 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$238(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$238(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$248(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$238(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$238(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$248(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$248(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";
@@ -224,6 +224,7 @@ const mcpProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"takt",
 	"vibe",
 	"warp",
 	"devin",
@@ -231,6 +232,7 @@ const mcpProcessorToolTargetTuple = [
 ];
 const commandsProcessorToolTargetTuple = [
 	"agentsmd",
+	"antigravity-cli",
 	"antigravity-ide",
 	"augmentcode",
 	"claudecode",
@@ -250,7 +252,9 @@ const commandsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"roo",
+	"rovodev",
 	"takt",
 	"devin"
 ];
@@ -335,11 +339,13 @@ const hooksProcessorToolTargetTuple = [
 	"deepagents",
 	"kiro",
 	"kiro-cli",
+	"kiro-ide",
 	"devin",
 	"augmentcode",
 	"junie",
 	"vibe",
-	"qwencode"
+	"qwencode",
+	"reasonix"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -350,16 +356,19 @@ const permissionsProcessorToolTargetTuple = [
 	"cline",
 	"codexcli",
 	"cursor",
+	"devin",
 	"factorydroid",
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"junie",
 	"kilo",
 	"kiro",
 	"kiro-cli",
 	"kiro-ide",
 	"opencode",
 	"qwencode",
+	"reasonix",
 	"rovodev",
 	"takt",
 	"vibe",
@@ -1399,7 +1408,7 @@ function extractConfigFileTargets(targets) {
 * Type guard to check if a value is a plain object (Record<string, unknown>).
 * This excludes arrays and null values.
 */
-function isRecord$1(value) {
+function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -1414,7 +1423,7 @@ function isRecord$1(value) {
 * malicious accessor descriptors.
 */
 function isPlainObject(value) {
-	if (!isRecord$1(value)) return false;
+	if (!isRecord(value)) return false;
 	const proto = Object.getPrototypeOf(value);
 	return proto === null || proto === Object.prototype;
 }
@@ -1765,6 +1774,17 @@ var ToolCommand = class extends AiFile {
 		throw new Error("Please implement this method in the subclass.");
 	}
 	/**
+	* Optional hook for tools whose commands are not purely one-file-per-command
+	* (e.g. Rovo Dev's `prompts.yml` manifest that indexes every saved-prompt
+	* content file). Given the full set of ToolCommand instances just generated
+	* for this target, returns any additional shared/aggregate files that must
+	* be written alongside them. Most tools don't need this and inherit the
+	* empty default (mirrors `ToolHooks.getAuxiliaryFiles`).
+	*/
+	static async getAuxiliaryFiles(_params) {
+		return [];
+	}
+	/**
 	* Convert a RulesyncCommand to the tool-specific command format.
 	*
 	* This method should:
@@ -1923,16 +1943,25 @@ var AgentsmdCommand = class AgentsmdCommand extends SimulatedCommand {
 	}
 };
 //#endregion
-//#region src/constants/antigravity-ide-paths.ts
-const ANTIGRAVITY_IDE_AGENTS_DIR = ".agents";
-const ANTIGRAVITY_IDE_COMMANDS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_IDE_AGENTS_DIR, "workflows");
-const ANTIGRAVITY_IDE_RULE_FILE_NAME = "AGENTS.md";
-const ANTIGRAVITY_IDE_GEMINI_DIR = ".gemini";
-const ANTIGRAVITY_IDE_GLOBAL_RULE_FILE_NAME = "GEMINI.md";
-const ANTIGRAVITY_IDE_GLOBAL_CONFIG_SUBDIR = "config";
-const ANTIGRAVITY_IDE_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_IDE_GEMINI_DIR, "antigravity", "global_workflows");
-const ANTIGRAVITY_IDE_PERMISSIONS_DIR = ".antigravity";
-const ANTIGRAVITY_IDE_PERMISSIONS_FILE_NAME = "settings.json";
+//#region src/constants/antigravity-paths.ts
+const ANTIGRAVITY_DIR = ".agents";
+const ANTIGRAVITY_SKILLS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "skills");
+const ANTIGRAVITY_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "workflows");
+const ANTIGRAVITY_MCP_FILE_NAME = "mcp_config.json";
+const ANTIGRAVITY_HOOKS_FILE_NAME = "hooks.json";
+const ANTIGRAVITY_IGNORE_FILE_NAME = ".geminiignore";
+const ANTIGRAVITY_GEMINI_DIR = ".gemini";
+const ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR = "antigravity-cli";
+const ANTIGRAVITY_CLI_PERMISSIONS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR);
+const ANTIGRAVITY_CLI_PERMISSIONS_FILE_NAME = "settings.json";
+const ANTIGRAVITY_CLI_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR, "global_workflows");
+const ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR = "config";
+const ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR);
+//#endregion
+//#region src/constants/antigravity-cli-paths.ts
+const ANTIGRAVITY_AGENTS_DIR = ANTIGRAVITY_DIR;
+const ANTIGRAVITY_RULE_FILE_NAME = "AGENTS.md";
+const ANTIGRAVITY_GLOBAL_RULE_FILE_NAME = "GEMINI.md";
 //#endregion
 //#region src/features/commands/antigravity-command.ts
 const AntigravityWorkflowFrontmatterSchema = zod_mini.z.looseObject({
@@ -2106,7 +2135,7 @@ var AntigravitySharedCommand = class extends ToolCommand {
 	}
 	static extractAntigravityConfig(rulesyncCommand) {
 		const antigravity = rulesyncCommand.getFrontmatter().antigravity;
-		return isRecord$1(antigravity) ? antigravity : void 0;
+		return isRecord(antigravity) ? antigravity : void 0;
 	}
 	static resolveTrigger(rulesyncCommand, antigravityConfig) {
 		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
@@ -2188,6 +2217,45 @@ var AntigravitySharedCommand = class extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/features/commands/antigravity-cli-command.ts
+/**
+* Command (workflow) generator for the Google Antigravity CLI (`agy`, Antigravity 2.0).
+*
+* Shares all body and frontmatter handling with {@link AntigravitySharedCommand};
+* the CLI reads project workflows from the same `.agents/workflows/` directory as
+* the IDE (the shared Antigravity 2.0 harness), but keeps its own global
+* workflows tree at `~/.gemini/antigravity-cli/global_workflows/` (mirroring the
+* CLI's global skills tree). It answers to the `antigravity-cli` target.
+*/
+var AntigravityCliCommand = class extends AntigravitySharedCommand {
+	static getProjectRelativeDirPath() {
+		return ANTIGRAVITY_WORKFLOWS_DIR_PATH;
+	}
+	static getGlobalRelativeDirPath() {
+		return ANTIGRAVITY_CLI_GLOBAL_WORKFLOWS_DIR_PATH;
+	}
+	getToolTargetName() {
+		return "antigravity-cli";
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "antigravity-cli"
+		});
+	}
+};
+//#endregion
+//#region src/constants/antigravity-ide-paths.ts
+const ANTIGRAVITY_IDE_AGENTS_DIR = ".agents";
+const ANTIGRAVITY_IDE_COMMANDS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_IDE_AGENTS_DIR, "workflows");
+const ANTIGRAVITY_IDE_RULE_FILE_NAME = "AGENTS.md";
+const ANTIGRAVITY_IDE_GEMINI_DIR = ".gemini";
+const ANTIGRAVITY_IDE_GLOBAL_RULE_FILE_NAME = "GEMINI.md";
+const ANTIGRAVITY_IDE_GLOBAL_CONFIG_SUBDIR = "config";
+const ANTIGRAVITY_IDE_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_IDE_GEMINI_DIR, "antigravity", "global_workflows");
+const ANTIGRAVITY_IDE_PERMISSIONS_DIR = ".antigravity";
+const ANTIGRAVITY_IDE_PERMISSIONS_FILE_NAME = "settings.json";
+//#endregion
 //#region src/features/commands/antigravity-ide-command.ts
 /**
 * Command (workflow) generator for the Google Antigravity IDE (Antigravity 2.0).
@@ -2572,6 +2640,16 @@ const CodexcliCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
 });
+/**
+* Generates Codex CLI's global-only custom prompts under `~/.codex/prompts/*.md`.
+*
+* Note: upstream Codex docs now state "Custom prompts are deprecated. Use skills for
+* reusable instructions" (https://developers.openai.com/codex/custom-prompts). No removal
+* date has been announced and custom prompts remain functional, so this class's
+* generation behavior is unchanged. Prefer rulesync's `codexcli` skills support
+* (see `src/features/skills/codexcli-skill.ts`) for new reusable instructions going
+* forward; this class is kept for users who still rely on custom prompts.
+*/
 var CodexcliCommand = class CodexcliCommand extends ToolCommand {
 	frontmatter;
 	body;
@@ -2695,7 +2773,7 @@ const COPILOTCLI_PROJECT_MCP_FILE_NAME = "mcp.json";
 const COPILOTCLI_AGENTS_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "agents");
 const COPILOTCLI_HOOKS_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "hooks");
 const COPILOTCLI_HOOKS_FILE_NAME = "copilotcli-hooks.json";
-const COPILOTCLI_SKILLS_GLOBAL_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "skills");
+const COPILOT_SKILLS_GLOBAL_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "skills");
 //#endregion
 //#region src/features/commands/copilot-command.ts
 const CopilotCommandFrontmatterSchema = zod_mini.z.looseObject({
@@ -2945,20 +3023,17 @@ var CursorCommand = class CursorCommand extends ToolCommand {
 //#endregion
 //#region src/constants/devin-paths.ts
 const DEVIN_DIR = ".devin";
-const WINDSURF_DIR = ".windsurf";
-const CODEIUM_DIR = ".codeium";
-const WINDSURF_SUBDIR = "windsurf";
-const CODEIUM_WINDSURF_DIR = (0, node_path.join)(CODEIUM_DIR, WINDSURF_SUBDIR);
-const WINDSURF_MEMORIES_SUBDIR = (0, node_path.join)(WINDSURF_SUBDIR, "memories");
+const CODEIUM_WINDSURF_DIR = (0, node_path.join)(".codeium", "windsurf");
 const DEVIN_WORKFLOWS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "workflows");
 const DEVIN_SKILLS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "skills");
 const DEVIN_AGENTS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "agents");
-const DEVIN_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(".config", "devin", "agents");
+const DEVIN_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(".config", "devin");
+const DEVIN_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(DEVIN_GLOBAL_CONFIG_DIR_PATH, "agents");
 const CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(CODEIUM_WINDSURF_DIR, "global_workflows");
 const CODEIUM_WINDSURF_SKILLS_DIR_PATH = (0, node_path.join)(CODEIUM_WINDSURF_DIR, "skills");
-const DEVIN_MCP_FILE_NAME = "mcp_config.json";
-const DEVIN_HOOKS_FILE_NAME = "hooks.json";
-const DEVIN_GLOBAL_RULES_FILE_NAME = "global_rules.md";
+const DEVIN_CONFIG_FILE_NAME = "config.json";
+const DEVIN_HOOKS_V1_FILE_NAME = "hooks.v1.json";
+const DEVIN_GLOBAL_AGENTS_FILE_NAME = "AGENTS.md";
 const DEVIN_IGNORE_FILE_NAME = ".devinignore";
 const DEVIN_LEGACY_IGNORE_FILE_NAME = ".codeiumignore";
 //#endregion
@@ -3207,6 +3282,8 @@ const GOOSE_MCP_FILE_NAME = "config.yaml";
 const GOOSE_PERMISSIONS_FILE_NAME = "permission.yaml";
 const GOOSE_HOOKS_DIR_PATH = (0, node_path.join)(".agents", "plugins", "rulesync", "hooks");
 const GOOSE_HOOKS_FILE_NAME = "hooks.json";
+const GOOSE_PLUGIN_MCP_DIR_PATH = (0, node_path.join)(".agents", "plugins", "rulesync");
+const GOOSE_PLUGIN_MCP_FILE_NAME = ".mcp.json";
 const GOOSE_SKILLS_DIR_PATH = (0, node_path.join)(GOOSE_DIR, "skills");
 const GOOSE_RECIPES_DIR_PATH = (0, node_path.join)(GOOSE_DIR, "recipes");
 const GOOSE_GLOBAL_RECIPES_DIR_PATH = (0, node_path.join)(GOOSE_GLOBAL_DIR, "recipes");
@@ -3465,6 +3542,7 @@ const JUNIE_ALT_AGENTS_DIR_PATH = ".agents";
 const JUNIE_MCP_DIR_PATH = (0, node_path.join)(JUNIE_DIR, "mcp");
 const JUNIE_MCP_FILE_NAME = "mcp.json";
 const JUNIE_HOOKS_FILE_NAME = "config.json";
+const JUNIE_PERMISSIONS_FILE_NAME = "allowlist.json";
 const JUNIE_IGNORE_FILE_NAME = ".aiignore";
 const JUNIE_RULE_FILE_NAME = "AGENTS.md";
 const JUNIE_LEGACY_RULE_FILE_NAME = "guidelines.md";
@@ -3717,6 +3795,15 @@ const KIRO_SKILLS_DIR_PATH = (0, node_path.join)(KIRO_DIR, "skills");
 const KIRO_SETTINGS_DIR_PATH = (0, node_path.join)(KIRO_DIR, "settings");
 const KIRO_AGENTS_DIR_PATH = (0, node_path.join)(KIRO_DIR, "agents");
 const KIRO_HOOKS_FILE_NAME = "default.json";
+/**
+* Kiro IDE 1.0 stores hooks as structured JSON files in `.kiro/hooks/`
+* (workspace) and `~/.kiro/hooks/` (user). A single file may declare multiple
+* hooks in its `hooks` array, so rulesync emits all generated hooks into one
+* `rulesync.json` file per scope.
+* @see https://kiro.dev/docs/hooks/
+*/
+const KIRO_IDE_HOOKS_DIR_PATH = (0, node_path.join)(KIRO_DIR, "hooks");
+const KIRO_IDE_HOOKS_FILE_NAME = "rulesync.json";
 const KIRO_MCP_FILE_NAME = "mcp.json";
 const KIRO_IGNORE_FILE_NAME = ".kiroignore";
 //#endregion
@@ -4296,6 +4383,135 @@ var QwencodeCommand = class QwencodeCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/reasonix-paths.ts
+const REASONIX_PROJECT_MCP_FILE_NAME = "reasonix.toml";
+const REASONIX_GLOBAL_DIR = ".reasonix";
+const REASONIX_GLOBAL_MCP_FILE_NAME = "config.toml";
+const REASONIX_PROJECT_PERMISSIONS_FILE_NAME = REASONIX_PROJECT_MCP_FILE_NAME;
+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");
+//#endregion
+//#region src/features/commands/reasonix-command.ts
+/**
+* Reasonix custom slash commands are Markdown files under `.reasonix/commands/`
+* (project) / `~/.reasonix/commands/` (global) — directly analogous to Claude
+* Code's `.claude/commands/` (Reasonix explicitly copies Claude Code's
+* conventions). Frontmatter supports `description` and `argument-hint`; the
+* body uses the same `$ARGUMENTS` / `$1`…`$N` placeholder syntax rulesync's
+* universal command-body syntax already targets.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/GUIDE.md
+*/
+const ReasonixCommandFrontmatterSchema = zod_mini.z.looseObject({
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
+});
+var ReasonixCommand = class ReasonixCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = ReasonixCommandFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: REASONIX_COMMANDS_DIR_PATH };
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	toRulesyncCommand() {
+		const { description, ...restFields } = this.frontmatter;
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description,
+			...Object.keys(restFields).length > 0 && { reasonix: restFields }
+		};
+		const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent,
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const reasonixFields = rulesyncFrontmatter.reasonix ?? {};
+		return new ReasonixCommand({
+			outputRoot,
+			frontmatter: {
+				description: rulesyncFrontmatter.description,
+				...reasonixFields
+			},
+			body: rulesyncCommand.getBody(),
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = ReasonixCommandFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "reasonix"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = ReasonixCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new ReasonixCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/constants/roo-paths.ts
 const ROO_DIR = ".roo";
 const ROO_COMMANDS_DIR_PATH = (0, node_path.join)(ROO_DIR, "commands");
@@ -4427,6 +4643,217 @@ var RooCommand = class RooCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/rovodev-paths.ts
+const ROVODEV_DIR = ".rovodev";
+const ROVODEV_SKILLS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "skills");
+const ROVODEV_SUBAGENTS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "subagents");
+const ROVODEV_MODULAR_RULES_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, ".rulesync", "modular-rules");
+const ROVODEV_RULE_FILE_NAME = "AGENTS.md";
+const ROVODEV_LEGACY_RULE_FILE_NAME = "AGENTS.local.md";
+const ROVODEV_MCP_FILE_NAME = "mcp.json";
+const ROVODEV_CONFIG_FILE_NAME = "config.yml";
+const ROVODEV_AGENTS_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
+const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
+const ROVODEV_PROMPTS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "prompts");
+//#endregion
+//#region src/types/tool-file.ts
+var ToolFile = class extends AiFile {};
+//#endregion
+//#region src/features/commands/rovodev-command.ts
+/**
+* Rovo Dev CLI "saved prompts": a file-based custom-command surface made of a
+* `prompts.yml` manifest (`{ name, description, content_file }` entries) plus
+* per-prompt Markdown content files, discovered in repo-root `.rovodev/`, cwd
+* `.rovodev/`, and global `~/.rovodev/`, and invoked via `/prompts [title] [extra]`.
+*
+* This class represents a single prompt's **content file** — pure Markdown,
+* no frontmatter — written to `.rovodev/prompts/<name>.md` (project) or
+* `~/.rovodev/prompts/<name>.md` (global). The `name`/`description` are kept
+* on the instance (not serialized into the content file itself) so that
+* {@link RovodevCommand.getAuxiliaryFiles} can build the sibling
+* `prompts.yml` manifest that indexes every generated prompt.
+*
+* @see https://support.atlassian.com/rovo/docs/save-and-reuse-a-prompt-in-rovo-dev-cli/
+* @see https://support.atlassian.com/rovo/docs/rovo-dev-cli-commands/
+*/
+var RovodevCommand = class RovodevCommand extends ToolCommand {
+	name;
+	description;
+	body;
+	constructor({ name, description, body, ...rest }) {
+		super({
+			...rest,
+			fileContent: body
+		});
+		this.name = name;
+		this.description = description;
+		this.body = body;
+		if (rest.validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: ROVODEV_PROMPTS_DIR_PATH };
+	}
+	getName() {
+		return this.name;
+	}
+	getDescription() {
+		return this.description;
+	}
+	getBody() {
+		return this.body;
+	}
+	validate() {
+		if (!this.name) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: Rovo Dev saved-prompt name must not be empty`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncCommand() {
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description: this.description
+		};
+		const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.getRelativeFilePath(),
+			fileContent,
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const relativeFilePath = rulesyncCommand.getRelativeFilePath();
+		const name = (0, node_path.basename)(relativeFilePath, ".md");
+		const paths = this.getSettablePaths({ global });
+		return new RovodevCommand({
+			outputRoot,
+			name,
+			description: rulesyncFrontmatter.description ?? "",
+			body: rulesyncCommand.getBody(),
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "rovodev"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const body = (await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath))).trim();
+		const name = (0, node_path.basename)(relativeFilePath, ".md");
+		return new RovodevCommand({
+			outputRoot,
+			name,
+			description: await lookupPromptDescription({
+				outputRoot,
+				relativeFilePath,
+				name
+			}),
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new RovodevCommand({
+			outputRoot,
+			name: (0, node_path.basename)(relativeFilePath, ".md"),
+			description: "",
+			body: "",
+			relativeDirPath,
+			relativeFilePath,
+			validate: false,
+			global
+		});
+	}
+	/**
+	* Rebuilds `.rovodev/prompts.yml` (project) / `~/.rovodev/prompts.yml`
+	* (global) from every `RovodevCommand` generated in this pass. The `prompts`
+	* array is fully replaced with the current set of rulesync-managed prompts
+	* (mirrors `RovodevMcp` fully replacing `mcpServers`); any other top-level
+	* key in an existing manifest is preserved.
+	*/
+	static async getAuxiliaryFiles({ toolCommands, outputRoot = process.cwd(), global = false }) {
+		const rovodevCommands = toolCommands.filter((command) => command instanceof RovodevCommand);
+		if (rovodevCommands.length === 0) return [];
+		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;
+		} catch {}
+		const prompts = rovodevCommands.map((command) => ({
+			name: command.getName(),
+			description: command.getDescription(),
+			content_file: toPosixPath((0, node_path.join)("prompts", command.getRelativeFilePath()))
+		})).toSorted((a, b) => a.name.localeCompare(b.name));
+		return [new RovodevPromptsManifest({
+			outputRoot,
+			relativeDirPath: ROVODEV_DIR,
+			relativeFilePath: ROVODEV_PROMPTS_FILE_NAME,
+			fileContent: (0, js_yaml.dump)({
+				...existing,
+				prompts
+			}),
+			global
+		})];
+	}
+};
+/**
+* The `prompts` entry shape read back from `content_file`, matched against
+* either the resolved path (relative to `prompts.yml`, i.e. the `.rovodev/`
+* directory) or the entry `name`, to recover the `description` that isn't
+* stored in the content file itself.
+*/
+async function lookupPromptDescription({ outputRoot, relativeFilePath, name }) {
+	const manifestContent = await readFileContentOrNull((0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
+	if (!manifestContent) return "";
+	let parsed;
+	try {
+		parsed = (0, js_yaml.load)(manifestContent);
+	} catch {
+		return "";
+	}
+	if (!isPlainObject(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 : "";
+}
+/**
+* The shared `.rovodev/prompts.yml` manifest that indexes every saved prompt.
+* Never deleted by orphan cleanup: it is regenerated (not individually
+* discovered) alongside the per-prompt content files it references.
+*/
+var RovodevPromptsManifest = class extends ToolFile {
+	isDeletable() {
+		return false;
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+};
+//#endregion
 //#region src/constants/takt-paths.ts
 const TAKT_DIR = ".takt";
 const TAKT_FACETS_SUBDIR = "facets";
@@ -4444,6 +4871,14 @@ const TAKT_RULE_OVERVIEW_FILE_NAME = "overview.md";
 * @see https://github.com/nrslib/takt/blob/main/docs/configuration.md
 */
 const TAKT_CONFIG_FILE_NAME = "config.yaml";
+/**
+* Top-level key in Takt's `config.yaml` holding the workflow MCP transport
+* allowlist (`stdio` / `sse` / `http` booleans). Takt is default-deny: a
+* transport must be explicitly enabled here before any workflow-defined MCP
+* server using it is permitted to run.
+* @see https://github.com/nrslib/takt/blob/main/docs/configuration.md
+*/
+const TAKT_WORKFLOW_MCP_SERVERS_KEY = "workflow_mcp_servers";
 //#endregion
 //#region src/features/takt-shared.ts
 /**
@@ -4619,6 +5054,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["antigravity-cli", {
+		class: AntigravityCliCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: false
+		}
+	}],
 	["antigravity-ide", {
 		class: AntigravityIdeCommand,
 		meta: {
@@ -4764,7 +5209,7 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsProject: true,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			isSimulated: false,
 			supportsSubdirectory: false
 		}
@@ -4809,6 +5254,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["roo", {
 		class: RooCommand,
 		meta: {
@@ -4819,6 +5274,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: true
 		}
 	}],
+	["rovodev", {
+		class: RovodevCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: false
+		}
+	}],
 	["takt", {
 		class: TaktCommand,
 		meta: {
@@ -4876,7 +5341,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 		const rulesyncCommands = rulesyncFiles.filter((file) => file instanceof RulesyncCommand);
 		const factory = this.getFactory(this.toolTarget);
 		const flattenedPathOrigins = /* @__PURE__ */ new Map();
-		return rulesyncCommands.map((rulesyncCommand) => {
+		const toolCommands = rulesyncCommands.map((rulesyncCommand) => {
 			if (!factory.class.isTargetedByRulesyncCommand(rulesyncCommand)) return null;
 			const originalRelativePath = rulesyncCommand.getRelativeFilePath();
 			const commandToConvert = factory.meta.supportsSubdirectory ? rulesyncCommand : this.flattenRelativeFilePath(rulesyncCommand);
@@ -4892,6 +5357,14 @@ var CommandsProcessor = class extends FeatureProcessor {
 				global: this.global
 			});
 		}).filter((command) => command !== null);
+		const auxiliaryFiles = await factory.class.getAuxiliaryFiles?.({
+			toolCommands,
+			outputRoot: this.outputRoot,
+			global: this.global
+		});
+		const result = [...toolCommands];
+		if (auxiliaryFiles && auxiliaryFiles.length > 0) result.push(...auxiliaryFiles);
+		return result;
 	}
 	async convertToolFilesToRulesyncFiles(toolFiles) {
 		return toolFiles.filter((file) => file instanceof ToolCommand).map((toolCommand) => {
@@ -5050,7 +5523,14 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.optional(safeString),
 	description: zod_mini.z.optional(safeString),
 	failClosed: zod_mini.z.optional(zod_mini.z.boolean()),
-	sequential: zod_mini.z.optional(zod_mini.z.boolean())
+	sequential: zod_mini.z.optional(zod_mini.z.boolean()),
+	async: zod_mini.z.optional(zod_mini.z.boolean()),
+	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), safeString)),
+	shell: zod_mini.z.optional(safeString),
+	statusMessage: zod_mini.z.optional(safeString),
+	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), safeString)),
+	allowedEnvVars: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	once: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /** Hook events supported by Cursor. */
 const CURSOR_HOOK_EVENTS = [
@@ -5114,6 +5594,30 @@ const CLAUDE_HOOK_EVENTS = [
 	"elicitation",
 	"elicitationResult"
 ];
+/**
+* Hook events supported by Devin Local (native `.devin/` hooks).
+*
+* Devin Local adopts a Claude-Code-style lifecycle hooks surface. It documents
+* seven events: `PreToolUse`, `PostToolUse`, `PermissionRequest`,
+* `UserPromptSubmit`, `Stop`, `SessionStart`, and `SessionEnd`. The
+* tool/permission events (`PreToolUse`/`PostToolUse`/`PermissionRequest`) carry
+* a `matcher` (regex against `tool_name`); the session/turn events do not.
+*
+* Hooks live in `.devin/hooks.v1.json` (project, standalone — the hooks object
+* is the entire file) or under the `"hooks"` key of `.devin/config.json` /
+* `~/.config/devin/config.json`.
+*
+* @see https://docs.devin.ai/cli/extensibility/hooks/overview
+*/
+const DEVIN_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"preToolUse",
+	"postToolUse",
+	"beforeSubmitPrompt",
+	"stop",
+	"permissionRequest"
+];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
 	"sessionStart",
@@ -5156,7 +5660,11 @@ const COPILOT_HOOK_EVENTS = [
 * `sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`.
+* `notification`, `preMcpToolCall` ← `beforeMCPExecution`.
+*
+* `preMcpToolCall` (canonical `beforeMCPExecution`) was added in Copilot CLI
+* v1.0.51 (2026-05-20) for hook providers to control outgoing MCP request
+* metadata. https://github.com/github/copilot-cli/blob/main/changelog.md
 *
 * @see https://docs.github.com/en/copilot/reference/hooks-configuration
 */
@@ -5173,7 +5681,8 @@ const COPILOTCLI_HOOK_EVENTS = [
 	"afterError",
 	"preCompact",
 	"permissionRequest",
-	"notification"
+	"notification",
+	"beforeMCPExecution"
 ];
 /**
 * Hook events supported by Factory Droid.
@@ -5258,6 +5767,25 @@ const KIRO_HOOK_EVENTS = [
 	"stop"
 ];
 /**
+* Hook events supported by the Kiro IDE (`.kiro/hooks/*.json` v1).
+*
+* Kiro IDE 1.0 exposes PascalCase triggers. rulesync maps the canonical
+* lifecycle events that have a clean 1:1 IDE equivalent: `SessionStart`,
+* `Stop`, `UserPromptSubmit`, `PreToolUse`, and `PostToolUse`. The IDE also
+* documents file-event (`PostFileCreate`/`PostFileSave`/`PostFileDelete`) and
+* spec-task (`PreTaskExec`/`PostTaskExec`) triggers that have no canonical
+* equivalent; those can still be emitted verbatim via a `kiro-ide` override
+* block (unknown event keys pass through unchanged).
+* @see https://kiro.dev/docs/hooks/types/
+*/
+const KIRO_IDE_HOOK_EVENTS = [
+	"sessionStart",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"stop"
+];
+/**
 * Hook events supported by Google Antigravity (both the IDE and the CLI).
 *
 * Antigravity exposes a Claude-style hooks surface covering the five
@@ -5308,18 +5836,23 @@ const VIBE_HOOK_EVENTS = [
 /**
 * Hook events supported by JetBrains Junie CLI.
 *
-* Junie CLI exposes four lifecycle events under the `"hooks"` key of
-* `~/.junie/config.json`: `SessionStart`, `UserPromptSubmit`, `Stop`, and
-* `SessionEnd`. Matchers apply only to `SessionStart` / `SessionEnd`
-* (e.g. `startup` / `resume`); `UserPromptSubmit` and `Stop` are
-* matcher-less. Only `type: "command"` hooks are supported. Project-local
-* hooks are ignored for safety.
+* Junie CLI exposes seven lifecycle events under the `"hooks"` key of
+* `~/.junie/config.json`: `SessionStart`, `UserPromptSubmit`, `PreToolUse`,
+* `Stop`, `StopFailure`, `PermissionRequest`, and `SessionEnd`. Matchers apply
+* to `SessionStart` (source), `PreToolUse` (tool name), `StopFailure` (error
+* type), `PermissionRequest` (tool name), and `SessionEnd` (reason);
+* `UserPromptSubmit` and `Stop` are matcher-less and always run. Only
+* `type: "command"` hooks are supported. Project-local hooks are ignored for
+* safety.
 * @see https://junie.jetbrains.com/docs/junie-cli-hooks.html
 */
 const JUNIE_HOOK_EVENTS = [
 	"sessionStart",
 	"beforeSubmitPrompt",
+	"preToolUse",
 	"stop",
+	"stopFailure",
+	"permissionRequest",
 	"sessionEnd"
 ];
 /**
@@ -5351,6 +5884,69 @@ const QWENCODE_HOOK_EVENTS = [
 	"todoCreated",
 	"todoCompleted"
 ];
+/**
+* Hook events supported by Reasonix.
+*
+* 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.
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
+*/
+const REASONIX_HOOK_EVENTS = [
+	"preToolUse",
+	"postToolUse",
+	"beforeSubmitPrompt",
+	"stop"
+];
+/**
+* Hook events supported by Hermes Agent's native Shell Hooks system.
+*
+* Hermes validates hook events against a fixed `VALID_HOOKS` set:
+* `pre_tool_call`, `post_tool_call`, `pre_llm_call`, `post_llm_call`,
+* `pre_verify`, `on_session_start`, `on_session_end`, `on_session_finalize`,
+* `on_session_reset`, `subagent_start`, `subagent_stop`, `pre_gateway_dispatch`,
+* `pre_approval_request`, `post_approval_response`, `transform_tool_result`,
+* `transform_terminal_output`, `transform_llm_output`. Only the events with a
+* clean 1:1 canonical equivalent are mapped here; the remaining `VALID_HOOKS`
+* entries (`pre_verify`, `on_session_finalize`, `on_session_reset`,
+* `pre_gateway_dispatch`, `pre_approval_request`, `post_approval_response`, the
+* `transform_*` result-rewriting hooks) have no canonical rulesync equivalent,
+* so no canonical event maps to them.
+* @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
+*/
+const HERMESAGENT_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"preToolUse",
+	"postToolUse",
+	"preModelInvocation",
+	"postModelInvocation",
+	"subagentStart",
+	"subagentStop"
+];
+/**
+* Map canonical camelCase event names to Hermes Agent's native `VALID_HOOKS`
+* snake_case keys under the `hooks:` block of `~/.hermes/config.yaml`.
+*/
+const CANONICAL_TO_HERMESAGENT_EVENT_NAMES = {
+	sessionStart: "on_session_start",
+	sessionEnd: "on_session_end",
+	preToolUse: "pre_tool_call",
+	postToolUse: "post_tool_call",
+	preModelInvocation: "pre_llm_call",
+	postModelInvocation: "post_llm_call",
+	subagentStart: "subagent_start",
+	subagentStop: "subagent_stop"
+};
+/**
+* Map Hermes Agent's native `VALID_HOOKS` keys back to canonical camelCase.
+*/
+const HERMESAGENT_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_HERMESAGENT_EVENT_NAMES).map(([k, v]) => [v, k]));
 const hooksRecordSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.array(HookDefinitionSchema));
 /**
 * Canonical hooks config (canonical event names in camelCase).
@@ -5370,12 +5966,15 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	deepagents: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	kiro: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"kiro-cli": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	"kiro-ide": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	devin: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	augmentcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"antigravity-ide": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"antigravity-cli": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	hermesagent: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	junie: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -5421,6 +6020,26 @@ const CANONICAL_TO_CLAUDE_EVENT_NAMES = {
 */
 const CLAUDE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CLAUDE_EVENT_NAMES).map(([k, v]) => [v, k]));
 /**
+* Map canonical camelCase event names to Devin Local PascalCase.
+*
+* Devin Local reuses the same Claude-style PascalCase event names for the
+* subset of events it supports.
+* @see https://docs.devin.ai/cli/extensibility/hooks/overview
+*/
+const CANONICAL_TO_DEVIN_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	stop: "Stop",
+	permissionRequest: "PermissionRequest"
+};
+/**
+* Map Devin Local PascalCase event names to canonical camelCase.
+*/
+const DEVIN_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_DEVIN_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Map canonical camelCase event names to AugmentCode PascalCase.
 * Auggie reuses the same PascalCase names as Claude for the events it supports.
 */
@@ -5551,7 +6170,8 @@ const CANONICAL_TO_COPILOTCLI_EVENT_NAMES = {
 	afterError: "errorOccurred",
 	preCompact: "preCompact",
 	permissionRequest: "permissionRequest",
-	notification: "notification"
+	notification: "notification",
+	beforeMCPExecution: "preMcpToolCall"
 };
 /** Map GitHub Copilot CLI event names back to canonical camelCase. */
 const COPILOTCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_COPILOTCLI_EVENT_NAMES).map(([k, v]) => [v, k]));
@@ -5633,13 +6253,35 @@ const CANONICAL_TO_KIRO_EVENT_NAMES = {
 */
 const KIRO_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_KIRO_EVENT_NAMES).map(([k, v]) => [v, k]));
 /**
+* Map canonical camelCase event names to Kiro IDE PascalCase triggers.
+*
+* Only the canonical lifecycle events with a clean IDE equivalent are mapped.
+* Unknown keys (e.g. IDE-only `PostFileSave`/`PreTaskExec` set via a `kiro-ide`
+* override) pass through unchanged.
+* @see https://kiro.dev/docs/hooks/types/
+*/
+const CANONICAL_TO_KIRO_IDE_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	stop: "Stop"
+};
+/**
+* Map Kiro IDE PascalCase trigger names to canonical camelCase.
+*/
+const KIRO_IDE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_KIRO_IDE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Map canonical camelCase event names to Junie PascalCase.
 * Junie reuses the same PascalCase names as Claude for the events it supports.
 */
 const CANONICAL_TO_JUNIE_EVENT_NAMES = {
 	sessionStart: "SessionStart",
 	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
 	stop: "Stop",
+	stopFailure: "StopFailure",
+	permissionRequest: "PermissionRequest",
 	sessionEnd: "SessionEnd"
 };
 /**
@@ -5692,19 +6334,22 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 * Map Qwen Code PascalCase event names to canonical camelCase.
 */
 const QWENCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_QWENCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
-//#endregion
-//#region src/constants/antigravity-paths.ts
-const ANTIGRAVITY_DIR = ".agents";
-const ANTIGRAVITY_SKILLS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "skills");
-const ANTIGRAVITY_MCP_FILE_NAME = "mcp_config.json";
-const ANTIGRAVITY_HOOKS_FILE_NAME = "hooks.json";
-const ANTIGRAVITY_IGNORE_FILE_NAME = ".geminiignore";
-const ANTIGRAVITY_GEMINI_DIR = ".gemini";
-const ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR = "antigravity-cli";
-const ANTIGRAVITY_CLI_PERMISSIONS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR);
-const ANTIGRAVITY_CLI_PERMISSIONS_FILE_NAME = "settings.json";
-const ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR = "config";
-const ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR);
+/**
+* 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.
+* @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"
+};
+/**
+* Map Reasonix PascalCase event names to canonical camelCase.
+*/
+const REASONIX_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_REASONIX_EVENT_NAMES).map(([k, v]) => [v, k]));
 //#endregion
 //#region src/utils/prototype-pollution.ts
 /**
@@ -5752,7 +6397,7 @@ function isToolMatcherEntry(x) {
 /**
 * Filter the shared canonical hooks to the supported events and merge tool overrides on top.
 */
-function buildEffectiveHooks({ config, toolOverrideHooks, supportedEvents }) {
+function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
 	const supported = new Set(supportedEvents);
 	const sharedHooks = {};
 	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) sharedHooks[event] = defs;
@@ -5781,7 +6426,7 @@ function groupDefinitionsByMatcher(definitions) {
 function applyCommandPrefix({ def, converterConfig }) {
 	const commandText = def.command;
 	const trimmedCommand = typeof commandText === "string" ? commandText.trimStart() : void 0;
-	return converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith(".")) && typeof trimmedCommand === "string" ? `${converterConfig.projectDirVar}/${trimmedCommand.replace(/^\.\//, "")}` : def.command;
+	return converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith(".")) && typeof trimmedCommand === "string" ? `"${converterConfig.projectDirVar}"/${trimmedCommand.replace(/^\.\//, "")}` : def.command;
 }
 /**
 * Convert the definitions of a single matcher group into tool hook entries,
@@ -5814,7 +6459,7 @@ function buildToolHooks({ defs, converterConfig }) {
 * (e.g. beforeSubmitPrompt → UserPromptSubmit).
 */
 function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logger }) {
-	const effectiveHooks = buildEffectiveHooks({
+	const effectiveHooks = buildEffectiveHooks$1({
 		config,
 		toolOverrideHooks,
 		supportedEvents: converterConfig.supportedEvents
@@ -5857,7 +6502,13 @@ function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logg
 */
 function stripCommandPrefix({ command, converterConfig }) {
 	const cmd = typeof command === "string" ? command : void 0;
-	if (converterConfig.projectDirVar !== "" && typeof cmd === "string" && cmd.includes(`${converterConfig.projectDirVar}/`)) return cmd.replace(new RegExp(`^${converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\/?`), "./");
+	if (converterConfig.projectDirVar === "" || typeof cmd !== "string") return cmd;
+	const quotedPrefix = `"${converterConfig.projectDirVar}"/`;
+	if (cmd.startsWith(quotedPrefix)) return `./${cmd.slice(quotedPrefix.length)}`;
+	if (cmd.includes(`${converterConfig.projectDirVar}/`)) {
+		const escapedVar = converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		return cmd.replace(new RegExp(`^${escapedVar}\\/?`), "./");
+	}
 	return cmd;
 }
 /**
@@ -5910,9 +6561,6 @@ function toolHooksToCanonical({ hooks, converterConfig }) {
 	return canonical;
 }
 //#endregion
-//#region src/types/tool-file.ts
-var ToolFile = class extends AiFile {};
-//#endregion
 //#region src/features/hooks/rulesync-hooks.ts
 var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	json;
@@ -6466,9 +7114,15 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	passthroughFields: ["name", "description"]
 };
 /**
-* Build the content for `.codex/config.toml` with `[features] hooks = true`.
-* Reads the existing file (if any), parses TOML, sets the flag, and returns the content
-* without writing to disk. The caller is responsible for writing via the normal write phase.
+* Build the content for `.codex/config.toml`, cleaning up the deprecated `codex_hooks` key.
+* Reads the existing file (if any), parses TOML, and returns the content without writing to
+* disk. The caller is responsible for writing via the normal write phase.
+*
+* Hooks are GA and enabled by default in Codex CLI, so `[features] hooks = true` is no longer
+* required and is intentionally NOT force-written here (doing so used to be harmless/idempotent,
+* but is now redundant and could mask a user's own `hooks = false` opt-out on a later edit).
+* See https://developers.openai.com/codex/hooks. Only the legacy `codex_hooks` alias — superseded
+* by `hooks` — is still cleaned up.
 */
 async function buildCodexConfigTomlContent({ outputRoot }) {
 	const configPath = (0, node_path.join)(outputRoot, CODEXCLI_DIR, CODEXCLI_MCP_FILE_NAME);
@@ -6479,10 +7133,7 @@ async function buildCodexConfigTomlContent({ outputRoot }) {
 	} catch (error) {
 		throw new Error(`Failed to parse existing Codex CLI config at ${configPath}: ${formatError(error)}`, { cause: error });
 	}
-	if (typeof configToml.features !== "object" || configToml.features === null) configToml.features = {};
-	const features = configToml.features;
-	delete features.codex_hooks;
-	features.hooks = true;
+	if (typeof configToml.features === "object" && configToml.features !== null) delete configToml.features.codex_hooks;
 	return smol_toml.stringify(configToml);
 }
 /**
@@ -6518,6 +7169,12 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			relativeFilePath: CODEXCLI_HOOKS_FILE_NAME
 		};
 	}
+	static getExtraSharedWritePaths() {
+		return [{
+			relativeDirPath: CODEXCLI_DIR,
+			relativeFilePath: CODEXCLI_MCP_FILE_NAME
+		}];
+	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
 		const paths = CodexcliHooks.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
@@ -6750,6 +7407,20 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/utils/object.ts
+/**
+* Return a shallow copy of `obj` keeping only the entries whose value is
+* neither `undefined` nor `null`.
+*
+* Used to assemble generated config objects without one conditional spread per
+* optional field (which would otherwise exceed the lint complexity budget).
+*/
+function compact(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== null) result[key] = value;
+	return result;
+}
+//#endregion
 //#region src/features/hooks/copilotcli-hooks.ts
 /**
 * GitHub Copilot CLI hooks.
@@ -6761,7 +7432,7 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 * (`sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`). Each entry supports three hook types:
+* `notification`, `preMcpToolCall`). Each entry supports three hook types:
 *
 * - `command` — the `bash` / `powershell` command-field shape with optional
 *   `timeoutSec`, plus optional `cwd` / `env`.
@@ -6874,20 +7545,24 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 		} else if (hookType === "http") entries.push({
 			type: "http",
 			...matcherPart,
-			...def.url !== void 0 && def.url !== null && { url: def.url },
+			...compact({
+				url: def.url,
+				headers: def.headers,
+				allowedEnvVars: def.allowedEnvVars
+			}),
+			...timeoutPart,
+			...rest
+		});
+		else entries.push({
+			type: "command",
+			...matcherPart,
+			...compact({
+				[commandField]: def.command,
+				env: def.env
+			}),
 			...timeoutPart,
 			...rest
 		});
-		else {
-			const command = def.command;
-			entries.push({
-				type: "command",
-				...matcherPart,
-				...command !== void 0 && command !== null && { [commandField]: command },
-				...timeoutPart,
-				...rest
-			});
-		}
 	}
 	return entries;
 }
@@ -7296,148 +7971,63 @@ var DeepagentsHooks = class DeepagentsHooks extends ToolHooks {
 };
 //#endregion
 //#region src/features/hooks/devin-hooks.ts
+const DEVIN_CONVERTER_CONFIG = {
+	supportedEvents: DEVIN_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_DEVIN_EVENT_NAMES,
+	toolToCanonicalEventNames: DEVIN_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	supportedHookTypes: /* @__PURE__ */ new Set(["command", "prompt"]),
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"sessionStart",
+		"sessionEnd",
+		"stop",
+		"beforeSubmitPrompt"
+	])
+};
 /**
-* Map canonical camelCase event names to Devin event names.
-*
-* The mapping is bijective for every event with a Devin equivalent, so the
-* conversion round-trips cleanly. Devin splits the generic tool lifecycle
-* into file/command/MCP specific events, so we line them up with the closest
-* file/command/MCP specific canonical events rather than the generic
-* preToolUse/postToolUse pair:
-*
-* - beforeReadFile      ⇄ pre_read_code
-* - beforeTabFileRead   ⇄ post_read_code
-* - afterTabFileEdit    ⇄ pre_write_code
-* - afterFileEdit       ⇄ post_write_code
-* - beforeShellExecution⇄ pre_run_command
-* - afterShellExecution ⇄ post_run_command
-* - beforeMCPExecution  ⇄ pre_mcp_tool_use
-* - afterMCPExecution   ⇄ post_mcp_tool_use
-* - beforeSubmitPrompt  ⇄ pre_user_prompt
-* - afterAgentResponse  ⇄ post_cascade_response
-* - beforeAgentResponse ⇄ post_cascade_response_with_transcript
-* - worktreeCreate      ⇄ post_setup_worktree
-*
-* NOTE on the before/after prefix mismatch: rulesync's canonical vocabulary has
-* no `afterReadFile` or `beforeWriteFile`/`beforeFileEdit` event — the only read
-* events are `beforeReadFile`/`beforeTabFileRead` (both read-side) and the only
-* edit events are `afterFileEdit`/`afterTabFileEdit` (both edit-side). To cover
-* all twelve Devin events bijectively we therefore pair the second read/write
-* event by DOMAIN (read↔read, write↔write) rather than by timing, which inverts
-* the prefix on `post_read_code` (⇄ beforeTabFileRead) and `pre_write_code`
-* (⇄ afterTabFileEdit). The alternative — pairing by timing — would leave two
-* Devin events unmapped and drop user hooks. The round-trip stays lossless;
-* only the human-readable prefix differs, so this is a deliberate trade-off.
-*
-* Canonical events that have no Devin equivalent (e.g. sessionStart, stop)
-* are dropped with a logged warning during export.
-*/
-const CANONICAL_TO_DEVIN_EVENT_NAMES = {
-	beforeReadFile: "pre_read_code",
-	beforeTabFileRead: "post_read_code",
-	afterTabFileEdit: "pre_write_code",
-	afterFileEdit: "post_write_code",
-	beforeShellExecution: "pre_run_command",
-	afterShellExecution: "post_run_command",
-	beforeMCPExecution: "pre_mcp_tool_use",
-	afterMCPExecution: "post_mcp_tool_use",
-	beforeSubmitPrompt: "pre_user_prompt",
-	afterAgentResponse: "post_cascade_response",
-	beforeAgentResponse: "post_cascade_response_with_transcript",
-	worktreeCreate: "post_setup_worktree"
-};
-/**
-* Map Devin event names back to canonical camelCase event names.
-*/
-const DEVIN_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_DEVIN_EVENT_NAMES).map(([k, v]) => [v, k]));
-/**
-* Canonical hook events supported by Devin (the keys of the bijective map).
+* Hooks generator for Devin Local (native `.devin/` hooks).
 *
-* Listed explicitly (rather than derived via `Object.keys`) so each value is
-* type-checked against `HookEvent` and stays in sync with
-* `CANONICAL_TO_DEVIN_EVENT_NAMES`.
-*/
-const DEVIN_HOOK_EVENTS = [
-	"beforeReadFile",
-	"beforeTabFileRead",
-	"afterTabFileEdit",
-	"afterFileEdit",
-	"beforeShellExecution",
-	"afterShellExecution",
-	"beforeMCPExecution",
-	"afterMCPExecution",
-	"beforeSubmitPrompt",
-	"afterAgentResponse",
-	"beforeAgentResponse",
-	"worktreeCreate"
-];
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
-* Read the per-tool `devin` override hooks from the rulesync hooks config.
+* Devin Local adopts a Claude-Code-style lifecycle hooks model: each event maps
+* to an array of `{ matcher?, hooks: [{ type, command|prompt, timeout? }] }`
+* matcher groups.
 *
-* `HooksConfigSchema` surfaces an optional `devin` block (mirroring every
-* other hooks target), so the override hooks are read directly off the typed
-* config without any cast.
-*/
-function getDevinOverrideHooks(config) {
-	return config.devin?.hooks ?? {};
-}
-/**
-* Convert a canonical hook definition into a Devin hook object, keeping only
-* the Devin-supported fields. Returns null when neither command nor
-* powershell is present (Devin requires at least one of them).
-*/
-function canonicalDefToDevinHook(def) {
-	const hook = {};
-	if (typeof def.command === "string") hook.command = def.command;
-	if (typeof def.powershell === "string") hook.powershell = def.powershell;
-	if (typeof def.show_output === "boolean") hook.show_output = def.show_output;
-	if (typeof def.working_directory === "string") hook.working_directory = def.working_directory;
-	if (hook.command === void 0 && hook.powershell === void 0) return null;
-	return hook;
-}
-/**
-* Convert a Devin hook object into a canonical hook definition.
-*/
-function devinHookToCanonicalDef(hook) {
-	const def = { type: "command" };
-	if (typeof hook.command === "string") def.command = hook.command;
-	if (typeof hook.powershell === "string") def.powershell = hook.powershell;
-	if (typeof hook.show_output === "boolean") def.show_output = hook.show_output;
-	if (typeof hook.working_directory === "string") def.working_directory = hook.working_directory;
-	return def;
-}
-/**
-* Hooks generator for Devin Cascade (GA).
+* - Project scope: `.devin/hooks.v1.json`. This is a standalone file whose top
+*   level IS the event map (no wrapper key).
+* - Global scope: `~/.config/devin/config.json` under the `"hooks"` key. This
+*   file is shared with the MCP (`mcpServers`) and permissions (`permissions`)
+*   features, so reads and writes merge into the existing JSON and the file is
+*   never deleted in global mode.
 *
-* Writes a dedicated `hooks.json` whose top-level `hooks` key maps each
-* Devin event name to a flat array of hook objects. Project and global modes
-* share the same shape; only the location differs (`.windsurf/hooks.json` vs
-* `~/.codeium/windsurf/hooks.json`). The harness overrides `outputRoot` with the
-* home directory in global mode.
+* @see https://docs.devin.ai/cli/extensibility/hooks/overview
 */
 var DevinHooks = class DevinHooks extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
-			fileContent: params.fileContent ?? JSON.stringify({ hooks: {} }, null, 2)
+			fileContent: params.fileContent ?? "{}"
 		});
 	}
+	/**
+	* The project standalone `hooks.v1.json` is owned wholesale by rulesync and
+	* may be deleted as an orphan. The global `config.json` is shared with the MCP
+	* and permissions features, so it must never be deleted.
+	*/
+	isDeletable() {
+		return this.getRelativeFilePath() !== DEVIN_CONFIG_FILE_NAME;
+	}
 	static getSettablePaths({ global = false } = {}) {
 		if (global) return {
-			relativeDirPath: CODEIUM_WINDSURF_DIR,
-			relativeFilePath: DEVIN_HOOKS_FILE_NAME
+			relativeDirPath: DEVIN_GLOBAL_CONFIG_DIR_PATH,
+			relativeFilePath: DEVIN_CONFIG_FILE_NAME
 		};
 		return {
-			relativeDirPath: WINDSURF_DIR,
-			relativeFilePath: DEVIN_HOOKS_FILE_NAME
+			relativeDirPath: DEVIN_DIR,
+			relativeFilePath: DEVIN_HOOKS_V1_FILE_NAME
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
 		const paths = DevinHooks.getSettablePaths({ global });
-		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ hooks: {} });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
 		return new DevinHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -7448,31 +8038,32 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 	}
 	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
 		const paths = DevinHooks.getSettablePaths({ global });
-		await readOrInitializeFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({ hooks: {} }, null, 2));
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const config = rulesyncHooks.getJson();
-		const supported = new Set(DEVIN_HOOK_EVENTS);
-		const sharedHooks = {};
-		for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) sharedHooks[event] = defs;
-		const overrideHooks = getDevinOverrideHooks(config);
-		const effectiveHooks = {
-			...sharedHooks,
-			...overrideHooks
-		};
-		const devinHooks = {};
-		for (const [canonicalEvent, defs] of Object.entries(effectiveHooks)) {
-			const devinEvent = CANONICAL_TO_DEVIN_EVENT_NAMES[canonicalEvent];
-			if (devinEvent === void 0) {
-				logger?.warn(`Skipped hook event "${canonicalEvent}" for devin (no Devin equivalent)`);
-				continue;
-			}
-			const objects = [];
-			for (const def of defs) {
-				const hook = canonicalDefToDevinHook(def);
-				if (hook !== null) objects.push(hook);
+		const devinHooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.devin?.hooks,
+			converterConfig: DEVIN_CONVERTER_CONFIG,
+			logger
+		});
+		let fileContent;
+		if (global) {
+			const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
+			let parsedSettings;
+			try {
+				parsedSettings = JSON.parse(existingContent);
+			} catch (error) {
+				throw new Error(`Failed to parse existing Devin config at ${filePath}: ${formatError(error)}`, { cause: error });
 			}
-			if (objects.length > 0) devinHooks[devinEvent] = objects;
+			const merged = {
+				...isRecord(parsedSettings) ? parsedSettings : {},
+				hooks: devinHooks
+			};
+			fileContent = JSON.stringify(merged, null, 2);
+		} else {
+			await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
+			fileContent = JSON.stringify(devinHooks, null, 2);
 		}
-		const fileContent = JSON.stringify({ hooks: devinHooks }, null, 2);
 		return new DevinHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -7488,22 +8079,13 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 		} catch (error) {
 			throw new Error(`Failed to parse Devin hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const canonicalHooks = {};
-		const devinHooks = parsed.hooks;
-		if (isRecord(devinHooks)) for (const [devinEvent, rawObjects] of Object.entries(devinHooks)) {
-			if (!Array.isArray(rawObjects)) continue;
-			const canonicalEvent = DEVIN_TO_CANONICAL_EVENT_NAMES[devinEvent];
-			if (canonicalEvent === void 0) continue;
-			const defs = [];
-			for (const rawObject of rawObjects) {
-				if (!isRecord(rawObject)) continue;
-				defs.push(devinHookToCanonicalDef(rawObject));
-			}
-			if (defs.length > 0) canonicalHooks[canonicalEvent] = defs;
-		}
+		const hooks = toolHooksToCanonical({
+			hooks: this.getRelativeFilePath() === "config.json" ? isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {} : parsed,
+			converterConfig: DEVIN_CONVERTER_CONFIG
+		});
 		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
 			version: 1,
-			hooks: canonicalHooks
+			hooks
 		}, null, 2) });
 	}
 	validate() {
@@ -7517,7 +8099,7 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			fileContent: "{}",
 			validate: false
 		});
 	}
@@ -7744,6 +8326,106 @@ function mergeHermesConfig(fileContent, patch) {
 }
 //#endregion
 //#region src/features/hooks/hermesagent-hooks.ts
+/**
+* Canonical events that map to a Hermes tool-call event (`pre_tool_call` /
+* `post_tool_call`) and therefore carry a `matcher`. Every other supported
+* canonical event maps to a Hermes lifecycle event, which never accepts a
+* `matcher`.
+* @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
+*/
+const HERMESAGENT_MATCHER_EVENTS = /* @__PURE__ */ new Set(["preToolUse", "postToolUse"]);
+/**
+* Filter the shared canonical hooks to the events Hermes understands and merge
+* the `hermesagent`-specific override block on top.
+*/
+function buildEffectiveHooks(config, toolOverrideHooks) {
+	const supported = new Set(HERMESAGENT_HOOK_EVENTS);
+	const shared = {};
+	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) shared[event] = defs;
+	return {
+		...shared,
+		...toolOverrideHooks
+	};
+}
+/**
+* Convert the canonical hooks config into Hermes's native
+* `hooks: { <event>: [{ matcher?, command, timeout? }] }` shape.
+*
+* Only `type: "command"` canonical hooks are emitted — Hermes shell hooks run
+* via `shlex.split`/`shell=False`, so `prompt`/`http` hooks have no native
+* equivalent and are skipped (the shared `HooksProcessor` already warns about
+* unsupported hook types centrally). `matcher` is only carried through for
+* `pre_tool_call`/`post_tool_call`; on any other event it is dropped with a
+* warning, mirroring how other adapters (e.g. AugmentCode) handle
+* matcher-less lifecycle events.
+*/
+function canonicalToHermesHooks({ config, toolOverrideHooks, logger }) {
+	const effectiveHooks = buildEffectiveHooks(config, toolOverrideHooks);
+	const result = {};
+	for (const [canonicalEvent, defs] of Object.entries(effectiveHooks)) {
+		const nativeEvent = CANONICAL_TO_HERMESAGENT_EVENT_NAMES[canonicalEvent];
+		if (!nativeEvent) continue;
+		const supportsMatcher = HERMESAGENT_MATCHER_EVENTS.has(canonicalEvent);
+		const entries = [];
+		for (const def of defs) {
+			if ((def.type ?? "command") !== "command") continue;
+			if (typeof def.command !== "string" || def.command === "") continue;
+			const entry = { command: def.command };
+			if (typeof def.matcher === "string" && def.matcher !== "") if (supportsMatcher) entry.matcher = def.matcher;
+			else logger?.warn(`matcher "${def.matcher}" on "${canonicalEvent}" hook will be ignored — Hermes Agent only supports matchers on pre_tool_call/post_tool_call`);
+			if (typeof def.timeout === "number") entry.timeout = def.timeout;
+			entries.push(entry);
+		}
+		if (entries.length > 0) result[nativeEvent] = entries;
+	}
+	return result;
+}
+/**
+* Reverse {@link canonicalToHermesHooks}: parse Hermes's native
+* `hooks: { <event>: [...] }` map back into a canonical event → definition[]
+* record. Native events with no canonical equivalent (`pre_verify`,
+* `transform_tool_result`, ...) are skipped since there is nothing to round
+* -trip them into.
+*/
+function hermesHooksToCanonical(hooks) {
+	const canonical = {};
+	if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) return canonical;
+	for (const [nativeEvent, entries] of Object.entries(hooks)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(nativeEvent) || !Array.isArray(entries)) continue;
+		const canonicalEvent = HERMESAGENT_TO_CANONICAL_EVENT_NAMES[nativeEvent];
+		if (!canonicalEvent) continue;
+		const defs = [];
+		for (const raw of entries) {
+			if (raw === null || typeof raw !== "object" || Array.isArray(raw)) continue;
+			const entry = raw;
+			if (typeof entry.command !== "string") continue;
+			const def = {
+				type: "command",
+				command: entry.command
+			};
+			if (typeof entry.matcher === "string" && entry.matcher !== "") def.matcher = entry.matcher;
+			if (typeof entry.timeout === "number") def.timeout = entry.timeout;
+			defs.push(def);
+		}
+		if (defs.length > 0) canonical[canonicalEvent] = defs;
+	}
+	return canonical;
+}
+/**
+* Hermes Agent shell hooks.
+*
+* Hermes Agent registers shell-command hooks under the `hooks:` key of the
+* shared user config file `~/.hermes/config.yaml` (the HERMES_HOME directory;
+* global only — Hermes has no project-scoped hooks location). Hermes only runs
+* hooks declared under its fixed `VALID_HOOKS` event keys (`pre_tool_call`,
+* `post_tool_call`, `pre_llm_call`, `post_llm_call`, `on_session_start`,
+* `on_session_end`, `subagent_start`, `subagent_stop`, ...); any other key is
+* silently ignored. Generation therefore maps canonical events onto the real
+* `VALID_HOOKS` keys and merges the resulting `hooks:` block into the existing
+* config instead of overwriting it, since that file also holds other Hermes
+* settings (model, `mcp_servers`, `command_allowlist`, ...).
+* @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
+*/
 var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 	static getSettablePaths() {
 		return {
@@ -7763,6 +8445,9 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 			error: null
 		};
 	}
+	isDeletable() {
+		return false;
+	}
 	shouldMergeExistingFileContent() {
 		return true;
 	}
@@ -7770,18 +8455,21 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 		this.fileContent = mergeHermesConfig(fileContent, parseHermesConfig(this.fileContent));
 	}
 	toRulesyncHooks() {
-		const config = parseHermesConfig(this.getFileContent());
-		const hooks = config.hooks && typeof config.hooks === "object" ? config.hooks.rulesync : {};
-		return new RulesyncHooks({
-			relativeDirPath: "",
-			relativeFilePath: ".rulesync/hooks.json",
-			fileContent: JSON.stringify(hooks ?? {}, null, 2)
-		});
+		const hooks = hermesHooksToCanonical(parseHermesConfig(this.getFileContent()).hooks);
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
 	}
-	static fromRulesyncHooks({ outputRoot, rulesyncHooks }) {
+	static fromRulesyncHooks({ outputRoot, rulesyncHooks, logger }) {
+		const config = rulesyncHooks.getJson();
 		return new HermesagentHooks({
 			outputRoot,
-			fileContent: stringifyHermesConfig({ hooks: { rulesync: rulesyncHooks.getJson() } })
+			fileContent: stringifyHermesConfig({ hooks: canonicalToHermesHooks({
+				config,
+				toolOverrideHooks: config.hermesagent?.hooks,
+				logger
+			}) })
 		});
 	}
 };
@@ -8251,9 +8939,8 @@ var KiroHooks = class KiroHooks extends ToolHooks {
 * the tool-specific override key to `kiro-cli` (so `kiro-cli.hooks` overrides in
 * the rulesync hooks config are honored, rather than the legacy `kiro.hooks`).
 *
-* (The Kiro IDE uses multi-file `.kiro/hooks/*.kiro.hook` hooks, which the
-* single-file hooks pipeline does not emit yet, so `kiro-ide` has no hooks
-* adapter.)
+* (The Kiro IDE uses the structured `.kiro/hooks/*.json` v1 format instead; see
+* {@link import("./kiro-ide-hooks.js").KiroIdeHooks}.)
 */
 var KiroCliHooks = class extends KiroHooks {
 	static getOverrideKey() {
@@ -8261,6 +8948,203 @@ var KiroCliHooks = class extends KiroHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/kiro-ide-hooks.ts
+/**
+* One hook entry inside the Kiro IDE v1 `hooks` array.
+*
+* `z.looseObject` keeps unknown fields added by future Kiro IDE versions, so
+* imports do not drop data they do not yet understand.
+* @see https://kiro.dev/docs/hooks/types/
+*/
+const KiroIdeHookActionSchema = zod_mini.z.union([zod_mini.z.looseObject({
+	type: zod_mini.z.literal("command"),
+	command: zod_mini.z.optional(safeString)
+}), zod_mini.z.looseObject({
+	type: zod_mini.z.literal("agent"),
+	prompt: zod_mini.z.optional(safeString)
+})]);
+const KiroIdeHookEntrySchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	trigger: zod_mini.z.optional(zod_mini.z.string()),
+	matcher: zod_mini.z.optional(zod_mini.z.string()),
+	action: zod_mini.z.optional(KiroIdeHookActionSchema),
+	timeout: zod_mini.z.optional(zod_mini.z.number()),
+	enabled: zod_mini.z.optional(zod_mini.z.boolean())
+});
+const KiroIdeHooksFileSchema = zod_mini.z.looseObject({
+	version: zod_mini.z.optional(zod_mini.z.string()),
+	hooks: zod_mini.z.optional(zod_mini.z.array(KiroIdeHookEntrySchema))
+});
+/**
+* Build the Kiro IDE hook entries for a single canonical event's definitions.
+*
+* `command`-type definitions become `{ type: "command", command }` actions and
+* `prompt`-type definitions become `{ type: "agent", prompt }` actions. Other
+* types are skipped (the {@link import("./hooks-processor.js").HooksProcessor}
+* already warns about unsupported types).
+*/
+function buildKiroIdeEntriesForEvent(trigger, definitions) {
+	const entries = [];
+	for (const def of definitions) {
+		const type = def.type ?? "command";
+		let action;
+		if (type === "command") {
+			if (def.command === void 0) continue;
+			action = {
+				type: "command",
+				command: def.command
+			};
+		} else if (type === "prompt") {
+			if (def.prompt === void 0) continue;
+			action = {
+				type: "agent",
+				prompt: def.prompt
+			};
+		} else continue;
+		entries.push({
+			name: def.name ?? trigger,
+			...def.description !== void 0 && def.description !== null && { description: def.description },
+			trigger,
+			...def.matcher !== void 0 && def.matcher !== null && def.matcher !== "" && { matcher: def.matcher },
+			action,
+			...def.timeout !== void 0 && def.timeout !== null && def.timeout >= 0 && { timeout: def.timeout },
+			enabled: true
+		});
+	}
+	return entries;
+}
+function canonicalToKiroIdeHooks(config) {
+	const kiroIdeSupported = new Set(KIRO_IDE_HOOK_EVENTS);
+	const sharedHooks = {};
+	for (const [event, defs] of Object.entries(config.hooks)) if (kiroIdeSupported.has(event)) sharedHooks[event] = defs;
+	const effectiveHooks = {
+		...sharedHooks,
+		...config["kiro-ide"]?.hooks
+	};
+	const entries = [];
+	for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
+		const trigger = CANONICAL_TO_KIRO_IDE_EVENT_NAMES[eventName] ?? eventName;
+		entries.push(...buildKiroIdeEntriesForEvent(trigger, definitions));
+	}
+	return entries;
+}
+function kiroIdeHooksToCanonical(entries) {
+	const canonical = {};
+	for (const entry of entries) {
+		if (entry.trigger === void 0 || entry.action === void 0) continue;
+		const eventName = KIRO_IDE_TO_CANONICAL_EVENT_NAMES[entry.trigger] ?? entry.trigger;
+		if (isPrototypePollutionKey(eventName)) continue;
+		const def = {};
+		if (entry.action.type === "command") {
+			if (!entry.action.command) continue;
+			def.type = "command";
+			def.command = entry.action.command;
+		} else {
+			if (!entry.action.prompt) continue;
+			def.type = "prompt";
+			def.prompt = entry.action.prompt;
+		}
+		if (entry.name !== void 0 && entry.name !== null) def.name = entry.name;
+		if (entry.description !== void 0 && entry.description !== null) def.description = entry.description;
+		if (entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "") def.matcher = entry.matcher;
+		if (entry.timeout !== void 0 && entry.timeout !== null) def.timeout = entry.timeout;
+		(canonical[eventName] ??= []).push(def);
+	}
+	return canonical;
+}
+/**
+* Hooks generator for the **Kiro IDE** (`.kiro/hooks/*.json` v1).
+*
+* Kiro IDE 1.0 reads structured JSON hooks from `.kiro/hooks/` (workspace) and
+* `~/.kiro/hooks/` (user). A single file may declare multiple hooks in its
+* `hooks` array, so rulesync emits every generated hook into one
+* `rulesync.json` file per scope (`{ "version": "v1", "hooks": [ ... ] }`),
+* which keeps it within the single-file hooks architecture.
+*
+* This is distinct from the Kiro CLI ({@link import("./kiro-cli-hooks.js").
+* KiroCliHooks}), which uses the `.kiro/agents/default.json` agent-config shape.
+*
+* @see https://kiro.dev/docs/hooks/
+*/
+var KiroIdeHooks = class KiroIdeHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? JSON.stringify({
+				version: "v1",
+				hooks: []
+			}, null, 2)
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: KIRO_IDE_HOOKS_DIR_PATH,
+			relativeFilePath: KIRO_IDE_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = KiroIdeHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({
+			version: "v1",
+			hooks: []
+		}, null, 2);
+		return new KiroIdeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+		const paths = KiroIdeHooks.getSettablePaths({ global });
+		const hooks = canonicalToKiroIdeHooks(rulesyncHooks.getJson());
+		const fileContent = JSON.stringify({
+			version: "v1",
+			hooks
+		}, null, 2);
+		return new KiroIdeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		let parsed;
+		try {
+			parsed = KiroIdeHooksFileSchema.parse(JSON.parse(this.getFileContent()));
+		} catch (error) {
+			throw new Error(`Failed to parse Kiro IDE hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = kiroIdeHooksToCanonical(parsed.hooks ?? []);
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new KiroIdeHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({
+				version: "v1",
+				hooks: []
+			}, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/opencode-hooks.ts
 var OpencodeHooks = class OpencodeHooks extends ToolHooks {
 	constructor(params) {
@@ -8319,6 +9203,35 @@ var OpencodeHooks = class OpencodeHooks extends ToolHooks {
 //#endregion
 //#region src/features/hooks/qwencode-hooks.ts
 /**
+* Build a single Qwen Code hook object from a canonical hook definition.
+* Command-only fields (`async`/`env`/`shell`) are emitted only on command hooks
+* and http-only fields (`headers`/`allowedEnvVars`/`once`) only on http hooks,
+* matching upstream. `statusMessage` applies to both.
+* https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/hooks.md
+*/
+function canonicalDefToQwencodeHook(def) {
+	const type = def.type ?? "command";
+	const isHttp = type === "http";
+	const isCommand = type === "command";
+	return {
+		type,
+		...compact({
+			command: def.command,
+			url: def.url,
+			timeout: def.timeout,
+			name: def.name,
+			description: def.description,
+			statusMessage: def.statusMessage,
+			async: isCommand ? def.async : void 0,
+			env: isCommand ? def.env : void 0,
+			shell: isCommand ? def.shell : void 0,
+			headers: isHttp ? def.headers : void 0,
+			allowedEnvVars: isHttp ? def.allowedEnvVars : void 0,
+			once: isHttp ? def.once : void 0
+		})
+	};
+}
+/**
 * Convert canonical hooks config to Qwen Code format.
 * Filters shared hooks to QWENCODE_HOOK_EVENTS, merges config.qwencode?.hooks,
 * then converts to PascalCase and Qwen Code matcher/hooks structure.
@@ -8346,16 +9259,7 @@ function canonicalToQwencodeHooks(config) {
 		}
 		const entries = [];
 		for (const [matcherKey, defs] of byMatcher) {
-			const hooks = defs.map((def) => {
-				return {
-					type: def.type ?? "command",
-					...def.command !== void 0 && def.command !== null && { command: def.command },
-					...def.url !== void 0 && def.url !== null && { url: def.url },
-					...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
-					...def.name !== void 0 && def.name !== null && { name: def.name },
-					...def.description !== void 0 && def.description !== null && { description: def.description }
-				};
-			});
+			const hooks = defs.map(canonicalDefToQwencodeHook);
 			const sequential = defs.some((def) => def.sequential === true);
 			const group = matcherKey ? {
 				matcher: matcherKey,
@@ -8379,7 +9283,14 @@ const QwencodeHookEntrySchema = zod_mini.z.looseObject({
 	url: zod_mini.z.optional(zod_mini.z.string()),
 	timeout: zod_mini.z.optional(zod_mini.z.number()),
 	name: zod_mini.z.optional(zod_mini.z.string()),
-	description: zod_mini.z.optional(zod_mini.z.string())
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	statusMessage: zod_mini.z.optional(zod_mini.z.string()),
+	async: zod_mini.z.optional(zod_mini.z.boolean()),
+	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
+	shell: zod_mini.z.optional(zod_mini.z.string()),
+	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
+	allowedEnvVars: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	once: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * A matcher group entry in a Qwen Code event array.
@@ -8398,18 +9309,29 @@ function qwencodeMatcherEntryToCanonical(entry) {
 	const defs = [];
 	const hooks = entry.hooks ?? [];
 	const sequential = entry.sequential === true;
+	const matcher = entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" ? entry.matcher : void 0;
 	for (const h of hooks) {
-		const command = h.command;
 		const hookType = h.type === "command" || h.type === "prompt" || h.type === "http" ? h.type : "command";
+		const isHttp = hookType === "http";
+		const isCommand = hookType === "command";
 		defs.push({
 			type: hookType,
-			...command !== void 0 && command !== null && { command },
-			...h.url !== void 0 && h.url !== null && { url: h.url },
-			...h.timeout !== void 0 && h.timeout !== null && { timeout: h.timeout },
-			...h.name !== void 0 && h.name !== null && { name: h.name },
-			...h.description !== void 0 && h.description !== null && { description: h.description },
-			...sequential && { sequential: true },
-			...entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" && { matcher: entry.matcher }
+			...compact({
+				command: h.command,
+				url: h.url,
+				timeout: h.timeout,
+				name: h.name,
+				description: h.description,
+				statusMessage: h.statusMessage,
+				async: isCommand ? h.async : void 0,
+				env: isCommand ? h.env : void 0,
+				shell: isCommand ? h.shell : void 0,
+				headers: isHttp ? h.headers : void 0,
+				allowedEnvVars: isHttp ? h.allowedEnvVars : void 0,
+				once: isHttp ? h.once : void 0,
+				sequential: sequential ? true : void 0,
+				matcher
+			})
 		});
 	}
 	return defs;
@@ -8522,6 +9444,169 @@ var QwencodeHooks = class QwencodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/reasonix-hooks.ts
+/**
+* Only PreToolUse/PostToolUse honor the `match` field (an anchored regex
+* against the tool name); it is ignored on every other event.
+*/
+const REASONIX_MATCHER_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+const SUPPORTED_REASONIX_EVENTS = new Set(REASONIX_HOOK_EVENTS);
+/**
+* Convert canonical hooks config to the Reasonix `hooks` object.
+* Filters shared hooks to REASONIX_HOOK_EVENTS, merges `config.reasonix?.hooks`,
+* then maps event names and emits flat per-event hook-entry arrays.
+*/
+function canonicalToReasonixHooks({ config, toolOverrideHooks, logger }) {
+	const sharedHooks = {};
+	for (const [event, defs] of Object.entries(config.hooks)) if (SUPPORTED_REASONIX_EVENTS.has(event)) sharedHooks[event] = defs;
+	const effectiveHooks = {
+		...sharedHooks,
+		...toolOverrideHooks
+	};
+	const result = {};
+	for (const [event, defs] of Object.entries(effectiveHooks)) {
+		if (!SUPPORTED_REASONIX_EVENTS.has(event)) continue;
+		const reasonixEvent = CANONICAL_TO_REASONIX_EVENT_NAMES[event] ?? event;
+		const isMatcherEvent = REASONIX_MATCHER_EVENTS.has(reasonixEvent);
+		const entries = [];
+		for (const def of defs) {
+			if ((def.type ?? "command") !== "command") continue;
+			if (typeof def.command !== "string") continue;
+			const entry = { command: def.command };
+			if (typeof def.matcher === "string" && def.matcher !== "") if (isMatcherEvent) entry.match = def.matcher;
+			else logger?.warn(`matcher "${def.matcher}" on "${event}" hook will be ignored — Reasonix's "${reasonixEvent}" event does not support matchers`);
+			if (typeof def.description === "string" && def.description !== "") entry.description = def.description;
+			if (typeof def.timeout === "number") entry.timeout = Math.round(def.timeout * 1e3);
+			entries.push(entry);
+		}
+		if (entries.length > 0) result[reasonixEvent] = [...result[reasonixEvent] ?? [], ...entries];
+	}
+	return result;
+}
+/**
+* Reverse {@link canonicalToReasonixHooks}: parse the Reasonix `hooks` object
+* back into a canonical event -> definition[] record.
+*/
+function reasonixHooksToCanonical(hooks) {
+	const canonical = {};
+	if (hooks === null || hooks === void 0 || typeof hooks !== "object" || Array.isArray(hooks)) return canonical;
+	for (const [reasonixEvent, rawEntries] of Object.entries(hooks)) {
+		if (!Array.isArray(rawEntries)) continue;
+		const canonicalEvent = REASONIX_TO_CANONICAL_EVENT_NAMES[reasonixEvent] ?? reasonixEvent;
+		const defs = [];
+		for (const rawEntry of rawEntries) {
+			if (rawEntry === null || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
+			const entry = rawEntry;
+			if (typeof entry.command !== "string") continue;
+			const def = {
+				type: "command",
+				command: entry.command
+			};
+			if (typeof entry.match === "string" && entry.match !== "") def.matcher = entry.match;
+			if (typeof entry.description === "string" && entry.description !== "") def.description = entry.description;
+			if (typeof entry.timeout === "number") def.timeout = entry.timeout / 1e3;
+			defs.push(def);
+		}
+		if (defs.length > 0) canonical[canonicalEvent] = [...canonical[canonicalEvent] ?? [], ...defs];
+	}
+	return canonical;
+}
+/**
+* Reasonix hooks adapter.
+*
+* 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).
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
+*/
+var ReasonixHooks = class ReasonixHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: REASONIX_DIR,
+			relativeFilePath: REASONIX_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = ReasonixHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new ReasonixHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = ReasonixHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
+		let settings;
+		try {
+			settings = JSON.parse(existingContent);
+		} catch (error) {
+			throw new Error(`Failed to parse existing Reasonix settings at ${filePath}: ${formatError(error)}`, { cause: error });
+		}
+		const config = rulesyncHooks.getJson();
+		const reasonixHooks = canonicalToReasonixHooks({
+			config,
+			toolOverrideHooks: config.reasonix?.hooks,
+			logger
+		});
+		const merged = {
+			...settings,
+			hooks: reasonixHooks
+		};
+		const fileContent = JSON.stringify(merged, null, 2);
+		return new ReasonixHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		let settings;
+		try {
+			settings = JSON.parse(this.getFileContent());
+		} catch (error) {
+			throw new Error(`Failed to parse Reasonix hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = reasonixHooksToCanonical(settings.hooks);
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/vibe-hooks.ts
 const VIBE_DIR = ".vibe";
 const VIBE_HOOKS_FILE_NAME = "hooks.toml";
@@ -8680,6 +9765,12 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 			relativeFilePath: VIBE_HOOKS_FILE_NAME
 		};
 	}
+	static getExtraSharedWritePaths() {
+		return [{
+			relativeDirPath: VIBE_DIR,
+			relativeFilePath: VIBE_CONFIG_FILE_NAME
+		}];
+	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
 		const paths = VibeHooks.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({});
@@ -8747,6 +9838,19 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 //#endregion
 //#region src/features/hooks/hooks-processor.ts
 const HooksProcessorToolTargetSchema = zod_mini.z.enum(hooksProcessorToolTargetTuple);
+/**
+* Event names present in the config that the target's adapter cannot emit.
+*
+* When the factory passes override-block keys through verbatim
+* (`passthroughOverrideEvents`), those keys are excluded from the check so
+* documented passthrough triggers aren't falsely reported as skipped.
+*/
+function unsupportedEventNames(params) {
+	const { factory, sharedHooks, effectiveHooks } = params;
+	const supportedEvents = new Set(factory.supportedEvents);
+	const eventNames = factory.passthroughOverrideEvents ? Object.keys(sharedHooks) : Object.keys(effectiveHooks);
+	return [...new Set(eventNames)].filter((e) => !supportedEvents.has(e));
+}
 const toolHooksFactories = /* @__PURE__ */ new Map([
 	["antigravity-cli", {
 		class: AntigravityCliHooks,
@@ -8880,12 +9984,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true,
 			supportsImport: true
 		},
-		supportedEvents: CLAUDE_HOOK_EVENTS,
-		supportedHookTypes: [
-			"command",
-			"prompt",
-			"http"
-		],
+		supportedEvents: HERMESAGENT_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
 	["deepagents", {
@@ -8921,6 +10021,18 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["kiro-ide", {
+		class: KiroIdeHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: KIRO_IDE_HOOK_EVENTS,
+		supportedHookTypes: ["command", "prompt"],
+		supportsMatcher: true,
+		passthroughOverrideEvents: true
+	}],
 	["devin", {
 		class: DevinHooks,
 		meta: {
@@ -8929,8 +10041,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: DEVIN_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
-		supportsMatcher: false
+		supportedHookTypes: ["command", "prompt"],
+		supportsMatcher: true
 	}],
 	["augmentcode", {
 		class: AugmentcodeHooks,
@@ -8975,6 +10087,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedEvents: QWENCODE_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
+	}],
+	["reasonix", {
+		class: ReasonixHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: REASONIX_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
 	}]
 ]);
 const hooksProcessorToolTargets = [...toolHooksFactories.entries()].filter(([, f]) => f.meta.supportsProject).map(([t]) => t);
@@ -9050,8 +10173,11 @@ var HooksProcessor = class extends FeatureProcessor {
 			...overrideHooks
 		};
 		{
-			const supportedEvents = new Set(factory.supportedEvents);
-			const skipped = [...new Set(Object.keys(effectiveHooks))].filter((e) => !supportedEvents.has(e));
+			const skipped = unsupportedEventNames({
+				factory,
+				sharedHooks,
+				effectiveHooks
+			});
 			if (skipped.length > 0) this.logger.warn(`Skipped hook event(s) for ${this.toolTarget} (not supported): ${skipped.join(", ")}`);
 		}
 		{
@@ -9247,11 +10373,6 @@ var AiassistantIgnore = class AiassistantIgnore extends ToolIgnore {
 	}
 };
 //#endregion
-//#region src/constants/antigravity-cli-paths.ts
-const ANTIGRAVITY_AGENTS_DIR = ANTIGRAVITY_DIR;
-const ANTIGRAVITY_RULE_FILE_NAME = "AGENTS.md";
-const ANTIGRAVITY_GLOBAL_RULE_FILE_NAME = "GEMINI.md";
-//#endregion
 //#region src/features/ignore/antigravity-cli-ignore.ts
 /**
 * Antigravity CLI is the successor to Gemini CLI and is built on the same
@@ -10483,9 +11604,9 @@ function parseAmpSettingsJsonc(fileContent) {
 }
 function filterMcpServers(mcpServers) {
 	const filtered = {};
-	if (!isRecord$1(mcpServers)) return filtered;
+	if (!isRecord(mcpServers)) return filtered;
 	for (const [name, config] of Object.entries(mcpServers)) {
-		if (isPrototypePollutionKey(name) || !isRecord$1(config)) continue;
+		if (isPrototypePollutionKey(name) || !isRecord(config)) continue;
 		const filteredConfig = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (isPrototypePollutionKey(key)) continue;
@@ -10600,7 +11721,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 			success: true,
 			error: null
 		};
-		if (!isRecord$1(mcpServers)) return {
+		if (!isRecord(mcpServers)) return {
 			success: false,
 			error: /* @__PURE__ */ new Error(`${AMP_MCP_SERVERS_KEY} must be a JSON object`)
 		};
@@ -10609,7 +11730,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 				success: false,
 				error: /* @__PURE__ */ new Error(`Server name "${serverName}" is a prototype pollution key and is not allowed`)
 			};
-			if (!isRecord$1(serverConfig)) return {
+			if (!isRecord(serverConfig)) return {
 				success: false,
 				error: /* @__PURE__ */ new Error(`MCP server "${serverName}" must be a JSON object`)
 			};
@@ -11130,7 +12251,7 @@ const MAX_REMOVE_EMPTY_ENTRIES_DEPTH$1 = 32;
 function convertFromCodexFormat(codexMcp) {
 	const result = {};
 	for (const [name, config] of Object.entries(codexMcp)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -11150,7 +12271,7 @@ function convertToCodexFormat(mcpServers) {
 	const result = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
-		if (!isRecord$1(config)) continue;
+		if (!isRecord(config)) continue;
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -11212,19 +12333,19 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		const strippedMcpServers = rulesyncMcp.getMcpServers();
 		const rawMcpServers = rulesyncMcp.getJson().mcpServers;
 		const converted = convertToCodexFormat(Object.fromEntries(Object.entries(strippedMcpServers).map(([serverName, serverConfig]) => {
-			const rawServer = isRecord$1(rawMcpServers) ? rawMcpServers[serverName] : void 0;
+			const rawServer = isRecord(rawMcpServers) ? rawMcpServers[serverName] : void 0;
 			return [serverName, {
 				...serverConfig,
-				...isRecord$1(rawServer) && isStringArray(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
+				...isRecord(rawServer) && isStringArray(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
 			}];
 		})));
 		const filteredMcpServers = this.removeEmptyEntries(converted);
 		for (const name of Object.keys(converted)) if (!Object.hasOwn(filteredMcpServers, name)) warnWithFallback(void 0, `MCP server "${name}" had no non-empty configuration and was dropped from the codex CLI config`);
-		const existingMcpServers = isRecord$1(configToml["mcp_servers"]) ? configToml["mcp_servers"] : {};
+		const existingMcpServers = isRecord(configToml["mcp_servers"]) ? configToml["mcp_servers"] : {};
 		configToml["mcp_servers"] = Object.fromEntries(Object.entries(filteredMcpServers).map(([name, serverConfig]) => {
-			const existingServer = isRecord$1(existingMcpServers[name]) ? existingMcpServers[name] : void 0;
+			const existingServer = isRecord(existingMcpServers[name]) ? existingMcpServers[name] : void 0;
 			const serverRecord = serverConfig;
-			if (existingServer && isRecord$1(existingServer["tools"]) && !("tools" in serverRecord)) return [name, {
+			if (existingServer && isRecord(existingServer["tools"]) && !("tools" in serverRecord)) return [name, {
 				...serverRecord,
 				tools: existingServer["tools"]
 			}];
@@ -11734,18 +12855,20 @@ var DeepagentsMcp = class DeepagentsMcp extends ToolMcp {
 //#endregion
 //#region src/features/mcp/devin-mcp.ts
 /**
-* MCP generator for Devin (Cascade).
+* MCP generator for Devin Local (native `.devin/` configuration).
+*
+* Devin reads MCP servers from the `mcpServers` key of its native config file:
+* - Project scope: `.devin/config.json`
+* - Global scope: `~/.config/devin/config.json`
 *
-* Devin reads file-based MCP configuration from:
-* - Project scope: `.windsurf/mcp_config.json`
-* - Global scope: `~/.codeium/windsurf/mcp_config.json`
+* The config file is shared with the permissions feature (`permissions` key)
+* and, in global mode, the hooks feature (`hooks` key), so reads and writes
+* merge into the existing JSON rather than overwriting it, and the file is
+* never deleted. Each server is a stdio entry ({ command, args, env }) or a
+* remote entry ({ serverUrl | url, headers }), and may carry an optional
+* `disabledTools` array.
 *
-* The official docs document only the global path; the project path mirrors
-* the same `mcp_config.json` filename so both scopes fit the processor
-* framework cleanly. The top-level key is `mcpServers`; each server is a
-* stdio entry ({ command, args, env }) or a remote entry
-* ({ serverUrl | url, headers }), and may carry an optional `disabledTools`
-* array.
+* @see https://docs.devin.ai/cli/extensibility/configuration
 */
 var DevinMcp = class DevinMcp extends ToolMcp {
 	json;
@@ -11763,14 +12886,21 @@ var DevinMcp = class DevinMcp extends ToolMcp {
 			throw new Error(`Failed to parse Devin MCP config at ${(0, node_path.join)(relativeDirPath, relativeFilePath)}: ${formatError(error)}`, { cause: error });
 		}
 	}
+	/**
+	* config.json may carry the permissions/hooks features' keys, so it is never
+	* deleted; only the managed `mcpServers` key is rewritten.
+	*/
+	isDeletable() {
+		return false;
+	}
 	static getSettablePaths({ global = false } = {}) {
 		if (global) return {
-			relativeDirPath: CODEIUM_WINDSURF_DIR,
-			relativeFilePath: DEVIN_MCP_FILE_NAME
+			relativeDirPath: DEVIN_GLOBAL_CONFIG_DIR_PATH,
+			relativeFilePath: DEVIN_CONFIG_FILE_NAME
 		};
 		return {
-			relativeDirPath: WINDSURF_DIR,
-			relativeFilePath: DEVIN_MCP_FILE_NAME
+			relativeDirPath: DEVIN_DIR,
+			relativeFilePath: DEVIN_CONFIG_FILE_NAME
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
@@ -11885,7 +13015,7 @@ var FactorydroidMcp = class FactorydroidMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/goose-mcp.ts
-const GOOSE_GLOBAL_ONLY_MESSAGE$1 = "Goose MCP is global-only; use --global to sync ~/.config/goose/config.yaml";
+const GOOSE_PLUGIN_MCP_RELATIVE_PATH = (0, node_path.join)(GOOSE_PLUGIN_MCP_DIR_PATH, GOOSE_PLUGIN_MCP_FILE_NAME);
 function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
 	let parsed;
@@ -11972,7 +13102,7 @@ function convertServerToGooseExtension(name, config) {
 function convertToGooseFormat(mcpServers) {
 	const extensions = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		extensions[name] = convertServerToGooseExtension(name, config);
 	}
 	return extensions;
@@ -11989,7 +13119,7 @@ function convertToGooseFormat(mcpServers) {
 function convertFromGooseFormat(extensions) {
 	const result = {};
 	for (const [name, ext] of Object.entries(extensions)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(ext)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(ext)) continue;
 		const server = {};
 		const type = typeof ext.type === "string" ? ext.type : void 0;
 		if (type === "sse") server.type = "sse";
@@ -12007,39 +13137,102 @@ function convertFromGooseFormat(extensions) {
 	return result;
 }
 /**
+* Builds a Claude-style stdio server entry (`command`/`args`/`env`/`cwd`) for the
+* open-plugins `.mcp.json` manifest.
+*/
+function buildGoosePluginStdioServer(config) {
+	const server = {};
+	const command = config.command;
+	if (Array.isArray(command)) {
+		if (typeof command[0] === "string") server.command = command[0];
+		const rest = command.slice(1).filter((c) => typeof c === "string");
+		const args = isStringArray(config.args) ? config.args : [];
+		if (rest.length > 0 || args.length > 0) server.args = [...rest, ...args];
+	} else if (typeof command === "string") {
+		server.command = command;
+		if (isStringArray(config.args)) server.args = config.args;
+	}
+	if (isPlainObject(config.env)) server.env = omitPrototypePollutionKeys(config.env);
+	if (typeof config.cwd === "string") server.cwd = config.cwd;
+	return server;
+}
+/**
+* Converts rulesync canonical MCP servers into the Claude-style `mcpServers` map
+* used by Goose open-plugin manifests (`.agents/plugins/rulesync/.mcp.json`).
+*
+* The open-plugins manifest is **stdio-only** (no `url`/`headers`), so remote
+* (http/sse/streamable_http) and `builtin` servers cannot be represented. They
+* are skipped with a warning rather than silently dropped — remote servers stay
+* global-config-only (sync them with `--global` to `~/.config/goose/config.yaml`).
+*/
+function convertToGoosePluginMcpServers(mcpServers, logger) {
+	const result = {};
+	for (const [name, config] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
+		const gooseType = resolveGooseType(config, resolveGooseUrl(config));
+		if (gooseType !== "stdio") {
+			warnWithFallback(logger, `Goose open-plugin MCP manifest (${GOOSE_PLUGIN_MCP_RELATIVE_PATH}) is stdio-only; skipping "${name}" (${gooseType}). Sync it with --global to ~/.config/goose/config.yaml instead.`);
+			continue;
+		}
+		result[name] = buildGoosePluginStdioServer(config);
+	}
+	return result;
+}
+/**
 * Goose MCP servers.
 *
-* Goose configures MCP servers as "extensions" in the shared user config file
-* `~/.config/goose/config.yaml` (global only — Goose has no project-scoped MCP
-* location). That file also holds other Goose settings (model, provider, ...),
-* so generation merges the `extensions:` block into the existing config instead
-* of overwriting it, and the file is never deleted.
+* Goose configures MCP servers in two locations:
+*
+* - **Global** (`--global`): "extensions" in the shared user config
+*   `~/.config/goose/config.yaml`. That file also holds other Goose settings
+*   (model, provider, ...), so generation merges the `extensions:` block into the
+*   existing config instead of overwriting it, and the file is never deleted.
+*   This location supports both stdio and remote (http/sse) servers.
+* - **Project**: a stdio-only open-plugin manifest at
+*   `.agents/plugins/rulesync/.mcp.json` (Goose v1.39.0+), reusing the same
+*   `.agents/plugins/rulesync/` tree as Goose hooks. The manifest uses the
+*   Claude-style `{ "mcpServers": { "<name>": { command, args, env, cwd } } }`
+*   shape and cannot express `url`/`headers`, so remote servers are skipped with
+*   a warning in project mode (use `--global` to sync them instead).
 *
 * @see https://block.github.io/goose/docs/getting-started/using-extensions/
+* @see https://github.com/block/goose/pull/9471
 */
 var GooseMcp = class GooseMcp extends ToolMcp {
 	config;
 	constructor(params) {
 		super(params);
-		if (this.fileContent !== void 0) this.config = parseGooseConfig(this.fileContent, this.relativeDirPath, this.relativeFilePath);
-		else this.config = {};
+		if (this.fileContent === void 0) this.config = {};
+		else if (params.global) this.config = parseGooseConfig(this.fileContent, this.relativeDirPath, this.relativeFilePath);
+		else this.config = this.fileContent ? this.parsePluginManifest(this.fileContent) : {};
+	}
+	parsePluginManifest(fileContent) {
+		try {
+			const parsed = JSON.parse(fileContent);
+			return isRecord(parsed) ? parsed : {};
+		} catch (error) {
+			throw new Error(`Failed to parse Goose MCP manifest at ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(error)}`, { cause: error });
+		}
 	}
 	getConfig() {
 		return this.config;
 	}
 	isDeletable() {
-		return false;
+		return !this.global;
 	}
-	static getSettablePaths(_options) {
-		return {
+	static getSettablePaths({ global = false } = {}) {
+		if (global) return {
 			relativeDirPath: GOOSE_GLOBAL_DIR,
 			relativeFilePath: GOOSE_MCP_FILE_NAME
 		};
+		return {
+			relativeDirPath: GOOSE_PLUGIN_MCP_DIR_PATH,
+			relativeFilePath: GOOSE_PLUGIN_MCP_FILE_NAME
+		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error(GOOSE_GLOBAL_ONLY_MESSAGE$1);
 		const paths = this.getSettablePaths({ global });
-		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? (global ? "" : JSON.stringify({ mcpServers: {} }, null, 2));
 		return new GooseMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -12049,9 +13242,19 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 			global
 		});
 	}
-	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
-		if (!global) throw new Error(GOOSE_GLOBAL_ONLY_MESSAGE$1);
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
 		const paths = this.getSettablePaths({ global });
+		if (!global) {
+			const mcpServers = convertToGoosePluginMcpServers(rulesyncMcp.getMcpServers(), logger);
+			return new GooseMcp({
+				outputRoot,
+				relativeDirPath: paths.relativeDirPath,
+				relativeFilePath: paths.relativeFilePath,
+				fileContent: JSON.stringify({ mcpServers }, null, 2),
+				validate,
+				global
+			});
+		}
 		const merged = {
 			...parseGooseConfig(await readOrInitializeFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath), ""), paths.relativeDirPath, paths.relativeFilePath),
 			extensions: convertToGooseFormat(rulesyncMcp.getMcpServers())
@@ -12066,7 +13269,11 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		const mcpServers = convertFromGooseFormat(isRecord$1(this.config.extensions) ? this.config.extensions : {});
+		if (!this.global) {
+			const mcpServers = isRecord(this.config.mcpServers) ? this.config.mcpServers : {};
+			return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+		}
+		const mcpServers = convertFromGooseFormat(isRecord(this.config.extensions) ? this.config.extensions : {});
 		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
 	}
 	validate() {
@@ -12143,7 +13350,7 @@ function convertToGrokFormat(mcpServers) {
 	const result = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
-		if (!isRecord$1(config)) continue;
+		if (!isRecord(config)) continue;
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -12158,7 +13365,7 @@ function convertToGrokFormat(mcpServers) {
 function convertFromGrokFormat(grokMcp) {
 	const result = {};
 	for (const [name, config] of Object.entries(grokMcp)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -12321,13 +13528,13 @@ function convertServerToHermes(config) {
 function convertToHermesFormat(mcpServers) {
 	const result = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		result[name] = convertServerToHermes(config);
 	}
 	return result;
 }
 function mergeHermesMcpServers(config, mcpServers) {
-	const existingMcpServers = isRecord$1(config.mcp_servers) ? config.mcp_servers : {};
+	const existingMcpServers = isRecord(config.mcp_servers) ? config.mcp_servers : {};
 	return {
 		...config,
 		mcp_servers: {
@@ -12345,7 +13552,7 @@ function mergeHermesMcpServers(config, mcpServers) {
 function convertFromHermesFormat(mcpServers) {
 	const result = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
-		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord$1(config)) continue;
+		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		const server = {};
 		if (typeof config.command === "string") server.command = config.command;
 		if (isStringArray(config.args)) server.args = config.args;
@@ -12381,7 +13588,7 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 		return true;
 	}
 	setFileContent(fileContent) {
-		const merged = mergeHermesMcpServers(parseHermesConfig(fileContent), isRecord$1(this.config.mcp_servers) ? this.config.mcp_servers : {});
+		const merged = mergeHermesMcpServers(parseHermesConfig(fileContent), isRecord(this.config.mcp_servers) ? this.config.mcp_servers : {});
 		this.config = merged;
 		super.setFileContent(stringifyHermesConfig(merged));
 	}
@@ -12421,7 +13628,7 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		const servers = convertFromHermesFormat(isRecord$1(this.config.mcp_servers) ? this.config.mcp_servers : {});
+		const servers = convertFromHermesFormat(isRecord(this.config.mcp_servers) ? this.config.mcp_servers : {});
 		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: servers }, null, 2) });
 	}
 	validate() {
@@ -13256,11 +14463,6 @@ var QwencodeMcp = class QwencodeMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/constants/reasonix-paths.ts
-const REASONIX_PROJECT_MCP_FILE_NAME = "reasonix.toml";
-const REASONIX_GLOBAL_DIR = ".reasonix";
-const REASONIX_GLOBAL_MCP_FILE_NAME = "config.toml";
-//#endregion
 //#region src/features/mcp/reasonix-mcp.ts
 const REASONIX_PLUGIN_FIELDS = [
 	"type",
@@ -13268,13 +14470,14 @@ const REASONIX_PLUGIN_FIELDS = [
 	"args",
 	"env",
 	"url",
-	"headers"
+	"headers",
+	"trusted_read_only_tools"
 ];
 var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	toml;
 	constructor(params) {
 		super(params);
-		this.toml = parseReasonixConfig(this.fileContent);
+		this.toml = parseReasonixConfig$1(this.fileContent);
 	}
 	getToml() {
 		return this.toml;
@@ -13298,7 +14501,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const config = parseReasonixConfig(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
+		const config = parseReasonixConfig$1(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
 		config.plugins = normalizePluginsArray(config.plugins);
 		return new ReasonixMcp({
 			outputRoot,
@@ -13311,7 +14514,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
-		const config = parseReasonixConfig(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
+		const config = parseReasonixConfig$1(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
 		config.plugins = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToReasonix(name, server));
 		return new ReasonixMcp({
 			outputRoot,
@@ -13328,7 +14531,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	}
 	validate() {
 		try {
-			parseReasonixConfig(this.fileContent);
+			parseReasonixConfig$1(this.fileContent);
 			return {
 				success: true,
 				error: null
@@ -13351,7 +14554,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 		});
 	}
 };
-function parseReasonixConfig(fileContent) {
+function parseReasonixConfig$1(fileContent) {
 	const parsed = smol_toml.parse(fileContent || smol_toml.stringify({}));
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
 	return { ...parsed };
@@ -13491,17 +14694,6 @@ var RooMcp = class RooMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/constants/rovodev-paths.ts
-const ROVODEV_DIR = ".rovodev";
-const ROVODEV_SKILLS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "skills");
-const ROVODEV_SUBAGENTS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "subagents");
-const ROVODEV_MODULAR_RULES_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, ".rulesync", "modular-rules");
-const ROVODEV_RULE_FILE_NAME = "AGENTS.md";
-const ROVODEV_LEGACY_RULE_FILE_NAME = "AGENTS.local.md";
-const ROVODEV_MCP_FILE_NAME = "mcp.json";
-const ROVODEV_CONFIG_FILE_NAME = "config.yml";
-const ROVODEV_AGENTS_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
-//#endregion
 //#region src/features/mcp/rovodev-mcp.ts
 function parseRovodevMcpJson(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
@@ -13595,6 +14787,178 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/shared/takt-config.ts
+/**
+* Parse a Takt `config.yaml` into a plain object, treating an empty file as `{}`.
+*
+* Shared by the Takt adapters that read-modify-write the same `config.yaml`
+* (mcp, permissions, ...). Uses `isPlainObject` (not `isRecord`) so class
+* instances are rejected for prototype-pollution hardening; a YAML mapping
+* always parses to a plain object.
+*/
+function parseTaktConfig(fileContent, relativeDirPath, relativeFilePath) {
+	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
+	let parsed;
+	try {
+		parsed = fileContent.trim() === "" ? {} : (0, js_yaml.load)(fileContent);
+	} catch (error) {
+		throw new Error(`Failed to parse Takt config at ${configPath}: ${formatError(error)}`, { cause: error });
+	}
+	if (parsed === void 0 || parsed === null) return {};
+	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Takt config at ${configPath}: expected a YAML mapping`);
+	return parsed;
+}
+//#endregion
+//#region src/features/mcp/takt-mcp.ts
+/**
+* MCP adapter for Takt (`.takt/config.yaml` project / `~/.takt/config.yaml`
+* global).
+*
+* IMPORTANT — what this adapter can and cannot represent.
+*
+* Takt does NOT have a project- or global-level registry of MCP *server
+* definitions*. The concrete `mcp_servers` map (a server's `command`/`args`/`env`
+* or `type`/`url`/`headers`) is declared per-step inside individual *workflow*
+* YAML files; there is no top-level `mcp_servers` key in `config.yaml`, and the
+* config loader hard-rejects unknown top-level keys
+* (`assertNoUnknownGlobalConfigKeys`). Writing a server map into `config.yaml`
+* would therefore both be ignored and break the user's config.
+*
+* What `config.yaml` *does* hold is the default-deny transport allowlist
+* `workflow_mcp_servers: { stdio, sse, http }`. Without it, workflow-defined MCP
+* servers are refused regardless of how they are declared. So this adapter emits
+* the transport allowlist derived from the transports present in
+* `.rulesync/mcp.json`, enabling exactly the transports the user's servers need.
+*
+* Lossiness (documented, intentional): the per-server names, commands, env, URLs
+* and headers are NOT representable in `config.yaml` and are intentionally not
+* written. Users still declare the concrete servers in their workflow YAML
+* steps; rulesync only opens the transport gate that permits them. As a
+* corollary, import (`toRulesyncMcp`) cannot reconstruct server definitions from
+* a transport allowlist and yields an empty `mcpServers` map.
+*
+* The shared `config.yaml` is merged in place: only the
+* `workflow_mcp_servers` key is set; every other top-level key (provider,
+* provider_profiles, etc.) is preserved. The file is never deleted.
+*
+* @see https://github.com/nrslib/takt/blob/main/docs/configuration.md
+* @see https://github.com/nrslib/takt/blob/main/src/core/models/mcp-schemas.ts
+*/
+var TaktMcp = class TaktMcp extends ToolMcp {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? ""
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options) {
+		return {
+			relativeDirPath: TAKT_DIR,
+			relativeFilePath: TAKT_CONFIG_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = TaktMcp.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
+		return new TaktMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
+		const paths = TaktMcp.getSettablePaths({ global });
+		const config = parseTaktConfig(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "", paths.relativeDirPath, paths.relativeFilePath);
+		const allowlist = deriveTransportAllowlist(rulesyncMcp.getMcpServers());
+		const merged = {
+			...config,
+			[TAKT_WORKFLOW_MCP_SERVERS_KEY]: allowlist
+		};
+		return new TaktMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: (0, js_yaml.dump)(merged),
+			validate,
+			global
+		});
+	}
+	/**
+	* A transport allowlist cannot reconstruct the per-step server definitions,
+	* so import yields an empty `mcpServers` map. This keeps the round-trip honest
+	* rather than fabricating placeholder servers.
+	*/
+	toRulesyncMcp() {
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: {} }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new TaktMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+/**
+* Map a rulesync MCP server onto the single Takt transport its allowlist gates.
+*
+* Takt allows only `stdio` / `sse` / `http`, so the broader rulesync alias set is
+* folded: `local` ⇒ stdio; `streamable-http` / `ws` ⇒ http. A server with no
+* explicit transport is treated as stdio when it carries a `command`, else as a
+* remote `http` server (it must have a `url`). Returns `undefined` only when the
+* shape is too ambiguous to classify.
+*/
+function transportOf(server) {
+	switch (server.type ?? server.transport) {
+		case "stdio":
+		case "local": return "stdio";
+		case "sse": return "sse";
+		case "http":
+		case "streamable-http":
+		case "ws": return "http";
+		default: break;
+	}
+	if (server.command !== void 0) return "stdio";
+	if (server.url !== void 0 || server.httpUrl !== void 0) return "http";
+}
+/**
+* Derive Takt's `workflow_mcp_servers` allowlist from the transports present in
+* the rulesync servers. All three keys are emitted explicitly (default-deny made
+* visible): a transport is `true` only when at least one server uses it.
+*
+* Server entries are read defensively (record guard); prototype-pollution server
+* names are irrelevant here because no user-controlled key or value is written —
+* only the three fixed boolean keys are.
+*/
+function deriveTransportAllowlist(servers) {
+	const allowlist = {
+		stdio: false,
+		sse: false,
+		http: false
+	};
+	for (const server of Object.values(servers)) {
+		if (!isRecord(server)) continue;
+		const transport = transportOf(server);
+		if (transport) allowlist[transport] = true;
+	}
+	return allowlist;
+}
+//#endregion
 //#region src/features/mcp/vibe-mcp.ts
 const VIBE_MCP_SERVER_FIELDS = [
 	"transport",
@@ -14055,7 +15419,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 	["goose", {
 		class: GooseMcp,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
 			supportsDisabledTools: false
@@ -14169,6 +15533,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["takt", {
+		class: TaktMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["vibe", {
 		class: VibeMcp,
 		meta: {
@@ -14297,7 +15670,8 @@ var McpProcessor = class extends FeatureProcessor {
 			return await factory.class.fromRulesyncMcp({
 				outputRoot: this.outputRoot,
 				rulesyncMcp: filteredRulesyncMcp,
-				global: this.global
+				global: this.global,
+				logger: this.logger
 			});
 		}));
 	}
@@ -14811,7 +16185,7 @@ const ANTIGRAVITY_CLI_TO_CANONICAL_TOOL_NAMES = {
 function toAntigravityCliToolName(canonical) {
 	return CANONICAL_TO_ANTIGRAVITY_CLI_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$5(cliName) {
+function toCanonicalToolName$6(cliName) {
 	return ANTIGRAVITY_CLI_TO_CANONICAL_TOOL_NAMES[cliName] ?? cliName;
 }
 /**
@@ -14994,7 +16368,7 @@ function convertAntigravityCliToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { toolName, pattern } = parsePermissionEntry$1(entry);
-			const canonical = toCanonicalToolName$5(toolName);
+			const canonical = toCanonicalToolName$6(toolName);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
 		}
@@ -15033,7 +16407,7 @@ const IDE_ACTION_TO_CANONICAL = {
 function toIdeAction(canonical) {
 	return CANONICAL_TO_IDE_ACTION[canonical] ?? canonical;
 }
-function toCanonicalCategory$1(ideAction) {
+function toCanonicalCategory$2(ideAction) {
 	return IDE_ACTION_TO_CANONICAL[ideAction] ?? ideAction;
 }
 /**
@@ -15207,7 +16581,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { action: ideAction, pattern } = parsePermissionEntry(entry);
-			const canonical = toCanonicalCategory$1(ideAction);
+			const canonical = toCanonicalCategory$2(ideAction);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
 		}
@@ -15256,7 +16630,7 @@ const AUGMENT_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONI
 function toAugmentToolName(canonical) {
 	return CANONICAL_TO_AUGMENT_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$4(augmentName) {
+function toCanonicalToolName$5(augmentName) {
 	return AUGMENT_TO_CANONICAL_TOOL_NAMES[augmentName] ?? augmentName;
 }
 function actionToAugmentType(action) {
@@ -15600,7 +16974,7 @@ function convertAugmentToRulesyncPermissions({ entries, logger }) {
 		}
 		const type = entry.permission.type;
 		if (!isBasicAugmentType(type)) continue;
-		const canonical = toCanonicalToolName$4(entry.toolName);
+		const canonical = toCanonicalToolName$5(entry.toolName);
 		if (forbiddenMapKeys.has(canonical)) {
 			logger?.warn(`AugmentCode permissions: skipping entry for tool '${entry.toolName}' because it maps to the reserved object key '${canonical}', which cannot be used as a permission key.`);
 			continue;
@@ -15653,7 +17027,7 @@ const CLAUDE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONIC
 function toClaudeToolName(canonical) {
 	return CANONICAL_TO_CLAUDE_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$3(claudeName) {
+function toCanonicalToolName$4(claudeName) {
 	return CLAUDE_TO_CANONICAL_TOOL_NAMES[claudeName] ?? claudeName;
 }
 /**
@@ -15827,7 +17201,7 @@ function convertClaudeToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { toolName, pattern } = parseClaudePermissionEntry(entry);
-			const canonical = toCanonicalToolName$3(toolName);
+			const canonical = toCanonicalToolName$4(toolName);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
 		}
@@ -16454,7 +17828,7 @@ function toCursorPattern(canonical, pattern) {
 	}
 	return pattern;
 }
-function toCanonicalCategory(cursorType, pattern) {
+function toCanonicalCategory$1(cursorType, pattern) {
 	if (cursorType === "Mcp") {
 		const match = pattern.match(/^([^:()]+):([^:()]+)$/);
 		if (match) return `${MCP_CANONICAL_PREFIX}${match[1] ?? "*"}__${match[2] ?? "*"}`;
@@ -16679,7 +18053,7 @@ function convertCursorToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { type, pattern } = parseCursorPermissionEntry(entry);
-			const canonical = toCanonicalCategory(type, pattern);
+			const canonical = toCanonicalCategory$1(type, pattern);
 			if (!permission[canonical]) permission[canonical] = {};
 			const canonicalPattern = type === "Mcp" && canonical.startsWith(MCP_CANONICAL_PREFIX) ? "*" : pattern;
 			permission[canonical][canonicalPattern] = action;
@@ -16690,6 +18064,245 @@ function convertCursorToRulesyncPermissions(params) {
 	return { permission };
 }
 //#endregion
+//#region src/features/permissions/devin-permissions.ts
+/**
+* Mapping from rulesync canonical tool category names to Devin Local permission
+* scope matchers.
+*
+* Devin expresses permissions with scope-based matchers — `Read(glob)`,
+* `Write(glob)`, `Exec(prefix)`, and `Fetch(pattern)` — plus MCP tool patterns
+* (`mcp__server__tool`). The canonical `edit` and `write` categories both map
+* onto Devin's single `Write` scope; on import `Write` maps back to `write`, so
+* `edit` rules round-trip as `write` (a lossy but documented collapse). Unknown
+* names (e.g. `mcp__github__list_issues`) pass through verbatim.
+*
+* @see https://docs.devin.ai/cli/reference/permissions
+*/
+const CANONICAL_TO_DEVIN_SCOPE = {
+	read: "Read",
+	write: "Write",
+	edit: "Write",
+	bash: "Exec",
+	webfetch: "Fetch"
+};
+/**
+* Reverse mapping from Devin scope matchers to rulesync canonical names.
+*/
+const DEVIN_SCOPE_TO_CANONICAL = {
+	Read: "read",
+	Write: "write",
+	Exec: "bash",
+	Fetch: "webfetch"
+};
+function toDevinScope(canonical) {
+	return CANONICAL_TO_DEVIN_SCOPE[canonical] ?? canonical;
+}
+function toCanonicalCategory(devinScope) {
+	return DEVIN_SCOPE_TO_CANONICAL[devinScope] ?? devinScope;
+}
+/**
+* Parse a Devin permission entry like `Read(src/**)` into scope and pattern.
+* Bare entries (e.g. `Read`, or a whole-tool name like `exec`) yield `*`.
+*/
+function parseDevinPermissionEntry(entry) {
+	const parenIndex = entry.indexOf("(");
+	if (parenIndex === -1) return {
+		scope: entry,
+		pattern: "*"
+	};
+	const scope = entry.slice(0, parenIndex);
+	if (!entry.endsWith(")")) return {
+		scope,
+		pattern: "*"
+	};
+	return {
+		scope,
+		pattern: entry.slice(parenIndex + 1, -1) || "*"
+	};
+}
+/**
+* Build a Devin permission entry like `Read(src/**)`. A `*` pattern collapses to
+* the bare scope (`Read`), matching the whole scope.
+*/
+function buildDevinPermissionEntry(scope, pattern) {
+	if (pattern === "*") return scope;
+	return `${scope}(${pattern})`;
+}
+/**
+* Permissions generator for Devin Local (native `.devin/` configuration).
+*
+* Maps rulesync permission actions onto Devin's `permissions` block inside its
+* native config file — `allow` / `deny` / `ask` arrays of scope matchers
+* (`Read(glob)`, `Write(glob)`, `Exec(prefix)`, `Fetch(pattern)`, plus
+* `mcp__server__tool` patterns). Devin evaluates the arrays with strict
+* precedence: `deny` is checked before `ask`, which is checked before `allow`,
+* so a deny rule always wins.
+*
+* - Project scope: `.devin/config.json`
+* - Global scope: `~/.config/devin/config.json`
+*
+* The config file is shared with the MCP (`mcpServers`) and, in global mode, the
+* hooks (`hooks`) features, so reads and writes merge into the existing JSON and
+* the file is never deleted; only the managed `permissions` key is rewritten.
+*
+* @see https://docs.devin.ai/cli/reference/permissions
+*/
+var DevinPermissions = class DevinPermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	/**
+	* config.json may carry the MCP/hooks features' keys, so it is never deleted;
+	* only the managed `permissions` key is rewritten.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		if (global) return {
+			relativeDirPath: DEVIN_GLOBAL_CONFIG_DIR_PATH,
+			relativeFilePath: DEVIN_CONFIG_FILE_NAME
+		};
+		return {
+			relativeDirPath: DEVIN_DIR,
+			relativeFilePath: DEVIN_CONFIG_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = DevinPermissions.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"permissions\":{}}";
+		return new DevinPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, global = false, validate = true }) {
+		const paths = DevinPermissions.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
+		let settings;
+		try {
+			const parsed = JSON.parse(existingContent);
+			settings = isRecord(parsed) ? parsed : {};
+		} catch (error) {
+			throw new Error(`Failed to parse existing Devin config at ${filePath}: ${formatError(error)}`, { cause: error });
+		}
+		const config = rulesyncPermissions.getJson();
+		const { allow, ask, deny } = convertRulesyncToDevinPermissions(config);
+		const managedScopes = new Set(Object.keys(config.permission).map((category) => toDevinScope(category)));
+		const existingPermissions = isRecord(settings.permissions) ? settings.permissions : {};
+		const preserve = (entries) => (entries ?? []).filter((entry) => !managedScopes.has(parseDevinPermissionEntry(entry).scope));
+		const mergedAllow = (0, es_toolkit.uniq)([...preserve(existingPermissions.allow), ...allow].toSorted());
+		const mergedAsk = (0, es_toolkit.uniq)([...preserve(existingPermissions.ask), ...ask].toSorted());
+		const mergedDeny = (0, es_toolkit.uniq)([...preserve(existingPermissions.deny), ...deny].toSorted());
+		const mergedPermissions = { ...existingPermissions };
+		if (mergedAllow.length > 0) mergedPermissions.allow = mergedAllow;
+		else delete mergedPermissions.allow;
+		if (mergedAsk.length > 0) mergedPermissions.ask = mergedAsk;
+		else delete mergedPermissions.ask;
+		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
+		else delete mergedPermissions.deny;
+		const merged = {
+			...settings,
+			permissions: mergedPermissions
+		};
+		return new DevinPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(merged, null, 2),
+			validate
+		});
+	}
+	toRulesyncPermissions() {
+		let settings;
+		try {
+			const parsed = JSON.parse(this.getFileContent());
+			settings = isRecord(parsed) ? parsed : {};
+		} catch (error) {
+			throw new Error(`Failed to parse Devin permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const permissions = isRecord(settings.permissions) ? settings.permissions : {};
+		const config = convertDevinToRulesyncPermissions({
+			allow: Array.isArray(permissions.allow) ? permissions.allow : [],
+			ask: Array.isArray(permissions.ask) ? permissions.ask : [],
+			deny: Array.isArray(permissions.deny) ? permissions.deny : []
+		});
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new DevinPermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ permissions: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+/**
+* Convert rulesync permissions config to Devin allow/ask/deny arrays.
+*/
+function convertRulesyncToDevinPermissions(config) {
+	const allow = [];
+	const ask = [];
+	const deny = [];
+	for (const [category, rules] of Object.entries(config.permission)) {
+		const scope = toDevinScope(category);
+		for (const [pattern, action] of Object.entries(rules)) {
+			const entry = buildDevinPermissionEntry(scope, pattern);
+			switch (action) {
+				case "allow":
+					allow.push(entry);
+					break;
+				case "ask":
+					ask.push(entry);
+					break;
+				case "deny":
+					deny.push(entry);
+					break;
+			}
+		}
+	}
+	return {
+		allow,
+		ask,
+		deny
+	};
+}
+/**
+* Convert Devin allow/ask/deny arrays to rulesync permissions config. Entries
+* are applied allow → ask → deny so the most restrictive action wins for a
+* given (scope, pattern), mirroring Devin's deny > ask > allow precedence.
+*/
+function convertDevinToRulesyncPermissions(params) {
+	const permission = {};
+	const processEntries = (entries, action) => {
+		for (const entry of entries) {
+			const { scope, pattern } = parseDevinPermissionEntry(entry);
+			if (isPrototypePollutionKey(scope) || isPrototypePollutionKey(pattern)) continue;
+			const canonical = toCanonicalCategory(scope);
+			(permission[canonical] ??= {})[pattern] = action;
+		}
+	};
+	processEntries(params.allow, "allow");
+	processEntries(params.ask, "ask");
+	processEntries(params.deny, "deny");
+	return { permission };
+}
+//#endregion
 //#region src/features/permissions/factorydroid-permissions.ts
 /**
 * Permissions adapter for Factory Droid.
@@ -16949,7 +18562,7 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse existing Goose permission.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
-		const config = isRecord$1(parsed) ? { ...parsed } : {};
+		const config = isRecord(parsed) ? { ...parsed } : {};
 		config[GOOSE_USER_KEY] = convertRulesyncToGoosePermissionConfig({
 			config: rulesyncPermissions.getJson(),
 			logger
@@ -16971,8 +18584,8 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const config = isRecord$1(parsed) ? parsed : {};
-		const rulesyncConfig = convertGoosePermissionConfigToRulesync(isRecord$1(config[GOOSE_USER_KEY]) ? config[GOOSE_USER_KEY] : {});
+		const config = isRecord(parsed) ? parsed : {};
+		const rulesyncConfig = convertGoosePermissionConfigToRulesync(isRecord(config[GOOSE_USER_KEY]) ? config[GOOSE_USER_KEY] : {});
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(rulesyncConfig, null, 2) });
 	}
 	validate() {
@@ -17112,7 +18725,7 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			throw new Error(`Failed to parse existing Grok config.toml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
 		const mode = deriveGrokPermissionMode(rulesyncPermissions.getJson());
-		const existingUi = isRecord$1(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {};
+		const existingUi = isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {};
 		parsed[GROKCLI_UI_KEY] = {
 			...existingUi,
 			[GROKCLI_PERMISSION_MODE_KEY]: mode
@@ -17134,7 +18747,7 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Grok config.toml content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const action = (isRecord$1(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {})[GROKCLI_PERMISSION_MODE_KEY] === "always-approve" ? "allow" : "ask";
+		const action = (isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {})[GROKCLI_PERMISSION_MODE_KEY] === "always-approve" ? "allow" : "ask";
 		const rulesyncConfig = { permission: { bash: { [CATCH_ALL_PATTERN$2]: action } } };
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(rulesyncConfig, null, 2) });
 	}
@@ -17216,6 +18829,205 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 	}
 };
 //#endregion
+//#region src/features/permissions/junie-permissions.ts
+/**
+* JetBrains Junie CLI Action Allowlist (`allowlist.json`).
+*
+* Junie gates actions through an allowlist evaluated top-to-bottom (first match
+* wins). Project scope lives in `.junie/allowlist.json`; user scope lives in
+* `~/.junie/allowlist.json`.
+*
+* ```json
+* {
+*   "defaultBehavior": "ask",
+*   "allowReadonlyCommands": true,
+*   "rules": {
+*     "executables":       [ { "prefix": "git ", "action": "allow" } ],
+*     "fileEditing":       [ { "pattern": "src/**", "action": "allow" } ],
+*     "mcpTools":          [ { "prefix": "search", "action": "allow" } ],
+*     "readOutsideProject":[ { "pattern": "/etc/**", "action": "deny" } ]
+*   }
+* }
+* ```
+*
+* Each rule carries a literal `prefix` (matches commands that start with it) or
+* a glob `pattern` (`*`, `**`, `?`, `[abc]`, `[!abc]`) plus an `action`
+* (`allow` | `ask` | `deny`). rulesync's canonical actions map 1:1 onto Junie's.
+*
+* Category mapping (rulesync canonical <-> Junie rule group):
+* - `bash`         <-> `executables`
+* - `edit`/`write` -> `fileEditing`  (imported back as `edit`)
+* - `read`         <-> `readOutsideProject`
+* - `mcp`          <-> `mcpTools`
+*
+* Categories Junie cannot represent (e.g. `webfetch`) are skipped on export
+* (with a warning when they carry rules). The top-level `defaultBehavior` and
+* `allowReadonlyCommands` settings have no canonical equivalent: they are
+* preserved verbatim on export but not imported into the rulesync model.
+*
+* @see https://junie.jetbrains.com/docs/action-allowlist-junie-cli.html
+*/
+const JUNIE_RULE_GROUPS = [
+	"executables",
+	"fileEditing",
+	"mcpTools",
+	"readOutsideProject"
+];
+const CANONICAL_TO_JUNIE_GROUP = {
+	bash: "executables",
+	edit: "fileEditing",
+	write: "fileEditing",
+	read: "readOutsideProject",
+	mcp: "mcpTools"
+};
+const JUNIE_GROUP_TO_CANONICAL = {
+	executables: "bash",
+	fileEditing: "edit",
+	mcpTools: "mcp",
+	readOutsideProject: "read"
+};
+const JUNIE_DEFAULT_BEHAVIOR = "ask";
+function isPermissionAction$1(value) {
+	return PermissionActionSchema.safeParse(value).success;
+}
+/**
+* Whether a rulesync pattern uses glob syntax. Junie expresses literal
+* "starts-with" matches as `prefix` and glob matches as `pattern`, so a pattern
+* containing any glob metacharacter (`*`, `?`, `[`) is emitted as `pattern`.
+*/
+function isGlobPattern(pattern) {
+	return /[*?[]/.test(pattern);
+}
+var JuniePermissions = class JuniePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: JUNIE_DIR,
+			relativeFilePath: JUNIE_PERMISSIONS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = JuniePermissions.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new JuniePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
+		const paths = JuniePermissions.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readOrInitializeFileContent(filePath, "{}");
+		let existing;
+		try {
+			const parsed = JSON.parse(existingContent);
+			existing = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch (error) {
+			throw new Error(`Failed to parse existing Junie allowlist at ${filePath}: ${formatError(error)}`, { cause: error });
+		}
+		const rules = convertRulesyncToJunieRules({
+			config: rulesyncPermissions.getJson(),
+			logger
+		});
+		const merged = {
+			...existing,
+			defaultBehavior: existing.defaultBehavior ?? JUNIE_DEFAULT_BEHAVIOR,
+			rules
+		};
+		return new JuniePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(merged, null, 2),
+			validate: true
+		});
+	}
+	toRulesyncPermissions() {
+		let allowlist;
+		try {
+			const parsed = JSON.parse(this.getFileContent());
+			allowlist = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch (error) {
+			throw new Error(`Failed to parse Junie permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const config = convertJunieToRulesyncPermissions({ allowlist });
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new JuniePermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false
+		});
+	}
+};
+/**
+* Convert rulesync permissions config into Junie's `rules` object. Categories
+* with no Junie rule group (e.g. `webfetch`) are skipped, with a warning when
+* they carry any rule so the gap is surfaced.
+*/
+function convertRulesyncToJunieRules({ config, logger }) {
+	const rules = {};
+	for (const [category, patterns] of Object.entries(config.permission)) {
+		const group = CANONICAL_TO_JUNIE_GROUP[category];
+		if (!group) {
+			if (Object.keys(patterns).length > 0) logger?.warn(`Junie allowlist only models executables/fileEditing/mcpTools/readOutsideProject (canonical bash/edit/write/read/mcp); '${category}' rules cannot be represented and were skipped.`);
+			continue;
+		}
+		for (const [pattern, action] of Object.entries(patterns)) {
+			const rule = isGlobPattern(pattern) ? {
+				pattern,
+				action
+			} : {
+				prefix: pattern,
+				action
+			};
+			(rules[group] ??= []).push(rule);
+		}
+	}
+	return rules;
+}
+/**
+* Convert a Junie allowlist back into rulesync permissions config. The
+* top-level `defaultBehavior` / `allowReadonlyCommands` settings have no
+* canonical equivalent and are not imported.
+*/
+function convertJunieToRulesyncPermissions({ allowlist }) {
+	const permission = {};
+	const rules = allowlist.rules;
+	if (rules && typeof rules === "object") for (const group of JUNIE_RULE_GROUPS) {
+		const list = rules[group];
+		if (!Array.isArray(list)) continue;
+		const category = JUNIE_GROUP_TO_CANONICAL[group];
+		for (const rule of list) {
+			if (!rule || typeof rule !== "object") continue;
+			const pattern = typeof rule.pattern === "string" ? rule.pattern : typeof rule.prefix === "string" ? rule.prefix : void 0;
+			if (pattern === void 0 || !isPermissionAction$1(rule.action)) continue;
+			(permission[category] ??= {})[pattern] = rule.action;
+		}
+	}
+	return { permission };
+}
+//#endregion
 //#region src/features/permissions/kilo-permissions.ts
 const KiloPermissionSchema = zod_mini.z.union([zod_mini.z.enum([
 	"allow",
@@ -17564,7 +19376,11 @@ const OpencodePermissionSchema = zod_mini.z.union([zod_mini.z.enum([
 	"ask",
 	"deny"
 ]))]);
-const OpencodePermissionsConfigSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), OpencodePermissionSchema)) });
+const OpencodePermissionsConfigSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.enum([
+	"allow",
+	"ask",
+	"deny"
+]), zod_mini.z.record(zod_mini.z.string(), OpencodePermissionSchema)])) });
 var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 	json;
 	constructor(params) {
@@ -17667,6 +19483,7 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 	}
 	normalizePermission(permission) {
 		if (!permission) return {};
+		if (typeof permission === "string") return { "*": { "*": permission } };
 		return Object.fromEntries(Object.entries(permission).map(([tool, value]) => [tool, typeof value === "string" ? { "*": value } : value]));
 	}
 };
@@ -17703,7 +19520,7 @@ const QWEN_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL
 function toQwenToolName(canonical) {
 	return CANONICAL_TO_QWEN_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$2(qwenName) {
+function toCanonicalToolName$3(qwenName) {
 	return QWEN_TO_CANONICAL_TOOL_NAMES[qwenName] ?? qwenName;
 }
 function parseQwenPermissionEntry(entry, options = {}) {
@@ -17897,13 +19714,242 @@ function convertQwenToRulesyncPermissions(params) {
 			const parsed = parseQwenPermissionEntry(entry, { logger });
 			if (!parsed.ok) {
 				if (action === "deny") {
-					const canonical = toCanonicalToolName$2(parsed.toolName);
+					const canonical = toCanonicalToolName$3(parsed.toolName);
 					if (!permission[canonical]) permission[canonical] = {};
 					permission[canonical]["*"] = action;
 				}
 				continue;
 			}
 			const { toolName, pattern } = parsed;
+			const canonical = toCanonicalToolName$3(toolName);
+			if (!permission[canonical]) permission[canonical] = {};
+			permission[canonical][pattern] = action;
+		}
+	};
+	processEntries(params.allow, "allow");
+	processEntries(params.ask, "ask");
+	processEntries(params.deny, "deny");
+	return { permission };
+}
+//#endregion
+//#region src/features/permissions/reasonix-permissions.ts
+/**
+* Mapping from rulesync canonical tool category names (lowercase) to Reasonix
+* permission-rule tool families (PascalCase).
+*
+* Reasonix's `[permissions]` rule syntax (SPEC.md §3.7) is explicitly
+* documented as "Claude Code-style": "Bash and file mutation approvals use
+* Claude Code-style families such as `Bash(npm run build)`, `Bash(npm run
+* test:*)`, and `Edit(docs/**)`." Reasonix also accepts legacy lowercase tool
+* IDs for compatibility, but new rules are saved using these PascalCase
+* families, so rulesync reuses the same mapping `claudecode-permissions.ts`
+* uses (the closest documented precedent for this syntax).
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/SPEC.md
+*/
+const CANONICAL_TO_REASONIX_TOOL_NAMES = {
+	bash: "Bash",
+	read: "Read",
+	edit: "Edit",
+	write: "Write",
+	webfetch: "WebFetch",
+	websearch: "WebSearch",
+	grep: "Grep",
+	glob: "Glob",
+	notebookedit: "NotebookEdit",
+	agent: "Agent"
+};
+/**
+* Reverse mapping from Reasonix tool names to rulesync canonical names.
+*/
+const REASONIX_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_REASONIX_TOOL_NAMES).map(([k, v]) => [v, k]));
+function toReasonixToolName(canonical) {
+	return CANONICAL_TO_REASONIX_TOOL_NAMES[canonical] ?? canonical;
+}
+function toCanonicalToolName$2(reasonixName) {
+	return REASONIX_TO_CANONICAL_TOOL_NAMES[reasonixName] ?? reasonixName;
+}
+/**
+* Parse a Reasonix permission entry like "Bash(npm run *)" into tool name and pattern.
+* If no parentheses, returns the tool name with "*" as the pattern.
+*/
+function parseReasonixPermissionEntry(entry) {
+	const parenIndex = entry.indexOf("(");
+	if (parenIndex === -1) return {
+		toolName: entry,
+		pattern: "*"
+	};
+	const toolName = entry.slice(0, parenIndex);
+	if (!entry.endsWith(")")) return {
+		toolName,
+		pattern: "*"
+	};
+	return {
+		toolName,
+		pattern: entry.slice(parenIndex + 1, -1) || "*"
+	};
+}
+/**
+* Build a Reasonix permission entry like "Bash(npm run *)".
+* If the pattern is "*", returns just the tool name.
+*/
+function buildReasonixPermissionEntry(toolName, pattern) {
+	if (pattern === "*") return toolName;
+	return `${toolName}(${pattern})`;
+}
+function parseReasonixConfig(fileContent) {
+	const parsed = smol_toml.parse(fileContent || smol_toml.stringify({}));
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+	return { ...parsed };
+}
+function toStringArray$1(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string");
+}
+function toPermissionsTable(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return { ...value };
+}
+var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
+	toml;
+	constructor(params) {
+		super(params);
+		this.toml = parseReasonixConfig(this.getFileContent());
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths({ global } = {}) {
+		if (global) return {
+			relativeDirPath: REASONIX_GLOBAL_DIR,
+			relativeFilePath: REASONIX_GLOBAL_PERMISSIONS_FILE_NAME
+		};
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: REASONIX_PROJECT_PERMISSIONS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({});
+		return new ReasonixPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, validate = true, logger, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const parsed = parseReasonixConfig(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smol_toml.stringify({}));
+		const config = rulesyncPermissions.getJson();
+		const { allow, ask, deny } = convertRulesyncToReasonixPermissions(config);
+		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toReasonixToolName(category)));
+		const existingPermissions = toPermissionsTable(parsed.permissions);
+		const preservedAllow = toStringArray$1(existingPermissions.allow).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const preservedAsk = toStringArray$1(existingPermissions.ask).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const preservedDeny = toStringArray$1(existingPermissions.deny).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		if (logger && managedToolNames.has("Read")) {
+			const droppedReadDenyEntries = toStringArray$1(existingPermissions.deny).filter((entry) => {
+				const { toolName } = parseReasonixPermissionEntry(entry);
+				return toolName === "Read";
+			});
+			if (droppedReadDenyEntries.length > 0) logger.warn(`Permissions feature manages 'Read' tool and will overwrite ${droppedReadDenyEntries.length} existing Read deny entries (possibly from ignore feature). Permissions take precedence.`);
+		}
+		const mergedPermissions = { ...existingPermissions };
+		const mergedAllow = (0, es_toolkit.uniq)([...preservedAllow, ...allow].toSorted());
+		const mergedAsk = (0, es_toolkit.uniq)([...preservedAsk, ...ask].toSorted());
+		const mergedDeny = (0, es_toolkit.uniq)([...preservedDeny, ...deny].toSorted());
+		if (mergedAllow.length > 0) mergedPermissions.allow = mergedAllow;
+		else delete mergedPermissions.allow;
+		if (mergedAsk.length > 0) mergedPermissions.ask = mergedAsk;
+		else delete mergedPermissions.ask;
+		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
+		else delete mergedPermissions.deny;
+		const merged = {
+			...parsed,
+			permissions: mergedPermissions
+		};
+		const fileContent = smol_toml.stringify(merged);
+		return new ReasonixPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncPermissions() {
+		const permissions = toPermissionsTable(this.toml.permissions);
+		const config = convertReasonixToRulesyncPermissions({
+			allow: toStringArray$1(permissions.allow),
+			ask: toStringArray$1(permissions.ask),
+			deny: toStringArray$1(permissions.deny)
+		});
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
+	}
+	validate() {
+		try {
+			parseReasonixConfig(this.getFileContent());
+			return {
+				success: true,
+				error: null
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: /* @__PURE__ */ new Error(`Failed to parse Reasonix config TOML: ${formatError(error)}`)
+			};
+		}
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixPermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: smol_toml.stringify({}),
+			validate: false
+		});
+	}
+};
+/**
+* Convert rulesync permissions config to Reasonix allow/ask/deny arrays.
+*/
+function convertRulesyncToReasonixPermissions(config) {
+	const allow = [];
+	const ask = [];
+	const deny = [];
+	for (const [category, rules] of Object.entries(config.permission)) {
+		const reasonixToolName = toReasonixToolName(category);
+		for (const [pattern, action] of Object.entries(rules)) {
+			const entry = buildReasonixPermissionEntry(reasonixToolName, pattern);
+			switch (action) {
+				case "allow":
+					allow.push(entry);
+					break;
+				case "ask":
+					ask.push(entry);
+					break;
+				case "deny":
+					deny.push(entry);
+					break;
+			}
+		}
+	}
+	return {
+		allow,
+		ask,
+		deny
+	};
+}
+/**
+* Convert Reasonix allow/ask/deny arrays to rulesync permissions config.
+*/
+function convertReasonixToRulesyncPermissions(params) {
+	const permission = {};
+	const processEntries = (entries, action) => {
+		for (const entry of entries) {
+			const { toolName, pattern } = parseReasonixPermissionEntry(entry);
 			const canonical = toCanonicalToolName$2(toolName);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
@@ -18016,13 +20062,13 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse existing Rovodev config at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
-		const config = isRecord$1(parsed) ? { ...parsed } : {};
+		const config = isRecord(parsed) ? { ...parsed } : {};
 		const toolPermissions = convertRulesyncToRovodevToolPermissions({
 			config: rulesyncPermissions.getJson(),
 			logger
 		});
 		config.toolPermissions = {
-			...isRecord$1(config.toolPermissions) ? { ...config.toolPermissions } : {},
+			...isRecord(config.toolPermissions) ? { ...config.toolPermissions } : {},
 			...toolPermissions
 		};
 		return new RovodevPermissions({
@@ -18042,8 +20088,8 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const config = isRecord$1(parsed) ? parsed : {};
-		const rulesyncConfig = convertRovodevToolPermissionsToRulesync(isRecord$1(config.toolPermissions) ? config.toolPermissions : {});
+		const config = isRecord(parsed) ? parsed : {};
+		const rulesyncConfig = convertRovodevToolPermissionsToRulesync(isRecord(config.toolPermissions) ? config.toolPermissions : {});
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(rulesyncConfig, null, 2) });
 	}
 	validate() {
@@ -18121,11 +20167,11 @@ function convertBashRules(rules) {
 function convertRovodevToolPermissionsToRulesync(toolPermissions) {
 	const permission = {};
 	const bash = toolPermissions.bash;
-	if (isRecord$1(bash)) {
+	if (isRecord(bash)) {
 		const bashRules = {};
 		if (isPermissionAction(bash.default)) bashRules[CATCH_ALL_PATTERN$1] = bash.default;
 		if (Array.isArray(bash.commands)) {
-			for (const entry of bash.commands) if (isRecord$1(entry) && typeof entry.command === "string" && isPermissionAction(entry.permission)) bashRules[entry.command] = entry.permission;
+			for (const entry of bash.commands) if (isRecord(entry) && typeof entry.command === "string" && isPermissionAction(entry.permission)) bashRules[entry.command] = entry.permission;
 		}
 		if (Object.keys(bashRules).length > 0) permission.bash = bashRules;
 	}
@@ -18264,21 +20310,6 @@ var TaktPermissions = class TaktPermissions extends ToolPermissions {
 	}
 };
 /**
-* Parse a Takt `config.yaml` into a plain object, treating an empty file as `{}`.
-*/
-function parseTaktConfig(fileContent, relativeDirPath, relativeFilePath) {
-	const configPath = (0, node_path.join)(relativeDirPath, relativeFilePath);
-	let parsed;
-	try {
-		parsed = fileContent.trim() === "" ? {} : (0, js_yaml.load)(fileContent);
-	} catch (error) {
-		throw new Error(`Failed to parse Takt config at ${configPath}: ${formatError(error)}`, { cause: error });
-	}
-	if (parsed === void 0 || parsed === null) return {};
-	if (!isPlainObject(parsed)) throw new Error(`Failed to parse Takt config at ${configPath}: expected a YAML mapping`);
-	return parsed;
-}
-/**
 * Resolve the active Takt provider: the top-level `provider:` value, else the
 * sole key in `provider_profiles`, else the `claude` default.
 */
@@ -18600,8 +20631,8 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 			config: rulesyncPermissions.getJson(),
 			logger
 		});
-		const agents = isRecord$1(settings.agents) ? { ...settings.agents } : {};
-		const profiles = isRecord$1(agents.profiles) ? { ...agents.profiles } : {};
+		const agents = isRecord(settings.agents) ? { ...settings.agents } : {};
+		const profiles = isRecord(agents.profiles) ? { ...agents.profiles } : {};
 		const mergedAllow = (0, es_toolkit.uniq)(allow.toSorted());
 		const mergedDeny = (0, es_toolkit.uniq)(deny.toSorted());
 		if (mergedAllow.length > 0) profiles[ALLOWLIST_KEY] = mergedAllow;
@@ -18626,8 +20657,8 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Warp permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const agents = isRecord$1(settings.agents) ? settings.agents : {};
-		const profiles = isRecord$1(agents.profiles) ? agents.profiles : {};
+		const agents = isRecord(settings.agents) ? settings.agents : {};
+		const profiles = isRecord(agents.profiles) ? agents.profiles : {};
 		const config = convertWarpToRulesyncPermissions({
 			allow: isStringArray(profiles[ALLOWLIST_KEY]) ? profiles[ALLOWLIST_KEY] : [],
 			deny: isStringArray(profiles[DENYLIST_KEY]) ? profiles[DENYLIST_KEY] : []
@@ -18978,6 +21009,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["devin", {
+		class: DevinPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["factorydroid", {
 		class: FactorydroidPermissions,
 		meta: {
@@ -19010,6 +21049,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["junie", {
+		class: JuniePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["kilo", {
 		class: KiloPermissions,
 		meta: {
@@ -19058,6 +21105,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["rovodev", {
 		class: RovodevPermissions,
 		meta: {
@@ -19610,7 +21665,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	opencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 		license: zod_mini.z.optional(zod_mini.z.string()),
-		compatibility: zod_mini.z.optional(zod_mini.z.looseObject({})),
+		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 	})),
 	kilo: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -19631,7 +21686,8 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	})),
 	copilotcli: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
-		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+		"argument-hint": zod_mini.z.optional(zod_mini.z.string())
 	})),
 	pi: zod_mini.z.optional(zod_mini.z.looseObject({
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
@@ -21385,7 +23441,11 @@ const CopilotSkillFrontmatterSchema = zod_mini.z.looseObject({
 });
 /**
 * Represents a GitHub Copilot skill directory.
-* Skills are stored under the .github/skills directory with SKILL.md files.
+*
+* Copilot discovers project skills from `.github/skills/` and personal/global
+* skills from `~/.copilot/skills/`. Each skill is a directory containing a
+* `SKILL.md` file with `name`/`description` frontmatter.
+* https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
 */
 var CopilotSkill = class CopilotSkill extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = COPILOT_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
@@ -21407,7 +23467,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		}
 	}
 	static getSettablePaths(options) {
-		if (options?.global) throw new Error("CopilotSkill does not support global mode.");
+		if (options?.global) return { relativeDirPath: COPILOT_SKILLS_GLOBAL_DIR_PATH };
 		return { relativeDirPath: COPILOT_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
@@ -21522,7 +23582,8 @@ const CopilotcliSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	license: zod_mini.z.optional(zod_mini.z.string()),
-	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
 });
 /**
 * Represents a GitHub Copilot CLI skill directory.
@@ -21552,7 +23613,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		}
 	}
 	static getSettablePaths(options) {
-		if (options?.global) return { relativeDirPath: COPILOTCLI_SKILLS_GLOBAL_DIR_PATH };
+		if (options?.global) return { relativeDirPath: COPILOT_SKILLS_GLOBAL_DIR_PATH };
 		return { relativeDirPath: COPILOT_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
@@ -21580,7 +23641,8 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		const frontmatter = this.getFrontmatter();
 		const copilotcliSection = {
 			...frontmatter.license !== void 0 && { license: frontmatter.license },
-			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] }
+			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] },
+			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -21606,7 +23668,8 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...rulesyncFrontmatter.copilotcli?.license !== void 0 && { license: rulesyncFrontmatter.copilotcli.license },
-			...rulesyncFrontmatter.copilotcli?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilotcli["allowed-tools"] }
+			...rulesyncFrontmatter.copilotcli?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilotcli["allowed-tools"] },
+			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] }
 		};
 		return new CopilotcliSkill({
 			outputRoot,
@@ -22832,8 +24895,7 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 			if (!result.success) throw result.error;
 		}
 	}
-	static getSettablePaths(options) {
-		if (options?.global) throw new Error("KiroSkill does not support global mode.");
+	static getSettablePaths(_options) {
 		return { relativeDirPath: KIRO_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
@@ -22975,10 +25037,19 @@ const OpenCodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	license: zod_mini.z.optional(zod_mini.z.string()),
-	compatibility: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
+/**
+* Reads a top-level `compatibility` value from rulesync frontmatter, accepting
+* both the documented string form (e.g. `compatibility: opencode`) and the
+* legacy object form. Returns `undefined` for any other shape.
+*/
+function readTopLevelCompatibility(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null) return value;
+}
 var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = OPENCODE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
 		super({
@@ -23055,7 +25126,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 		const opencodeSection = rulesyncFrontmatter.opencode;
 		const looseTopLevel = rulesyncFrontmatter;
 		const topLevelLicense = typeof looseTopLevel.license === "string" ? looseTopLevel.license : void 0;
-		const topLevelCompatibility = typeof looseTopLevel.compatibility === "object" && looseTopLevel.compatibility !== null ? looseTopLevel.compatibility : void 0;
+		const topLevelCompatibility = readTopLevelCompatibility(looseTopLevel.compatibility);
 		const topLevelMetadata = typeof looseTopLevel.metadata === "object" && looseTopLevel.metadata !== null ? looseTopLevel.metadata : void 0;
 		const license = opencodeSection?.license ?? topLevelLicense;
 		const compatibility = opencodeSection?.compatibility ?? topLevelCompatibility;
@@ -24409,7 +26480,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["copilotcli", {
@@ -24497,7 +26568,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["kiro-ide", {
@@ -24505,7 +26576,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["opencode", {
@@ -28593,7 +30664,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 		class: KiroCliSubagent,
 		meta: {
 			supportsSimulated: false,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			filePattern: "*.json"
 		}
 	}],
@@ -28601,7 +30672,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 		class: KiroIdeSubagent,
 		meta: {
 			supportsSimulated: false,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			filePattern: "*.md"
 		}
 	}],
@@ -31138,7 +33209,7 @@ const STRATEGIES = [
 *   plus companion `globs`/`description` fields. (`.devin/rules/` is the
 *   pre-rebrand legacy location the tool still reads.)
 * - Global scope: a single plain-markdown, always-on file (no frontmatter) at
-*   `~/.codeium/windsurf/memories/global_rules.md` (unchanged by the rebrand).
+*   `~/.config/devin/AGENTS.md` (Devin Local global always-on rules).
 *
 * Trigger inference (when no explicit devin trigger is persisted):
 * - Specific globs (non wildcard) → glob
@@ -31165,8 +33236,8 @@ var DevinRule = class DevinRule extends ToolRule {
 	}
 	static getGlobalRootPath(excludeToolDir) {
 		return {
-			relativeDirPath: buildToolPath(CODEIUM_DIR, WINDSURF_MEMORIES_SUBDIR, excludeToolDir),
-			relativeFilePath: DEVIN_GLOBAL_RULES_FILE_NAME
+			relativeDirPath: buildToolPath(DEVIN_GLOBAL_CONFIG_DIR_PATH, ".", excludeToolDir),
+			relativeFilePath: DEVIN_GLOBAL_AGENTS_FILE_NAME
 		};
 	}
 	static getSettablePaths({ global = false, excludeToolDir } = {}) {
@@ -31729,6 +33800,9 @@ var KiloRule = class KiloRule extends ToolRule {
 			nonRoot: { relativeDirPath: buildToolPath(KILO_DIR, KILO_RULES_DIR_NAME, excludeToolDir) }
 		};
 	}
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		return global ? [] : [KiloMcp.getSettablePaths({ global: false })];
+	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
 		if (relativeFilePath === paths.root.relativeFilePath) {
@@ -31990,6 +34064,9 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 			nonRoot: { relativeDirPath: buildToolPath(OPENCODE_DIR, "memories", excludeToolDir) }
 		};
 	}
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		return global ? [] : [OpencodeMcp.getSettablePaths({ global: false })];
+	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
 		if (relativeFilePath === paths.root.relativeFilePath) {
@@ -32056,7 +34133,7 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 /**
 * Rule generator for Pi Coding Agent.
 *
-* Pi loads instruction context only from the `AGENTS.md` / `CLAUDE.md` family —
+* Pi loads instruction context from the `AGENTS.md` / `CLAUDE.md` family —
 * the global `~/.pi/agent/AGENTS.md` plus files discovered by walking up the
 * directory tree from the current working directory. It does NOT resolve
 * `@`-imports or a TOON file list, and has no `.agents/memories/` concept, so
@@ -32067,6 +34144,15 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 * to map onto; their bodies are folded into the single root `AGENTS.md` by the
 * RulesProcessor (there is no separate non-root output location — `nonRoot` is
 * `undefined`). This mirrors the codexcli, grokcli, warp, and deepagents targets.
+*
+* Pi also loads two system-prompt instruction files that rulesync does NOT emit:
+* `.pi/SYSTEM.md` (global `~/.pi/agent/SYSTEM.md`) *replaces* the default system
+* prompt entirely, and `.pi/APPEND_SYSTEM.md` (global
+* `~/.pi/agent/APPEND_SYSTEM.md`) *appends* to it. rulesync's rules model only
+* routes a designated `root` rule to a single context file and has no convention
+* for marking a rule as "replace" vs "append" the system prompt, so these
+* surfaces are documented in docs/reference/file-formats.md and left to be
+* authored by hand rather than mapped to a speculative new frontmatter flag.
 */
 var PiRule = class PiRule extends ToolRule {
 	constructor({ fileContent, root, ...rest }) {
@@ -32657,6 +34743,37 @@ var RovodevRule = class RovodevRule extends ToolRule {
 			toolTarget: "rovodev"
 		});
 	}
+	/**
+	* Mirror the primary `.rovodev/AGENTS.md` root rule to `./AGENTS.md` so project
+	* memory stays discoverable at the repo root. Empty when `rootRule` is not the primary root.
+	*/
+	static getRootMirrorFiles({ outputRoot, rootRule, content }) {
+		if (!(rootRule instanceof RovodevRule)) return [];
+		const primary = this.getSettablePaths({ global: false }).root;
+		if (rootRule.getRelativeDirPath() !== primary.relativeDirPath || rootRule.getRelativeFilePath() !== primary.relativeFilePath) return [];
+		return [new RovodevRule({
+			outputRoot,
+			relativeDirPath: ".",
+			relativeFilePath: ROVODEV_RULE_FILE_NAME,
+			fileContent: content,
+			validate: true,
+			root: true
+		})];
+	}
+	/**
+	* Globs for mirror deletion: the `./AGENTS.md` mirror (`mirrorGlob`) is deleted
+	* only when the primary `.rovodev/AGENTS.md` (`primaryGlob`) still exists.
+	*/
+	static getRootMirrorDeletionGlobs({ outputRoot }) {
+		return {
+			primaryGlob: (0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_RULE_FILE_NAME),
+			mirrorGlob: (0, node_path.join)(outputRoot, ROVODEV_RULE_FILE_NAME)
+		};
+	}
+	/** Glob for the `separate-local-file` deletion; rovodev writes it at project root, not under `.rovodev/`. */
+	static getLocalRootDeletionGlob({ outputRoot, fileName }) {
+		return (0, node_path.join)(outputRoot, fileName);
+	}
 };
 //#endregion
 //#region src/features/rules/takt-rule.ts
@@ -33379,7 +35496,7 @@ var RulesProcessor = class extends FeatureProcessor {
 		});
 		this.applyRootRuleSections({
 			toolRules,
-			meta
+			factory
 		});
 		return [...toolRules, ...extraFiles];
 	}
@@ -33441,31 +35558,16 @@ var RulesProcessor = class extends FeatureProcessor {
 	* reference and conventions sections to the root rule content. Mutates the
 	* root rule in place.
 	*/
-	applyRootRuleSections({ toolRules, meta }) {
+	applyRootRuleSections({ toolRules, factory }) {
+		const { meta } = factory;
 		const rootRule = toolRules.find((rule) => rule.isRoot());
 		if (!rootRule) return;
 		const newContent = this.generateReferenceSectionFromMeta(meta, toolRules) + (!meta.createsSeparateConventionsRule && meta.additionalConventions ? this.generateAdditionalConventionsSectionFromMeta(meta) : "") + rootRule.getFileContent();
 		rootRule.setFileContent(newContent);
-		if (meta.mirrorsRootToAgentsMd && !this.global) this.mirrorRootRuleToAgentsMd({
-			toolRules,
+		if (meta.mirrorsRootToAgentsMd && !this.global && factory.class.getRootMirrorFiles) toolRules.push(...factory.class.getRootMirrorFiles({
+			outputRoot: this.outputRoot,
 			rootRule,
 			content: newContent
-		});
-	}
-	/**
-	* Mirror the primary root rule to a project-root `AGENTS.md` for tools whose
-	* primary root lives in a subdirectory (rovodev: `.rovodev/AGENTS.md`).
-	*/
-	mirrorRootRuleToAgentsMd({ toolRules, rootRule, content }) {
-		if (!(rootRule instanceof RovodevRule)) return;
-		const primary = RovodevRule.getSettablePaths({ global: false }).root;
-		if (rootRule.getRelativeDirPath() === primary.relativeDirPath && rootRule.getRelativeFilePath() === primary.relativeFilePath) toolRules.push(new RovodevRule({
-			outputRoot: this.outputRoot,
-			relativeDirPath: ".",
-			relativeFilePath: "AGENTS.md",
-			fileContent: content,
-			validate: true,
-			root: true
 		}));
 	}
 	buildSkillList(skillClass) {
@@ -33691,15 +35793,19 @@ 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 === RovodevRule) return buildDeletionRulesFromPaths(await findFilesByGlobs((0, node_path.join)(this.outputRoot, fileName)));
+				if (factory.class.getLocalRootDeletionGlob) return buildDeletionRulesFromPaths(await findFilesByGlobs(factory.class.getLocalRootDeletionGlob({
+					outputRoot: this.outputRoot,
+					fileName
+				})));
 				if (!settablePaths.root) return [];
 				return buildDeletionRulesFromPaths(await findFilesWithFallback((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName)));
 			})();
 			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 !== RovodevRule) return [];
-				if ((await findFilesByGlobs((0, node_path.join)(this.outputRoot, ".rovodev", "AGENTS.md"))).length === 0) return [];
-				return buildDeletionRulesFromPaths(await findFilesByGlobs((0, node_path.join)(this.outputRoot, "AGENTS.md")));
+				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 nonRootToolRules = await (async () => {
 				if (!settablePaths.nonRoot) return [];
@@ -34148,63 +36254,228 @@ function warnUnsupportedTargets(params) {
 async function checkRulesyncDirExists(params) {
 	return fileExists((0, node_path.join)(params.inputRoot, RULESYNC_RELATIVE_DIR_PATH));
 }
+function dependsOnReachable(byId, from, target) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [from];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0 || seen.has(current)) continue;
+		seen.add(current);
+		if (current === target) return true;
+		for (const dep of byId.get(current)?.dependsOn ?? []) stack.push(dep);
+	}
+	return false;
+}
+function assertSharedFilesOrdered(steps, byId) {
+	const writersByFile = /* @__PURE__ */ new Map();
+	for (const step of steps) for (const file of step.writesSharedFile ?? []) writersByFile.set(file, [...writersByFile.get(file) ?? [], step.id]);
+	for (const [file, writers] of writersByFile) for (let i = 0; i < writers.length; i++) for (let j = i + 1; j < writers.length; j++) {
+		const a = writers[i];
+		const b = writers[j];
+		if (!dependsOnReachable(byId, a, b) && !dependsOnReachable(byId, b, a)) throw new Error(`Generation steps '${a}' and '${b}' both write the shared file '${file}' but neither declares a 'dependsOn' the other. Add a 'dependsOn' so the read-modify-write order is fixed; otherwise one step silently drops the other's keys.`);
+	}
+}
+/**
+* Topologically sort generation steps and reject ordering hazards: a shared file
+* with two writers not ordered by `dependsOn` (a silent data-loss trap), an
+* unknown dependency, or a cycle. Reordering `steps` stays safe as a result.
+*
+* @throws Error if a shared file has unordered writers, a dependency is unknown,
+*   or the dependency graph contains a cycle.
+*/
+function resolveExecutionOrder(steps) {
+	const byId = new Map(steps.map((step) => [step.id, step]));
+	assertSharedFilesOrdered(steps, byId);
+	const unresolvedDeps = new Map(steps.map((step) => [step.id, 0]));
+	const dependents = /* @__PURE__ */ new Map();
+	for (const step of steps) for (const dep of step.dependsOn ?? []) {
+		if (!byId.has(dep)) throw new Error(`Generation step '${step.id}' depends on unknown step '${dep}'.`);
+		unresolvedDeps.set(step.id, (unresolvedDeps.get(step.id) ?? 0) + 1);
+		dependents.set(dep, [...dependents.get(dep) ?? [], step.id]);
+	}
+	const ready = steps.filter((step) => (unresolvedDeps.get(step.id) ?? 0) === 0).map((step) => step.id);
+	const ordered = [];
+	while (ready.length > 0) {
+		const id = ready.shift();
+		ordered.push(byId.get(id));
+		for (const dependent of dependents.get(id) ?? []) {
+			const next = (unresolvedDeps.get(dependent) ?? 0) - 1;
+			unresolvedDeps.set(dependent, next);
+			if (next === 0) ready.push(dependent);
+		}
+	}
+	if (ordered.length !== steps.length) throw new Error("Generation steps contain a cyclic 'dependsOn' dependency.");
+	return ordered;
+}
+/**
+* The static shape of the generation step graph: which steps write which shared
+* (read-modify-write) config files, and the `dependsOn` edges that fix a safe order
+* for those writers. Exported (separately from the `run` closures, which need a
+* live `config`/`logger`) so `resolveExecutionOrder`'s ordering guarantee can be
+* tested directly against the real graph rather than a hand-copied one. Readonly
+* so a consumer can't mutate this module-level singleton and affect every
+* subsequent `generate()` call in the process.
+*/
+const GENERATION_STEP_GRAPH = [
+	{
+		id: "ignore",
+		writesSharedFile: [".claude/settings.json", ".zed/settings.json"]
+	},
+	{
+		id: "mcp",
+		writesSharedFile: [
+			".amp/settings.json",
+			".augment/settings.json",
+			".codex/config.toml",
+			".config/amp/settings.json",
+			".config/devin/config.json",
+			".config/opencode/opencode.json",
+			".config/zed/settings.json",
+			".devin/config.json",
+			".grok/config.toml",
+			".hermes/config.yaml",
+			".qwen/settings.json",
+			".reasonix/config.toml",
+			".takt/config.yaml",
+			".vibe/config.toml",
+			".zed/settings.json",
+			"kilo.json",
+			"opencode.json",
+			"reasonix.toml"
+		],
+		dependsOn: ["ignore"]
+	},
+	{ id: "commands" },
+	{ id: "subagents" },
+	{ id: "skills" },
+	{
+		id: "hooks",
+		writesSharedFile: [
+			".augment/settings.json",
+			".claude/settings.json",
+			".codex/config.toml",
+			".config/devin/config.json",
+			".hermes/config.yaml",
+			".kiro/agents/default.json",
+			".qwen/settings.json",
+			".vibe/config.toml"
+		],
+		dependsOn: ["ignore", "mcp"]
+	},
+	{
+		id: "permissions",
+		writesSharedFile: [
+			".amp/settings.json",
+			".augment/settings.json",
+			".claude/settings.json",
+			".codex/config.toml",
+			".config/amp/settings.json",
+			".config/devin/config.json",
+			".config/opencode/opencode.json",
+			".config/zed/settings.json",
+			".devin/config.json",
+			".grok/config.toml",
+			".hermes/config.yaml",
+			".kiro/agents/default.json",
+			".qwen/settings.json",
+			".reasonix/config.toml",
+			".takt/config.yaml",
+			".vibe/config.toml",
+			".zed/settings.json",
+			"opencode.json",
+			"reasonix.toml"
+		],
+		dependsOn: [
+			"ignore",
+			"hooks",
+			"mcp"
+		]
+	},
+	{
+		id: "rules",
+		writesSharedFile: ["kilo.json", "opencode.json"],
+		dependsOn: [
+			"mcp",
+			"skills",
+			"permissions"
+		]
+	}
+];
 /**
 * Generate configuration files for AI tools.
 * @throws Error if generation fails
 */
 async function generate(params) {
 	const { config, logger } = params;
-	const ignoreResult = await generateIgnoreCore({
-		config,
-		logger
-	});
-	const mcpResult = await generateMcpCore({
-		config,
-		logger
-	});
-	const commandsResult = await generateCommandsCore({
-		config,
-		logger
-	});
-	const subagentsResult = await generateSubagentsCore({
-		config,
-		logger
-	});
-	const skillsResult = await generateSkillsCore({
-		config,
-		logger
-	});
-	const hooksResult = await generateHooksCore({
-		config,
-		logger
-	});
-	const permissionsResult = await generatePermissionsCore({
-		config,
-		logger
-	});
-	const rulesResult = await generateRulesCore({
-		config,
-		logger,
-		skills: skillsResult.skills
-	});
-	const hasDiff = ignoreResult.hasDiff || mcpResult.hasDiff || commandsResult.hasDiff || subagentsResult.hasDiff || skillsResult.hasDiff || hooksResult.hasDiff || permissionsResult.hasDiff || rulesResult.hasDiff;
+	let skillsResult;
+	const runners = {
+		ignore: () => generateIgnoreCore({
+			config,
+			logger
+		}),
+		mcp: () => generateMcpCore({
+			config,
+			logger
+		}),
+		commands: () => generateCommandsCore({
+			config,
+			logger
+		}),
+		subagents: () => generateSubagentsCore({
+			config,
+			logger
+		}),
+		skills: async () => {
+			skillsResult = await generateSkillsCore({
+				config,
+				logger
+			});
+			return skillsResult;
+		},
+		hooks: () => generateHooksCore({
+			config,
+			logger
+		}),
+		permissions: () => generatePermissionsCore({
+			config,
+			logger
+		}),
+		rules: () => generateRulesCore({
+			config,
+			logger,
+			skills: skillsResult?.skills
+		})
+	};
+	const orderedSteps = resolveExecutionOrder(GENERATION_STEP_GRAPH.map((meta) => ({
+		...meta,
+		run: runners[meta.id]
+	})));
+	const resultsById = /* @__PURE__ */ new Map();
+	for (const step of orderedSteps) resultsById.set(step.id, await step.run());
+	if (!skillsResult) throw new Error("Skills generation step did not run.");
+	const get = (id) => {
+		const result = resultsById.get(id);
+		if (!result) throw new Error(`Missing generation result for step '${id}'.`);
+		return result;
+	};
+	const hasDiff = orderedSteps.some((step) => get(step.id).hasDiff);
 	return {
-		rulesCount: rulesResult.count,
-		rulesPaths: rulesResult.paths,
-		ignoreCount: ignoreResult.count,
-		ignorePaths: ignoreResult.paths,
-		mcpCount: mcpResult.count,
-		mcpPaths: mcpResult.paths,
-		commandsCount: commandsResult.count,
-		commandsPaths: commandsResult.paths,
-		subagentsCount: subagentsResult.count,
-		subagentsPaths: subagentsResult.paths,
+		rulesCount: get("rules").count,
+		rulesPaths: get("rules").paths,
+		ignoreCount: get("ignore").count,
+		ignorePaths: get("ignore").paths,
+		mcpCount: get("mcp").count,
+		mcpPaths: get("mcp").paths,
+		commandsCount: get("commands").count,
+		commandsPaths: get("commands").paths,
+		subagentsCount: get("subagents").count,
+		subagentsPaths: get("subagents").paths,
 		skillsCount: skillsResult.count,
 		skillsPaths: skillsResult.paths,
-		hooksCount: hooksResult.count,
-		hooksPaths: hooksResult.paths,
-		permissionsCount: permissionsResult.count,
-		permissionsPaths: permissionsResult.paths,
+		hooksCount: get("hooks").count,
+		hooksPaths: get("hooks").paths,
+		permissionsCount: get("permissions").count,
+		permissionsPaths: get("permissions").paths,
 		skills: skillsResult.skills,
 		hasDiff
 	};