rulesync 11.0.0 → 13.0.0

package/dist/{import-ESr9cSFw.cjs → import-nbmxtKYi.cjs}

@@ -37,6 +37,7 @@ let gray_matter = require("gray-matter");
 gray_matter = __toESM(gray_matter, 1);
 let js_yaml = require("js-yaml");
 let es_toolkit_object = require("es-toolkit/object");
+let node_crypto = require("node:crypto");
 let _toon_format_toon = require("@toon-format/toon");
 //#region src/types/features.ts
 const ALL_FEATURES = [
@@ -47,7 +48,8 @@ const ALL_FEATURES = [
 	"commands",
 	"skills",
 	"hooks",
-	"permissions"
+	"permissions",
+	"checks"
 ];
 const ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 const FeatureSchema = zod_mini.z.enum(ALL_FEATURES);
@@ -114,25 +116,26 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$251 } = node_path.posix;
+const { join: join$256 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$256(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$256(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
@@ -289,6 +292,7 @@ const subagentsProcessorToolTargetTuple = [
 	"kiro-ide",
 	"opencode",
 	"qwencode",
+	"reasonix",
 	"roo",
 	"rovodev",
 	"takt",
@@ -385,6 +389,7 @@ const permissionsProcessorToolTargetTuple = [
 	"warp",
 	"zed"
 ];
+const checksProcessorToolTargetTuple = ["amp"];
 //#endregion
 //#region src/types/tool-targets.ts
 const ALL_TOOL_TARGETS = [...new Set([
@@ -395,7 +400,8 @@ const ALL_TOOL_TARGETS = [...new Set([
 	subagentsProcessorToolTargetTuple,
 	skillsProcessorToolTargetTuple,
 	hooksProcessorToolTargetTuple,
-	permissionsProcessorToolTargetTuple
+	permissionsProcessorToolTargetTuple,
+	checksProcessorToolTargetTuple
 ].flat())];
 const ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
 const ToolTargetSchema = zod_mini.z.enum(ALL_TOOL_TARGETS);
@@ -1469,7 +1475,7 @@ function isPlainObject$1(value) {
 /**
 * Type guard to check if a value is an array of strings.
 */
-function isStringArray(value) {
+function isStringArray$1(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 //#endregion
@@ -1717,13 +1723,17 @@ var FeatureProcessor = class {
 	}
 };
 //#endregion
-//#region src/constants/agentsmd-paths.ts
-const AGENTSMD_DIR = ".agents";
-const AGENTSMD_MEMORIES_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "memories");
-const AGENTSMD_COMMANDS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "commands");
-const AGENTSMD_SKILLS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "skills");
-const AGENTSMD_SUBAGENTS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "subagents");
-const AGENTSMD_RULE_FILE_NAME = "AGENTS.md";
+//#region src/constants/amp-paths.ts
+const AMP_DIR = ".amp";
+const AMP_GLOBAL_DIR = (0, node_path.join)(".config", "amp");
+const AMP_AGENTS_DIR = ".agents";
+const AMP_SKILLS_PROJECT_DIR = (0, node_path.join)(AMP_AGENTS_DIR, "skills");
+const AMP_SKILLS_GLOBAL_DIR = (0, node_path.join)(".config", "agents", "skills");
+const AMP_CHECKS_PROJECT_DIR = (0, node_path.join)(AMP_AGENTS_DIR, "checks");
+const AMP_CHECKS_GLOBAL_DIR = (0, node_path.join)(AMP_GLOBAL_DIR, "checks");
+const AMP_RULE_FILE_NAME = "AGENTS.md";
+const AMP_SETTINGS_FILE_NAME = "settings.json";
+const AMP_SETTINGS_JSONC_FILE_NAME = "settings.jsonc";
 //#endregion
 //#region src/types/ai-file.ts
 var AiFile = class {
@@ -1797,6 +1807,414 @@ var AiFile = class {
 	}
 };
 //#endregion
+//#region src/types/rulesync-file.ts
+var RulesyncFile = class extends AiFile {
+	static async fromFile(_params) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+};
+//#endregion
+//#region src/features/checks/rulesync-check.ts
+const RulesyncCheckFrontmatterSchema = zod_mini.z.looseObject({
+	targets: zod_mini.z._default(RulesyncTargetsSchema, ["*"]),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	severity: zod_mini.z.optional(zod_mini.z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	])),
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
+var RulesyncCheck = class RulesyncCheck extends RulesyncFile {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		const parseResult = RulesyncCheckFrontmatterSchema.safeParse(frontmatter);
+		if (!parseResult.success && rest.validate !== false) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(parseResult.error)}`);
+		const parsedFrontmatter = parseResult.success ? {
+			...frontmatter,
+			...parseResult.data
+		} : {
+			...frontmatter,
+			targets: frontmatter?.targets ?? ["*"]
+		};
+		super({
+			...rest,
+			fileContent: stringifyFrontmatter(body, parsedFrontmatter)
+		});
+		this.frontmatter = parsedFrontmatter;
+		this.body = body;
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: RULESYNC_CHECKS_RELATIVE_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = RulesyncCheckFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath }) {
+		const filePath = (0, node_path.join)(outputRoot, RULESYNC_CHECKS_RELATIVE_DIR_PATH, relativeFilePath);
+		const { frontmatter, body: content, hasFrontmatter } = parseFrontmatter(await readFileContent(filePath), filePath);
+		if (!hasFrontmatter) throw new Error(`Missing frontmatter in ${filePath}. Rulesync files must begin with a YAML frontmatter block delimited by '---'.`);
+		const result = RulesyncCheckFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
+		const filename = (0, node_path.basename)(relativeFilePath);
+		return new RulesyncCheck({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths().relativeDirPath,
+			relativeFilePath: filename,
+			frontmatter: result.data,
+			body: content.trim()
+		});
+	}
+};
+//#endregion
+//#region src/types/tool-file.ts
+var ToolFile = class extends AiFile {};
+//#endregion
+//#region src/features/checks/tool-check.ts
+var ToolCheck = class extends ToolFile {
+	static getSettablePaths(_options = {}) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	static async fromFile(_params) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	/**
+	* Create a minimal instance for deletion purposes.
+	* This method does not read or parse file content, making it safe to use
+	* even when files have old/incompatible formats.
+	*/
+	static forDeletion(_params) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	static fromRulesyncCheck(_params) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	static isTargetedByRulesyncCheck(_rulesyncCheck) {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	static isTargetedByRulesyncCheckDefault({ rulesyncCheck, toolTarget }) {
+		const targets = rulesyncCheck.getFrontmatter().targets;
+		if (!targets) return true;
+		if (targets.includes("*")) return true;
+		if (targets.includes(toolTarget)) return true;
+		return false;
+	}
+	static filterToolSpecificSection(rawSection, excludeFields) {
+		const filtered = {};
+		for (const [key, value] of Object.entries(rawSection)) if (!excludeFields.includes(key)) filtered[key] = value;
+		return filtered;
+	}
+};
+//#endregion
+//#region src/features/checks/amp-check.ts
+const AmpCheckFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	"severity-default": zod_mini.z.optional(zod_mini.z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	])),
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
+/**
+* Represents an Amp code review check.
+*
+* Amp natively reads code review checks as Markdown files with YAML frontmatter,
+* scoped to the project (`.agents/checks/`) and user-wide (`~/.config/amp/checks/`).
+* Each check runs as a per-check subagent during code review.
+* @see https://ampcode.com/manual
+*/
+var AmpCheck = class AmpCheck extends ToolCheck {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = AmpCheckFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { relativeDirPath: global ? AMP_CHECKS_GLOBAL_DIR : AMP_CHECKS_PROJECT_DIR };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncCheck() {
+		const { name: _name, description, "severity-default": severityDefault, tools, ...restFields } = this.frontmatter;
+		return new RulesyncCheck({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				...description !== void 0 && { description },
+				...severityDefault !== void 0 && { severity: severityDefault },
+				...tools !== void 0 && { tools },
+				...restFields
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_CHECKS_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	static fromRulesyncCheck({ outputRoot = process.cwd(), rulesyncCheck, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCheck.getFrontmatter();
+		const relativeFilePath = rulesyncCheck.getRelativeFilePath();
+		const name = (0, node_path.basename)(relativeFilePath, ".md");
+		const { targets: _targets, description, severity, tools, ...restFields } = rulesyncFrontmatter;
+		const toolTargetKeys = new Set(ALL_TOOL_TARGETS);
+		const passthroughFields = Object.fromEntries(Object.entries(restFields).filter(([key]) => !toolTargetKeys.has(key) && key !== "name"));
+		const ampSection = this.filterToolSpecificSection(rulesyncFrontmatter.amp ?? {}, ["name"]);
+		const rawAmpFrontmatter = {
+			name,
+			...description !== void 0 && { description },
+			...severity !== void 0 && { "severity-default": severity },
+			...tools !== void 0 && { tools },
+			...passthroughFields,
+			...ampSection
+		};
+		const result = AmpCheckFrontmatterSchema.safeParse(rawAmpFrontmatter);
+		if (!result.success) throw new Error(`Invalid amp check frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
+		const ampFrontmatter = result.data;
+		const body = rulesyncCheck.getBody();
+		const fileContent = stringifyFrontmatter(body, ampFrontmatter);
+		const paths = this.getSettablePaths({ global });
+		return new AmpCheck({
+			outputRoot,
+			frontmatter: ampFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = AmpCheckFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncCheck(rulesyncCheck) {
+		return this.isTargetedByRulesyncCheckDefault({
+			rulesyncCheck,
+			toolTarget: "amp"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const result = AmpCheckFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new AmpCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new AmpCheck({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { name: "" },
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
+//#region src/features/checks/checks-processor.ts
+const ChecksProcessorToolTargetSchema = zod_mini.z.enum(checksProcessorToolTargetTuple);
+/**
+* Factory Map mapping tool targets to their check factories.
+* Using Map to preserve insertion order for consistent iteration.
+*/
+const toolCheckFactories = /* @__PURE__ */ new Map([["amp", {
+	class: AmpCheck,
+	meta: {
+		supportsGlobal: true,
+		filePattern: "*.md"
+	}
+}]]);
+const defaultGetFactory$6 = (target) => {
+	const factory = toolCheckFactories.get(target);
+	if (!factory) throw new Error(`Unsupported tool target: ${target}`);
+	return factory;
+};
+const allToolTargetKeys$5 = [...toolCheckFactories.keys()];
+const checksProcessorToolTargets = allToolTargetKeys$5;
+const checksProcessorToolTargetsGlobal = allToolTargetKeys$5.filter((target) => {
+	return toolCheckFactories.get(target)?.meta.supportsGlobal ?? false;
+});
+var ChecksProcessor = class extends FeatureProcessor {
+	toolTarget;
+	global;
+	getFactory;
+	constructor({ outputRoot = process.cwd(), inputRoot = process.cwd(), toolTarget, global = false, getFactory = defaultGetFactory$6, dryRun = false, logger }) {
+		super({
+			outputRoot,
+			inputRoot,
+			dryRun,
+			logger
+		});
+		const result = ChecksProcessorToolTargetSchema.safeParse(toolTarget);
+		if (!result.success) throw new Error(`Invalid tool target for ChecksProcessor: ${toolTarget}. ${formatError(result.error)}`);
+		this.toolTarget = result.data;
+		this.global = global;
+		this.getFactory = getFactory;
+	}
+	async convertRulesyncFilesToToolFiles(rulesyncFiles) {
+		const rulesyncChecks = rulesyncFiles.filter((file) => file instanceof RulesyncCheck);
+		const factory = this.getFactory(this.toolTarget);
+		return rulesyncChecks.filter((rulesyncCheck) => factory.class.isTargetedByRulesyncCheck(rulesyncCheck)).map((rulesyncCheck) => factory.class.fromRulesyncCheck({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RulesyncCheck.getSettablePaths().relativeDirPath,
+			rulesyncCheck,
+			global: this.global
+		}));
+	}
+	async convertToolFilesToRulesyncFiles(toolFiles) {
+		return toolFiles.filter((file) => file instanceof ToolCheck).map((toolCheck) => toolCheck.toRulesyncCheck());
+	}
+	/**
+	* Implementation of abstract method from Processor
+	* Load and parse rulesync check files from .rulesync/checks/ directory
+	*/
+	async loadRulesyncFiles() {
+		const checksDir = (0, node_path.join)(this.inputRoot, RulesyncCheck.getSettablePaths().relativeDirPath);
+		if (!await directoryExists(checksDir)) {
+			this.logger.debug(`Rulesync checks directory not found: ${checksDir}`);
+			return [];
+		}
+		const mdFiles = (await listDirectoryFiles(checksDir)).filter((file) => file.endsWith(".md"));
+		if (mdFiles.length === 0) {
+			this.logger.debug(`No markdown files found in rulesync checks directory: ${checksDir}`);
+			return [];
+		}
+		this.logger.debug(`Found ${mdFiles.length} check files in ${checksDir}`);
+		const rulesyncChecks = [];
+		for (const mdFile of mdFiles) {
+			const filepath = (0, node_path.join)(checksDir, mdFile);
+			try {
+				const rulesyncCheck = await RulesyncCheck.fromFile({
+					outputRoot: this.inputRoot,
+					relativeFilePath: mdFile,
+					validate: true
+				});
+				rulesyncChecks.push(rulesyncCheck);
+				this.logger.debug(`Successfully loaded check: ${mdFile}`);
+			} catch (error) {
+				this.logger.warn(`Failed to load check file ${filepath}: ${formatError(error)}`);
+				continue;
+			}
+		}
+		this.logger.debug(`Successfully loaded ${rulesyncChecks.length} rulesync checks`);
+		return rulesyncChecks;
+	}
+	/**
+	* Implementation of abstract method from Processor
+	* Load tool-specific check files and parse them into ToolCheck instances
+	*/
+	async loadToolFiles({ forDeletion = false } = {}) {
+		const factory = this.getFactory(this.toolTarget);
+		const paths = factory.class.getSettablePaths({ global: this.global });
+		const baseDir = (0, node_path.join)(this.outputRoot, paths.relativeDirPath);
+		const checkFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern));
+		const toRelativeFilePath = (path) => (0, node_path.relative)(baseDir, path);
+		if (forDeletion) return checkFilePaths.map((path) => factory.class.forDeletion({
+			outputRoot: this.outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: toRelativeFilePath(path),
+			global: this.global
+		})).filter((check) => check.isDeletable());
+		const loaded = await Promise.all(checkFilePaths.map((path) => factory.class.fromFile({
+			outputRoot: this.outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: toRelativeFilePath(path),
+			global: this.global
+		})));
+		this.logger.debug(`Successfully loaded ${loaded.length} ${this.toolTarget} checks from ${paths.relativeDirPath}`);
+		return loaded;
+	}
+	/**
+	* Implementation of abstract method from FeatureProcessor
+	* Return the tool targets that this processor supports
+	*/
+	static getToolTargets({ global = false } = {}) {
+		if (global) return [...checksProcessorToolTargetsGlobal];
+		return [...checksProcessorToolTargets];
+	}
+	static getToolTargetsSimulated() {
+		return [];
+	}
+	/**
+	* Get the factory for a specific tool target.
+	* This is a static version of the internal getFactory for external use.
+	* @param target - The tool target. Must be a valid ChecksProcessorToolTarget.
+	* @returns The factory for the target, or undefined if not found.
+	*/
+	static getFactory(target) {
+		const result = ChecksProcessorToolTargetSchema.safeParse(target);
+		if (!result.success) return;
+		return toolCheckFactories.get(result.data);
+	}
+};
+//#endregion
+//#region src/constants/agentsmd-paths.ts
+const AGENTSMD_DIR = ".agents";
+const AGENTSMD_MEMORIES_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "memories");
+const AGENTSMD_COMMANDS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "commands");
+const AGENTSMD_SKILLS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "skills");
+const AGENTSMD_SUBAGENTS_DIR_PATH = (0, node_path.join)(AGENTSMD_DIR, "subagents");
+const AGENTSMD_RULE_FILE_NAME = "AGENTS.md";
+//#endregion
 //#region src/features/commands/tool-command.ts
 /**
 * Abstract base class for AI development tool-specific command formats.
@@ -2044,13 +2462,6 @@ const AntigravityCommandFrontmatterSchema = zod_mini.z.looseObject({
 	...AntigravityWorkflowFrontmatterSchema.shape
 });
 //#endregion
-//#region src/types/rulesync-file.ts
-var RulesyncFile = class extends AiFile {
-	static async fromFile(_params) {
-		throw new Error("Please implement this method in the subclass.");
-	}
-};
-//#endregion
 //#region src/features/commands/rulesync-command.ts
 const RulesyncCommandFrontmatterSchema = zod_mini.z.looseObject({
 	targets: zod_mini.z._default(RulesyncTargetsSchema, ["*"]),
@@ -3111,135 +3522,118 @@ var CursorCommand = class CursorCommand extends ToolCommand {
 //#endregion
 //#region src/constants/devin-paths.ts
 const DEVIN_DIR = ".devin";
-const CODEIUM_WINDSURF_DIR = (0, node_path.join)(".codeium", "windsurf");
-const DEVIN_WORKFLOWS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "workflows");
 const DEVIN_SKILLS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "skills");
 const DEVIN_AGENTS_DIR_PATH = (0, node_path.join)(DEVIN_DIR, "agents");
 const DEVIN_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(".config", "devin");
 const DEVIN_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(DEVIN_GLOBAL_CONFIG_DIR_PATH, "agents");
 const DEVIN_GLOBAL_SKILLS_DIR_PATH = (0, node_path.join)(DEVIN_GLOBAL_CONFIG_DIR_PATH, "skills");
-const CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(CODEIUM_WINDSURF_DIR, "global_workflows");
 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
+//#region src/constants/general.ts
+const SKILL_FILE_NAME$1 = "SKILL.md";
+//#endregion
+//#region src/features/commands/command-skill-ownership.ts
+/**
+* Slug used for the per-command `<slug>/SKILL.md` directory when a tool's
+* commands are emitted onto its skills surface (Devin, Hermes Agent).
+*/
+function commandSlug(relativeFilePath) {
+	return (0, node_path.basename)(relativeFilePath, ".md").replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+/**
+* Whether a rulesync command exists whose slug matches `dirName`.
+*
+* Used by the skills-surface `isDirOwned` hooks of tools whose commands are
+* emitted as `<slug>/SKILL.md` into the skills tree: a directory matching a
+* current command slug is owned by the commands feature, so the skills
+* feature must neither import it as a skill nor delete it as an orphan
+* skill. Once the command is removed from `.rulesync/commands/`, the
+* directory stops matching and the skills feature cleans it up as a regular
+* orphan.
+*/
+async function rulesyncCommandSlugExists({ inputRoot, dirName }) {
+	return (await findFilesByGlobs((0, node_path.join)(inputRoot, RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "**", "*.md"))).some((filePath) => commandSlug((0, node_path.basename)(filePath)) === dirName);
+}
+//#endregion
 //#region src/features/commands/devin-command.ts
-const DevinCommandFrontmatterSchema = zod_mini.z.looseObject({ description: zod_mini.z.optional(zod_mini.z.string()) });
+function commandSkillContent$1(rulesyncCommand) {
+	const slug = commandSlug(rulesyncCommand.getRelativeFilePath());
+	const description = rulesyncCommand.getFrontmatter().description ?? `${slug} command`;
+	return stringifyFrontmatter(rulesyncCommand.getBody().trim(), {
+		name: slug,
+		description
+	});
+}
 /**
-* Represents a Devin (Cascade, now Devin Desktop) workflow command.
-* Devin supports workflows in both project mode under .devin/workflows/
-* (preferred since the Devin Desktop rebrand; .devin/workflows/ is the
-* legacy fallback the tool still reads) and global mode under
-* ~/.codeium/windsurf/global_workflows/ (unchanged by the rebrand).
+* Represents a Devin slash command, emitted as a Devin Skill.
+*
+* Devin's extensibility docs no longer document a standalone
+* workflows/commands component — reusable prompts invoked as slash commands
+* are Skills (`/name`). Commands are therefore emitted onto the native skills
+* surface, one `SKILL.md` per command: `.devin/skills/<slug>/SKILL.md`
+* (project) and `~/.config/devin/skills/<slug>/SKILL.md` (global). The legacy
+* Windsurf/Cascade-era `.devin/workflows/` and
+* `~/.codeium/windsurf/global_workflows/` locations are no longer emitted.
+*
+* Import and deletion are intentionally no-ops for this target: the skills
+* feature owns the `.devin/skills/` tree, so importing it as commands would
+* double-import every skill (mirrors the Hermes Agent commands target).
+*
+* @see https://docs.devin.ai/cli/extensibility
+* @see https://docs.devin.ai/cli/extensibility/skills/overview
 */
 var DevinCommand = class DevinCommand extends ToolCommand {
-	frontmatter;
-	body;
-	constructor({ frontmatter, body, ...rest }) {
-		if (rest.validate) {
-			const result = DevinCommandFrontmatterSchema.safeParse(frontmatter);
-			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
-		}
-		super({
-			...rest,
-			fileContent: stringifyFrontmatter(body, frontmatter)
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "devin"
 		});
-		this.frontmatter = frontmatter;
-		this.body = body;
 	}
 	static getSettablePaths({ global = false } = {}) {
-		if (global) return { relativeDirPath: CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_PATH };
-		return { relativeDirPath: DEVIN_WORKFLOWS_DIR_PATH };
-	}
-	getBody() {
-		return this.body;
-	}
-	getFrontmatter() {
-		return this.frontmatter;
+		return { relativeDirPath: global ? DEVIN_GLOBAL_SKILLS_DIR_PATH : DEVIN_SKILLS_DIR_PATH };
 	}
-	toRulesyncCommand() {
-		const { description, ...restFields } = this.frontmatter;
-		const rulesyncFrontmatter = {
-			targets: ["*"],
-			description,
-			...Object.keys(restFields).length > 0 && { devin: restFields }
-		};
-		const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
-		return new RulesyncCommand({
-			outputRoot: process.cwd(),
-			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 devinFields = rulesyncFrontmatter.devin ?? {};
-		const devinFrontmatter = {
-			description: rulesyncFrontmatter.description,
-			...devinFields
-		};
-		const body = rulesyncCommand.getBody();
-		const paths = this.getSettablePaths({ global });
-		return new DevinCommand({
-			outputRoot,
-			frontmatter: devinFrontmatter,
-			body,
-			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
-			validate
+	constructor({ slug, ...params }) {
+		super({
+			...params,
+			...slug !== void 0 && {
+				relativeDirPath: (0, node_path.join)(params.relativeDirPath, slug),
+				relativeFilePath: "SKILL.md"
+			}
 		});
 	}
 	validate() {
-		if (!this.frontmatter) return {
-			success: true,
-			error: null
-		};
-		const result = DevinCommandFrontmatterSchema.safeParse(this.frontmatter);
-		if (result.success) return {
+		return {
 			success: true,
 			error: null
 		};
-		else return {
-			success: false,
-			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
-		};
 	}
-	static isTargetedByRulesyncCommand(rulesyncCommand) {
-		return this.isTargetedByRulesyncCommandDefault({
-			rulesyncCommand,
-			toolTarget: "devin"
+	toRulesyncCommand() {
+		const slug = (0, node_path.basename)((0, node_path.dirname)(this.getRelativePathFromCwd()));
+		const { frontmatter, body } = parseFrontmatter(this.getFileContent(), this.getFilePath());
+		const description = typeof frontmatter.description === "string" ? frontmatter.description : void 0;
+		return new RulesyncCommand({
+			relativeDirPath: RULESYNC_COMMANDS_RELATIVE_DIR_PATH,
+			relativeFilePath: `${slug}.md`,
+			frontmatter: { description },
+			body: body.trimStart()
 		});
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
-		const paths = this.getSettablePaths({ global });
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
-		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
-		const result = DevinCommandFrontmatterSchema.safeParse(frontmatter);
-		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+	static fromRulesyncCommand({ outputRoot, rulesyncCommand, global = false }) {
+		const paths = DevinCommand.getSettablePaths({ global });
 		return new DevinCommand({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath,
-			frontmatter: result.data,
-			body: content.trim(),
-			validate
+			relativeFilePath: SKILL_FILE_NAME$1,
+			slug: commandSlug(rulesyncCommand.getRelativeFilePath()),
+			fileContent: commandSkillContent$1(rulesyncCommand)
 		});
 	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new DevinCommand({
-			outputRoot,
-			relativeDirPath,
-			relativeFilePath,
-			frontmatter: { description: "" },
-			body: "",
-			validate: false
-		});
+	getFileContent() {
+		return this.fileContent;
 	}
 };
 //#endregion
@@ -3568,10 +3962,7 @@ const HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_MANIFEST_PATH = (0, node_path.join)(
 const HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_INIT_PATH = (0, node_path.join)(HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_DIR_PATH, "__init__.py");
 //#endregion
 //#region src/features/commands/hermesagent-command.ts
-const SKILL_FILE_NAME$1 = "SKILL.md";
-function commandSlug(relativeFilePath) {
-	return (0, node_path.basename)(relativeFilePath, ".md").replace(/[^a-zA-Z0-9_-]/g, "-");
-}
+const SKILL_FILE_NAME = "SKILL.md";
 function commandSkillContent(rulesyncCommand) {
 	const slug = commandSlug(rulesyncCommand.getRelativeFilePath());
 	const description = rulesyncCommand.getFrontmatter().description ?? `${slug} command`;
@@ -3588,7 +3979,7 @@ var HermesagentCommand = class HermesagentCommand extends ToolCommand {
 	static getSettablePaths({ slug = "command" } = {}) {
 		return {
 			relativeDirPath: (0, node_path.join)(HERMESAGENT_SKILLS_DIR_PATH, slug),
-			relativeFilePath: SKILL_FILE_NAME$1
+			relativeFilePath: SKILL_FILE_NAME
 		};
 	}
 	constructor({ slug, ...params }) {
@@ -3619,7 +4010,7 @@ var HermesagentCommand = class HermesagentCommand extends ToolCommand {
 		return new HermesagentCommand({
 			outputRoot,
 			relativeDirPath: "",
-			relativeFilePath: SKILL_FILE_NAME$1,
+			relativeFilePath: SKILL_FILE_NAME,
 			slug: commandSlug(rulesyncCommand.getRelativeFilePath()),
 			fileContent: commandSkillContent(rulesyncCommand)
 		});
@@ -4854,6 +5245,7 @@ const PI_AGENT_SKILLS_DIR_PATH = (0, node_path.join)(PI_AGENT_DIR, "skills");
 const PI_PROMPTS_DIR_PATH = (0, node_path.join)(".pi", "prompts");
 const PI_SKILLS_DIR_PATH = (0, node_path.join)(".pi", "skills");
 const PI_RULE_FILE_NAME = "AGENTS.md";
+const PI_APPEND_SYSTEM_FILE_NAME = "APPEND_SYSTEM.md";
 //#endregion
 //#region src/features/commands/pi-command.ts
 /**
@@ -5118,6 +5510,9 @@ const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "commands");
 const REASONIX_RULE_FILE_NAME = "REASONIX.md";
 const REASONIX_SKILLS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "skills");
+const REASONIX_SUBAGENTS_DIR_PATH = REASONIX_SKILLS_DIR_PATH;
+const REASONIX_SUBAGENT_INVOCATION = "manual";
+const REASONIX_SUBAGENT_RUN_AS = "subagent";
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -5385,9 +5780,6 @@ const ROVODEV_AGENTS_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
 const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
 const ROVODEV_PROMPTS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "prompts");
 //#endregion
-//#region src/types/tool-file.ts
-var ToolFile = class extends AiFile {};
-//#endregion
 //#region src/features/commands/rovodev-command.ts
 /**
 * Rovo Dev CLI "saved prompts": a file-based custom-command surface made of a
@@ -5876,7 +6268,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: false,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: true
+			supportsSubdirectory: true,
+			skipToolFileScan: true
 		}
 	}],
 	["junie", {
@@ -6006,7 +6399,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: false
+			supportsSubdirectory: false,
+			skipToolFileScan: true
 		}
 	}]
 ]);
@@ -6109,6 +6503,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 	*/
 	async loadToolFiles({ forDeletion = false } = {}) {
 		const factory = this.getFactory(this.toolTarget);
+		if (factory.meta.skipToolFileScan) return [];
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const outputRootFull = (0, node_path.join)(this.outputRoot, paths.relativeDirPath);
 		const commandFilePaths = await findFilesByGlobs(factory.meta.supportsSubdirectory ? (0, node_path.join)(outputRootFull, "**", `*.${factory.meta.extension}`) : (0, node_path.join)(outputRootFull, `*.${factory.meta.extension}`));
@@ -6218,7 +6613,10 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	type: zod_mini.z.optional(zod_mini.z.enum([
 		"command",
 		"prompt",
-		"http"
+		"http",
+		"agent",
+		"mcp_tool",
+		"function"
 	])),
 	url: zod_mini.z.optional(safeString),
 	timeout: zod_mini.z.optional(zod_mini.z.number()),
@@ -6231,12 +6629,71 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	sequential: zod_mini.z.optional(zod_mini.z.boolean()),
 	async: zod_mini.z.optional(zod_mini.z.boolean()),
 	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), safeString)),
-	shell: zod_mini.z.optional(safeString),
+	shell: zod_mini.z.optional(zod_mini.z.enum(["bash", "powershell"])),
 	statusMessage: zod_mini.z.optional(safeString),
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), safeString)),
 	allowedEnvVars: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-	once: zod_mini.z.optional(zod_mini.z.boolean())
+	once: zod_mini.z.optional(zod_mini.z.boolean()),
+	server: zod_mini.z.optional(safeString),
+	tool: zod_mini.z.optional(safeString),
+	input: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	model: zod_mini.z.optional(safeString)
 });
+/**
+* All canonical hook event names.
+* Each tool supports a subset of these events.
+*/
+const HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"preToolUse",
+	"postToolUse",
+	"preModelInvocation",
+	"postModelInvocation",
+	"beforeSubmitPrompt",
+	"stop",
+	"subagentStop",
+	"preCompact",
+	"postCompact",
+	"contextOffload",
+	"postToolUseFailure",
+	"subagentStart",
+	"beforeShellExecution",
+	"afterShellExecution",
+	"beforeMCPExecution",
+	"afterMCPExecution",
+	"beforeReadFile",
+	"afterFileEdit",
+	"beforeAgentResponse",
+	"afterAgentResponse",
+	"afterAgentThought",
+	"beforeTabFileRead",
+	"afterTabFileEdit",
+	"permissionRequest",
+	"notification",
+	"setup",
+	"afterError",
+	"beforeToolSelection",
+	"worktreeCreate",
+	"worktreeRemove",
+	"workspaceOpen",
+	"messageDisplay",
+	"todoCreated",
+	"todoCompleted",
+	"stopFailure",
+	"instructionsLoaded",
+	"userPromptExpansion",
+	"postToolBatch",
+	"permissionDenied",
+	"taskCreated",
+	"taskCompleted",
+	"teammateIdle",
+	"configChange",
+	"cwdChanged",
+	"fileChanged",
+	"elicitation",
+	"elicitationResult"
+];
 /** Hook events supported by Cursor. */
 const CURSOR_HOOK_EVENTS = [
 	"sessionStart",
@@ -6711,12 +7168,28 @@ const CANONICAL_TO_HERMESAGENT_EVENT_NAMES = {
 */
 const HERMESAGENT_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_HERMESAGENT_EVENT_NAMES).map(([k, v]) => [v, k]));
 const hooksRecordSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.array(HookDefinitionSchema));
+const HOOK_EVENT_SET = new Set(HOOK_EVENTS);
+/** Whether `value` is a canonical hook event name. */
+const isHookEvent = (value) => HOOK_EVENT_SET.has(value);
+/**
+* Top-level `hooks` record whose keys must be canonical event names, so typos
+* are rejected at parse time. Keys are validated with a refinement (instead of
+* an enum key schema) to keep the inferred type a plain string record.
+*
+* The per-tool override blocks below deliberately keep the lenient
+* `hooksRecordSchema`: some are documented to pass tool-native event keys
+* through verbatim (e.g. kiro-ide's IDE-only `PostFileSave`/`PreTaskExec`
+* triggers), which the canonical enum would reject.
+*/
+const canonicalHooksRecordSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.array(HookDefinitionSchema)).check(zod_mini.z.refine((record) => Object.keys(record).every((key) => HOOK_EVENT_SET.has(key)), { error: (issue) => {
+	return `unknown hook event name(s): ${Object.keys(issue.input ?? {}).filter((key) => !HOOK_EVENT_SET.has(key)).join(", ")}`;
+} }));
 /**
 * Canonical hooks config (canonical event names in camelCase).
 */
 const HooksConfigSchema = zod_mini.z.looseObject({
 	version: zod_mini.z.optional(zod_mini.z.number()),
-	hooks: hooksRecordSchema,
+	hooks: canonicalHooksRecordSchema,
 	cursor: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	claudecode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	copilot: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
@@ -7153,6 +7626,20 @@ const CANONICAL_TO_GROKCLI_EVENT_NAMES = {
 */
 const GROKCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_GROKCLI_EVENT_NAMES).map(([k, v]) => [v, k]));
 //#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/tool-hooks-converter.ts
 function isToolMatcherEntry(x) {
 	if (x === null || typeof x !== "object") return false;
@@ -7210,6 +7697,25 @@ function importBooleanPassthroughFields({ h, converterConfig }) {
 	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "boolean").map(({ canonical, tool }) => [canonical, h[tool]]));
 }
 /**
+* Emit the payload fields specific to a hook type — `url`/`headers`/
+* `allowedEnvVars` for http, `server`/`tool`/`input` for mcp_tool, `model`
+* for prompt/agent. https://code.claude.com/docs/en/hooks
+*/
+function emitTypePayloadFields({ def, hookType, converterConfig }) {
+	if (hookType === "http") return compact({
+		url: def.url,
+		headers: def.headers,
+		allowedEnvVars: def.allowedEnvVars
+	});
+	if (hookType === "mcp_tool") return compact({
+		server: def.server,
+		tool: def.tool,
+		input: def.input
+	});
+	if ((hookType === "prompt" || hookType === "agent") && converterConfig.emitsPromptModel) return compact({ model: def.model });
+	return {};
+}
+/**
 * Convert the definitions of a single matcher group into tool hook entries,
 * honoring supported hook types and passthrough fields.
 */
@@ -7231,6 +7737,11 @@ function buildToolHooks({ defs, converterConfig }) {
 			...command !== void 0 && command !== null && { command },
 			...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
 			...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt },
+			...emitTypePayloadFields({
+				def,
+				hookType,
+				converterConfig
+			}),
 			...converterConfig.passthroughFields?.includes("name") && def.name !== void 0 && def.name !== null && { name: def.name },
 			...converterConfig.passthroughFields?.includes("description") && def.description !== void 0 && def.description !== null && { description: def.description }
 		});
@@ -7297,6 +7808,46 @@ function stripCommandPrefix({ command, converterConfig }) {
 	return cmd;
 }
 /**
+* Hook types preserved verbatim on import — Claude Code's five documented
+* handler types. Anything else is coerced to `command` as before.
+* https://code.claude.com/docs/en/hooks
+*/
+const IMPORTED_HOOK_TYPES = /* @__PURE__ */ new Set([
+	"command",
+	"prompt",
+	"http",
+	"mcp_tool",
+	"agent"
+]);
+function isImportedHookType(value) {
+	return typeof value === "string" && IMPORTED_HOOK_TYPES.has(value);
+}
+function isStringRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	return Object.values(value).every((v) => typeof v === "string");
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+/**
+* Import the payload fields specific to a hook type, type-checking each raw
+* value before it enters the canonical definition.
+*/
+function importTypePayloadFields({ h, hookType }) {
+	if (hookType === "http") return {
+		...typeof h.url === "string" && { url: h.url },
+		...isStringRecord(h.headers) && { headers: h.headers },
+		...isStringArray(h.allowedEnvVars) && { allowedEnvVars: h.allowedEnvVars }
+	};
+	if (hookType === "mcp_tool") return {
+		...typeof h.server === "string" && { server: h.server },
+		...typeof h.tool === "string" && { tool: h.tool },
+		...h.input !== null && typeof h.input === "object" && !Array.isArray(h.input) && { input: h.input }
+	};
+	if (hookType === "prompt" || hookType === "agent") return typeof h.model === "string" ? { model: h.model } : {};
+	return {};
+}
+/**
 * Convert a single tool hook record into a canonical hook definition.
 */
 function toolHookToCanonical({ h, rawEntry, converterConfig }) {
@@ -7304,7 +7855,7 @@ function toolHookToCanonical({ h, rawEntry, converterConfig }) {
 		command: h.command,
 		converterConfig
 	});
-	const hookType = h.type === "command" || h.type === "prompt" ? h.type : "command";
+	const hookType = isImportedHookType(h.type) ? h.type : "command";
 	const timeout = typeof h.timeout === "number" ? h.timeout : void 0;
 	const prompt = typeof h.prompt === "string" ? h.prompt : void 0;
 	return {
@@ -7312,6 +7863,10 @@ function toolHookToCanonical({ h, rawEntry, converterConfig }) {
 		...command !== void 0 && command !== null && { command },
 		...timeout !== void 0 && timeout !== null && { timeout },
 		...prompt !== void 0 && prompt !== null && { prompt },
+		...importTypePayloadFields({
+			h,
+			hookType
+		}),
 		...converterConfig.passthroughFields?.includes("name") && typeof h.name === "string" && { name: h.name },
 		...converterConfig.passthroughFields?.includes("description") && typeof h.description === "string" && { description: h.description },
 		...importBooleanPassthroughFields({
@@ -7331,6 +7886,32 @@ function toolMatcherEntryToCanonical({ rawEntry, converterConfig }) {
 		converterConfig
 	}));
 }
+/**
+* Assemble the canonical hooks config a tool importer writes to
+* `.rulesync/hooks.json`.
+*
+* The top-level `hooks` record only accepts canonical event names, so any
+* imported native event key without a canonical mapping is moved under the
+* importing tool's own override block (`<overrideKey>.hooks`), whose keys stay
+* lenient. This mirrors the generate direction — override blocks pass
+* tool-native keys through verbatim — so documented native triggers (e.g.
+* kiro-ide's `PostFileSave`) survive an import → generate round-trip instead
+* of failing canonical validation.
+*/
+function buildImportedHooksConfig({ hooks, overrideKey, version = 1, extraOverride }) {
+	const canonical = {};
+	const native = {};
+	for (const [event, defs] of Object.entries(hooks)) if (isHookEvent(event)) canonical[event] = defs;
+	else native[event] = defs;
+	const override = { ...extraOverride };
+	if (Object.keys(native).length > 0) override.hooks = native;
+	const config = {
+		version,
+		hooks: canonical
+	};
+	if (Object.keys(override).length > 0) config[overrideKey] = override;
+	return config;
+}
 function toolHooksToCanonical({ hooks, converterConfig }) {
 	if (hooks === null || hooks === void 0 || typeof hooks !== "object") return {};
 	const canonical = {};
@@ -7501,7 +8082,8 @@ const ANTIGRAVITY_CONVERTER_CONFIG = {
 		"preModelInvocation",
 		"postModelInvocation",
 		"stop"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
 };
 /**
 * Antigravity's `hooks.json` is keyed by a named hook whose value holds the
@@ -7608,10 +8190,11 @@ var AntigravityHooks = class extends ToolHooks {
 			hooks: flattenAntigravityHooks(parsed),
 			converterConfig: ANTIGRAVITY_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		const overrideKey = this.constructor.getOverrideKey();
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -7732,7 +8315,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 		"sessionEnd",
 		"stop",
 		"notification"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
 };
 /**
 * AugmentCode (Auggie CLI) lifecycle hooks.
@@ -7814,10 +8398,10 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 			hooks: settings.hooks,
 			converterConfig: AUGMENTCODE_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "augmentcode"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -7852,7 +8436,15 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"taskCompleted",
 		"teammateIdle",
 		"cwdChanged"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set([
+		"command",
+		"prompt",
+		"http",
+		"mcp_tool",
+		"agent"
+	]),
+	emitsPromptModel: true
 };
 var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
@@ -7917,10 +8509,10 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 			hooks: settings.hooks,
 			converterConfig: CLAUDE_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "claudecode"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8063,10 +8655,10 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			hooks: parsed.hooks,
 			converterConfig: CODEXCLI_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "codexcli"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8234,10 +8826,10 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			throw new Error(`Failed to parse Copilot hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = copilotHooksToCanonical(parsed.hooks, options?.logger);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "copilot"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8256,20 +8848,6 @@ 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.
@@ -8402,7 +8980,7 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else entries.push({
+		else if (hookType === "command") entries.push({
 			type: "command",
 			...matcherPart,
 			...compact({
@@ -8554,10 +9132,10 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 			throw new Error(`Failed to parse Copilot CLI hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = copilotCliHooksToCanonical(parsed.hooks, options?.logger);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "copilotcli"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8612,9 +9190,10 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			...config.cursor?.hooks
 		};
 		const mappedHooks = {};
+		const cursorSupportedTypes = /* @__PURE__ */ new Set(["command", "prompt"]);
 		for (const [eventName, defs] of Object.entries(mergedHooks)) {
 			const cursorEventName = CANONICAL_TO_CURSOR_EVENT_NAMES[eventName] ?? eventName;
-			mappedHooks[cursorEventName] = defs.map((def) => ({
+			const mappedDefs = defs.filter((def) => cursorSupportedTypes.has(def.type ?? "command")).map((def) => ({
 				...def.type !== void 0 && def.type !== null && { type: def.type },
 				...def.command !== void 0 && def.command !== null && { command: def.command },
 				...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
@@ -8623,6 +9202,7 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 				...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt },
 				...def.failClosed !== void 0 && def.failClosed !== null && { failClosed: def.failClosed }
 			}));
+			if (mappedDefs.length > 0) mappedHooks[cursorEventName] = mappedDefs;
 		}
 		const cursorConfig = {
 			version: config.version ?? 1,
@@ -8649,10 +9229,11 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			canonicalHooks[eventName] = defs;
 		}
 		const version = parsed.version ?? 1;
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version,
-			hooks: canonicalHooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks: canonicalHooks,
+			overrideKey: "cursor",
+			version
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8707,7 +9288,7 @@ function canonicalToDeepagentsHooks(config) {
 		const deepagentsEvent = CANONICAL_TO_DEEPAGENTS_EVENT_NAMES[canonicalEvent];
 		if (!deepagentsEvent) continue;
 		for (const def of definitions) {
-			if (def.type === "prompt") continue;
+			if ((def.type ?? "command") !== "command") continue;
 			if (!def.command) continue;
 			if (def.matcher) continue;
 			entries.push({
@@ -8797,10 +9378,10 @@ var DeepagentsHooks = class DeepagentsHooks extends ToolHooks {
 			throw new Error(`Failed to parse deepagents hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = deepagentsToCanonicalHooks(isDeepagentsHooksFile(parsed) ? parsed.hooks : []);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "deepagents"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8929,10 +9510,10 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 			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
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "devin"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -8956,7 +9537,8 @@ const FACTORYDROID_CONVERTER_CONFIG = {
 	supportedEvents: FACTORYDROID_HOOK_EVENTS,
 	canonicalToToolEventNames: CANONICAL_TO_FACTORYDROID_EVENT_NAMES,
 	toolToCanonicalEventNames: FACTORYDROID_TO_CANONICAL_EVENT_NAMES,
-	projectDirVar: "$FACTORY_PROJECT_DIR"
+	projectDirVar: "$FACTORY_PROJECT_DIR",
+	supportedHookTypes: /* @__PURE__ */ new Set(["command", "prompt"])
 };
 var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 	constructor(params) {
@@ -9024,10 +9606,10 @@ var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 			hooks: settings.hooks,
 			converterConfig: FACTORYDROID_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "factorydroid"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -9118,10 +9700,10 @@ var GooseHooks = class GooseHooks extends ToolHooks {
 			hooks: parsed.hooks && typeof parsed.hooks === "object" && !Array.isArray(parsed.hooks) ? Object.fromEntries(Object.entries(parsed.hooks).filter(([eventName]) => Object.hasOwn(GOOSE_TO_CANONICAL_EVENT_NAMES, eventName))) : parsed.hooks,
 			converterConfig: GOOSE_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "goose"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -9279,10 +9861,10 @@ var GrokcliHooks = class GrokcliHooks extends ToolHooks {
 			hooks: isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {},
 			converterConfig: GROKCLI_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "grokcli"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -9443,10 +10025,10 @@ var HermesagentHooks = class HermesagentHooks extends ToolHooks {
 			format: "yaml",
 			fileContent: this.getFileContent()
 		}).hooks);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "hermesagent"
+		}), null, 2) });
 	}
 	static fromRulesyncHooks({ outputRoot, rulesyncHooks, logger }) {
 		const config = rulesyncHooks.getJson();
@@ -9549,10 +10131,10 @@ var JunieHooks = class JunieHooks extends ToolHooks {
 			hooks: settings.hooks,
 			converterConfig: JUNIE_CONVERTER_CONFIG
 		});
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "junie"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -9597,7 +10179,7 @@ function collectOpencodeStyleHandlers({ effectiveHooks, eventMap, namedEventHand
 		if (!toolEvent) continue;
 		const handlers = [];
 		for (const def of definitions) {
-			if (def.type === "prompt") continue;
+			if ((def.type ?? "command") !== "command") continue;
 			if (!def.command) continue;
 			handlers.push({
 				command: def.command,
@@ -9902,10 +10484,11 @@ var KiroHooks = class KiroHooks extends ToolHooks {
 			throw new Error(`Failed to parse Kiro hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = kiroHooksToCanonical(agentConfig.hooks);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		const overrideKey = this.constructor.getOverrideKey();
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -10114,10 +10697,10 @@ var KiroIdeHooks = class KiroIdeHooks extends ToolHooks {
 			throw new Error(`Failed to parse Kiro IDE hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = kiroIdeHooksToCanonical(parsed.hooks ?? []);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "kiro-ide"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -10241,11 +10824,18 @@ function canonicalToQwencodeHooks(config) {
 		...sharedHooks,
 		...config.qwencode?.hooks
 	};
+	const qwencodeSupportedTypes = /* @__PURE__ */ new Set([
+		"command",
+		"prompt",
+		"http",
+		"function"
+	]);
 	const qwencode = {};
 	for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
 		const qwencodeEventName = CANONICAL_TO_QWENCODE_EVENT_NAMES[eventName] ?? eventName;
 		const byMatcher = /* @__PURE__ */ new Map();
 		for (const def of definitions) {
+			if (!qwencodeSupportedTypes.has(def.type ?? "command")) continue;
 			const key = def.matcher ?? "";
 			const list = byMatcher.get(key);
 			if (list) list.push(def);
@@ -10305,9 +10895,10 @@ function qwencodeMatcherEntryToCanonical(entry) {
 	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 hookType = h.type === "command" || h.type === "prompt" || h.type === "http" ? h.type : "command";
+		const hookType = h.type === "command" || h.type === "prompt" || h.type === "http" || h.type === "function" ? h.type : "command";
 		const isHttp = hookType === "http";
 		const isCommand = hookType === "command";
+		const shell = h.shell === "bash" || h.shell === "powershell" ? h.shell : void 0;
 		defs.push({
 			type: hookType,
 			...compact({
@@ -10319,7 +10910,7 @@ function qwencodeMatcherEntryToCanonical(entry) {
 				statusMessage: h.statusMessage,
 				async: isCommand ? h.async : void 0,
 				env: isCommand ? h.env : void 0,
-				shell: isCommand ? h.shell : void 0,
+				shell: isCommand ? shell : void 0,
 				headers: isHttp ? h.headers : void 0,
 				allowedEnvVars: isHttp ? h.allowedEnvVars : void 0,
 				once: isHttp ? h.once : void 0,
@@ -10406,15 +10997,11 @@ var QwencodeHooks = class QwencodeHooks extends ToolHooks {
 		} catch (error) {
 			throw new Error(`Failed to parse Qwen Code hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const hooks = qwencodeHooksToCanonical(settings.hooks);
-		const canonical = typeof settings.disableAllHooks === "boolean" ? {
-			version: 1,
-			hooks,
-			qwencode: { disableAllHooks: settings.disableAllHooks }
-		} : {
-			version: 1,
-			hooks
-		};
+		const canonical = buildImportedHooksConfig({
+			hooks: qwencodeHooksToCanonical(settings.hooks),
+			overrideKey: "qwencode",
+			...typeof settings.disableAllHooks === "boolean" && { extraOverride: { disableAllHooks: settings.disableAllHooks } }
+		});
 		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(canonical, null, 2) });
 	}
 	validate() {
@@ -10576,10 +11163,10 @@ var ReasonixHooks = class ReasonixHooks extends ToolHooks {
 			throw new Error(`Failed to parse Reasonix hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = reasonixHooksToCanonical(settings.hooks);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "reasonix"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -10802,10 +11389,10 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 			throw new Error(`Failed to parse Vibe hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = vibeHooksToCanonical(parsed);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "vibe"
+		}), null, 2) });
 	}
 	validate() {
 		try {
@@ -10892,7 +11479,13 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: CLAUDE_HOOK_EVENTS,
-		supportedHookTypes: ["command", "prompt"],
+		supportedHookTypes: [
+			"command",
+			"prompt",
+			"http",
+			"mcp_tool",
+			"agent"
+		],
 		supportsMatcher: true
 	}],
 	["codexcli", {
@@ -11084,7 +11677,12 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: QWENCODE_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
+		supportedHookTypes: [
+			"command",
+			"prompt",
+			"http",
+			"function"
+		],
 		supportsMatcher: true
 	}],
 	["reasonix", {
@@ -12386,16 +12984,6 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	}
 };
 //#endregion
-//#region src/constants/amp-paths.ts
-const AMP_DIR = ".amp";
-const AMP_GLOBAL_DIR = (0, node_path.join)(".config", "amp");
-const AMP_AGENTS_DIR = ".agents";
-const AMP_SKILLS_PROJECT_DIR = (0, node_path.join)(AMP_AGENTS_DIR, "skills");
-const AMP_SKILLS_GLOBAL_DIR = (0, node_path.join)(".config", "agents", "skills");
-const AMP_RULE_FILE_NAME = "AGENTS.md";
-const AMP_SETTINGS_FILE_NAME = "settings.json";
-const AMP_SETTINGS_JSONC_FILE_NAME = "settings.jsonc";
-//#endregion
 //#region src/types/mcp.ts
 const EnvVarNameSchema = zod_mini.z.string().check((0, zod_mini.refine)((value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), "envVars entries must be valid environment variable names"));
 const McpServerSchema = zod_mini.z.looseObject({
@@ -13487,10 +14075,19 @@ function mapOauthFromCodex(oauth) {
 }
 const CODEX_MCP_SERVER_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 function normalizeCodexMcpServerName(name) {
-	if (PROTOTYPE_POLLUTION_KEYS.has(name)) return null;
-	if (CODEX_MCP_SERVER_NAME_PATTERN.test(name)) return name;
+	if (!PROTOTYPE_POLLUTION_KEYS.has(name) && CODEX_MCP_SERVER_NAME_PATTERN.test(name)) return {
+		codexName: name,
+		usedFallback: false
+	};
 	const normalizedName = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-	return normalizedName && !PROTOTYPE_POLLUTION_KEYS.has(normalizedName) ? normalizedName : null;
+	if (normalizedName && !PROTOTYPE_POLLUTION_KEYS.has(normalizedName)) return {
+		codexName: normalizedName,
+		usedFallback: false
+	};
+	return {
+		codexName: `mcp_${(0, node_crypto.createHash)("sha256").update(name).digest("hex").slice(0, 8)}`,
+		usedFallback: true
+	};
 }
 function convertFromCodexFormat(codexMcp) {
 	const result = {};
@@ -13504,7 +14101,7 @@ function convertFromCodexFormat(codexMcp) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthFromCodex(value);
 			else if (Object.hasOwn(CODEX_TO_RULESYNC_FIELD_MAP, key)) {
 				const mappedKey = CODEX_TO_RULESYNC_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `Ignored malformed array for ${key} in MCP server ${name}`);
 			} else converted[key] = value;
 		}
@@ -13516,12 +14113,9 @@ function convertToCodexFormat(mcpServers) {
 	const result = {};
 	const originalNames = /* @__PURE__ */ new Map();
 	for (const [name, config] of Object.entries(mcpServers)) {
-		const codexName = normalizeCodexMcpServerName(name);
-		if (codexName === null) {
-			warnWithFallback(void 0, `MCP server "${name}" could not be normalized to a valid Codex MCP server name and was skipped.`);
-			continue;
-		}
 		if (!isRecord(config)) continue;
+		const { codexName, usedFallback } = normalizeCodexMcpServerName(name);
+		if (usedFallback) warnWithFallback(void 0, `MCP server "${name}" cannot be represented as a Codex MCP server name (ASCII [a-zA-Z0-9_-] only), so the stable fallback name "${codexName}" was used. Rename the server in .rulesync/mcp.json to choose a readable Codex name.`);
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -13530,12 +14124,12 @@ function convertToCodexFormat(mcpServers) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthToCodex(value);
 			else if (Object.hasOwn(RULESYNC_TO_CODEX_FIELD_MAP, key)) {
 				const mappedKey = RULESYNC_TO_CODEX_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string array, got ${typeof value}`);
 			} else converted[key] = value;
 		}
 		const previousName = originalNames.get(codexName);
-		if (previousName !== void 0) warnWithFallback(void 0, `Codex MCP server name collision: "${previousName}" and "${name}" both normalize to "${codexName}". Only the last processed server will be used.`);
+		if (previousName !== void 0) warnWithFallback(void 0, `Codex MCP server name collision: "${previousName}" and "${name}" both normalize to "${codexName}"; "${name}" (processed last) overwrites "${previousName}".`);
 		originalNames.set(codexName, name);
 		result[codexName] = converted;
 	}
@@ -13602,7 +14196,7 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			const rawServer = isRecord(rawMcpServers) ? rawMcpServers[serverName] : void 0;
 			return [serverName, {
 				...serverConfig,
-				...isRecord(rawServer) && isStringArray(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
+				...isRecord(rawServer) && isStringArray$1(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
 			}];
 		})));
 		const filteredMcpServers = this.removeEmptyEntries(converted);
@@ -14339,11 +14933,11 @@ function applyGooseStdioFields(ext, config) {
 	if (Array.isArray(command)) {
 		if (typeof command[0] === "string") ext.cmd = command[0];
 		const rest = command.slice(1).filter((c) => typeof c === "string");
-		const args = isStringArray(config.args) ? config.args : [];
+		const args = isStringArray$1(config.args) ? config.args : [];
 		if (rest.length > 0 || args.length > 0) ext.args = [...rest, ...args];
 	} else if (typeof command === "string") {
 		ext.cmd = command;
-		if (isStringArray(config.args)) ext.args = config.args;
+		if (isStringArray$1(config.args)) ext.args = config.args;
 	}
 	if (isPlainObject$1(config.env)) ext.envs = omitPrototypePollutionKeys(config.env);
 }
@@ -14401,7 +14995,7 @@ function convertFromGooseFormat(extensions) {
 		else if (type === "streamable_http") server.type = "http";
 		else if (type === "stdio") server.type = "stdio";
 		if (typeof ext.cmd === "string") server.command = ext.cmd;
-		if (isStringArray(ext.args)) server.args = ext.args;
+		if (isStringArray$1(ext.args)) server.args = ext.args;
 		if (isPlainObject$1(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
 		if (typeof ext.uri === "string") server.url = ext.uri;
 		if (isPlainObject$1(ext.headers)) server.headers = omitPrototypePollutionKeys(ext.headers);
@@ -14421,11 +15015,11 @@ function buildGoosePluginStdioServer(config) {
 	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 : [];
+		const args = isStringArray$1(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 (isStringArray$1(config.args)) server.args = config.args;
 	}
 	if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 	if (typeof config.cwd === "string") server.cwd = config.cwd;
@@ -14738,7 +15332,7 @@ function resolveHermesTimeout(config) {
 */
 function copyHermesAdvancedFields(source, target) {
 	if (typeof source.auth === "string") target.auth = source.auth;
-	if (typeof source.client_cert === "string" || isStringArray(source.client_cert)) target.client_cert = source.client_cert;
+	if (typeof source.client_cert === "string" || isStringArray$1(source.client_cert)) target.client_cert = source.client_cert;
 	if (typeof source.client_key === "string") target.client_key = source.client_key;
 	if (typeof source.connect_timeout === "number") target.connect_timeout = source.connect_timeout;
 	if (typeof source.supports_parallel_tool_calls === "boolean") target.supports_parallel_tool_calls = source.supports_parallel_tool_calls;
@@ -14757,8 +15351,8 @@ function copyHermesAdvancedFields(source, target) {
 */
 function buildHermesToolsBlock(config) {
 	const tools = {};
-	if (isStringArray(config.enabledTools)) tools.include = config.enabledTools;
-	if (isStringArray(config.disabledTools)) tools.exclude = config.disabledTools;
+	if (isStringArray$1(config.enabledTools)) tools.include = config.enabledTools;
+	if (isStringArray$1(config.disabledTools)) tools.exclude = config.disabledTools;
 	if (typeof config.promptsEnabled === "boolean") tools.prompts = config.promptsEnabled;
 	if (typeof config.resourcesEnabled === "boolean") tools.resources = config.resourcesEnabled;
 	return tools;
@@ -14770,8 +15364,8 @@ function buildHermesToolsBlock(config) {
 * `promptsEnabled`/`resourcesEnabled` top-level toggles.
 */
 function applyHermesToolsBlock(hermesTools, server) {
-	if (isStringArray(hermesTools.include)) server.enabledTools = hermesTools.include;
-	if (isStringArray(hermesTools.exclude)) server.disabledTools = hermesTools.exclude;
+	if (isStringArray$1(hermesTools.include)) server.enabledTools = hermesTools.include;
+	if (isStringArray$1(hermesTools.exclude)) server.disabledTools = hermesTools.exclude;
 	if (typeof hermesTools.prompts === "boolean") server.promptsEnabled = hermesTools.prompts;
 	if (typeof hermesTools.resources === "boolean") server.resourcesEnabled = hermesTools.resources;
 }
@@ -14795,11 +15389,11 @@ function convertServerToHermes(config) {
 		if (Array.isArray(command)) {
 			if (typeof command[0] === "string") out.command = command[0];
 			const rest = command.slice(1).filter((c) => typeof c === "string");
-			const args = isStringArray(config.args) ? config.args : [];
+			const args = isStringArray$1(config.args) ? config.args : [];
 			if (rest.length > 0 || args.length > 0) out.args = [...rest, ...args];
 		} else if (typeof command === "string") {
 			out.command = command;
-			if (isStringArray(config.args)) out.args = config.args;
+			if (isStringArray$1(config.args)) out.args = config.args;
 		}
 		if (isPlainObject$1(config.env)) out.env = omitPrototypePollutionKeys(config.env);
 	} else if (url !== void 0) {
@@ -14847,7 +15441,7 @@ function convertFromHermesFormat(mcpServers) {
 		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;
+		if (isStringArray$1(config.args)) server.args = config.args;
 		if (isPlainObject$1(config.env)) server.env = omitPrototypePollutionKeys(config.env);
 		if (typeof config.url === "string") server.url = config.url;
 		if (isPlainObject$1(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
@@ -17172,7 +17766,11 @@ const VibePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 */
 const CursorPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	approvalMode: zod_mini.z.optional(zod_mini.z.string()),
+	approvalMode: zod_mini.z.optional(zod_mini.z.enum([
+		"allowlist",
+		"auto-review",
+		"unrestricted"
+	])),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
@@ -17260,7 +17858,11 @@ const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
 */
 const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	agent_mode_coding_permissions: zod_mini.z.optional(zod_mini.z.string()),
+	agent_mode_coding_permissions: zod_mini.z.optional(zod_mini.z.enum([
+		"always_ask_before_reading",
+		"always_allow_reading",
+		"allow_reading_specific_files"
+	])),
 	agent_mode_coding_file_read_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	agent_mode_execute_readonly_commands: zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -17306,7 +17908,11 @@ const JuniePermissionsOverrideSchema = zod_mini.z.looseObject({
 */
 const TaktPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	step_permission_overrides: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
+	step_permission_overrides: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.enum([
+		"readonly",
+		"edit",
+		"full"
+	]))),
 	provider_options: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
@@ -17336,9 +17942,15 @@ const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	permissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
 		tool: zod_mini.z.string(),
-		action: zod_mini.z.string()
+		action: zod_mini.z.enum([
+			"allow",
+			"ask",
+			"reject",
+			"delegate"
+		]),
+		context: zod_mini.z.optional(zod_mini.z.enum(["thread", "subagent"]))
 	}))),
-	mcpPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({}))),
+	mcpPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({ action: zod_mini.z.enum(["allow", "reject"]) }))),
 	guardedFiles: zod_mini.z.optional(zod_mini.z.looseObject({ allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) })),
 	dangerouslyAllowAll: zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -17363,7 +17975,12 @@ const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
 */
 const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	toolPermission: zod_mini.z.optional(zod_mini.z.string()),
+	toolPermission: zod_mini.z.optional(zod_mini.z.enum([
+		"request-review",
+		"proceed-in-sandbox",
+		"always-proceed",
+		"strict"
+	])),
 	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
@@ -17392,7 +18009,14 @@ const AugmentcodePermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	toolPermissions: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
 		toolName: zod_mini.z.string(),
-		permission: zod_mini.z.looseObject({ type: zod_mini.z.string() })
+		eventType: zod_mini.z.optional(zod_mini.z.enum(["tool-call", "tool-response"])),
+		permission: zod_mini.z.looseObject({ type: zod_mini.z.enum([
+			"allow",
+			"deny",
+			"ask-user",
+			"webhook-policy",
+			"script-policy"
+		]) })
 	})))
 });
 /**
@@ -17482,12 +18106,20 @@ const CodexApprovalsReviewerSchema = zod_mini.z.enum([
 * `[permissions.rulesync]` profile may extend. Codex ships three built-in
 * profiles (`:read-only`, `:workspace`, `:danger-full-access`; the leading
 * colon is reserved for built-ins), but `extends` rejects
-* `:danger-full-access` at config load time, so only the two extendable
-* baselines are accepted here. The value list is exported so the Codex CLI
-* translator derives its import-side baseline check from the same source.
+* `:danger-full-access` at config load time, so only these two are valid
+* `extends` parents. The value list is exported so the Codex CLI translator
+* derives its import-side baseline check from the same source.
 * @see https://learn.chatgpt.com/docs/permissions
 */
-const CODEX_BASE_PERMISSION_PROFILES = [":read-only", ":workspace"];
+const CODEX_EXTENDABLE_BASELINE_PROFILES = [":read-only", ":workspace"];
+/**
+* All accepted `codexcli.base_permission_profile` values. `:danger-full-access`
+* cannot be an `extends` parent, so selecting it makes rulesync emit
+* `default_permissions = ":danger-full-access"` directly and skip the managed
+* `[permissions.rulesync]` profile entirely (there is no sandbox for
+* filesystem/network rules to refine in that mode).
+*/
+const CODEX_BASE_PERMISSION_PROFILES = [...CODEX_EXTENDABLE_BASELINE_PROFILES, ":danger-full-access"];
 const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_PROFILES);
 /**
 * Codex CLI-scoped permission override.
@@ -17498,10 +18130,14 @@ const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_P
 * override whose fields are written verbatim as top-level `.codex/config.toml`
 * keys (the override wins per key; existing sibling keys the user set directly
 * are preserved):
-* - `base_permission_profile` — the built-in profile the managed
-*   `[permissions.rulesync]` profile extends (`:read-only` | `:workspace`).
-*   Unlike the other keys it is not a top-level config key: it is emitted as
-*   the profile's `extends` value. Defaults to `:workspace` when unspecified.
+* - `base_permission_profile` — the built-in baseline profile (`:read-only` |
+*   `:workspace` | `:danger-full-access`). Unlike the other keys it is not a
+*   top-level config key: the extendable baselines are emitted as the managed
+*   `[permissions.rulesync]` profile's `extends` value, while
+*   `:danger-full-access` (which Codex rejects as an `extends` parent) is
+*   selected directly via `default_permissions` and skips the managed profile
+*   entirely — canonical filesystem/network rules are ignored in that mode.
+*   Defaults to `:workspace` when unspecified.
 * - `approval_policy` — `untrusted` | `on-request` (legacy alias `on-failure`) |
 *   `never`, or a `{ granular = { … } }` table (kept verbatim; the granular
 *   schema has required fields that are brittle to model as typed keys).
@@ -17521,6 +18157,15 @@ const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_P
 *   | `guardian_subagent`), or a table for the richer reviewer config.
 *   Defaults to `auto_review` when neither the override nor the existing
 *   config sets it.
+* - `git_write_rules` — whether the managed profile's `:workspace_roots` table
+*   emits the default `.git` carve-out (`".git/**" = "write"`). Codex's
+*   `:workspace` baseline makes `.git` read-only, which denies basic git
+*   workflows (commit/stage writes to `.git/index`, `.git/objects`, refs,
+*   logs; everyday commands like `git remote add` or `git push -u` write to
+*   `.git/config`), so the carve-out is emitted by default. Defaults to
+*   `true`; only an explicit `false` suppresses it. Like
+*   `base_permission_profile` it is consumed by the profile builder, not
+*   written as a top-level config key.
 *
 * Two surfaces are deliberately NOT authorable here so the override can never
 * clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
@@ -17546,7 +18191,8 @@ const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
 	/** @deprecated Superseded by `base_permission_profile` (permission profiles). */
 	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})]))
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})])),
+	git_write_rules: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * Permissions configuration.
@@ -19515,11 +20161,14 @@ var ClinePermissions = class ClinePermissions extends ToolPermissions {
 const RULESYNC_PROFILE_NAME = "rulesync";
 const CODEX_WORKSPACE_ROOTS_KEY = ":workspace_roots";
 const CODEX_WORKSPACE_BASELINE = ":workspace";
-const CODEX_EXTENDABLE_BASELINES = new Set(CODEX_BASE_PERMISSION_PROFILES);
+const CODEX_READ_ONLY_BASELINE = ":read-only";
+const CODEX_DANGER_FULL_ACCESS_BASELINE = ":danger-full-access";
+const CODEX_EXTENDABLE_BASELINES = new Set(CODEX_EXTENDABLE_BASELINE_PROFILES);
 const CODEX_DEFAULT_APPROVAL_POLICY = "on-request";
 const CODEX_DEFAULT_APPROVALS_REVIEWER = "auto_review";
 const CODEX_GLOB_SCAN_MAX_DEPTH = 8;
 const CODEX_MINIMAL_KEY = ":minimal";
+const CODEX_GIT_WRITE_RULES = { ".git/**": "write" };
 const GLOBAL_WILDCARD_DOMAIN = "*";
 var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
@@ -19547,8 +20196,40 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		const existing = toMutableTable(smol_toml.parse(existingContent || smol_toml.stringify({})));
+		const canonicalConfig = rulesyncPermissions.getJson();
+		if (canonicalConfig.codexcli?.base_permission_profile === CODEX_DANGER_FULL_ACCESS_BASELINE) {
+			const ignoredCategories = Object.entries(canonicalConfig.permission).filter(([category, rules]) => category !== "bash" && Object.keys(rules).length > 0).map(([category]) => category);
+			if (ignoredCategories.length > 0) logger?.warn(`Codex CLI baseline ":danger-full-access" removes the sandbox, so canonical ${ignoredCategories.join("/")} rules are not representable and are ignored for Codex CLI.`);
+			const permissionsTable = toMutableTable(existing.permissions);
+			if (permissionsTable[RULESYNC_PROFILE_NAME] !== void 0) {
+				logger?.warn(`Codex CLI baseline ":danger-full-access" prunes the managed "[permissions.${RULESYNC_PROFILE_NAME}]" profile; any hand-written keys inside it (e.g. network settings) are removed. Move them to a sibling profile or re-add them after switching baselines.`);
+				delete permissionsTable[RULESYNC_PROFILE_NAME];
+			}
+			const overridePatch = computeCodexcliOverridePatch({
+				existing,
+				override: canonicalConfig.codexcli,
+				logger
+			});
+			return new CodexcliPermissions({
+				outputRoot,
+				relativeDirPath: paths.relativeDirPath,
+				relativeFilePath: paths.relativeFilePath,
+				fileContent: applySharedConfigPatch({
+					fileKey: sharedConfigFileKey(paths),
+					feature: "permissions",
+					existingContent,
+					patch: {
+						permissions: Object.keys(permissionsTable).length > 0 ? permissionsTable : void 0,
+						default_permissions: CODEX_DANGER_FULL_ACCESS_BASELINE,
+						...overridePatch
+					},
+					filePath
+				}),
+				validate
+			});
+		}
 		const newProfile = convertRulesyncToCodexProfile({
-			config: rulesyncPermissions.getJson(),
+			config: canonicalConfig,
 			logger
 		});
 		const permissionsTable = toMutableTable(existing.permissions);
@@ -19609,6 +20290,7 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 		});
 		const override = extractCodexcliOverride(table);
 		if (typeof profile?.extends === "string" && CODEX_EXTENDABLE_BASELINES.has(profile.extends)) override.base_permission_profile = profile.extends;
+		if (defaultProfile === CODEX_DANGER_FULL_ACCESS_BASELINE) override.base_permission_profile = CODEX_DANGER_FULL_ACCESS_BASELINE;
 		const result = Object.keys(override).length > 0 ? {
 			...config,
 			codexcli: override
@@ -19664,16 +20346,10 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 	const filesystem = { [CODEX_MINIMAL_KEY]: "read" };
 	const workspaceRootFilesystem = {};
 	const domains = {};
+	const filesystemCategoryRules = {};
 	for (const [toolName, rules] of Object.entries(config.permission)) {
 		if (toolName === "read" || toolName === "edit" || toolName === "write") {
-			const mapAction = toolName === "read" ? mapReadAction : mapWriteAction;
-			for (const [pattern, action] of Object.entries(rules)) addFilesystemRule({
-				filesystem,
-				workspaceRootFilesystem,
-				pattern,
-				access: mapAction(action),
-				logger
-			});
+			filesystemCategoryRules[toolName] = rules;
 			continue;
 		}
 		if (toolName === "webfetch") {
@@ -19686,6 +20362,21 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 		}
 		logger?.warn(`Codex CLI permissions support only read/edit/write/webfetch categories. Skipping: ${toolName}`);
 	}
+	for (const [pattern, access] of mergeFilesystemCategoryRules({
+		categoryRules: filesystemCategoryRules,
+		logger
+	})) addFilesystemRule({
+		filesystem,
+		workspaceRootFilesystem,
+		pattern,
+		access,
+		logger
+	});
+	applyDefaultGitWriteRules({
+		config,
+		filesystem,
+		workspaceRootFilesystem
+	});
 	if (Object.keys(workspaceRootFilesystem).length > 0) {
 		if (typeof filesystem[CODEX_WORKSPACE_ROOTS_KEY] === "string") logger?.warn(`"${CODEX_WORKSPACE_ROOTS_KEY}" is set as a direct filesystem access rule in the permissions, but it will be overwritten by workspace-root rules. Consider removing the direct "${CODEX_WORKSPACE_ROOTS_KEY}" entry.`);
 		if (Object.keys(workspaceRootFilesystem).some((pattern) => pattern.includes("**"))) filesystem.glob_scan_max_depth = CODEX_GLOB_SCAN_MAX_DEPTH;
@@ -19703,6 +20394,12 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 		...network ? { network } : {}
 	};
 }
+function applyDefaultGitWriteRules({ config, filesystem, workspaceRootFilesystem }) {
+	if (config.codexcli?.git_write_rules === false) return;
+	if (config.codexcli?.base_permission_profile === CODEX_READ_ONLY_BASELINE) return;
+	if (typeof filesystem[CODEX_WORKSPACE_ROOTS_KEY] === "string") return;
+	for (const [pattern, access] of Object.entries(CODEX_GIT_WRITE_RULES)) workspaceRootFilesystem[pattern] ??= access;
+}
 function convertCodexProfileToRulesync({ profile, domainsHadUnknown }) {
 	const permission = {};
 	if (profile?.filesystem) {
@@ -19714,7 +20411,10 @@ function convertCodexProfileToRulesync({ profile, domainsHadUnknown }) {
 				addRulesyncFilesystemRule(permission, pattern, access);
 				continue;
 			}
-			if (isCodexFilesystemRuleTable(access)) for (const [nestedPattern, nestedAccess] of Object.entries(access)) addRulesyncFilesystemRule(permission, nestedPattern, nestedAccess);
+			if (isCodexFilesystemRuleTable(access)) for (const [nestedPattern, nestedAccess] of Object.entries(access)) {
+				if (pattern === CODEX_WORKSPACE_ROOTS_KEY && CODEX_GIT_WRITE_RULES[nestedPattern] === nestedAccess) continue;
+				addRulesyncFilesystemRule(permission, nestedPattern, nestedAccess);
+			}
 		}
 	}
 	if (profile?.network && profile.network.enabled !== false) {
@@ -19756,9 +20456,28 @@ function toCodexProfile(value) {
 }
 function warnAboutPreservedProfileState({ existingProfile, newProfile, existingDomainsHadUnknown, logger }) {
 	if (existingProfile !== void 0 && existingProfile.extends !== newProfile.extends) logger?.warn(`Existing "extends" value "${existingProfile.extends ?? "(none)"}" will be replaced by Rulesync-managed "${newProfile.extends ?? "(none)"}".`);
+	warnAboutPreservedNetworkState({
+		existingProfile,
+		newProfile,
+		logger
+	});
+	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
+}
+function networkHasAllowDomain(network) {
+	return Object.values(network?.domains ?? {}).some((action) => action === "allow");
+}
+function warnAboutNetworkEnabledState({ existingProfile, newProfile, logger }) {
+	if (existingProfile?.network?.enabled !== void 0 && newProfile.network?.enabled === void 0 && !networkHasAllowDomain(existingProfile.network)) logger?.warn(`Preserving existing "network.enabled" from config. Review this value manually as it may enable network access beyond the Rulesync-managed domain rules.`);
+	if (existingProfile?.network?.enabled === false && newProfile.network?.enabled === true) logger?.warn(`Existing "network.enabled = false" will be replaced by Rulesync-managed "enabled = true" because the canonical model contains an allow domain.`);
+}
+function warnAboutPreservedNetworkState({ existingProfile, newProfile, logger }) {
 	if (existingProfile?.network?.unix_sockets !== void 0) logger?.warn(`Preserving existing "network.unix_sockets" from config. Review these entries manually as they may grant broad system access.`);
+	warnAboutNetworkEnabledState({
+		existingProfile,
+		newProfile,
+		logger
+	});
 	if (existingProfile?.network?.mode !== void 0) logger?.warn(`Preserving existing "network.mode" from config. Review this value manually as it may grant broader network access than the Rulesync-managed domain rules.`);
-	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
 }
 const MANAGED_PROFILE_KEYS = /* @__PURE__ */ new Set([
 	"description",
@@ -19800,6 +20519,7 @@ function preserveUnmanagedProfileKeys({ rawExistingProfile, profile, logger }) {
 function mergeWithExistingProfile({ newProfile, existingProfile }) {
 	if (!existingProfile) return newProfile;
 	const mergedNetwork = { ...newProfile.network };
+	if (existingProfile.network?.enabled !== void 0 && mergedNetwork.enabled === void 0 && !networkHasAllowDomain(existingProfile.network)) mergedNetwork.enabled = existingProfile.network.enabled;
 	if (existingProfile.network?.mode !== void 0 && mergedNetwork.mode === void 0) mergedNetwork.mode = existingProfile.network.mode;
 	if (existingProfile.network?.unix_sockets !== void 0 && mergedNetwork.unix_sockets === void 0) mergedNetwork.unix_sockets = existingProfile.network.unix_sockets;
 	const hasNetwork = Object.keys(mergedNetwork).length > 0;
@@ -19851,7 +20571,7 @@ function computeCodexcliOverridePatch({ existing, override, logger }) {
 	const patch = {};
 	const allowed = new Set(CODEXCLI_OVERRIDE_KEYS);
 	for (const [key, value] of Object.entries(override ?? {})) {
-		if (key === "base_permission_profile") continue;
+		if (key === "base_permission_profile" || key === "git_write_rules") continue;
 		if (!allowed.has(key)) {
 			logger?.warn(`Codex CLI permission override key "${key}" is not managed and was skipped. "permissions"/"default_permissions" are owned by the canonical permission model and "mcp_servers" gating by the MCP feature.`);
 			continue;
@@ -19932,6 +20652,67 @@ function mapReadAction(action) {
 function mapWriteAction(action) {
 	return action === "allow" ? "write" : "deny";
 }
+/**
+* Merge the canonical read/edit/write category rules into one Codex access
+* level per path pattern (Codex models a single `deny` < `read` < `write`
+* level, with no `ask`).
+*
+* - `edit` and `write` collapse onto Codex's write side; when both carry the
+*   same pattern, the more restrictive action wins (`deny` > `ask` > `allow`).
+* - `read: allow` + write-side `allow` → `"write"`.
+* - `read: allow` + write-side non-allow → `"read"` (readable but not
+*   writable — exactly what Codex's `"read"` level expresses).
+* - `read` non-allow → `"deny"` regardless of the write side; a contradictory
+*   write-side `allow` (unreadable but writable is not expressible in Codex)
+*   is warned about.
+* - Single-category patterns keep the existing mapReadAction/mapWriteAction
+*   mappings.
+*
+* Iteration order is read → edit → write with first-seen pattern order, so
+* the emitted table is stable regardless of the authored category order.
+* Note the merge is one-way: `"{path}" = "read"` imports back as
+* `read: allow` only (the explicit write-side deny is implied by Codex's
+* access level and not re-materialized).
+*/
+function mergeFilesystemCategoryRules({ categoryRules, logger }) {
+	const readRules = categoryRules.read ?? {};
+	const writeSideRestrictiveness = {
+		deny: 2,
+		ask: 1,
+		allow: 0
+	};
+	const writeSideRules = {};
+	for (const category of ["edit", "write"]) for (const [pattern, action] of Object.entries(categoryRules[category] ?? {})) {
+		const existing = writeSideRules[pattern];
+		if (existing === void 0 || writeSideRestrictiveness[action] > writeSideRestrictiveness[existing]) writeSideRules[pattern] = action;
+	}
+	const patterns = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const pattern of [...Object.keys(readRules), ...Object.keys(writeSideRules)]) if (!seen.has(pattern)) {
+		seen.add(pattern);
+		patterns.push(pattern);
+	}
+	const merged = [];
+	for (const pattern of patterns) {
+		const readAction = readRules[pattern];
+		const writeAction = writeSideRules[pattern];
+		if (readAction === void 0) {
+			merged.push([pattern, mapWriteAction(writeAction)]);
+			continue;
+		}
+		if (writeAction === void 0) {
+			merged.push([pattern, mapReadAction(readAction)]);
+			continue;
+		}
+		if (readAction === "allow") {
+			merged.push([pattern, writeAction === "allow" ? "write" : "read"]);
+			continue;
+		}
+		if (writeAction === "allow") logger?.warn(`Codex CLI cannot express "writable but not readable": pattern "${pattern}" has read: ${readAction} and a write-side allow. Emitting "deny".`);
+		merged.push([pattern, "deny"]);
+	}
+	return merged;
+}
 function buildCodexBashRulesContent(config) {
 	const bashRules = config.permission.bash ?? {};
 	const entries = Object.entries(bashRules);
@@ -20883,7 +21664,7 @@ function convertRulesyncToGoosePermissionConfig({ config, logger }) {
 function convertGoosePermissionConfigToRulesync(userPermission) {
 	const permission = {};
 	for (const key of GOOSE_PERMISSION_LIST_KEYS) {
-		const toolNames = isStringArray(userPermission[key]) ? userPermission[key] : [];
+		const toolNames = isStringArray$1(userPermission[key]) ? userPermission[key] : [];
 		const action = GOOSE_LIST_TO_ACTION[key];
 		for (const toolName of toolNames) {
 			const category = GOOSE_TO_RULESYNC_TOOL_NAME[toolName] ?? toolName;
@@ -21123,7 +21904,7 @@ const ACTION_RANK = {
 * (mirrors the Cursor adapter's preservation of unmanaged types).
 */
 function unmanagedEntries(existingPermission, key) {
-	return (isStringArray(existingPermission[key]) ? existingPermission[key] : []).filter((entry) => parseGrokEntry(entry) === null);
+	return (isStringArray$1(existingPermission[key]) ? existingPermission[key] : []).filter((entry) => parseGrokEntry(entry) === null);
 }
 /**
 * Bucket canonical rules into Grok's `[permission]` allow/deny/ask arrays of
@@ -21164,9 +21945,9 @@ function buildGrokPermissionArrays(config, existingPermission, logger) {
 * arrays resolves to the strictest action.
 */
 function parseGrokPermissionArrays(permission) {
-	const allow = isStringArray(permission.allow) ? permission.allow : void 0;
-	const deny = isStringArray(permission.deny) ? permission.deny : void 0;
-	const ask = isStringArray(permission.ask) ? permission.ask : void 0;
+	const allow = isStringArray$1(permission.allow) ? permission.allow : void 0;
+	const deny = isStringArray$1(permission.deny) ? permission.deny : void 0;
+	const ask = isStringArray$1(permission.ask) ? permission.ask : void 0;
 	if ((allow?.length ?? 0) + (deny?.length ?? 0) + (ask?.length ?? 0) === 0) return null;
 	const result = {};
 	const apply = (entries, action) => {
@@ -22947,7 +23728,7 @@ function convertRovodevToolPermissionsToRulesync(toolPermissions) {
 			permission[category][CATCH_ALL_PATTERN$1] = value;
 		}
 	}
-	if (isStringArray(toolPermissions.allowedExternalPaths)) for (const path of toolPermissions.allowedExternalPaths) {
+	if (isStringArray$1(toolPermissions.allowedExternalPaths)) for (const path of toolPermissions.allowedExternalPaths) {
 		permission.read ??= {};
 		permission.read[path] = "allow";
 	}
@@ -23507,8 +24288,8 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		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] : []
+			allow: isStringArray$1(profiles[ALLOWLIST_KEY]) ? profiles[ALLOWLIST_KEY] : [],
+			deny: isStringArray$1(profiles[DENYLIST_KEY]) ? profiles[DENYLIST_KEY] : []
 		});
 		const warpOverride = {};
 		for (const key of WARP_OVERRIDE_KEYS) if (profiles[key] !== void 0) warpOverride[key] = profiles[key];
@@ -24088,9 +24869,6 @@ var PermissionsProcessor = class extends FeatureProcessor {
 	}
 };
 //#endregion
-//#region src/constants/general.ts
-const SKILL_FILE_NAME = "SKILL.md";
-//#endregion
 //#region src/types/ai-dir.ts
 var AiDir = class {
 	/**
@@ -24291,10 +25069,10 @@ var ToolSkill = class extends AiDir {
 		const settablePaths = getSettablePaths({ global });
 		const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
 		const skillDirPath = (0, node_path.join)(outputRoot, actualRelativeDirPath, dirName);
-		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1);
+		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME$1} not found in ${skillDirPath}`);
 		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
-		const otherFiles = await this.collectOtherFiles(outputRoot, actualRelativeDirPath, dirName, SKILL_FILE_NAME);
+		const otherFiles = await this.collectOtherFiles(outputRoot, actualRelativeDirPath, dirName, SKILL_FILE_NAME$1);
 		return {
 			outputRoot,
 			relativeDirPath: actualRelativeDirPath,
@@ -24336,7 +25114,7 @@ var SimulatedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24394,12 +25172,12 @@ var SimulatedSkill = class extends ToolSkill {
 		const settablePaths = this.getSettablePaths();
 		const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
 		const skillDirPath = (0, node_path.join)(outputRoot, actualRelativeDirPath, dirName);
-		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1);
+		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME$1} not found in ${skillDirPath}`);
 		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
 		const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
-		const otherFiles = await this.collectOtherFiles(outputRoot, actualRelativeDirPath, dirName, SKILL_FILE_NAME);
+		const otherFiles = await this.collectOtherFiles(outputRoot, actualRelativeDirPath, dirName, SKILL_FILE_NAME$1);
 		return {
 			outputRoot,
 			relativeDirPath: actualRelativeDirPath,
@@ -24609,7 +25387,7 @@ var RulesyncSkill = class RulesyncSkill extends AiDir {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24644,13 +25422,13 @@ var RulesyncSkill = class RulesyncSkill extends AiDir {
 	}
 	static async fromDir({ outputRoot = process.cwd(), relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName, global = false }) {
 		const skillDirPath = (0, node_path.join)(outputRoot, relativeDirPath, dirName);
-		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = (0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1);
+		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME$1} not found in ${skillDirPath}`);
 		const { frontmatter, body: content, hasFrontmatter } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
 		if (!hasFrontmatter) throw new Error(`Missing frontmatter in ${skillFilePath}. Rulesync files must begin with a YAML frontmatter block delimited by '---'.`);
 		const result = RulesyncSkillFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
-		const otherFiles = await this.collectOtherFiles(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME);
+		const otherFiles = await this.collectOtherFiles(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME$1);
 		return new RulesyncSkill({
 			outputRoot,
 			relativeDirPath,
@@ -24690,7 +25468,7 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24717,7 +25495,7 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = RovodevSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -24793,10 +25571,10 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 		const result = RovodevSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME$1);
 			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
 		}
 		return new RovodevSkill({
@@ -24961,7 +25739,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24985,7 +25763,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = AgentsSkillsSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25057,7 +25835,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 		const result = AgentsSkillsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new this({
 			outputRoot: loaded.outputRoot,
@@ -25114,7 +25892,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25139,7 +25917,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = AiassistantSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25199,7 +25977,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 		const result = AiassistantSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AiassistantSkill({
 			outputRoot: loaded.outputRoot,
@@ -25250,7 +26028,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25274,7 +26052,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = AmpSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25334,7 +26112,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 		const result = AmpSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AmpSkill({
 			outputRoot: loaded.outputRoot,
@@ -25390,7 +26168,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25423,7 +26201,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = AntigravitySkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25483,7 +26261,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 		const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new this({
 			outputRoot: loaded.outputRoot,
@@ -25567,7 +26345,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25594,7 +26372,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = AugmentcodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25654,7 +26432,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 		const result = AugmentcodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AugmentcodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -25795,7 +26573,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25822,7 +26600,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = ClaudecodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -25910,7 +26688,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 		const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ClaudecodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -25956,7 +26734,7 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25980,7 +26758,7 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = ClineSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26044,10 +26822,10 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 		const result = ClineSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME$1);
 			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
 		}
 		return new ClineSkill({
@@ -26161,7 +26939,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26185,7 +26963,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = CodexCliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26263,7 +27041,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 		const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CodexCliSkill({
 			outputRoot: loaded.outputRoot,
@@ -26315,7 +27093,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26340,7 +27118,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = CopilotSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26407,7 +27185,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CopilotSkill({
 			outputRoot: loaded.outputRoot,
@@ -26461,7 +27239,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26486,7 +27264,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = CopilotcliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26555,7 +27333,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		const result = CopilotcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CopilotcliSkill({
 			outputRoot: loaded.outputRoot,
@@ -26605,7 +27383,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26629,7 +27407,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = CursorSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26703,7 +27481,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 		const result = CursorSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CursorSkill({
 			outputRoot: loaded.outputRoot,
@@ -26750,7 +27528,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26774,7 +27552,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = DeepagentsSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26850,7 +27628,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 		const result = DeepagentsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new DeepagentsSkill({
 			outputRoot: loaded.outputRoot,
@@ -26901,7 +27679,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26926,7 +27704,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = DevinSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -26978,6 +27756,18 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 		const targets = rulesyncSkill.getFrontmatter().targets;
 		return targets.includes("*") || targets.includes("devin");
 	}
+	/**
+	* Commands are emitted into this same skills tree as `<slug>/SKILL.md`
+	* (see `DevinCommand`), so a directory matching a current rulesync command
+	* slug is owned by the commands feature: it must not be imported as a
+	* skill nor deleted as an orphan skill.
+	*/
+	static async isDirOwned({ dirName, inputRoot }) {
+		return !await rulesyncCommandSlugExists({
+			inputRoot,
+			dirName
+		});
+	}
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
@@ -26986,7 +27776,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 		const result = DevinSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new DevinSkill({
 			outputRoot: loaded.outputRoot,
@@ -27038,7 +27828,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27062,7 +27852,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = FactorydroidSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27137,7 +27927,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 		const result = FactorydroidSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new FactorydroidSkill({
 			outputRoot: loaded.outputRoot,
@@ -27184,7 +27974,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27209,7 +27999,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = GooseSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27269,7 +28059,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 		const result = GooseSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new GooseSkill({
 			outputRoot: loaded.outputRoot,
@@ -27322,7 +28112,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27346,7 +28136,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = GrokcliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27406,7 +28196,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 		const result = GrokcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new GrokcliSkill({
 			outputRoot: loaded.outputRoot,
@@ -27441,6 +28231,18 @@ var HermesagentSkill = class extends AgentsSkillsSkill {
 	static getSettablePaths() {
 		return { relativeDirPath: HERMESAGENT_SKILLS_DIR_PATH };
 	}
+	/**
+	* Commands are emitted into this same skills tree as `<slug>/SKILL.md`
+	* (see `HermesagentCommand`), so a directory matching a current rulesync
+	* command slug is owned by the commands feature: it must not be imported
+	* as a skill nor deleted as an orphan skill.
+	*/
+	static async isDirOwned({ dirName, inputRoot }) {
+		return !await rulesyncCommandSlugExists({
+			inputRoot,
+			dirName
+		});
+	}
 	constructor(params) {
 		super({
 			...params,
@@ -27465,7 +28267,7 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27489,7 +28291,7 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = JunieSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27553,10 +28355,10 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 		const result = JunieSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME$1);
 			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
 		}
 		return new JunieSkill({
@@ -27604,7 +28406,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27628,7 +28430,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = KiloSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27700,7 +28502,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 		const result = KiloSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new KiloSkill({
 			outputRoot: loaded.outputRoot,
@@ -27746,7 +28548,7 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27770,7 +28572,7 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = KiroSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -27834,10 +28636,10 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 		const result = KiroSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME$1);
 			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
 		}
 		return new KiroSkill({
@@ -27920,7 +28722,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27947,7 +28749,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = OpenCodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28026,7 +28828,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 		const result = OpenCodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new OpenCodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -28087,7 +28889,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 			relativeDirPath: resolvedDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28112,7 +28914,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = PiSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28187,7 +28989,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 		const result = PiSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new PiSkill({
 			outputRoot: loaded.outputRoot,
@@ -28240,7 +29042,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28264,7 +29066,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = QwencodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28344,7 +29146,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 		const result = QwencodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new QwencodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -28394,7 +29196,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28418,7 +29220,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = ReasonixSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28478,7 +29280,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 		const result = ReasonixSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ReasonixSkill({
 			outputRoot: loaded.outputRoot,
@@ -28491,6 +29293,24 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 			global: loaded.global
 		});
 	}
+	/**
+	* Whether the skill directory belongs to the skills feature.
+	*
+	* `.reasonix/skills/` is shared with the subagents feature: a directory whose
+	* SKILL.md declares `runAs: subagent` is a subagent profile, not a regular
+	* skill, so it must be neither imported as a skill nor deleted as an orphan
+	* skill. Directories without a readable/parsable SKILL.md keep the default
+	* skills-feature ownership, matching the previous behavior for such dirs.
+	*/
+	static async isDirOwned({ outputRoot, relativeDirPath, dirName }) {
+		const skillFilePath = (0, node_path.join)(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME$1);
+		try {
+			const { frontmatter } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
+			return frontmatter["runAs"] !== REASONIX_SUBAGENT_RUN_AS;
+		} catch {
+			return true;
+		}
+	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
 		return new ReasonixSkill({
 			outputRoot,
@@ -28533,7 +29353,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28557,7 +29377,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = ReplitSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28625,7 +29445,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 		const result = ReplitSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ReplitSkill({
 			outputRoot: loaded.outputRoot,
@@ -28672,7 +29492,7 @@ var RooSkill = class RooSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28696,7 +29516,7 @@ var RooSkill = class RooSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = RooSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -28760,10 +29580,10 @@ var RooSkill = class RooSkill extends ToolSkill {
 		const result = RooSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME$1);
 			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
 		}
 		return new RooSkill({
@@ -28980,7 +29800,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29007,7 +29827,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = VibeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -29071,7 +29891,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 		const result = VibeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new VibeSkill({
 			outputRoot: loaded.outputRoot,
@@ -29127,7 +29947,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29151,7 +29971,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 	validate() {
 		if (this.mainFile === void 0) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = WarpSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -29211,7 +30031,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 		const result = WarpSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new WarpSkill({
 			outputRoot: loaded.outputRoot,
@@ -29259,7 +30079,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29283,7 +30103,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 	validate() {
 		if (!this.mainFile) return {
 			success: false,
-			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME$1} file does not exist`)
 		};
 		const result = ZedSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
@@ -29352,7 +30172,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 		const result = ZedSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ZedSkill({
 			outputRoot: loaded.outputRoot,
@@ -29789,6 +30609,12 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			for (const dirPath of dirPaths) {
 				const dirName = (0, node_path.basename)(dirPath);
 				if (seenDirNames.has(dirName)) continue;
+				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: root,
+					dirName,
+					inputRoot: this.inputRoot
+				})) continue;
 				seenDirNames.add(dirName);
 				loadEntries.push({
 					root,
@@ -29815,6 +30641,12 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
 			for (const dirPath of dirPaths) {
 				const dirName = (0, node_path.basename)(dirPath);
+				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: root,
+					dirName,
+					inputRoot: this.inputRoot
+				})) continue;
 				const toolSkill = factory.class.forDeletion({
 					outputRoot: this.outputRoot,
 					relativeDirPath: root,
@@ -33114,6 +33946,188 @@ var OpenCodeSubagent = class OpenCodeSubagent extends OpenCodeStyleSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/reasonix-subagent.ts
+const ReasonixSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	invocation: zod_mini.z.optional(zod_mini.z.string()),
+	runAs: zod_mini.z.optional(zod_mini.z.string()),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	effort: zod_mini.z.optional(zod_mini.z.string()),
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	color: zod_mini.z.optional(zod_mini.z.string())
+});
+/**
+* Represents a DeepSeek-Reasonix subagent profile.
+*
+* Reasonix discovers subagents as directory-layout Skills (`<name>/SKILL.md`)
+* under `.reasonix/skills/` (project) and `~/.reasonix/skills/` (global); the
+* global scope is served by the processor supplying the home directory as
+* outputRoot, so the relative directory path is identical for both scopes. A
+* subagent is a Skill whose frontmatter declares `invocation: manual` and
+* `runAs: subagent`.
+*
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/SUBAGENT_PROFILES.md
+*/
+var ReasonixSubagent = class ReasonixSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = ReasonixSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: REASONIX_SUBAGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, invocation: _invocation, runAs: _runAs, ...restFields } = this.frontmatter;
+		const reasonixSection = { ...restFields };
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			name,
+			description,
+			...Object.keys(reasonixSection).length > 0 && { reasonix: reasonixSection }
+		};
+		return new RulesyncSubagent({
+			outputRoot: this.getOutputRoot(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: `${this.getSubagentName()}.md`,
+			validate: true
+		});
+	}
+	/**
+	* Derive the subagent name from this instance's relative file path.
+	*
+	* The tool-side layout is `<name>/SKILL.md`, so the name is the parent
+	* directory of the file. If the path is unexpectedly flat (e.g. a legacy
+	* `<name>.md`), fall back to the basename without extension.
+	*/
+	getSubagentName() {
+		const relativeFilePath = this.getRelativeFilePath();
+		const dir = (0, node_path.dirname)(relativeFilePath);
+		if (dir && dir !== ".") return (0, node_path.basename)(dir);
+		return (0, node_path.basename)(relativeFilePath, (0, node_path.extname)(relativeFilePath));
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const reasonixSection = this.filterToolSpecificSection(rulesyncFrontmatter.reasonix ?? {}, ["name", "description"]);
+		const rawReasonixFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...reasonixSection,
+			invocation: REASONIX_SUBAGENT_INVOCATION,
+			runAs: REASONIX_SUBAGENT_RUN_AS
+		};
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(rawReasonixFrontmatter);
+		if (!result.success) throw new Error(`Invalid reasonix subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
+		const reasonixFrontmatter = result.data;
+		const body = rulesyncSubagent.getBody();
+		const fileContent = stringifyFrontmatter(body, reasonixFrontmatter);
+		const paths = this.getSettablePaths({ global });
+		const subagentName = (0, node_path.basename)(rulesyncSubagent.getRelativeFilePath(), (0, node_path.extname)(rulesyncSubagent.getRelativeFilePath()));
+		return new ReasonixSubagent({
+			outputRoot,
+			frontmatter: reasonixFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: (0, node_path.join)(subagentName, SKILL_FILE_NAME$1),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "reasonix"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new ReasonixSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	/**
+	* Whether the SKILL.md at the given path is a subagent profile.
+	*
+	* `.reasonix/skills/` is shared with the skills feature: a regular skill and
+	* a subagent profile differ only by their frontmatter markers. Only files
+	* carrying `runAs: subagent` belong to this feature, so regular skills are
+	* neither imported as subagents nor deleted as orphans by the subagents
+	* feature. `runAs` alone is checked (not `invocation`) because it is the
+	* marker that switches the execution mode; generation always emits both.
+	* Unreadable or unparsable files are treated as not owned, erring on the
+	* side of leaving foreign files untouched.
+	*/
+	static async isFileOwned({ outputRoot, relativeDirPath, relativeFilePath }) {
+		const filePath = (0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath);
+		try {
+			const { frontmatter } = parseFrontmatter(await readFileContent(filePath), filePath);
+			return frontmatter["runAs"] === REASONIX_SUBAGENT_RUN_AS;
+		} catch {
+			return false;
+		}
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/roo-subagent.ts
 /**
 * Default tool groups assigned to a generated mode when the rulesync source
@@ -33748,6 +34762,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: (0, node_path.join)("*", "SKILL.md")
+		}
+	}],
 	["roo", {
 		class: RooSubagent,
 		meta: {
@@ -33900,8 +34922,17 @@ var SubagentsProcessor = class extends FeatureProcessor {
 			const baseDir = (0, node_path.join)(this.outputRoot, dirPath);
 			const subagentFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern));
 			const toRelativeFilePath = (path) => (0, node_path.relative)(baseDir, path);
+			let ownedFilePaths = subagentFilePaths;
+			if (factory.class.isFileOwned) {
+				const ownership = await Promise.all(subagentFilePaths.map((path) => factory.class.isFileOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: dirPath,
+					relativeFilePath: toRelativeFilePath(path)
+				})));
+				ownedFilePaths = subagentFilePaths.filter((_, index) => ownership[index]);
+			}
 			if (forDeletion) {
-				toolSubagents.push(...subagentFilePaths.map((path) => factory.class.forDeletion({
+				toolSubagents.push(...ownedFilePaths.map((path) => factory.class.forDeletion({
 					outputRoot: this.outputRoot,
 					relativeDirPath: dirPath,
 					relativeFilePath: toRelativeFilePath(path),
@@ -33909,7 +34940,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				})).filter((subagent) => subagent.isDeletable()));
 				continue;
 			}
-			const loaded = await Promise.all(subagentFilePaths.map((path) => factory.class.fromFile({
+			const loaded = await Promise.all(ownedFilePaths.map((path) => factory.class.fromFile({
 				outputRoot: this.outputRoot,
 				relativeDirPath: dirPath,
 				relativeFilePath: toRelativeFilePath(path),
@@ -34021,6 +35052,7 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 		name: zod_mini.z.optional(zod_mini.z.string()),
 		description: zod_mini.z.optional(zod_mini.z.string())
 	})),
+	pi: zod_mini.z.optional(zod_mini.z.looseObject({ systemPrompt: zod_mini.z.optional(zod_mini.z.enum(["append"])) })),
 	takt: zod_mini.z.optional(zod_mini.z.looseObject({
 		name: zod_mini.z.optional(zod_mini.z.string()),
 		extends: zod_mini.z.optional(zod_mini.z.string()),
@@ -34184,6 +35216,16 @@ var ToolRule = class extends ToolFile {
 	isRoot() {
 		return this.root;
 	}
+	/**
+	* Whether this rule must be left out of the root rule's reference/MCP
+	* instruction listings even though it is a non-root survivor. Used by files
+	* the tool loads through its own mechanism (e.g. Pi's `APPEND_SYSTEM.md`,
+	* which Pi appends to the system prompt itself — referencing it from
+	* `AGENTS.md` would double-load the content).
+	*/
+	isExcludedFromRootReferences() {
+		return false;
+	}
 	getDescription() {
 		return this.description;
 	}
@@ -36530,6 +37572,15 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 * is `undefined`). This mirrors the grokcli, warp, and deepagents targets.
 *
 * Goose uses plain markdown files (.goosehints) without frontmatter.
+*
+* Global scope emits only `~/.config/goose/.goosehints`. Goose v1.41.0 (PR
+* block/goose#9736) additionally loads the vendor-neutral
+* `~/.agents/AGENTS.md` alongside the config-dir hints, but rulesync
+* deliberately does not emit that shared path from the goose target: the
+* config-dir hints remain fully loaded (no capability loss), and the
+* cross-tool `~/.agents/AGENTS.md` is already written by targets that own it
+* (e.g. cline in global mode) — a second writer would need cross-target
+* shared-file coordination for zero gain (decision recorded in issue #2207).
 */
 var GooseRule = class GooseRule extends ToolRule {
 	static getSettablePaths({ global } = {}) {
@@ -36731,14 +37782,21 @@ var HermesagentRule = class HermesagentRule extends ToolRule {
 /**
 * Rule generator for JetBrains Junie AI coding agent
 *
-* Generates `.junie/AGENTS.md` files based on rulesync rule content. `.junie/AGENTS.md`
-* is the preferred guideline file in current Junie; the legacy `.junie/guidelines.md`
-* is still read by Junie and is accepted as an import fallback, but generation always
-* targets `.junie/AGENTS.md`. Junie uses plain markdown without frontmatter requirements.
-*
-* Global (user) scope writes a single `~/.junie/AGENTS.md` file. Junie merges these
-* user-scope guidelines with the project `.junie/AGENTS.md` (project takes priority on
-* conflicts); memory files (`.junie/memories/`) remain project-scoped only.
+* Generates `.junie/AGENTS.md` files based on rulesync rule content. Junie CLI
+* resolves project guidelines **first-match-wins**: `.junie/AGENTS.md` → root
+* `AGENTS.md` → legacy `.junie/guidelines.md` / `.junie/guidelines/`. Only the
+* first match is loaded, it documents no `@`-reference or file-inclusion
+* mechanism, and no `.junie/memories/` read path exists — so non-root rules
+* are folded into the single root `.junie/AGENTS.md` by the RulesProcessor
+* (`nonRoot` is `undefined`, mirroring the grokcli / warp / deepagents
+* targets; decision recorded in issue #2211). The legacy
+* `.junie/guidelines.md` is still accepted as an import fallback, but
+* generation always targets `.junie/AGENTS.md`. Junie uses plain markdown
+* without frontmatter requirements.
+*
+* Global (user) scope writes a single `~/.junie/AGENTS.md` file. Junie merges
+* these user-scope guidelines with the project guidelines (both are included
+* and marked clearly).
 *
 * @see https://junie.jetbrains.com/docs/junie-ide-plugin.html
 * @see https://junie.jetbrains.com/docs/guidelines-and-memory.html
@@ -36757,15 +37815,12 @@ var JunieRule = class JunieRule extends ToolRule {
 			alternativeRoots: [{
 				relativeDirPath: buildToolPath(JUNIE_DIR, ".", excludeToolDir),
 				relativeFilePath: JUNIE_LEGACY_RULE_FILE_NAME
-			}],
-			nonRoot: { relativeDirPath: buildToolPath(JUNIE_DIR, "memories", excludeToolDir) }
+			}]
 		};
 	}
 	/**
 	* Determines whether a given relative file path refers to a root guideline file.
 	* The preferred file is `AGENTS.md`; the legacy `guidelines.md` is still accepted.
-	* Memory files live under `.junie/memories/` and are passed in as bare filenames
-	* (e.g. `memo.md`), so a top-level `AGENTS.md`/`guidelines.md` is the root entry.
 	*/
 	static isRootRelativeFilePath(relativeFilePath) {
 		return relativeFilePath === "AGENTS.md" || relativeFilePath === "guidelines.md";
@@ -36784,10 +37839,7 @@ var JunieRule = class JunieRule extends ToolRule {
 				root: true
 			});
 		}
-		const isRoot = JunieRule.isRootRelativeFilePath(relativeFilePath);
-		const settablePaths = this.getSettablePaths();
-		if (!settablePaths.nonRoot) throw new Error("JunieRule project settable paths must include a nonRoot path");
-		const relativeDirPath = isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath;
+		const relativeDirPath = this.getSettablePaths().root.relativeDirPath;
 		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(relativeDirPath, relativeFilePath)));
 		return new JunieRule({
 			outputRoot,
@@ -36795,7 +37847,7 @@ var JunieRule = class JunieRule extends ToolRule {
 			relativeFilePath,
 			fileContent,
 			validate,
-			root: isRoot
+			root: JunieRule.isRootRelativeFilePath(relativeFilePath)
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
@@ -36810,13 +37862,15 @@ var JunieRule = class JunieRule extends ToolRule {
 				rootPath: paths.root
 			}));
 		}
-		return new JunieRule(this.buildToolRuleParamsDefault({
+		const { root } = this.getSettablePaths();
+		return new JunieRule({
 			outputRoot,
-			rulesyncRule,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
 			validate,
-			rootPath: this.getSettablePaths().root,
-			nonRootPath: this.getSettablePaths().nonRoot
-		}));
+			root: rulesyncRule.getFrontmatter().root ?? false
+		});
 	}
 	toRulesyncRule() {
 		return this.toRulesyncRuleDefault();
@@ -37219,31 +38273,68 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 * 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 also loads two system-prompt instruction files. `.pi/APPEND_SYSTEM.md`
+* (global `~/.pi/agent/APPEND_SYSTEM.md`) *appends* to the default system prompt,
+* and rulesync emits it from any rule that opts in via the `pi.systemPrompt:
+* append` frontmatter block: those bodies are routed here instead of being folded
+* into `AGENTS.md`, and multiple opted-in rules concatenate in source order.
 * `.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.
+* prompt entirely — which silently disables Pi's built-in tool instructions — so
+* rulesync deliberately never emits it and leaves it to be authored by hand.
+* See docs/reference/file-formats.md.
 */
 var PiRule = class PiRule extends ToolRule {
-	constructor({ fileContent, root, ...rest }) {
+	appendSystemPrompt;
+	constructor({ fileContent, root, appendSystemPrompt = false, ...rest }) {
 		super({
 			...rest,
 			fileContent,
 			root: root ?? false
 		});
+		this.appendSystemPrompt = appendSystemPrompt;
 	}
 	static getSettablePaths({ global = false, excludeToolDir } = {}) {
-		return { root: {
-			relativeDirPath: global ? buildToolPath(".pi", "agent", excludeToolDir) : ".",
-			relativeFilePath: PI_RULE_FILE_NAME
-		} };
+		return {
+			root: {
+				relativeDirPath: global ? buildToolPath(".pi", "agent", excludeToolDir) : ".",
+				relativeFilePath: PI_RULE_FILE_NAME
+			},
+			appendSystemPrompt: {
+				relativeDirPath: global ? buildToolPath(".pi", "agent", excludeToolDir) : ".pi",
+				relativeFilePath: PI_APPEND_SYSTEM_FILE_NAME
+			}
+		};
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
-		const { root } = this.getSettablePaths({ global });
+	/**
+	* Extra fixed files this tool manages beyond the root rule. The
+	* RulesProcessor enumerates these for import and deletion so a stale
+	* `APPEND_SYSTEM.md` is cleaned up once no rule opts in anymore.
+	*/
+	static getExtraFixedFiles({ global = false } = {}) {
+		return [this.getSettablePaths({ global }).appendSystemPrompt];
+	}
+	/**
+	* Pi appends `APPEND_SYSTEM.md` to the system prompt itself, so listing it in
+	* the root rule's reference section (toon/explicit discovery modes) would
+	* double-load the content.
+	*/
+	isExcludedFromRootReferences() {
+		return this.appendSystemPrompt;
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const { root, appendSystemPrompt } = this.getSettablePaths({ global });
+		if (relativeFilePath === "APPEND_SYSTEM.md") {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(appendSystemPrompt.relativeDirPath, appendSystemPrompt.relativeFilePath)));
+			return new PiRule({
+				outputRoot,
+				relativeDirPath: appendSystemPrompt.relativeDirPath,
+				relativeFilePath: appendSystemPrompt.relativeFilePath,
+				fileContent,
+				validate,
+				root: false,
+				appendSystemPrompt: true
+			});
+		}
 		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
 		return new PiRule({
 			outputRoot,
@@ -37255,8 +38346,18 @@ var PiRule = class PiRule extends ToolRule {
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
-		const { root } = this.getSettablePaths({ global });
-		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		const { root, appendSystemPrompt } = this.getSettablePaths({ global });
+		const frontmatter = rulesyncRule.getFrontmatter();
+		if (!frontmatter.root && frontmatter.pi?.systemPrompt === "append") return new PiRule({
+			outputRoot,
+			relativeDirPath: appendSystemPrompt.relativeDirPath,
+			relativeFilePath: appendSystemPrompt.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: false,
+			appendSystemPrompt: true
+		});
+		const isRoot = frontmatter.root ?? false;
 		return new PiRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -37267,6 +38368,17 @@ var PiRule = class PiRule extends ToolRule {
 		});
 	}
 	toRulesyncRule() {
+		if (this.appendSystemPrompt) return new RulesyncRule({
+			outputRoot: process.cwd(),
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: PI_APPEND_SYSTEM_FILE_NAME,
+			frontmatter: {
+				root: false,
+				targets: ["pi"],
+				pi: { systemPrompt: "append" }
+			},
+			body: this.getFileContent()
+		});
 		return this.toRulesyncRuleDefault();
 	}
 	validate() {
@@ -37277,6 +38389,15 @@ var PiRule = class PiRule extends ToolRule {
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		const { root } = this.getSettablePaths({ global });
+		if (relativeFilePath === "APPEND_SYSTEM.md") return new PiRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: false,
+			appendSystemPrompt: true
+		});
 		const isRoot = relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === root.relativeDirPath);
 		return new PiRule({
 			outputRoot,
@@ -38436,7 +39557,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "auto",
+			foldsNonRootIntoRoot: true
 		}
 	}],
 	["kilo", {
@@ -38702,7 +39824,7 @@ var RulesProcessor = class extends FeatureProcessor {
 	*/
 	async buildMcpInstructionFiles({ toolRules, meta }) {
 		if (!meta.mcpInstructionsRegistrar || this.global) return [];
-		const instructionPaths = toolRules.filter((rule) => !rule.isRoot()).map((rule) => toPosixPath((0, node_path.join)(rule.getRelativeDirPath(), rule.getRelativeFilePath())));
+		const instructionPaths = toolRules.filter((rule) => !rule.isRoot() && !rule.isExcludedFromRootReferences()).map((rule) => toPosixPath((0, node_path.join)(rule.getRelativeDirPath(), rule.getRelativeFilePath())));
 		if (instructionPaths.length === 0) return [];
 		return [await meta.mcpInstructionsRegistrar.fromInstructions({
 			outputRoot: this.outputRoot,
@@ -38734,7 +39856,7 @@ var RulesProcessor = class extends FeatureProcessor {
 		const toolRelativeDirPath = skillClass.getSettablePaths({ global: this.global }).relativeDirPath;
 		return this.skills.filter((skill) => skillClass.isTargetedByRulesyncSkill(skill)).map((skill) => {
 			const frontmatter = skill.getFrontmatter();
-			const relativePath = (0, node_path.join)(toolRelativeDirPath, skill.getDirName(), SKILL_FILE_NAME);
+			const relativePath = (0, node_path.join)(toolRelativeDirPath, skill.getDirName(), SKILL_FILE_NAME$1);
 			return {
 				name: frontmatter.name,
 				description: frontmatter.description,
@@ -38758,11 +39880,25 @@ var RulesProcessor = class extends FeatureProcessor {
 	*/
 	foldNonRootRulesIntoRootRule(toolRules) {
 		if (toolRules.length <= 1) return;
-		const target = toolRules.find((rule) => rule.isRoot()) ?? toolRules[0];
-		if (!target) return;
-		const mergedContent = [target, ...toolRules.filter((rule) => rule !== target)].map((rule) => rule.getFileContent().trim()).filter((content) => content.length > 0).join("\n\n");
-		target.setFileContent(mergedContent);
-		for (let i = toolRules.length - 1; i >= 0; i--) if (toolRules[i] !== target) toolRules.splice(i, 1);
+		const groups = /* @__PURE__ */ new Map();
+		for (const rule of toolRules) {
+			const path = (0, node_path.join)(rule.getRelativeDirPath(), rule.getRelativeFilePath());
+			const group = groups.get(path);
+			if (group) group.push(rule);
+			else groups.set(path, [rule]);
+		}
+		const survivors = /* @__PURE__ */ new Set();
+		for (const group of groups.values()) {
+			const target = group.find((rule) => rule.isRoot()) ?? group[0];
+			if (!target) continue;
+			const mergedContent = [target, ...group.filter((rule) => rule !== target)].map((rule) => rule.getFileContent().trim()).filter((content) => content.length > 0).join("\n\n");
+			target.setFileContent(mergedContent);
+			survivors.add(target);
+		}
+		for (let i = toolRules.length - 1; i >= 0; i--) {
+			const rule = toolRules[i];
+			if (rule && !survivors.has(rule)) toolRules.splice(i, 1);
+		}
 	}
 	/**
 	* Handle localRoot rule generation based on tool target.
@@ -38972,6 +40108,27 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				const mirrorPaths = await findFilesByGlobs(mirrorGlob);
 				return buildDeletionRulesFromPaths(mirrorPaths);
 			})();
+			const extraFixedToolRules = await (async () => {
+				const extraFiles = factory.class.getExtraFixedFiles?.({ global: this.global });
+				if (!extraFiles || extraFiles.length === 0) return [];
+				const filePaths = await findFilesByGlobs(extraFiles.map((file) => (0, node_path.join)(this.outputRoot, file.relativeDirPath, file.relativeFilePath)));
+				if (filePaths.length === 0) return [];
+				if (forDeletion) return buildDeletionRulesFromPaths(filePaths);
+				return await Promise.all(filePaths.map((filePath) => {
+					const relativeDirPath = resolveRelativeDirPath(filePath);
+					checkPathTraversal({
+						relativePath: relativeDirPath,
+						intendedRootDir: this.outputRoot
+					});
+					return factory.class.fromFile({
+						outputRoot: this.outputRoot,
+						relativeDirPath,
+						relativeFilePath: (0, node_path.basename)(filePath),
+						global: this.global
+					});
+				}));
+			})();
+			this.logger.debug(`Found ${extraFixedToolRules.length} extra fixed tool rule files`);
 			const nonRootToolRules = await (async () => {
 				if (!settablePaths.nonRoot) return [];
 				const nonRootOutputRoot = (0, node_path.join)(this.outputRoot, settablePaths.nonRoot.relativeDirPath);
@@ -39007,6 +40164,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				...rootToolRules,
 				...localRootToolRules,
 				...rootMirrorDeletionRules,
+				...extraFixedToolRules,
 				...nonRootToolRules
 			];
 		} catch (error) {
@@ -39034,7 +40192,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		return toolRuleFactories.get(result.data);
 	}
 	generateToonReferencesSection(toolRules) {
-		const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+		const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot() && !rule.isExcludedFromRootReferences());
 		if (toolRulesWithoutRoot.length === 0) return "";
 		const lines = [];
 		lines.push("Please also reference the following rules as needed. The list below is provided in TOON format, and `@` stands for the project root directory.");
@@ -39050,7 +40208,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		return lines.join("\n") + "\n\n";
 	}
 	generateReferencesSection(toolRules) {
-		const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+		const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot() && !rule.isExcludedFromRootReferences());
 		if (toolRulesWithoutRoot.length === 0) return "";
 		const lines = [];
 		lines.push("Please also reference the following rules as needed:");
@@ -39071,7 +40229,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 */
 async function convertFromTool(params) {
 	const ctx = params;
-	const [rulesCount, ignoreCount, mcpCount, commandsCount, subagentsCount, skillsCount, hooksCount, permissionsCount] = [
+	const [rulesCount, ignoreCount, mcpCount, commandsCount, subagentsCount, skillsCount, hooksCount, permissionsCount, checksCount] = [
 		await runFeatureConvert(ctx, buildRulesStrategy(ctx)),
 		await runFeatureConvert(ctx, buildIgnoreStrategy(ctx)),
 		await runFeatureConvert(ctx, buildMcpStrategy(ctx)),
@@ -39079,7 +40237,8 @@ async function convertFromTool(params) {
 		await runFeatureConvert(ctx, buildSubagentsStrategy(ctx)),
 		await runFeatureConvert(ctx, buildSkillsStrategy(ctx)),
 		await runFeatureConvert(ctx, buildHooksStrategy(ctx)),
-		await runFeatureConvert(ctx, buildPermissionsStrategy(ctx))
+		await runFeatureConvert(ctx, buildPermissionsStrategy(ctx)),
+		await runFeatureConvert(ctx, buildChecksStrategy(ctx))
 	];
 	return {
 		rulesCount,
@@ -39089,7 +40248,8 @@ async function convertFromTool(params) {
 		subagentsCount,
 		skillsCount,
 		hooksCount,
-		permissionsCount
+		permissionsCount,
+		checksCount
 	};
 }
 async function runFeatureConvert(ctx, strategy) {
@@ -39322,6 +40482,27 @@ function buildPermissionsStrategy(ctx) {
 		write: (p, files) => p.writeAiFiles(files)
 	};
 }
+function buildChecksStrategy(ctx) {
+	const { config, logger } = ctx;
+	const global = config.getGlobal();
+	const outputRoot = getOutputRoot(config);
+	return {
+		feature: "checks",
+		itemLabel: "check file(s)",
+		allTargets: ChecksProcessor.getToolTargets({ global }),
+		createProcessor: ({ toolTarget, dryRun }) => new ChecksProcessor({
+			outputRoot,
+			toolTarget,
+			global,
+			dryRun,
+			logger
+		}),
+		loadSource: (p) => p.loadToolFiles(),
+		toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
+		fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
+		write: (p, files) => p.writeAiFiles(files)
+	};
+}
 //#endregion
 //#region src/types/processor-registry.ts
 const PROCESSOR_REGISTRY = [
@@ -39372,6 +40553,12 @@ const PROCESSOR_REGISTRY = [
 		processor: PermissionsProcessor,
 		schema: PermissionsProcessorToolTargetSchema,
 		factory: toolPermissionsFactories
+	},
+	{
+		feature: "checks",
+		processor: ChecksProcessor,
+		schema: ChecksProcessorToolTargetSchema,
+		factory: toolCheckFactories
 	}
 ];
 const getProcessorRegistryEntry = (feature) => {
@@ -39721,6 +40908,7 @@ const GENERATION_STEP_GRAPH = [
 		id: "permissions",
 		...sharedWriteMeta("permissions")
 	},
+	{ id: "checks" },
 	{
 		id: "rules",
 		...sharedWriteMeta("rules"),
@@ -39728,11 +40916,51 @@ const GENERATION_STEP_GRAPH = [
 	}
 ];
 /**
+* Warn when a rulesync skill and a rulesync subagent share a name for a tool
+* that emits both features into the same directory (e.g. Reasonix, where both
+* write `<name>/SKILL.md` under `.reasonix/skills/`). The colliding outputs
+* target the same on-disk file, so whichever generation step runs later
+* silently overwrites the other's file.
+*/
+async function warnSkillSubagentNameCollisions(params) {
+	const { config, logger } = params;
+	const global = config.getGlobal();
+	for (const toolTarget of config.getTargets()) {
+		const features = config.getFeatures(toolTarget);
+		if (!features.includes("skills") || !features.includes("subagents")) continue;
+		if (!SubagentsProcessor.getToolTargets({ global }).includes(toolTarget) || !SkillsProcessor.getToolTargets({ global }).includes(toolTarget)) continue;
+		const subagentFactory = SubagentsProcessor.getFactory(toolTarget);
+		const skillFactory = SkillsProcessor.getFactory(toolTarget);
+		if (!subagentFactory || !skillFactory) continue;
+		const subagentsDirPath = subagentFactory.class.getSettablePaths({ global }).relativeDirPath;
+		if (subagentsDirPath !== skillFactory.class.getSettablePaths({ global }).relativeDirPath) continue;
+		const subagentsProcessor = new SubagentsProcessor({
+			inputRoot: config.getInputRoot(),
+			toolTarget,
+			global,
+			logger
+		});
+		const subagentNames = new Set((await subagentsProcessor.loadRulesyncFiles()).filter((file) => file instanceof RulesyncSubagent).filter((file) => subagentFactory.class.isTargetedByRulesyncSubagent(file)).map((file) => (0, node_path.basename)(file.getRelativeFilePath(), (0, node_path.extname)(file.getRelativeFilePath()))));
+		if (subagentNames.size === 0) continue;
+		const skillNames = (await new SkillsProcessor({
+			inputRoot: config.getInputRoot(),
+			toolTarget,
+			global,
+			logger
+		}).loadRulesyncDirs()).filter((dir) => dir instanceof RulesyncSkill).filter((skill) => skillFactory.class.isTargetedByRulesyncSkill(skill)).map((skill) => skill.getDirName());
+		for (const name of skillNames) if (subagentNames.has(name)) logger.warn(`Skill "${name}" and subagent "${name}" both target '${toolTarget}' and write the same path '${(0, node_path.join)(subagentsDirPath, name)}'; the later generation step overwrites the other's output. Rename one of them or narrow their targets.`);
+	}
+}
+/**
 * Generate configuration files for AI tools.
 * @throws Error if generation fails
 */
 async function generate(params) {
 	const { config, logger } = params;
+	await warnSkillSubagentNameCollisions({
+		config,
+		logger
+	});
 	let skillsResult;
 	const runners = {
 		ignore: () => generateIgnoreCore({
@@ -39766,6 +40994,10 @@ async function generate(params) {
 			config,
 			logger
 		}),
+		checks: () => generateChecksCore({
+			config,
+			logger
+		}),
 		rules: () => generateRulesCore({
 			config,
 			logger,
@@ -39802,6 +41034,8 @@ async function generate(params) {
 		hooksPaths: get("hooks").paths,
 		permissionsCount: get("permissions").count,
 		permissionsPaths: get("permissions").paths,
+		checksCount: get("checks").count,
+		checksPaths: get("checks").paths,
 		skills: skillsResult.skills,
 		hasDiff
 	};
@@ -40170,6 +41404,44 @@ async function generatePermissionsCore(params) {
 		hasDiff
 	};
 }
+async function generateChecksCore(params) {
+	const { config, logger } = params;
+	let totalCount = 0;
+	const allPaths = [];
+	let hasDiff = false;
+	const supportedChecksTargets = ChecksProcessor.getToolTargets({ global: config.getGlobal() });
+	const toolTargets = (0, es_toolkit.intersection)(config.getTargets(), supportedChecksTargets);
+	warnUnsupportedTargets({
+		config,
+		supportedTargets: supportedChecksTargets,
+		featureName: "checks",
+		logger
+	});
+	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
+		if (!config.getFeatures(toolTarget).includes("checks")) continue;
+		const processor = new ChecksProcessor({
+			outputRoot,
+			inputRoot: config.getInputRoot(),
+			toolTarget,
+			global: config.getGlobal(),
+			dryRun: config.isPreviewMode(),
+			logger
+		});
+		const result = await processFeatureWithRulesyncFiles({
+			config,
+			processor,
+			rulesyncFiles: await processor.loadRulesyncFiles()
+		});
+		totalCount += result.count;
+		allPaths.push(...result.paths);
+		if (result.hasDiff) hasDiff = true;
+	}
+	return {
+		count: totalCount,
+		paths: allPaths,
+		hasDiff
+	};
+}
 //#endregion
 //#region src/lib/import.ts
 /**
@@ -40227,6 +41499,11 @@ async function importFromTool(params) {
 			config,
 			tool,
 			logger
+		}),
+		checksCount: await importChecksCore({
+			config,
+			tool,
+			logger
 		})
 	};
 }
@@ -40443,6 +41720,27 @@ async function importPermissionsCore(params) {
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} permissions file(s)`);
 	return writtenCount;
 }
+async function importChecksCore(params) {
+	const { config, tool, logger } = params;
+	if (!config.getFeatures(tool).includes("checks")) return 0;
+	const global = config.getGlobal();
+	if (!ChecksProcessor.getToolTargets({ global }).includes(tool)) return 0;
+	const checksProcessor = new ChecksProcessor({
+		outputRoot: config.getOutputRoots()[0] ?? ".",
+		toolTarget: tool,
+		global,
+		logger
+	});
+	const toolFiles = await checksProcessor.loadToolFiles();
+	if (toolFiles.length === 0) {
+		logger.warn(`No check files found for ${tool}. Skipping import.`);
+		return 0;
+	}
+	const rulesyncFiles = await checksProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+	const { count: writtenCount } = await checksProcessor.writeAiFiles(rulesyncFiles);
+	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} check files`);
+	return writtenCount;
+}
 //#endregion
 Object.defineProperty(exports, "ALL_FEATURES", {
 	enumerable: true,
@@ -40504,12 +41802,24 @@ Object.defineProperty(exports, "CLIError", {
 		return CLIError;
 	}
 });
+Object.defineProperty(exports, "CODEXCLI_BASH_RULES_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return CODEXCLI_BASH_RULES_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "CODEXCLI_DIR", {
 	enumerable: true,
 	get: function() {
 		return CODEXCLI_DIR;
 	}
 });
+Object.defineProperty(exports, "ChecksProcessor", {
+	enumerable: true,
+	get: function() {
+		return ChecksProcessor;
+	}
+});
 Object.defineProperty(exports, "CommandsProcessor", {
 	enumerable: true,
 	get: function() {
@@ -40576,6 +41886,12 @@ Object.defineProperty(exports, "RULESYNC_AIIGNORE_RELATIVE_FILE_PATH", {
 		return RULESYNC_AIIGNORE_RELATIVE_FILE_PATH;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_CHECKS_RELATIVE_DIR_PATH", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_CHECKS_RELATIVE_DIR_PATH;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_COMMANDS_RELATIVE_DIR_PATH", {
 	enumerable: true,
 	get: function() {
@@ -40720,6 +42036,18 @@ Object.defineProperty(exports, "RulesProcessor", {
 		return RulesProcessor;
 	}
 });
+Object.defineProperty(exports, "RulesyncCheck", {
+	enumerable: true,
+	get: function() {
+		return RulesyncCheck;
+	}
+});
+Object.defineProperty(exports, "RulesyncCheckFrontmatterSchema", {
+	enumerable: true,
+	get: function() {
+		return RulesyncCheckFrontmatterSchema;
+	}
+});
 Object.defineProperty(exports, "RulesyncCommand", {
 	enumerable: true,
 	get: function() {
@@ -40795,7 +42123,7 @@ Object.defineProperty(exports, "RulesyncSubagentFrontmatterSchema", {
 Object.defineProperty(exports, "SKILL_FILE_NAME", {
 	enumerable: true,
 	get: function() {
-		return SKILL_FILE_NAME;
+		return SKILL_FILE_NAME$1;
 	}
 });
 Object.defineProperty(exports, "SkillsProcessor", {