rulesync 12.0.0 → 14.0.0

package/dist/{import-C0N0Lo_F.cjs → import-Dh9PCQKq.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,26 +116,28 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$252 } = node_path.posix;
+const { join: join$257 } = 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$252(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$257(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$252(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$252(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$257(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
+const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
 const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.json";
@@ -366,6 +370,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"copilot",
 	"cursor",
 	"devin",
 	"factorydroid",
@@ -386,6 +391,7 @@ const permissionsProcessorToolTargetTuple = [
 	"warp",
 	"zed"
 ];
+const checksProcessorToolTargetTuple = ["amp"];
 //#endregion
 //#region src/types/tool-targets.ts
 const ALL_TOOL_TARGETS = [...new Set([
@@ -396,7 +402,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);
@@ -875,9 +882,15 @@ const GITIGNORE_DESTINATION_KEY = "gitignoreDestination";
 const SourceEntrySchema = zod_mini.z.object({
 	source: zod_mini.z.string().check((0, zod_mini.minLength)(1, "source must be a non-empty string")),
 	skills: (0, zod_mini.optional)(zod_mini.z.array(zod_mini.z.string())),
-	transport: (0, zod_mini.optional)(zod_mini.z.enum(["github", "git"])),
+	transport: (0, zod_mini.optional)(zod_mini.z.enum([
+		"github",
+		"git",
+		"npm"
+	])),
 	ref: (0, zod_mini.optional)(zod_mini.z.string().check((0, zod_mini.refine)((v) => !v.startsWith("-"), "ref must not start with \"-\""), (0, zod_mini.refine)((v) => !hasControlCharacters(v), "ref must not contain control characters"))),
 	path: (0, zod_mini.optional)(zod_mini.z.string().check((0, zod_mini.refine)((v) => !v.includes(".."), "path must not contain \"..\""), (0, zod_mini.refine)((v) => !(0, node_path.isAbsolute)(v), "path must not be absolute"), (0, zod_mini.refine)((v) => !hasControlCharacters(v), "path must not contain control characters"))),
+	registry: (0, zod_mini.optional)(zod_mini.z.string().check((0, zod_mini.refine)((v) => v.startsWith("https://") || v.startsWith("http://"), "registry must be an http(s) URL"), (0, zod_mini.refine)((v) => !hasControlCharacters(v), "registry must not contain control characters"))),
+	tokenEnv: (0, zod_mini.optional)(zod_mini.z.string().check((0, zod_mini.refine)((v) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(v), "tokenEnv must be a valid environment variable name"))),
 	agent: (0, zod_mini.optional)(zod_mini.z.enum([
 		"github-copilot",
 		"claude-code",
@@ -887,7 +900,7 @@ const SourceEntrySchema = zod_mini.z.object({
 		"antigravity"
 	])),
 	scope: (0, zod_mini.optional)(zod_mini.z.enum(["project", "user"]))
-});
+}).check((0, zod_mini.refine)((entry) => entry.registry === void 0 && entry.tokenEnv === void 0 || entry.transport === "npm", "\"registry\" and \"tokenEnv\" are only valid with transport \"npm\""));
 const ConfigParamsSchema = zod_mini.z.object({
 	outputRoots: zod_mini.z.union([zod_mini.z.array(zod_mini.z.string()), zod_mini.z.record(zod_mini.z.string(), zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))]),
 	targets: RulesyncConfigTargetsSchema,
@@ -1470,7 +1483,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
@@ -1718,13 +1731,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 {
@@ -1798,6 +1815,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.
@@ -2045,13 +2470,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, ["*"]),
@@ -2854,6 +3272,7 @@ const COPILOT_HOOKS_DIR_PATH = (0, node_path.join)(GITHUB_DIR, "hooks");
 const COPILOT_HOOKS_FILE_NAME = "copilot-hooks.json";
 const COPILOT_MCP_DIR = ".vscode";
 const COPILOT_MCP_FILE_NAME = "mcp.json";
+const COPILOT_VSCODE_SETTINGS_FILE_NAME = "settings.json";
 const COPILOTCLI_MCP_FILE_NAME = "mcp-config.json";
 const COPILOTCLI_PROJECT_MCP_FILE_NAME = "mcp.json";
 const COPILOTCLI_AGENTS_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "agents");
@@ -3112,135 +3531,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 };
+		return { relativeDirPath: global ? DEVIN_GLOBAL_SKILLS_DIR_PATH : DEVIN_SKILLS_DIR_PATH };
 	}
-	getBody() {
-		return this.body;
-	}
-	getFrontmatter() {
-		return this.frontmatter;
-	}
-	toRulesyncCommand() {
-		const { description, ...restFields } = this.frontmatter;
-		const rulesyncFrontmatter = {
-			targets: ["*"],
-			description,
-			...Object.keys(restFields).length > 0 && { 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
@@ -3569,10 +3971,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`;
@@ -3589,7 +3988,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 }) {
@@ -3620,7 +4019,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)
 		});
@@ -4280,6 +4679,15 @@ const SHARED_CONFIG_OWNERSHIP = {
 			}
 		}
 	},
+	".vscode/settings.json": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: { permissions: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["chat.tools.terminal.autoApprove"]
+		} }
+	},
 	".qwen/settings.json": {
 		format: "json",
 		features: {
@@ -4855,6 +5263,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
 /**
@@ -5389,9 +5798,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
@@ -5880,7 +6286,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: false,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: true
+			supportsSubdirectory: true,
+			skipToolFileScan: true
 		}
 	}],
 	["junie", {
@@ -6010,7 +6417,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: false
+			supportsSubdirectory: false,
+			skipToolFileScan: true
 		}
 	}]
 ]);
@@ -6113,6 +6521,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}`));
@@ -6222,7 +6631,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()),
@@ -6235,12 +6647,72 @@ 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),
+	if: 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",
@@ -6715,12 +7187,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) })),
@@ -7157,6 +7645,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;
@@ -7214,6 +7716,41 @@ function importBooleanPassthroughFields({ h, converterConfig }) {
 	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "boolean").map(({ canonical, tool }) => [canonical, h[tool]]));
 }
 /**
+* Emit the configured string passthrough fields on the tool side, mapping each
+* canonical field name to its (possibly renamed) tool field name. Only non-empty
+* string values are carried through.
+*/
+function emitStringPassthroughFields({ def, converterConfig }) {
+	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "string" && def[canonical] !== "").map(({ canonical, tool }) => [tool, def[canonical]]));
+}
+/**
+* Import the configured string passthrough fields back into canonical fields,
+* reversing {@link emitStringPassthroughFields}. Only non-empty string values
+* are read.
+*/
+function importStringPassthroughFields({ h, converterConfig }) {
+	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "string" && h[tool] !== "").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,10 +7768,19 @@ function buildToolHooks({ defs, converterConfig }) {
 				def,
 				converterConfig
 			}),
+			...emitStringPassthroughFields({
+				def,
+				converterConfig
+			}),
 			type: hookType,
 			...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 }
 		});
@@ -7301,6 +7847,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 }) {
@@ -7308,7 +7894,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 {
@@ -7316,12 +7902,20 @@ 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({
 			h,
 			converterConfig
 		}),
+		...importStringPassthroughFields({
+			h,
+			converterConfig
+		}),
 		...rawEntry.matcher !== void 0 && rawEntry.matcher !== null && rawEntry.matcher !== "" && { matcher: rawEntry.matcher }
 	};
 }
@@ -7335,6 +7929,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 = {};
@@ -7505,7 +8125,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
@@ -7612,10 +8233,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 {
@@ -7736,7 +8358,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 		"sessionEnd",
 		"stop",
 		"notification"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
 };
 /**
 * AugmentCode (Auggie CLI) lifecycle hooks.
@@ -7818,10 +8441,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 {
@@ -7856,7 +8479,19 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"taskCompleted",
 		"teammateIdle",
 		"cwdChanged"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set([
+		"command",
+		"prompt",
+		"http",
+		"mcp_tool",
+		"agent"
+	]),
+	emitsPromptModel: true,
+	stringPassthroughFields: [{
+		canonical: "if",
+		tool: "if"
+	}]
 };
 var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
@@ -7921,10 +8556,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 {
@@ -8067,10 +8702,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 {
@@ -8238,10 +8873,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 {
@@ -8260,20 +8895,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.
@@ -8406,7 +9027,7 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else entries.push({
+		else if (hookType === "command") entries.push({
 			type: "command",
 			...matcherPart,
 			...compact({
@@ -8558,10 +9179,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 {
@@ -8616,9 +9237,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 },
@@ -8627,6 +9249,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,
@@ -8653,10 +9276,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 {
@@ -8711,7 +9335,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({
@@ -8801,10 +9425,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 {
@@ -8933,10 +9557,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 {
@@ -8960,7 +9584,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) {
@@ -9028,10 +9653,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 {
@@ -9122,10 +9747,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 {
@@ -9283,10 +9908,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 {
@@ -9447,10 +10072,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();
@@ -9553,10 +10178,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 {
@@ -9601,7 +10226,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,
@@ -9906,10 +10531,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 {
@@ -10118,10 +10744,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 {
@@ -10245,11 +10871,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);
@@ -10309,9 +10942,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({
@@ -10323,7 +10957,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,
@@ -10410,15 +11044,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() {
@@ -10580,10 +11210,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 {
@@ -10806,10 +11436,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 {
@@ -10896,7 +11526,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", {
@@ -11088,7 +11724,12 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: QWENCODE_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
+		supportedHookTypes: [
+			"command",
+			"prompt",
+			"http",
+			"function"
+		],
 		supportsMatcher: true
 	}],
 	["reasonix", {
@@ -12390,16 +13031,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({
@@ -13491,10 +14122,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 = {};
@@ -13508,7 +14148,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;
 		}
@@ -13520,12 +14160,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;
@@ -13534,12 +14171,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;
 	}
@@ -13606,7 +14243,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);
@@ -14343,11 +14980,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);
 }
@@ -14405,7 +15042,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);
@@ -14425,11 +15062,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;
@@ -14742,7 +15379,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;
@@ -14761,8 +15398,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;
@@ -14774,8 +15411,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;
 }
@@ -14799,11 +15436,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) {
@@ -14851,7 +15488,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);
@@ -17176,7 +17813,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({}))
 });
 /**
@@ -17264,7 +17905,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())
 });
@@ -17310,7 +17955,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({}))
 });
 /**
@@ -17340,9 +17989,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())
 });
@@ -17367,7 +18022,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())
 });
 /**
@@ -17396,7 +18056,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"
+		]) })
 	})))
 });
 /**
@@ -17486,12 +18153,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.
@@ -17502,10 +18177,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).
@@ -17526,13 +18205,14 @@ const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_P
 *   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-outs (`".git/**" = "write"` with
-*   `".git/config" = "read"` kept read-only as a security guard). Codex's
+*   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), so the carve-outs are emitted by default. Defaults to `true`; only
-*   an explicit `false` suppresses them. Like `base_permission_profile` it is
-*   consumed by the profile builder, not written as a top-level config key.
+*   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
@@ -17609,6 +18289,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	kiro: zod_mini.z.optional(KiroPermissionsOverrideSchema),
 	codexcli: zod_mini.z.optional(CodexcliPermissionsOverrideSchema),
 	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	copilot: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	devin: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
@@ -19529,15 +20210,13 @@ const RULESYNC_PROFILE_NAME = "rulesync";
 const CODEX_WORKSPACE_ROOTS_KEY = ":workspace_roots";
 const CODEX_WORKSPACE_BASELINE = ":workspace";
 const CODEX_READ_ONLY_BASELINE = ":read-only";
-const CODEX_EXTENDABLE_BASELINES = new Set(CODEX_BASE_PERMISSION_PROFILES);
+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",
-	".git/config": "read"
-};
+const CODEX_GIT_WRITE_RULES = { ".git/**": "write" };
 const GLOBAL_WILDCARD_DOMAIN = "*";
 var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
@@ -19565,8 +20244,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);
@@ -19627,6 +20338,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
@@ -19682,16 +20394,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") {
@@ -19704,6 +20410,16 @@ 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,
@@ -19984,6 +20700,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);
@@ -20016,6 +20793,135 @@ function mapBashActionToDecision(action) {
 	return "forbidden";
 }
 //#endregion
+//#region src/features/permissions/copilot-permissions.ts
+/**
+* The flat, dotted VS Code setting key this adapter manages. VS Code stores
+* settings with dotted keys flat at the document top level, so this is a single
+* literal key — not a nested `chat.tools.terminal` path.
+* @see https://code.visualstudio.com/docs/agents/approvals
+*/
+const AUTO_APPROVE_KEY = "chat.tools.terminal.autoApprove";
+/**
+* The canonical permission category this adapter maps. Only shell/terminal
+* commands (`bash`) have a clean, high-fidelity representation in VS Code's
+* `chat.tools.terminal.autoApprove` map; other categories (read/edit/webfetch/
+* …) have no terminal-command equivalent and are intentionally not mapped.
+*/
+const TERMINAL_CATEGORY = "bash";
+function asAutoApproveMap(value) {
+	if (!isPlainObject$1(value)) return {};
+	const result = {};
+	for (const [pattern, flag] of Object.entries(value)) if (typeof flag === "boolean") result[pattern] = flag;
+	return result;
+}
+/**
+* Permissions generator for GitHub Copilot Chat in VS Code.
+*
+* VS Code has no standalone, environment-agnostic Copilot policy file (like
+* `.claude/settings.json`); project-level terminal auto-approvals are managed
+* through the workspace `chat.tools.terminal.autoApprove` map inside
+* `.vscode/settings.json`. That file is a general workspace settings file with
+* many unrelated keys, so reads and writes merge into the existing JSON
+* (touching only the one managed key) and the file is never deleted.
+*
+* Scope is deliberately limited to `chat.tools.terminal.autoApprove` — the one
+* clean, non-lossy mapping. The canonical `bash` category's per-pattern rules
+* map as: `allow` → `true` (auto-approve), `deny` → `false` (never approve),
+* and `ask` → the entry is OMITTED (VS Code then falls through to its default
+* in-chat approval prompt, i.e. "ask"). Only project scope is modeled: VS Code's
+* user-scope settings.json lives at a platform-dependent path outside rulesync's
+* home-relative global model.
+*/
+var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	/**
+	* `.vscode/settings.json` is a user-managed workspace file with unrelated
+	* settings, so it must not be deleted.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: COPILOT_MCP_DIR,
+			relativeFilePath: COPILOT_VSCODE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
+		const paths = CopilotPermissions.getSettablePaths();
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new CopilotPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions }) {
+		const paths = CopilotPermissions.getSettablePaths();
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const rules = rulesyncPermissions.getJson().permission[TERMINAL_CATEGORY] ?? {};
+		const autoApprove = {};
+		for (const [pattern, action] of Object.entries(rules)) if (action === "allow") autoApprove[pattern] = true;
+		else if (action === "deny") autoApprove[pattern] = false;
+		const patchValue = Object.keys(autoApprove).length > 0 ? autoApprove : void 0;
+		return new CopilotPermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: { [AUTO_APPROVE_KEY]: patchValue },
+				filePath
+			}),
+			validate: true
+		});
+	}
+	toRulesyncPermissions() {
+		let settings;
+		try {
+			settings = parseSharedConfig({
+				format: "jsonc",
+				fileContent: this.getFileContent() || "{}",
+				filePath: (0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath()),
+				invalidRootPolicy: "error",
+				jsoncParseErrors: "error"
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse Copilot VS Code settings in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const autoApprove = asAutoApproveMap(settings[AUTO_APPROVE_KEY]);
+		const rules = {};
+		for (const [pattern, flag] of Object.entries(autoApprove)) rules[pattern] = flag ? "allow" : "deny";
+		const permission = Object.keys(rules).length > 0 ? { [TERMINAL_CATEGORY]: rules } : {};
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CopilotPermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/permissions/cursor-permissions.ts
 /**
 * Mapping from rulesync canonical tool category names (lowercase) to Cursor CLI
@@ -20935,7 +21841,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;
@@ -21175,7 +22081,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
@@ -21216,9 +22122,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) => {
@@ -22999,7 +23905,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";
 	}
@@ -23559,8 +24465,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];
@@ -23906,6 +24812,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["copilot", {
+		class: CopilotPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsImport: true
+		}
+	}],
 	["cursor", {
 		class: CursorPermissions,
 		meta: {
@@ -24140,9 +25054,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 {
 	/**
@@ -24343,10 +25254,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,
@@ -24388,7 +25299,7 @@ var SimulatedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24446,12 +25357,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,
@@ -24661,7 +25572,7 @@ var RulesyncSkill = class RulesyncSkill extends AiDir {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24696,13 +25607,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,
@@ -24742,7 +25653,7 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24769,7 +25680,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 {
@@ -24845,10 +25756,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({
@@ -25013,7 +25924,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25037,7 +25948,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 {
@@ -25109,7 +26020,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,
@@ -25166,7 +26077,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25191,7 +26102,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 {
@@ -25251,7 +26162,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,
@@ -25302,7 +26213,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25326,7 +26237,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 {
@@ -25386,7 +26297,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,
@@ -25442,7 +26353,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25475,7 +26386,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 {
@@ -25535,7 +26446,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,
@@ -25619,7 +26530,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25646,7 +26557,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 {
@@ -25706,7 +26617,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,
@@ -25847,7 +26758,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25874,7 +26785,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 {
@@ -25962,7 +26873,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,
@@ -26008,7 +26919,7 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26032,7 +26943,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 {
@@ -26096,10 +27007,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({
@@ -26213,7 +27124,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26237,7 +27148,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 {
@@ -26315,7 +27226,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,
@@ -26367,7 +27278,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26392,7 +27303,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 {
@@ -26459,7 +27370,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,
@@ -26513,7 +27424,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26538,7 +27449,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 {
@@ -26607,7 +27518,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,
@@ -26657,7 +27568,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26681,7 +27592,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 {
@@ -26755,7 +27666,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,
@@ -26802,7 +27713,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26826,7 +27737,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 {
@@ -26902,7 +27813,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,
@@ -26953,7 +27864,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26978,7 +27889,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 {
@@ -27030,6 +27941,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,
@@ -27038,7 +27961,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,
@@ -27090,7 +28013,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27114,7 +28037,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 {
@@ -27189,7 +28112,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,
@@ -27236,7 +28159,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27261,7 +28184,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 {
@@ -27321,7 +28244,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,
@@ -27374,7 +28297,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27398,7 +28321,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 {
@@ -27458,7 +28381,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,
@@ -27493,6 +28416,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,
@@ -27517,7 +28452,7 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27541,7 +28476,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 {
@@ -27605,10 +28540,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({
@@ -27656,7 +28591,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27680,7 +28615,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 {
@@ -27752,7 +28687,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,
@@ -27798,7 +28733,7 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27822,7 +28757,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 {
@@ -27886,10 +28821,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({
@@ -27972,7 +28907,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27999,7 +28934,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 {
@@ -28078,7 +29013,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,
@@ -28139,7 +29074,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 			relativeDirPath: resolvedDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28164,7 +29099,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 {
@@ -28239,7 +29174,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,
@@ -28292,7 +29227,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28316,7 +29251,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 {
@@ -28396,7 +29331,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,
@@ -28446,7 +29381,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28470,7 +29405,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 {
@@ -28530,7 +29465,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,
@@ -28553,7 +29488,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 	* 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);
+		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;
@@ -28603,7 +29538,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28627,7 +29562,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 {
@@ -28695,7 +29630,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,
@@ -28742,7 +29677,7 @@ var RooSkill = class RooSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28766,7 +29701,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 {
@@ -28830,10 +29765,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({
@@ -29050,7 +29985,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29077,7 +30012,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 {
@@ -29141,7 +30076,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,
@@ -29197,7 +30132,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29221,7 +30156,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 {
@@ -29281,7 +30216,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,
@@ -29329,7 +30264,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29353,7 +30288,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 {
@@ -29422,7 +30357,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,
@@ -29862,7 +30797,8 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
 					outputRoot: this.outputRoot,
 					relativeDirPath: root,
-					dirName
+					dirName,
+					inputRoot: this.inputRoot
 				})) continue;
 				seenDirNames.add(dirName);
 				loadEntries.push({
@@ -29893,7 +30829,8 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
 					outputRoot: this.outputRoot,
 					relativeDirPath: root,
-					dirName
+					dirName,
+					inputRoot: this.inputRoot
 				})) continue;
 				const toolSkill = factory.class.forDeletion({
 					outputRoot: this.outputRoot,
@@ -30996,7 +31933,6 @@ var CodexCliSubagent = class CodexCliSubagent extends ToolSubagent {
 };
 //#endregion
 //#region src/features/subagents/copilot-subagent.ts
-const REQUIRED_TOOL = "agent/runSubagent";
 const CopilotSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.optional(zod_mini.z.string()),
@@ -31006,10 +31942,6 @@ const normalizeTools = (tools) => {
 	if (!tools) return [];
 	return Array.isArray(tools) ? tools : [tools];
 };
-const ensureRequiredTool = (tools) => {
-	const mergedTools = /* @__PURE__ */ new Set([REQUIRED_TOOL, ...tools]);
-	return Array.from(mergedTools);
-};
 const toCopilotAgentFilePath = (relativeFilePath) => {
 	if (relativeFilePath.endsWith(".agent.md")) return relativeFilePath;
 	if (relativeFilePath.endsWith(".md")) return relativeFilePath.replace(/\.md$/, ".agent.md");
@@ -31063,14 +31995,14 @@ var CopilotSubagent = class CopilotSubagent extends ToolSubagent {
 	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
 		const copilotSection = rulesyncFrontmatter.copilot ?? {};
+		const { tools: _rawTools, ...copilotRest } = copilotSection;
 		const toolsField = copilotSection.tools;
 		const userTools = normalizeTools(Array.isArray(toolsField) || typeof toolsField === "string" ? toolsField : void 0);
-		const mergedTools = ensureRequiredTool(userTools);
 		const copilotFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...copilotSection,
-			...mergedTools.length > 0 && { tools: mergedTools }
+			...copilotRest,
+			...userTools.length > 0 && { tools: userTools }
 		};
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
@@ -33294,7 +34226,7 @@ var ReasonixSubagent = class ReasonixSubagent extends ToolSubagent {
 			frontmatter: reasonixFrontmatter,
 			body,
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: (0, node_path.join)(subagentName, SKILL_FILE_NAME),
+			relativeFilePath: (0, node_path.join)(subagentName, SKILL_FILE_NAME$1),
 			fileContent,
 			validate,
 			global
@@ -34300,6 +35232,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()),
@@ -34463,6 +35396,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;
 	}
@@ -36809,6 +37752,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 } = {}) {
@@ -37010,14 +37962,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
@@ -37036,15 +37995,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";
@@ -37063,10 +38019,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,
@@ -37074,7 +38027,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 }) {
@@ -37089,13 +38042,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();
@@ -37498,31 +38453,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,
@@ -37534,8 +38526,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,
@@ -37546,6 +38548,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() {
@@ -37556,6 +38569,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,
@@ -38715,7 +39737,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "auto",
+			foldsNonRootIntoRoot: true
 		}
 	}],
 	["kilo", {
@@ -38981,7 +40004,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,
@@ -39013,7 +40036,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,
@@ -39037,11 +40060,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.
@@ -39251,6 +40288,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);
@@ -39286,6 +40344,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				...rootToolRules,
 				...localRootToolRules,
 				...rootMirrorDeletionRules,
+				...extraFixedToolRules,
 				...nonRootToolRules
 			];
 		} catch (error) {
@@ -39313,7 +40372,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.");
@@ -39329,7 +40388,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:");
@@ -39350,7 +40409,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)),
@@ -39358,7 +40417,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,
@@ -39368,7 +40428,8 @@ async function convertFromTool(params) {
 		subagentsCount,
 		skillsCount,
 		hooksCount,
-		permissionsCount
+		permissionsCount,
+		checksCount
 	};
 }
 async function runFeatureConvert(ctx, strategy) {
@@ -39601,6 +40662,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 = [
@@ -39651,6 +40733,12 @@ const PROCESSOR_REGISTRY = [
 		processor: PermissionsProcessor,
 		schema: PermissionsProcessorToolTargetSchema,
 		factory: toolPermissionsFactories
+	},
+	{
+		feature: "checks",
+		processor: ChecksProcessor,
+		schema: ChecksProcessorToolTargetSchema,
+		factory: toolCheckFactories
 	}
 ];
 const getProcessorRegistryEntry = (feature) => {
@@ -40000,6 +41088,7 @@ const GENERATION_STEP_GRAPH = [
 		id: "permissions",
 		...sharedWriteMeta("permissions")
 	},
+	{ id: "checks" },
 	{
 		id: "rules",
 		...sharedWriteMeta("rules"),
@@ -40085,6 +41174,10 @@ async function generate(params) {
 			config,
 			logger
 		}),
+		checks: () => generateChecksCore({
+			config,
+			logger
+		}),
 		rules: () => generateRulesCore({
 			config,
 			logger,
@@ -40121,6 +41214,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
 	};
@@ -40489,6 +41584,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
 /**
@@ -40546,6 +41679,11 @@ async function importFromTool(params) {
 			config,
 			tool,
 			logger
+		}),
+		checksCount: await importChecksCore({
+			config,
+			tool,
+			logger
 		})
 	};
 }
@@ -40762,6 +41900,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,
@@ -40823,12 +41982,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() {
@@ -40895,6 +42066,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() {
@@ -40973,6 +42150,12 @@ Object.defineProperty(exports, "RULESYNC_MCP_SCHEMA_URL", {
 		return RULESYNC_MCP_SCHEMA_URL;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_OVERVIEW_FILE_NAME", {
 	enumerable: true,
 	get: function() {
@@ -41039,6 +42222,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() {
@@ -41114,7 +42309,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", {