rulesync 9.0.2 → 9.1.1

package/dist/{import-zmpFGK87.js → import-DywcWsgJ.js}

@@ -198,6 +198,7 @@ const mcpProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"takt",
 	"vibe",
 	"warp",
 	"devin",
@@ -205,6 +206,7 @@ const mcpProcessorToolTargetTuple = [
 ];
 const commandsProcessorToolTargetTuple = [
 	"agentsmd",
+	"antigravity-cli",
 	"antigravity-ide",
 	"augmentcode",
 	"claudecode",
@@ -224,7 +226,9 @@ const commandsProcessorToolTargetTuple = [
 	"opencode",
 	"pi",
 	"qwencode",
+	"reasonix",
 	"roo",
+	"rovodev",
 	"takt",
 	"devin"
 ];
@@ -309,11 +313,13 @@ const hooksProcessorToolTargetTuple = [
 	"deepagents",
 	"kiro",
 	"kiro-cli",
+	"kiro-ide",
 	"devin",
 	"augmentcode",
 	"junie",
 	"vibe",
-	"qwencode"
+	"qwencode",
+	"reasonix"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -324,16 +330,19 @@ const permissionsProcessorToolTargetTuple = [
 	"cline",
 	"codexcli",
 	"cursor",
+	"devin",
 	"factorydroid",
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"junie",
 	"kilo",
 	"kiro",
 	"kiro-cli",
 	"kiro-ide",
 	"opencode",
 	"qwencode",
+	"reasonix",
 	"rovodev",
 	"takt",
 	"vibe",
@@ -1373,7 +1382,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);
 }
 /**
@@ -1388,7 +1397,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;
 }
@@ -1739,6 +1748,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:
@@ -1897,16 +1917,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 = 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 = 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 = join(ANTIGRAVITY_DIR, "skills");
+const ANTIGRAVITY_WORKFLOWS_DIR_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 = join(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR);
+const ANTIGRAVITY_CLI_PERMISSIONS_FILE_NAME = "settings.json";
+const ANTIGRAVITY_CLI_GLOBAL_WORKFLOWS_DIR_PATH = join(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR, "global_workflows");
+const ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR = "config";
+const ANTIGRAVITY_GLOBAL_CONFIG_DIR_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 = z.looseObject({
@@ -2080,7 +2109,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();
@@ -2162,6 +2191,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 = 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 = 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).
@@ -2546,6 +2614,16 @@ const CodexcliCommandFrontmatterSchema = z.looseObject({
 	description: z.optional(z.string()),
 	"argument-hint": z.optional(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;
@@ -2669,7 +2747,7 @@ const COPILOTCLI_PROJECT_MCP_FILE_NAME = "mcp.json";
 const COPILOTCLI_AGENTS_DIR_PATH = join(COPILOT_DIR, "agents");
 const COPILOTCLI_HOOKS_DIR_PATH = join(COPILOT_DIR, "hooks");
 const COPILOTCLI_HOOKS_FILE_NAME = "copilotcli-hooks.json";
-const COPILOTCLI_SKILLS_GLOBAL_DIR_PATH = join(COPILOT_DIR, "skills");
+const COPILOT_SKILLS_GLOBAL_DIR_PATH = join(COPILOT_DIR, "skills");
 //#endregion
 //#region src/features/commands/copilot-command.ts
 const CopilotCommandFrontmatterSchema = z.looseObject({
@@ -2919,20 +2997,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 = join(CODEIUM_DIR, WINDSURF_SUBDIR);
-const WINDSURF_MEMORIES_SUBDIR = join(WINDSURF_SUBDIR, "memories");
+const CODEIUM_WINDSURF_DIR = join(".codeium", "windsurf");
 const DEVIN_WORKFLOWS_DIR_PATH = join(DEVIN_DIR, "workflows");
 const DEVIN_SKILLS_DIR_PATH = join(DEVIN_DIR, "skills");
 const DEVIN_AGENTS_DIR_PATH = join(DEVIN_DIR, "agents");
-const DEVIN_GLOBAL_AGENTS_DIR_PATH = join(".config", "devin", "agents");
+const DEVIN_GLOBAL_CONFIG_DIR_PATH = join(".config", "devin");
+const DEVIN_GLOBAL_AGENTS_DIR_PATH = join(DEVIN_GLOBAL_CONFIG_DIR_PATH, "agents");
 const CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_PATH = join(CODEIUM_WINDSURF_DIR, "global_workflows");
 const CODEIUM_WINDSURF_SKILLS_DIR_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
@@ -3181,6 +3256,8 @@ const GOOSE_MCP_FILE_NAME = "config.yaml";
 const GOOSE_PERMISSIONS_FILE_NAME = "permission.yaml";
 const GOOSE_HOOKS_DIR_PATH = join(".agents", "plugins", "rulesync", "hooks");
 const GOOSE_HOOKS_FILE_NAME = "hooks.json";
+const GOOSE_PLUGIN_MCP_DIR_PATH = join(".agents", "plugins", "rulesync");
+const GOOSE_PLUGIN_MCP_FILE_NAME = ".mcp.json";
 const GOOSE_SKILLS_DIR_PATH = join(GOOSE_DIR, "skills");
 const GOOSE_RECIPES_DIR_PATH = join(GOOSE_DIR, "recipes");
 const GOOSE_GLOBAL_RECIPES_DIR_PATH = join(GOOSE_GLOBAL_DIR, "recipes");
@@ -3438,6 +3515,7 @@ const JUNIE_ALT_AGENTS_DIR_PATH = ".agents";
 const JUNIE_MCP_DIR_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";
@@ -3690,6 +3768,15 @@ const KIRO_SKILLS_DIR_PATH = join(KIRO_DIR, "skills");
 const KIRO_SETTINGS_DIR_PATH = join(KIRO_DIR, "settings");
 const KIRO_AGENTS_DIR_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 = 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
@@ -4269,6 +4356,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 = 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 = z.looseObject({
+	description: z.optional(z.string()),
+	"argument-hint": z.optional(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 ${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 ${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 = 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 = join(ROO_DIR, "commands");
@@ -4400,6 +4616,217 @@ var RooCommand = class RooCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/rovodev-paths.ts
+const ROVODEV_DIR = ".rovodev";
+const ROVODEV_SKILLS_DIR_PATH = join(ROVODEV_DIR, "skills");
+const ROVODEV_SUBAGENTS_DIR_PATH = join(ROVODEV_DIR, "subagents");
+const ROVODEV_MODULAR_RULES_DIR_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 = join(".agents", "skills");
+const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
+const ROVODEV_PROMPTS_DIR_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(`${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 = 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(join(outputRoot, paths.relativeDirPath, relativeFilePath))).trim();
+		const name = 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: 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(join(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
+		let existing = {};
+		if (existingContent) try {
+			const parsed = load(existingContent);
+			if (isPlainObject(parsed)) existing = parsed;
+		} catch {}
+		const prompts = rovodevCommands.map((command) => ({
+			name: command.getName(),
+			description: command.getDescription(),
+			content_file: toPosixPath(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: 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(join(outputRoot, ROVODEV_DIR, ROVODEV_PROMPTS_FILE_NAME));
+	if (!manifestContent) return "";
+	let parsed;
+	try {
+		parsed = load(manifestContent);
+	} catch {
+		return "";
+	}
+	if (!isPlainObject(parsed) || !Array.isArray(parsed.prompts)) return "";
+	const expectedContentFile = toPosixPath(join("prompts", relativeFilePath));
+	const entry = parsed.prompts.find((candidate) => isRecord(candidate) && (candidate.content_file === expectedContentFile || candidate.name === name));
+	return isRecord(entry) && typeof entry.description === "string" ? entry.description : "";
+}
+/**
+* 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";
@@ -4417,6 +4844,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
 /**
@@ -4592,6 +5027,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: {
@@ -4737,7 +5182,7 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsProject: true,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			isSimulated: false,
 			supportsSubdirectory: false
 		}
@@ -4782,6 +5227,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: {
@@ -4792,6 +5247,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: {
@@ -4849,7 +5314,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);
@@ -4865,6 +5330,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) => {
@@ -5023,7 +5496,14 @@ const HookDefinitionSchema = z.looseObject({
 	name: z.optional(safeString),
 	description: z.optional(safeString),
 	failClosed: z.optional(z.boolean()),
-	sequential: z.optional(z.boolean())
+	sequential: z.optional(z.boolean()),
+	async: z.optional(z.boolean()),
+	env: z.optional(z.record(z.string(), safeString)),
+	shell: z.optional(safeString),
+	statusMessage: z.optional(safeString),
+	headers: z.optional(z.record(z.string(), safeString)),
+	allowedEnvVars: z.optional(z.array(z.string())),
+	once: z.optional(z.boolean())
 });
 /** Hook events supported by Cursor. */
 const CURSOR_HOOK_EVENTS = [
@@ -5087,6 +5567,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",
@@ -5129,7 +5633,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
 */
@@ -5146,7 +5654,8 @@ const COPILOTCLI_HOOK_EVENTS = [
 	"afterError",
 	"preCompact",
 	"permissionRequest",
-	"notification"
+	"notification",
+	"beforeMCPExecution"
 ];
 /**
 * Hook events supported by Factory Droid.
@@ -5231,6 +5740,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
@@ -5281,18 +5809,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"
 ];
 /**
@@ -5324,6 +5857,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 = z.record(z.string(), z.array(HookDefinitionSchema));
 /**
 * Canonical hooks config (canonical event names in camelCase).
@@ -5343,12 +5939,15 @@ const HooksConfigSchema = z.looseObject({
 	deepagents: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	kiro: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	"kiro-cli": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	"kiro-ide": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	devin: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	augmentcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	"antigravity-ide": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	"antigravity-cli": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	hermesagent: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	junie: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	vibe: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	reasonix: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -5394,6 +5993,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.
 */
@@ -5524,7 +6143,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]));
@@ -5606,13 +6226,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"
 };
 /**
@@ -5665,19 +6307,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 = 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 = 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 = 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
 /**
@@ -5725,7 +6370,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;
@@ -5754,7 +6399,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,
@@ -5787,7 +6432,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
@@ -5830,7 +6475,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;
 }
 /**
@@ -5883,9 +6534,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;
@@ -6439,9 +7087,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 = join(outputRoot, CODEXCLI_DIR, CODEXCLI_MCP_FILE_NAME);
@@ -6452,10 +7106,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 smolToml.stringify(configToml);
 }
 /**
@@ -6491,6 +7142,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
@@ -6723,6 +7380,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.
@@ -6734,7 +7405,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`.
@@ -6847,20 +7518,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;
 }
@@ -7269,148 +7944,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ hooks: {} });
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
 		return new DevinHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -7421,31 +8011,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), JSON.stringify({ hooks: {} }, null, 2));
+		const filePath = 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,
@@ -7461,22 +8052,13 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 		} catch (error) {
 			throw new Error(`Failed to parse Devin hooks content in ${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() {
@@ -7490,7 +8072,7 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
-			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			fileContent: "{}",
 			validate: false
 		});
 	}
@@ -7717,6 +8299,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 {
@@ -7736,6 +8418,9 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 			error: null
 		};
 	}
+	isDeletable() {
+		return false;
+	}
 	shouldMergeExistingFileContent() {
 		return true;
 	}
@@ -7743,18 +8428,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
+			}) })
 		});
 	}
 };
@@ -8224,9 +8912,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() {
@@ -8234,6 +8921,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 = z.union([z.looseObject({
+	type: z.literal("command"),
+	command: z.optional(safeString)
+}), z.looseObject({
+	type: z.literal("agent"),
+	prompt: z.optional(safeString)
+})]);
+const KiroIdeHookEntrySchema = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	trigger: z.optional(z.string()),
+	matcher: z.optional(z.string()),
+	action: z.optional(KiroIdeHookActionSchema),
+	timeout: z.optional(z.number()),
+	enabled: z.optional(z.boolean())
+});
+const KiroIdeHooksFileSchema = z.looseObject({
+	version: z.optional(z.string()),
+	hooks: z.optional(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(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 ${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) {
@@ -8292,6 +9176,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.
@@ -8319,16 +9232,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,
@@ -8352,7 +9256,14 @@ const QwencodeHookEntrySchema = z.looseObject({
 	url: z.optional(z.string()),
 	timeout: z.optional(z.number()),
 	name: z.optional(z.string()),
-	description: z.optional(z.string())
+	description: z.optional(z.string()),
+	statusMessage: z.optional(z.string()),
+	async: z.optional(z.boolean()),
+	env: z.optional(z.record(z.string(), z.string())),
+	shell: z.optional(z.string()),
+	headers: z.optional(z.record(z.string(), z.string())),
+	allowedEnvVars: z.optional(z.array(z.string())),
+	once: z.optional(z.boolean())
 });
 /**
 * A matcher group entry in a Qwen Code event array.
@@ -8371,18 +9282,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;
@@ -8495,6 +9417,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(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 = 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 ${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";
@@ -8653,6 +9738,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({});
@@ -8720,6 +9811,19 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 //#endregion
 //#region src/features/hooks/hooks-processor.ts
 const HooksProcessorToolTargetSchema = 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,
@@ -8853,12 +9957,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", {
@@ -8894,6 +9994,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: {
@@ -8902,8 +10014,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: DEVIN_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
-		supportsMatcher: false
+		supportedHookTypes: ["command", "prompt"],
+		supportsMatcher: true
 	}],
 	["augmentcode", {
 		class: AugmentcodeHooks,
@@ -8948,6 +10060,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);
@@ -9023,8 +10146,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(", ")}`);
 		}
 		{
@@ -9220,11 +10346,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
@@ -10456,9 +11577,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;
@@ -10573,7 +11694,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`)
 		};
@@ -10582,7 +11703,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`)
 			};
@@ -11103,7 +12224,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;
@@ -11123,7 +12244,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;
@@ -11185,19 +12306,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"]
 			}];
@@ -11707,18 +12828,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;
@@ -11736,14 +12859,21 @@ var DevinMcp = class DevinMcp extends ToolMcp {
 			throw new Error(`Failed to parse Devin MCP config at ${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 }) {
@@ -11858,7 +12988,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 = join(GOOSE_PLUGIN_MCP_DIR_PATH, GOOSE_PLUGIN_MCP_FILE_NAME);
 function parseGooseConfig(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = join(relativeDirPath, relativeFilePath);
 	let parsed;
@@ -11945,7 +13075,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;
@@ -11962,7 +13092,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";
@@ -11980,39 +13110,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 ${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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? (global ? "" : JSON.stringify({ mcpServers: {} }, null, 2));
 		return new GooseMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -12022,9 +13215,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath), ""), paths.relativeDirPath, paths.relativeFilePath),
 			extensions: convertToGooseFormat(rulesyncMcp.getMcpServers())
@@ -12039,7 +13242,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() {
@@ -12116,7 +13323,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;
@@ -12131,7 +13338,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;
@@ -12294,13 +13501,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: {
@@ -12318,7 +13525,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;
@@ -12354,7 +13561,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));
 	}
@@ -12394,7 +13601,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() {
@@ -13229,11 +14436,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",
@@ -13241,13 +14443,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;
@@ -13271,7 +14474,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
+		const config = parseReasonixConfig$1(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
 		config.plugins = normalizePluginsArray(config.plugins);
 		return new ReasonixMcp({
 			outputRoot,
@@ -13284,7 +14487,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
+		const config = parseReasonixConfig$1(await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.stringify({}));
 		config.plugins = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToReasonix(name, server));
 		return new ReasonixMcp({
 			outputRoot,
@@ -13301,7 +14504,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 	}
 	validate() {
 		try {
-			parseReasonixConfig(this.fileContent);
+			parseReasonixConfig$1(this.fileContent);
 			return {
 				success: true,
 				error: null
@@ -13324,7 +14527,7 @@ var ReasonixMcp = class ReasonixMcp extends ToolMcp {
 		});
 	}
 };
-function parseReasonixConfig(fileContent) {
+function parseReasonixConfig$1(fileContent) {
 	const parsed = smolToml.parse(fileContent || smolToml.stringify({}));
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
 	return { ...parsed };
@@ -13464,17 +14667,6 @@ var RooMcp = class RooMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/constants/rovodev-paths.ts
-const ROVODEV_DIR = ".rovodev";
-const ROVODEV_SKILLS_DIR_PATH = join(ROVODEV_DIR, "skills");
-const ROVODEV_SUBAGENTS_DIR_PATH = join(ROVODEV_DIR, "subagents");
-const ROVODEV_MODULAR_RULES_DIR_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 = join(".agents", "skills");
-//#endregion
 //#region src/features/mcp/rovodev-mcp.ts
 function parseRovodevMcpJson(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = join(relativeDirPath, relativeFilePath);
@@ -13568,6 +14760,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 = join(relativeDirPath, relativeFilePath);
+	let parsed;
+	try {
+		parsed = fileContent.trim() === "" ? {} : 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(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(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: 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",
@@ -14028,7 +15392,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 	["goose", {
 		class: GooseMcp,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
 			supportsDisabledTools: false
@@ -14142,6 +15506,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["takt", {
+		class: TaktMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["vibe", {
 		class: VibeMcp,
 		meta: {
@@ -14270,7 +15643,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
 			});
 		}));
 	}
@@ -14784,7 +16158,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;
 }
 /**
@@ -14967,7 +16341,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;
 		}
@@ -15006,7 +16380,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;
 }
 /**
@@ -15180,7 +16554,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;
 		}
@@ -15229,7 +16603,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) {
@@ -15573,7 +16947,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;
@@ -15626,7 +17000,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;
 }
 /**
@@ -15800,7 +17174,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;
 		}
@@ -16427,7 +17801,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] ?? "*"}`;
@@ -16652,7 +18026,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;
@@ -16663,6 +18037,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(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 = 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 = uniq([...preserve(existingPermissions.allow), ...allow].toSorted());
+		const mergedAsk = uniq([...preserve(existingPermissions.ask), ...ask].toSorted());
+		const mergedDeny = 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 ${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.
@@ -16922,7 +18535,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
@@ -16944,8 +18557,8 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Goose permissions content in ${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() {
@@ -17085,7 +18698,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
@@ -17107,7 +18720,7 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Grok config.toml content in ${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) });
 	}
@@ -17189,6 +18802,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(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 = 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 ${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 = z.union([z.enum([
 	"allow",
@@ -17537,7 +19349,11 @@ const OpencodePermissionSchema = z.union([z.enum([
 	"ask",
 	"deny"
 ]))]);
-const OpencodePermissionsConfigSchema = z.looseObject({ permission: z.optional(z.record(z.string(), OpencodePermissionSchema)) });
+const OpencodePermissionsConfigSchema = z.looseObject({ permission: z.optional(z.union([z.enum([
+	"allow",
+	"ask",
+	"deny"
+]), z.record(z.string(), OpencodePermissionSchema)])) });
 var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 	json;
 	constructor(params) {
@@ -17640,6 +19456,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]));
 	}
 };
@@ -17676,7 +19493,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 = {}) {
@@ -17870,13 +19687,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 = smolToml.parse(fileContent || smolToml.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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? smolToml.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 = uniq([...preservedAllow, ...allow].toSorted());
+		const mergedAsk = uniq([...preservedAsk, ...ask].toSorted());
+		const mergedDeny = 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 = smolToml.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: smolToml.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;
@@ -17989,13 +20035,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({
@@ -18015,8 +20061,8 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Rovodev permissions content in ${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() {
@@ -18094,11 +20140,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;
 	}
@@ -18237,21 +20283,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 = join(relativeDirPath, relativeFilePath);
-	let parsed;
-	try {
-		parsed = fileContent.trim() === "" ? {} : 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.
 */
@@ -18573,8 +20604,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 = uniq(allow.toSorted());
 		const mergedDeny = uniq(deny.toSorted());
 		if (mergedAllow.length > 0) profiles[ALLOWLIST_KEY] = mergedAllow;
@@ -18599,8 +20630,8 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Warp permissions content in ${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] : []
@@ -18951,6 +20982,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["devin", {
+		class: DevinPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["factorydroid", {
 		class: FactorydroidPermissions,
 		meta: {
@@ -18983,6 +21022,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["junie", {
+		class: JuniePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["kilo", {
 		class: KiloPermissions,
 		meta: {
@@ -19031,6 +21078,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["reasonix", {
+		class: ReasonixPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["rovodev", {
 		class: RovodevPermissions,
 		meta: {
@@ -19583,7 +21638,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	opencode: z.optional(z.looseObject({
 		"allowed-tools": z.optional(z.array(z.string())),
 		license: z.optional(z.string()),
-		compatibility: z.optional(z.looseObject({})),
+		compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
 		metadata: z.optional(z.looseObject({}))
 	})),
 	kilo: z.optional(z.looseObject({
@@ -19604,7 +21659,8 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	})),
 	copilotcli: z.optional(z.looseObject({
 		license: z.optional(z.string()),
-		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
+		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
+		"argument-hint": z.optional(z.string())
 	})),
 	pi: z.optional(z.looseObject({
 		"allowed-tools": z.optional(z.array(z.string())),
@@ -21358,7 +23414,11 @@ const CopilotSkillFrontmatterSchema = 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 }) {
@@ -21380,7 +23440,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() {
@@ -21495,7 +23555,8 @@ const CopilotcliSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.string(),
 	license: z.optional(z.string()),
-	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
+	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
+	"argument-hint": z.optional(z.string())
 });
 /**
 * Represents a GitHub Copilot CLI skill directory.
@@ -21525,7 +23586,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() {
@@ -21553,7 +23614,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,
@@ -21579,7 +23641,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,
@@ -22805,8 +24868,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() {
@@ -22948,10 +25010,19 @@ const OpenCodeSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.string(),
 	license: z.optional(z.string()),
-	compatibility: z.optional(z.looseObject({})),
+	compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
 	metadata: z.optional(z.looseObject({})),
 	"allowed-tools": z.optional(z.array(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({
@@ -23028,7 +25099,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;
@@ -24382,7 +26453,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["copilotcli", {
@@ -24470,7 +26541,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["kiro-ide", {
@@ -24478,7 +26549,7 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: false
+			supportsGlobal: true
 		}
 	}],
 	["opencode", {
@@ -28566,7 +30637,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 		class: KiroCliSubagent,
 		meta: {
 			supportsSimulated: false,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			filePattern: "*.json"
 		}
 	}],
@@ -28574,7 +30645,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 		class: KiroIdeSubagent,
 		meta: {
 			supportsSimulated: false,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			filePattern: "*.md"
 		}
 	}],
@@ -31111,7 +33182,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
@@ -31138,8 +33209,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 } = {}) {
@@ -31702,6 +33773,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) {
@@ -31963,6 +34037,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) {
@@ -32029,7 +34106,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
@@ -32040,6 +34117,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 }) {
@@ -32630,6 +34716,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: join(outputRoot, ROVODEV_DIR, ROVODEV_RULE_FILE_NAME),
+			mirrorGlob: 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 join(outputRoot, fileName);
+	}
 };
 //#endregion
 //#region src/features/rules/takt-rule.ts
@@ -33352,7 +35469,7 @@ var RulesProcessor = class extends FeatureProcessor {
 		});
 		this.applyRootRuleSections({
 			toolRules,
-			meta
+			factory
 		});
 		return [...toolRules, ...extraFiles];
 	}
@@ -33414,31 +35531,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) {
@@ -33664,15 +35766,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(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(join(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => 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(join(this.outputRoot, ".rovodev", "AGENTS.md"))).length === 0) return [];
-				return buildDeletionRulesFromPaths(await findFilesByGlobs(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 [];
@@ -34121,63 +36227,228 @@ function warnUnsupportedTargets(params) {
 async function checkRulesyncDirExists(params) {
 	return fileExists(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
 	};
@@ -34794,4 +37065,4 @@ async function importPermissionsCore(params) {
 //#endregion
 export { CLIError as $, IgnoreProcessor as A, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as At, toolCommandFactories as B, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Bt, PermissionsProcessorToolTargetSchema as C, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as Ct, McpProcessorToolTargetSchema as D, RULESYNC_HOOKS_FILE_NAME as Dt, McpProcessor as E, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as Et, HooksProcessorToolTargetSchema as F, RULESYNC_PERMISSIONS_FILE_NAME as Ft, CLAUDECODE_SKILLS_DIR_PATH as G, CLAUDECODE_LOCAL_RULE_FILE_NAME as H, formatError as Ht, toolHooksFactories as I, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as It, stringifyFrontmatter as J, RulesyncCommand as K, RulesyncHooks as L, RULESYNC_RELATIVE_DIR_PATH as Lt, toolIgnoreFactories as M, RULESYNC_MCP_RELATIVE_FILE_PATH as Mt, RulesyncIgnore as N, RULESYNC_MCP_SCHEMA_URL as Nt, toolMcpFactories as O, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Ot, HooksProcessor as P, RULESYNC_OVERVIEW_FILE_NAME as Pt, JsonLogger as Q, CommandsProcessor as R, RULESYNC_RULES_RELATIVE_DIR_PATH as Rt, PermissionsProcessor as S, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as St, RulesyncPermissions as T, RULESYNC_CONFIG_SCHEMA_URL as Tt, CLAUDECODE_MEMORIES_DIR_NAME as U, ALL_FEATURES as Ut, CLAUDECODE_DIR as V, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Vt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as W, ALL_FEATURES_WITH_WILDCARD as Wt, findControlCharacter as X, ConfigResolver as Y, ConsoleLogger as Z, toolSkillFactories as _, ALL_TOOL_TARGETS as _t, RulesProcessor as a, fileExists as at, RulesyncSkillFrontmatterSchema as b, MAX_FILE_SIZE as bt, RulesyncRule as c, getHomeDirectory as ct, SubagentsProcessorToolTargetSchema as d, readFileContent as dt, ErrorCodes as et, toolSubagentFactories as f, removeDirectory as ft, SkillsProcessorToolTargetSchema as g, writeFileContent as gt, SkillsProcessor as h, toPosixPath as ht, convertFromTool as i, ensureDir as it, IgnoreProcessorToolTargetSchema as j, RULESYNC_MCP_FILE_NAME as jt, RulesyncMcp as k, RULESYNC_IGNORE_RELATIVE_FILE_PATH as kt, RulesyncRuleFrontmatterSchema as l, isSymlink as lt, RulesyncSubagentFrontmatterSchema as m, removeTempDirectory as mt, checkRulesyncDirExists as n, createTempDirectory as nt, RulesProcessorToolTargetSchema as o, findFilesByGlobs as ot, RulesyncSubagent as p, removeFile as pt, RulesyncCommandFrontmatterSchema as q, generate as r, directoryExists as rt, toolRuleFactories as s, getFileSize as st, importFromTool as t, checkPathTraversal as tt, SubagentsProcessor as u, listDirectoryFiles as ut, getLocalSkillDirNames as v, ALL_TOOL_TARGETS_WITH_WILDCARD as vt, toolPermissionsFactories as w, RULESYNC_CONFIG_RELATIVE_FILE_PATH as wt, SKILL_FILE_NAME as x, RULESYNC_AIIGNORE_FILE_NAME as xt, RulesyncSkill as y, ToolTargetSchema as yt, CommandsProcessorToolTargetSchema as z, RULESYNC_SKILLS_RELATIVE_DIR_PATH as zt };
 
-//# sourceMappingURL=import-zmpFGK87.js.map
+//# sourceMappingURL=import-DywcWsgJ.js.map