rulesync 12.0.0 → 14.0.0

package/dist/{import-hM4jDZn1.js → import-CSnC5vl7.js}

@@ -12,6 +12,7 @@ import { parse as parse$1, stringify } from "smol-toml";
 import matter from "gray-matter";
 import { YAMLException, dump, load } from "js-yaml";
 import { omit } from "es-toolkit/object";
+import { createHash } from "node:crypto";
 import { encode } from "@toon-format/toon";
 //#region src/types/features.ts
 const ALL_FEATURES = [
@@ -22,7 +23,8 @@ const ALL_FEATURES = [
 	"commands",
 	"skills",
 	"hooks",
-	"permissions"
+	"permissions",
+	"checks"
 ];
 const ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 const FeatureSchema = z.enum(ALL_FEATURES);
@@ -96,6 +98,7 @@ const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULESYNC_RULES_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "rules");
 const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "commands");
 const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "checks");
 const RULESYNC_MCP_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
 const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
 const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
@@ -109,6 +112,7 @@ const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
 const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "skills");
 const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$1(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";
@@ -341,6 +345,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"copilot",
 	"cursor",
 	"devin",
 	"factorydroid",
@@ -361,6 +366,7 @@ const permissionsProcessorToolTargetTuple = [
 	"warp",
 	"zed"
 ];
+const checksProcessorToolTargetTuple = ["amp"];
 //#endregion
 //#region src/types/tool-targets.ts
 const ALL_TOOL_TARGETS = [...new Set([
@@ -371,7 +377,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 = z.enum(ALL_TOOL_TARGETS);
@@ -850,9 +857,15 @@ const GITIGNORE_DESTINATION_KEY = "gitignoreDestination";
 const SourceEntrySchema = z.object({
 	source: z.string().check(minLength(1, "source must be a non-empty string")),
 	skills: optional(z.array(z.string())),
-	transport: optional(z.enum(["github", "git"])),
+	transport: optional(z.enum([
+		"github",
+		"git",
+		"npm"
+	])),
 	ref: optional(z.string().check(refine((v) => !v.startsWith("-"), "ref must not start with \"-\""), refine((v) => !hasControlCharacters(v), "ref must not contain control characters"))),
 	path: optional(z.string().check(refine((v) => !v.includes(".."), "path must not contain \"..\""), refine((v) => !isAbsolute(v), "path must not be absolute"), refine((v) => !hasControlCharacters(v), "path must not contain control characters"))),
+	registry: optional(z.string().check(refine((v) => v.startsWith("https://") || v.startsWith("http://"), "registry must be an http(s) URL"), refine((v) => !hasControlCharacters(v), "registry must not contain control characters"))),
+	tokenEnv: optional(z.string().check(refine((v) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(v), "tokenEnv must be a valid environment variable name"))),
 	agent: optional(z.enum([
 		"github-copilot",
 		"claude-code",
@@ -862,7 +875,7 @@ const SourceEntrySchema = z.object({
 		"antigravity"
 	])),
 	scope: optional(z.enum(["project", "user"]))
-});
+}).check(refine((entry) => entry.registry === void 0 && entry.tokenEnv === void 0 || entry.transport === "npm", "\"registry\" and \"tokenEnv\" are only valid with transport \"npm\""));
 const ConfigParamsSchema = z.object({
 	outputRoots: z.union([z.array(z.string()), z.record(z.string(), z.union([z.string(), z.array(z.string())]))]),
 	targets: RulesyncConfigTargetsSchema,
@@ -1445,7 +1458,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
@@ -1693,13 +1706,17 @@ var FeatureProcessor = class {
 	}
 };
 //#endregion
-//#region src/constants/agentsmd-paths.ts
-const AGENTSMD_DIR = ".agents";
-const AGENTSMD_MEMORIES_DIR_PATH = join(AGENTSMD_DIR, "memories");
-const AGENTSMD_COMMANDS_DIR_PATH = join(AGENTSMD_DIR, "commands");
-const AGENTSMD_SKILLS_DIR_PATH = join(AGENTSMD_DIR, "skills");
-const AGENTSMD_SUBAGENTS_DIR_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 = join(".config", "amp");
+const AMP_AGENTS_DIR = ".agents";
+const AMP_SKILLS_PROJECT_DIR = join(AMP_AGENTS_DIR, "skills");
+const AMP_SKILLS_GLOBAL_DIR = join(".config", "agents", "skills");
+const AMP_CHECKS_PROJECT_DIR = join(AMP_AGENTS_DIR, "checks");
+const AMP_CHECKS_GLOBAL_DIR = 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 {
@@ -1773,6 +1790,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 = z.looseObject({
+	targets: z._default(RulesyncTargetsSchema, ["*"]),
+	description: z.optional(z.string()),
+	severity: z.optional(z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	])),
+	tools: z.optional(z.array(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 ${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 ${join(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath }) {
+		const filePath = 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 = 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 = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	"severity-default": z.optional(z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	])),
+	tools: z.optional(z.array(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 ${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 = 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 ${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 = 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 = 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 = 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 = 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 = join(this.outputRoot, paths.relativeDirPath);
+		const checkFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern));
+		const toRelativeFilePath = (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 = join(AGENTSMD_DIR, "memories");
+const AGENTSMD_COMMANDS_DIR_PATH = join(AGENTSMD_DIR, "commands");
+const AGENTSMD_SKILLS_DIR_PATH = join(AGENTSMD_DIR, "skills");
+const AGENTSMD_SUBAGENTS_DIR_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.
@@ -2020,13 +2445,6 @@ const AntigravityCommandFrontmatterSchema = 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 = z.looseObject({
 	targets: z._default(RulesyncTargetsSchema, ["*"]),
@@ -2829,6 +3247,7 @@ const COPILOT_HOOKS_DIR_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 = join(COPILOT_DIR, "agents");
@@ -3087,135 +3506,118 @@ var CursorCommand = class CursorCommand extends ToolCommand {
 //#endregion
 //#region src/constants/devin-paths.ts
 const DEVIN_DIR = ".devin";
-const CODEIUM_WINDSURF_DIR = join(".codeium", "windsurf");
-const DEVIN_WORKFLOWS_DIR_PATH = join(DEVIN_DIR, "workflows");
 const DEVIN_SKILLS_DIR_PATH = join(DEVIN_DIR, "skills");
 const DEVIN_AGENTS_DIR_PATH = join(DEVIN_DIR, "agents");
 const DEVIN_GLOBAL_CONFIG_DIR_PATH = join(".config", "devin");
 const DEVIN_GLOBAL_AGENTS_DIR_PATH = join(DEVIN_GLOBAL_CONFIG_DIR_PATH, "agents");
 const DEVIN_GLOBAL_SKILLS_DIR_PATH = join(DEVIN_GLOBAL_CONFIG_DIR_PATH, "skills");
-const CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_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 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(join(inputRoot, RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "**", "*.md"))).some((filePath) => commandSlug(basename(filePath)) === dirName);
+}
+//#endregion
 //#region src/features/commands/devin-command.ts
-const DevinCommandFrontmatterSchema = z.looseObject({ description: z.optional(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 ${join(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
-		}
-		super({
-			...rest,
-			fileContent: stringifyFrontmatter(body, frontmatter)
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "devin"
 		});
-		this.frontmatter = frontmatter;
-		this.body = body;
 	}
 	static getSettablePaths({ global = false } = {}) {
-		if (global) return { relativeDirPath: CODEIUM_WINDSURF_GLOBAL_WORKFLOWS_DIR_PATH };
-		return { relativeDirPath: DEVIN_WORKFLOWS_DIR_PATH };
-	}
-	getBody() {
-		return this.body;
+		return { relativeDirPath: global ? DEVIN_GLOBAL_SKILLS_DIR_PATH : DEVIN_SKILLS_DIR_PATH };
 	}
-	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: 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 ${join(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
-		};
 	}
-	static isTargetedByRulesyncCommand(rulesyncCommand) {
-		return this.isTargetedByRulesyncCommandDefault({
-			rulesyncCommand,
-			toolTarget: "devin"
+	toRulesyncCommand() {
+		const slug = basename(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 = 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
@@ -3543,10 +3945,7 @@ const HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_MANIFEST_PATH = join(HERMESAGENT_RUL
 const HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_INIT_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 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`;
@@ -3563,7 +3962,7 @@ var HermesagentCommand = class HermesagentCommand extends ToolCommand {
 	static getSettablePaths({ slug = "command" } = {}) {
 		return {
 			relativeDirPath: join(HERMESAGENT_SKILLS_DIR_PATH, slug),
-			relativeFilePath: SKILL_FILE_NAME$1
+			relativeFilePath: SKILL_FILE_NAME
 		};
 	}
 	constructor({ slug, ...params }) {
@@ -3594,7 +3993,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)
 		});
@@ -4254,6 +4653,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: {
@@ -4829,6 +5237,7 @@ const PI_AGENT_SKILLS_DIR_PATH = join(PI_AGENT_DIR, "skills");
 const PI_PROMPTS_DIR_PATH = join(".pi", "prompts");
 const PI_SKILLS_DIR_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
 /**
@@ -5363,9 +5772,6 @@ const ROVODEV_AGENTS_SKILLS_DIR_PATH = join(".agents", "skills");
 const ROVODEV_PROMPTS_FILE_NAME = "prompts.yml";
 const ROVODEV_PROMPTS_DIR_PATH = join(ROVODEV_DIR, "prompts");
 //#endregion
-//#region src/types/tool-file.ts
-var ToolFile = class extends AiFile {};
-//#endregion
 //#region src/features/commands/rovodev-command.ts
 /**
 * Rovo Dev CLI "saved prompts": a file-based custom-command surface made of a
@@ -5854,7 +6260,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: false,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: true
+			supportsSubdirectory: true,
+			skipToolFileScan: true
 		}
 	}],
 	["junie", {
@@ -5984,7 +6391,8 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			isSimulated: false,
-			supportsSubdirectory: false
+			supportsSubdirectory: false,
+			skipToolFileScan: true
 		}
 	}]
 ]);
@@ -6087,6 +6495,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 = join(this.outputRoot, paths.relativeDirPath);
 		const commandFilePaths = await findFilesByGlobs(factory.meta.supportsSubdirectory ? join(outputRootFull, "**", `*.${factory.meta.extension}`) : join(outputRootFull, `*.${factory.meta.extension}`));
@@ -6196,7 +6605,10 @@ const HookDefinitionSchema = z.looseObject({
 	type: z.optional(z.enum([
 		"command",
 		"prompt",
-		"http"
+		"http",
+		"agent",
+		"mcp_tool",
+		"function"
 	])),
 	url: z.optional(safeString),
 	timeout: z.optional(z.number()),
@@ -6209,12 +6621,72 @@ const HookDefinitionSchema = z.looseObject({
 	sequential: z.optional(z.boolean()),
 	async: z.optional(z.boolean()),
 	env: z.optional(z.record(z.string(), safeString)),
-	shell: z.optional(safeString),
+	shell: z.optional(z.enum(["bash", "powershell"])),
 	statusMessage: z.optional(safeString),
 	headers: z.optional(z.record(z.string(), safeString)),
 	allowedEnvVars: z.optional(z.array(z.string())),
-	once: z.optional(z.boolean())
+	once: z.optional(z.boolean()),
+	server: z.optional(safeString),
+	tool: z.optional(safeString),
+	input: z.optional(z.looseObject({})),
+	model: z.optional(safeString),
+	if: 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",
@@ -6689,12 +7161,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 = z.record(z.string(), 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 = z.record(z.string(), z.array(HookDefinitionSchema)).check(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 = z.looseObject({
 	version: z.optional(z.number()),
-	hooks: hooksRecordSchema,
+	hooks: canonicalHooksRecordSchema,
 	cursor: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	claudecode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	copilot: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
@@ -7131,6 +7619,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;
@@ -7188,6 +7690,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.
 */
@@ -7205,10 +7742,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 }
 		});
@@ -7275,6 +7821,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 }) {
@@ -7282,7 +7868,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 {
@@ -7290,12 +7876,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 }
 	};
 }
@@ -7309,6 +7903,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 = {};
@@ -7479,7 +8099,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
@@ -7586,10 +8207,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 {
@@ -7710,7 +8332,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 		"sessionEnd",
 		"stop",
 		"notification"
-	])
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
 };
 /**
 * AugmentCode (Auggie CLI) lifecycle hooks.
@@ -7792,10 +8415,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 {
@@ -7830,7 +8453,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) {
@@ -7895,10 +8530,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 {
@@ -8041,10 +8676,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 {
@@ -8212,10 +8847,10 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			throw new Error(`Failed to parse Copilot hooks content in ${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 {
@@ -8234,20 +8869,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.
@@ -8380,7 +9001,7 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else entries.push({
+		else if (hookType === "command") entries.push({
 			type: "command",
 			...matcherPart,
 			...compact({
@@ -8532,10 +9153,10 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 			throw new Error(`Failed to parse Copilot CLI hooks content in ${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 {
@@ -8590,9 +9211,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 },
@@ -8601,6 +9223,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,
@@ -8627,10 +9250,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 {
@@ -8685,7 +9309,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({
@@ -8775,10 +9399,10 @@ var DeepagentsHooks = class DeepagentsHooks extends ToolHooks {
 			throw new Error(`Failed to parse deepagents hooks content in ${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 {
@@ -8907,10 +9531,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 {
@@ -8934,7 +9558,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) {
@@ -9002,10 +9627,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 {
@@ -9096,10 +9721,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 {
@@ -9257,10 +9882,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 {
@@ -9421,10 +10046,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();
@@ -9527,10 +10152,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 {
@@ -9575,7 +10200,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,
@@ -9880,10 +10505,11 @@ var KiroHooks = class KiroHooks extends ToolHooks {
 			throw new Error(`Failed to parse Kiro hooks content in ${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 {
@@ -10092,10 +10718,10 @@ var KiroIdeHooks = class KiroIdeHooks extends ToolHooks {
 			throw new Error(`Failed to parse Kiro IDE hooks content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = kiroIdeHooksToCanonical(parsed.hooks ?? []);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "kiro-ide"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -10219,11 +10845,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);
@@ -10283,9 +10916,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({
@@ -10297,7 +10931,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,
@@ -10384,15 +11018,11 @@ var QwencodeHooks = class QwencodeHooks extends ToolHooks {
 		} catch (error) {
 			throw new Error(`Failed to parse Qwen Code hooks content in ${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() {
@@ -10554,10 +11184,10 @@ var ReasonixHooks = class ReasonixHooks extends ToolHooks {
 			throw new Error(`Failed to parse Reasonix hooks content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = reasonixHooksToCanonical(settings.hooks);
-		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
-			version: 1,
-			hooks
-		}, null, 2) });
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "reasonix"
+		}), null, 2) });
 	}
 	validate() {
 		return {
@@ -10780,10 +11410,10 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 			throw new Error(`Failed to parse Vibe hooks content in ${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 {
@@ -10870,7 +11500,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", {
@@ -11062,7 +11698,12 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: QWENCODE_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
+		supportedHookTypes: [
+			"command",
+			"prompt",
+			"http",
+			"function"
+		],
 		supportsMatcher: true
 	}],
 	["reasonix", {
@@ -12364,16 +13005,6 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	}
 };
 //#endregion
-//#region src/constants/amp-paths.ts
-const AMP_DIR = ".amp";
-const AMP_GLOBAL_DIR = join(".config", "amp");
-const AMP_AGENTS_DIR = ".agents";
-const AMP_SKILLS_PROJECT_DIR = join(AMP_AGENTS_DIR, "skills");
-const AMP_SKILLS_GLOBAL_DIR = 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 = z.string().check(refine((value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), "envVars entries must be valid environment variable names"));
 const McpServerSchema = z.looseObject({
@@ -13465,10 +14096,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_${createHash("sha256").update(name).digest("hex").slice(0, 8)}`,
+		usedFallback: true
+	};
 }
 function convertFromCodexFormat(codexMcp) {
 	const result = {};
@@ -13482,7 +14122,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;
 		}
@@ -13494,12 +14134,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;
@@ -13508,12 +14145,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;
 	}
@@ -13580,7 +14217,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);
@@ -14317,11 +14954,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);
 }
@@ -14379,7 +15016,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);
@@ -14399,11 +15036,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;
@@ -14716,7 +15353,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;
@@ -14735,8 +15372,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;
@@ -14748,8 +15385,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;
 }
@@ -14773,11 +15410,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) {
@@ -14825,7 +15462,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);
@@ -17150,7 +17787,11 @@ const VibePermissionsOverrideSchema = z.looseObject({ permission: z.optional(z.r
 */
 const CursorPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	approvalMode: z.optional(z.string()),
+	approvalMode: z.optional(z.enum([
+		"allowlist",
+		"auto-review",
+		"unrestricted"
+	])),
 	sandbox: z.optional(z.looseObject({}))
 });
 /**
@@ -17238,7 +17879,11 @@ const FactorydroidPermissionsOverrideSchema = z.looseObject({
 */
 const WarpPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	agent_mode_coding_permissions: z.optional(z.string()),
+	agent_mode_coding_permissions: z.optional(z.enum([
+		"always_ask_before_reading",
+		"always_allow_reading",
+		"allow_reading_specific_files"
+	])),
 	agent_mode_coding_file_read_allowlist: z.optional(z.array(z.string())),
 	agent_mode_execute_readonly_commands: z.optional(z.boolean())
 });
@@ -17284,7 +17929,11 @@ const JuniePermissionsOverrideSchema = z.looseObject({
 */
 const TaktPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	step_permission_overrides: z.optional(z.record(z.string(), z.string())),
+	step_permission_overrides: z.optional(z.record(z.string(), z.enum([
+		"readonly",
+		"edit",
+		"full"
+	]))),
 	provider_options: z.optional(z.looseObject({}))
 });
 /**
@@ -17314,9 +17963,15 @@ const AmpPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
 	permissions: z.optional(z.array(z.looseObject({
 		tool: z.string(),
-		action: z.string()
+		action: z.enum([
+			"allow",
+			"ask",
+			"reject",
+			"delegate"
+		]),
+		context: z.optional(z.enum(["thread", "subagent"]))
 	}))),
-	mcpPermissions: z.optional(z.array(z.looseObject({}))),
+	mcpPermissions: z.optional(z.array(z.looseObject({ action: z.enum(["allow", "reject"]) }))),
 	guardedFiles: z.optional(z.looseObject({ allowlist: z.optional(z.array(z.string())) })),
 	dangerouslyAllowAll: z.optional(z.boolean())
 });
@@ -17341,7 +17996,12 @@ const AmpPermissionsOverrideSchema = z.looseObject({
 */
 const AntigravityCliPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	toolPermission: z.optional(z.string()),
+	toolPermission: z.optional(z.enum([
+		"request-review",
+		"proceed-in-sandbox",
+		"always-proceed",
+		"strict"
+	])),
 	enableTerminalSandbox: z.optional(z.boolean())
 });
 /**
@@ -17370,7 +18030,14 @@ const AugmentcodePermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
 	toolPermissions: z.optional(z.array(z.looseObject({
 		toolName: z.string(),
-		permission: z.looseObject({ type: z.string() })
+		eventType: z.optional(z.enum(["tool-call", "tool-response"])),
+		permission: z.looseObject({ type: z.enum([
+			"allow",
+			"deny",
+			"ask-user",
+			"webhook-policy",
+			"script-policy"
+		]) })
 	})))
 });
 /**
@@ -17460,12 +18127,20 @@ const CodexApprovalsReviewerSchema = 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 = z.enum(CODEX_BASE_PERMISSION_PROFILES);
 /**
 * Codex CLI-scoped permission override.
@@ -17476,10 +18151,14 @@ const CodexBasePermissionProfileSchema = z.enum(CODEX_BASE_PERMISSION_PROFILES);
 * 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).
@@ -17500,13 +18179,14 @@ const CodexBasePermissionProfileSchema = z.enum(CODEX_BASE_PERMISSION_PROFILES);
 *   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
@@ -17583,6 +18263,7 @@ const PermissionsConfigSchema = z.looseObject({
 	kiro: z.optional(KiroPermissionsOverrideSchema),
 	codexcli: z.optional(CodexcliPermissionsOverrideSchema),
 	"antigravity-ide": z.optional(CanonicalPermissionsOverrideSchema),
+	copilot: z.optional(CanonicalPermissionsOverrideSchema),
 	devin: z.optional(CanonicalPermissionsOverrideSchema),
 	goose: z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: z.optional(CanonicalPermissionsOverrideSchema),
@@ -19503,15 +20184,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 = {}) {
@@ -19539,8 +20218,40 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		const existing = toMutableTable(smolToml.parse(existingContent || smolToml.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);
@@ -19601,6 +20312,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
@@ -19656,16 +20368,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") {
@@ -19678,6 +20384,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,
@@ -19958,6 +20674,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);
@@ -19990,6 +20767,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(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 = 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: join(this.getRelativeDirPath(), this.getRelativeFilePath()),
+				invalidRootPolicy: "error",
+				jsoncParseErrors: "error"
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse Copilot VS Code settings in ${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
@@ -20909,7 +21815,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;
@@ -21149,7 +22055,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
@@ -21190,9 +22096,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) => {
@@ -22973,7 +23879,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";
 	}
@@ -23533,8 +24439,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];
@@ -23880,6 +24786,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["copilot", {
+		class: CopilotPermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsImport: true
+		}
+	}],
 	["cursor", {
 		class: CursorPermissions,
 		meta: {
@@ -24114,9 +25028,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 {
 	/**
@@ -24317,10 +25228,10 @@ var ToolSkill = class extends AiDir {
 		const settablePaths = getSettablePaths({ global });
 		const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
 		const skillDirPath = join(outputRoot, actualRelativeDirPath, dirName);
-		const skillFilePath = join(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = 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,
@@ -24362,7 +25273,7 @@ var SimulatedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24420,12 +25331,12 @@ var SimulatedSkill = class extends ToolSkill {
 		const settablePaths = this.getSettablePaths();
 		const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
 		const skillDirPath = join(outputRoot, actualRelativeDirPath, dirName);
-		const skillFilePath = join(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = 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,
@@ -24635,7 +25546,7 @@ var RulesyncSkill = class RulesyncSkill extends AiDir {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24670,13 +25581,13 @@ var RulesyncSkill = class RulesyncSkill extends AiDir {
 	}
 	static async fromDir({ outputRoot = process.cwd(), relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName, global = false }) {
 		const skillDirPath = join(outputRoot, relativeDirPath, dirName);
-		const skillFilePath = join(skillDirPath, SKILL_FILE_NAME);
-		if (!await fileExists(skillFilePath)) throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+		const skillFilePath = 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,
@@ -24716,7 +25627,7 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -24743,7 +25654,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 {
@@ -24819,10 +25730,10 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 		const result = RovodevSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = 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({
@@ -24987,7 +25898,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25011,7 +25922,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 {
@@ -25083,7 +25994,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 		const result = AgentsSkillsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new this({
 			outputRoot: loaded.outputRoot,
@@ -25140,7 +26051,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25165,7 +26076,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 {
@@ -25225,7 +26136,7 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 		const result = AiassistantSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AiassistantSkill({
 			outputRoot: loaded.outputRoot,
@@ -25276,7 +26187,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25300,7 +26211,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 {
@@ -25360,7 +26271,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 		const result = AmpSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AmpSkill({
 			outputRoot: loaded.outputRoot,
@@ -25416,7 +26327,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25449,7 +26360,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 {
@@ -25509,7 +26420,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 		const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new this({
 			outputRoot: loaded.outputRoot,
@@ -25593,7 +26504,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25620,7 +26531,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 {
@@ -25680,7 +26591,7 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 		const result = AugmentcodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new AugmentcodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -25821,7 +26732,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -25848,7 +26759,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 {
@@ -25936,7 +26847,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 		const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ClaudecodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -25982,7 +26893,7 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26006,7 +26917,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 {
@@ -26070,10 +26981,10 @@ var ClineSkill = class ClineSkill extends ToolSkill {
 		const result = ClineSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = 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({
@@ -26187,7 +27098,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26211,7 +27122,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 {
@@ -26289,7 +27200,7 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 		const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CodexCliSkill({
 			outputRoot: loaded.outputRoot,
@@ -26341,7 +27252,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26366,7 +27277,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 {
@@ -26433,7 +27344,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CopilotSkill({
 			outputRoot: loaded.outputRoot,
@@ -26487,7 +27398,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26512,7 +27423,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 {
@@ -26581,7 +27492,7 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		const result = CopilotcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CopilotcliSkill({
 			outputRoot: loaded.outputRoot,
@@ -26631,7 +27542,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26655,7 +27566,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 {
@@ -26729,7 +27640,7 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 		const result = CursorSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new CursorSkill({
 			outputRoot: loaded.outputRoot,
@@ -26776,7 +27687,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26800,7 +27711,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 {
@@ -26876,7 +27787,7 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 		const result = DeepagentsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new DeepagentsSkill({
 			outputRoot: loaded.outputRoot,
@@ -26927,7 +27838,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -26952,7 +27863,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 {
@@ -27004,6 +27915,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,
@@ -27012,7 +27935,7 @@ var DevinSkill = class DevinSkill extends ToolSkill {
 		const result = DevinSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new DevinSkill({
 			outputRoot: loaded.outputRoot,
@@ -27064,7 +27987,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27088,7 +28011,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 {
@@ -27163,7 +28086,7 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 		const result = FactorydroidSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new FactorydroidSkill({
 			outputRoot: loaded.outputRoot,
@@ -27210,7 +28133,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27235,7 +28158,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 {
@@ -27295,7 +28218,7 @@ var GooseSkill = class GooseSkill extends ToolSkill {
 		const result = GooseSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new GooseSkill({
 			outputRoot: loaded.outputRoot,
@@ -27348,7 +28271,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27372,7 +28295,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 {
@@ -27432,7 +28355,7 @@ var GrokcliSkill = class GrokcliSkill extends ToolSkill {
 		const result = GrokcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new GrokcliSkill({
 			outputRoot: loaded.outputRoot,
@@ -27467,6 +28390,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,
@@ -27491,7 +28426,7 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27515,7 +28450,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 {
@@ -27579,10 +28514,10 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 		const result = JunieSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = 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({
@@ -27630,7 +28565,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27654,7 +28589,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 {
@@ -27726,7 +28661,7 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 		const result = KiloSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new KiloSkill({
 			outputRoot: loaded.outputRoot,
@@ -27772,7 +28707,7 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27796,7 +28731,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 {
@@ -27860,10 +28795,10 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 		const result = KiroSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = 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({
@@ -27946,7 +28881,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -27973,7 +28908,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 {
@@ -28052,7 +28987,7 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 		const result = OpenCodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new OpenCodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -28113,7 +29048,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 			relativeDirPath: resolvedDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28138,7 +29073,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 {
@@ -28213,7 +29148,7 @@ var PiSkill = class PiSkill extends ToolSkill {
 		const result = PiSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new PiSkill({
 			outputRoot: loaded.outputRoot,
@@ -28266,7 +29201,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28290,7 +29225,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 {
@@ -28370,7 +29305,7 @@ var QwencodeSkill = class QwencodeSkill extends ToolSkill {
 		const result = QwencodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new QwencodeSkill({
 			outputRoot: loaded.outputRoot,
@@ -28420,7 +29355,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28444,7 +29379,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 {
@@ -28504,7 +29439,7 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 		const result = ReasonixSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ReasonixSkill({
 			outputRoot: loaded.outputRoot,
@@ -28527,7 +29462,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 = join(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME);
+		const skillFilePath = join(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME$1);
 		try {
 			const { frontmatter } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
 			return frontmatter["runAs"] !== REASONIX_SUBAGENT_RUN_AS;
@@ -28577,7 +29512,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28601,7 +29536,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 {
@@ -28669,7 +29604,7 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 		const result = ReplitSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ReplitSkill({
 			outputRoot: loaded.outputRoot,
@@ -28716,7 +29651,7 @@ var RooSkill = class RooSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -28740,7 +29675,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 {
@@ -28804,10 +29739,10 @@ var RooSkill = class RooSkill extends ToolSkill {
 		const result = RooSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		if (result.data.name !== loaded.dirName) {
-			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			const skillFilePath = 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({
@@ -29024,7 +29959,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29051,7 +29986,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 {
@@ -29115,7 +30050,7 @@ var VibeSkill = class VibeSkill extends ToolSkill {
 		const result = VibeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new VibeSkill({
 			outputRoot: loaded.outputRoot,
@@ -29171,7 +30106,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29195,7 +30130,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 {
@@ -29255,7 +30190,7 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 		const result = WarpSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new WarpSkill({
 			outputRoot: loaded.outputRoot,
@@ -29303,7 +30238,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 			relativeDirPath,
 			dirName,
 			mainFile: {
-				name: SKILL_FILE_NAME,
+				name: SKILL_FILE_NAME$1,
 				body,
 				frontmatter: { ...frontmatter }
 			},
@@ -29327,7 +30262,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 {
@@ -29396,7 +30331,7 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 		const result = ZedSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
-			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME$1)}: ${formatError(result.error)}`);
 		}
 		return new ZedSkill({
 			outputRoot: loaded.outputRoot,
@@ -29836,7 +30771,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({
@@ -29867,7 +30803,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,
@@ -30970,7 +31907,6 @@ var CodexCliSubagent = class CodexCliSubagent extends ToolSubagent {
 };
 //#endregion
 //#region src/features/subagents/copilot-subagent.ts
-const REQUIRED_TOOL = "agent/runSubagent";
 const CopilotSubagentFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.optional(z.string()),
@@ -30980,10 +31916,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");
@@ -31037,14 +31969,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);
@@ -33268,7 +34200,7 @@ var ReasonixSubagent = class ReasonixSubagent extends ToolSubagent {
 			frontmatter: reasonixFrontmatter,
 			body,
 			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: join(subagentName, SKILL_FILE_NAME),
+			relativeFilePath: join(subagentName, SKILL_FILE_NAME$1),
 			fileContent,
 			validate,
 			global
@@ -34274,6 +35206,7 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		name: z.optional(z.string()),
 		description: z.optional(z.string())
 	})),
+	pi: z.optional(z.looseObject({ systemPrompt: z.optional(z.enum(["append"])) })),
 	takt: z.optional(z.looseObject({
 		name: z.optional(z.string()),
 		extends: z.optional(z.string()),
@@ -34437,6 +35370,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;
 	}
@@ -36783,6 +37726,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 } = {}) {
@@ -36984,14 +37936,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
@@ -37010,15 +37969,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";
@@ -37037,10 +37993,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(join(outputRoot, join(relativeDirPath, relativeFilePath)));
 		return new JunieRule({
 			outputRoot,
@@ -37048,7 +38001,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 }) {
@@ -37063,13 +38016,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();
@@ -37472,31 +38427,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(join(outputRoot, 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(join(outputRoot, join(root.relativeDirPath, root.relativeFilePath)));
 		return new PiRule({
 			outputRoot,
@@ -37508,8 +38500,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,
@@ -37520,6 +38522,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() {
@@ -37530,6 +38543,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,
@@ -38689,7 +39711,8 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "auto",
+			foldsNonRootIntoRoot: true
 		}
 	}],
 	["kilo", {
@@ -38955,7 +39978,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(join(rule.getRelativeDirPath(), rule.getRelativeFilePath())));
+		const instructionPaths = toolRules.filter((rule) => !rule.isRoot() && !rule.isExcludedFromRootReferences()).map((rule) => toPosixPath(join(rule.getRelativeDirPath(), rule.getRelativeFilePath())));
 		if (instructionPaths.length === 0) return [];
 		return [await meta.mcpInstructionsRegistrar.fromInstructions({
 			outputRoot: this.outputRoot,
@@ -38987,7 +40010,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 = join(toolRelativeDirPath, skill.getDirName(), SKILL_FILE_NAME);
+			const relativePath = join(toolRelativeDirPath, skill.getDirName(), SKILL_FILE_NAME$1);
 			return {
 				name: frontmatter.name,
 				description: frontmatter.description,
@@ -39011,11 +40034,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 = 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.
@@ -39225,6 +40262,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) => 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: 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 = join(this.outputRoot, settablePaths.nonRoot.relativeDirPath);
@@ -39260,6 +40318,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				...rootToolRules,
 				...localRootToolRules,
 				...rootMirrorDeletionRules,
+				...extraFixedToolRules,
 				...nonRootToolRules
 			];
 		} catch (error) {
@@ -39287,7 +40346,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.");
@@ -39303,7 +40362,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:");
@@ -39324,7 +40383,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)),
@@ -39332,7 +40391,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,
@@ -39342,7 +40402,8 @@ async function convertFromTool(params) {
 		subagentsCount,
 		skillsCount,
 		hooksCount,
-		permissionsCount
+		permissionsCount,
+		checksCount
 	};
 }
 async function runFeatureConvert(ctx, strategy) {
@@ -39575,6 +40636,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 = [
@@ -39625,6 +40707,12 @@ const PROCESSOR_REGISTRY = [
 		processor: PermissionsProcessor,
 		schema: PermissionsProcessorToolTargetSchema,
 		factory: toolPermissionsFactories
+	},
+	{
+		feature: "checks",
+		processor: ChecksProcessor,
+		schema: ChecksProcessorToolTargetSchema,
+		factory: toolCheckFactories
 	}
 ];
 const getProcessorRegistryEntry = (feature) => {
@@ -39974,6 +41062,7 @@ const GENERATION_STEP_GRAPH = [
 		id: "permissions",
 		...sharedWriteMeta("permissions")
 	},
+	{ id: "checks" },
 	{
 		id: "rules",
 		...sharedWriteMeta("rules"),
@@ -40059,6 +41148,10 @@ async function generate(params) {
 			config,
 			logger
 		}),
+		checks: () => generateChecksCore({
+			config,
+			logger
+		}),
 		rules: () => generateRulesCore({
 			config,
 			logger,
@@ -40095,6 +41188,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
 	};
@@ -40463,6 +41558,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 = 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
 /**
@@ -40520,6 +41653,11 @@ async function importFromTool(params) {
 			config,
 			tool,
 			logger
+		}),
+		checksCount: await importChecksCore({
+			config,
+			tool,
+			logger
 		})
 	};
 }
@@ -40736,7 +41874,28 @@ 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
-export { removeFile as $, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as At, ErrorCodes as B, RulesyncHooks as C, RULESYNC_PERMISSIONS_FILE_NAME as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_RELATIVE_DIR_PATH as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_SCHEMA_URL as Et, ConfigResolver as F, fileExists as G, createTempDirectory as H, findControlCharacter as I, getHomeDirectory as J, findFilesByGlobs as K, ConsoleLogger as L, RulesyncCommandFrontmatterSchema as M, formatError as Mt, stringifyFrontmatter as N, ALL_FEATURES as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RULES_RELATIVE_DIR_PATH as Ot, loadYaml as P, ALL_FEATURES_WITH_WILDCARD as Pt, removeDirectory as Q, JsonLogger as R, HooksProcessor as S, RULESYNC_OVERVIEW_FILE_NAME as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Tt, directoryExists as U, checkPathTraversal as V, ensureDir as W, listDirectoryFiles as X, isSymlink as Y, readFileContent as Z, RulesyncPermissions as _, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as _t, convertFromTool as a, ToolTargetSchema as at, IgnoreProcessor as b, RULESYNC_MCP_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CONFIG_SCHEMA_URL as dt, removeTempDirectory as et, SkillsProcessor as f, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ft, SKILL_FILE_NAME as g, RULESYNC_IGNORE_RELATIVE_FILE_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_HOOKS_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ALL_TOOL_TARGETS_WITH_WILDCARD as it, RulesyncCommand as j, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_SKILLS_RELATIVE_DIR_PATH as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as lt, RulesyncSkill as m, RULESYNC_HOOKS_JSONC_FILE_NAME as mt, checkRulesyncDirExists as n, writeFileContent as nt, RulesProcessor as o, MAX_FILE_SIZE as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_FILE_NAME as pt, getFileSize as q, generate as r, ALL_TOOL_TARGETS as rt, RulesyncRule as s, RULESYNC_AIIGNORE_FILE_NAME as st, importFromTool as t, toPosixPath as tt, RulesyncSubagent as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ut, McpProcessor as v, RULESYNC_MCP_FILE_NAME as vt, CommandsProcessor as w, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as wt, RulesyncIgnore as x, RULESYNC_MCP_SCHEMA_URL as xt, RulesyncMcp as y, RULESYNC_MCP_JSONC_FILE_NAME as yt, CLIError as z };
+export { isSymlink as $, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as A, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as At, findControlCharacter as B, ALL_FEATURES_WITH_WILDCARD as Bt, CommandsProcessor as C, RULESYNC_MCP_FILE_NAME as Ct, CLAUDECODE_DIR as D, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Dt, CODEXCLI_DIR as E, RULESYNC_MCP_SCHEMA_URL as Et, RulesyncCheck as F, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Ft, checkPathTraversal as G, JsonLogger as H, RulesyncCheckFrontmatterSchema as I, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as It, ensureDir as J, createTempDirectory as K, stringifyFrontmatter as L, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Lt, RulesyncCommand as M, RULESYNC_PERMISSIONS_SCHEMA_URL as Mt, RulesyncCommandFrontmatterSchema as N, RULESYNC_RELATIVE_DIR_PATH as Nt, CLAUDECODE_LOCAL_RULE_FILE_NAME as O, RULESYNC_OVERVIEW_FILE_NAME as Ot, ChecksProcessor as P, RULESYNC_RULES_RELATIVE_DIR_PATH as Pt, getHomeDirectory as Q, loadYaml as R, formatError as Rt, RulesyncHooks as S, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as St, CODEXCLI_BASH_RULES_FILE_NAME as T, RULESYNC_MCP_RELATIVE_FILE_PATH as Tt, CLIError as U, ConsoleLogger as V, ErrorCodes as W, findFilesByGlobs as X, fileExists as Y, getFileSize as Z, McpProcessor as _, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as _t, convertFromTool as a, toPosixPath as at, RulesyncIgnore as b, RULESYNC_HOOKS_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, ALL_TOOL_TARGETS_WITH_WILDCARD as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_AIIGNORE_FILE_NAME as dt, listDirectoryFiles as et, SkillsProcessor as f, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ft, RulesyncPermissions as g, RULESYNC_CONFIG_SCHEMA_URL as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, removeTempDirectory as it, CLAUDECODE_SKILLS_DIR_PATH as j, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as jt, CLAUDECODE_MEMORIES_DIR_NAME as k, RULESYNC_PERMISSIONS_FILE_NAME as kt, SubagentsProcessor as l, ToolTargetSchema as lt, RulesyncSkill as m, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as mt, checkRulesyncDirExists as n, removeDirectory as nt, RulesProcessor as o, writeFileContent as ot, getLocalSkillDirNames as p, RULESYNC_CHECKS_RELATIVE_DIR_PATH as pt, directoryExists as q, generate as r, removeFile as rt, RulesyncRule as s, ALL_TOOL_TARGETS as st, importFromTool as t, readFileContent as tt, RulesyncSubagent as u, MAX_FILE_SIZE as ut, RulesyncMcp as v, RULESYNC_HOOKS_FILE_NAME as vt, SKILL_FILE_NAME$1 as w, RULESYNC_MCP_JSONC_FILE_NAME as wt, HooksProcessor as x, RULESYNC_IGNORE_RELATIVE_FILE_PATH as xt, IgnoreProcessor as y, RULESYNC_HOOKS_JSONC_FILE_NAME as yt, ConfigResolver as z, ALL_FEATURES as zt };
 
-//# sourceMappingURL=import-hM4jDZn1.js.map
+//# sourceMappingURL=import-CSnC5vl7.js.map