rulesync 22.0.0 → 23.0.0

package/dist/{import-DNDrEvS2.js → import-CGIOcUpR.js}

@@ -2703,6 +2703,7 @@ var Config = class Config {
 	*/
 	objectFormTargetKeys;
 	configFileTargets;
+	configFileSelection;
 	verbose;
 	delete;
 	global;
@@ -2737,7 +2738,7 @@ var Config = class Config {
 	inputRoots;
 	configFilePath;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, preserveUnownedHooks, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, preserveUnownedHooks, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets, configFileSelection }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -2762,6 +2763,7 @@ var Config = class Config {
 		this.features = resolvedFeatures;
 		this.objectFormTargetKeys = isRulesyncConfigTargetsObject(resolvedTargets) ? Config.filterValidToolTargets(Object.keys(resolvedTargets)) : void 0;
 		this.configFileTargets = configFileTargets;
+		this.configFileSelection = configFileSelection;
 		this.verbose = verbose;
 		this.delete = isDelete;
 		this.global = global ?? false;
@@ -2852,17 +2854,54 @@ var Config = class Config {
 	getConfigFileTargets() {
 		return this.configFileTargets ?? this.getTargets();
 	}
+	/**
+	* The features `target` has for a run over the configuration file's
+	* targets, i.e. what `rulesync generate` without `--targets` would produce
+	* for it (a CLI `--features` still applies to array-form targets). Falls
+	* back to {@link getFeatures} when no configuration file declared `targets`.
+	*/
+	getConfigFileFeatures(target) {
+		const selection = this.configFileSelection;
+		if (selection === void 0) return this.getFeatures(target);
+		return Config.resolveTargetFeatures({
+			targets: selection.targets,
+			features: selection.features ?? [],
+			target
+		});
+	}
+	/**
+	* The options `target` sets for `feature` in the configuration file, for
+	* the same run as {@link getConfigFileFeatures}. Falls back to
+	* {@link getFeatureOptions} when no configuration file declared `targets`.
+	*/
+	getConfigFileFeatureOptions(target, feature) {
+		const selection = this.configFileSelection;
+		if (selection === void 0) return this.getFeatureOptions(target, feature);
+		return Config.resolveFeatureOptions({
+			targets: selection.targets,
+			target,
+			feature
+		});
+	}
 	getFeatures(target) {
-		if (isRulesyncConfigTargetsObject(this.targets)) {
-			if (target) {
-				const value = this.targets[target];
-				if (!value) return [];
-				return Config.normalizeTargetFeatures(value);
-			}
-			return Config.collectAllFeatures(Object.values(this.targets));
+		if (target) return Config.resolveTargetFeatures({
+			targets: this.targets,
+			features: this.features,
+			target
+		});
+		if (isRulesyncConfigTargetsObject(this.targets)) return Config.collectAllFeatures(Object.values(this.targets));
+		return Config.normalizeFeatureList(this.features);
+	}
+	static resolveTargetFeatures({ targets, features, target }) {
+		if (isRulesyncConfigTargetsObject(targets)) {
+			const value = targets[target];
+			return value ? Config.normalizeTargetFeatures(value) : [];
 		}
-		if (this.features.includes("*")) return [...ALL_FEATURES];
-		return this.features.filter((feature) => feature !== "*");
+		return Config.normalizeFeatureList(features);
+	}
+	static normalizeFeatureList(features) {
+		if (features.includes("*")) return [...ALL_FEATURES];
+		return features.filter((feature) => feature !== "*");
 	}
 	/**
 	* Normalize a per-target features value (array or per-feature object) into
@@ -2903,7 +2942,14 @@ var Config = class Config {
 	* feature is not enabled for the given target.
 	*/
 	getFeatureOptions(target, feature) {
-		const value = isRulesyncConfigTargetsObject(this.targets) ? this.targets[target] : void 0;
+		return Config.resolveFeatureOptions({
+			targets: this.targets,
+			target,
+			feature
+		});
+	}
+	static resolveFeatureOptions({ targets, target, feature }) {
+		const value = isRulesyncConfigTargetsObject(targets) ? targets[target] : void 0;
 		if (!value || Array.isArray(value)) return;
 		const featureValue = value[feature];
 		if (featureValue && typeof featureValue === "object" && isFeatureValueEnabled(featureValue)) return featureValue;
@@ -3338,7 +3384,15 @@ var ConfigResolver = class {
 			sources: configByFile.sources ?? getDefaults().sources,
 			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
 			language: configByFile.language,
-			configFileTargets: extractConfigFileTargets(configByFile.targets)
+			configFileTargets: extractConfigFileTargets(configByFile.targets),
+			configFileSelection: configByFile.targets === void 0 ? void 0 : {
+				targets: configByFile.targets,
+				features: resolveFeaturesAndTargets({
+					features,
+					targets: void 0,
+					configByFile
+				}).resolvedFeatures
+			}
 		});
 	}
 };
@@ -14940,6 +14994,7 @@ const ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH = join(ANTIGRAVITY_GLOBAL_CONFIG_DIR_PA
 const ANTIGRAVITY_AGENTS_DIR = ANTIGRAVITY_DIR;
 const ANTIGRAVITY_RULE_FILE_NAME = "AGENTS.md";
 const ANTIGRAVITY_GLOBAL_RULE_FILE_NAME = "GEMINI.md";
+const ANTIGRAVITY_GLOBAL_RULES_SUBDIR = join(ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR, "rules");
 //#endregion
 //#region src/features/commands/antigravity-command.ts
 const AntigravityWorkflowFrontmatterSchema = z.looseObject({
@@ -73137,97 +73192,6 @@ var AmpRule = class AmpRule extends ToolRule {
 	}
 };
 //#endregion
-//#region src/features/rules/antigravity-cli-rule.ts
-/**
-* Rule generator for the Google Antigravity CLI (`agy`, the Gemini-CLI
-* successor in Antigravity 2.0).
-*
-* The CLI reads the same plain-markdown context files as Gemini CLI — a root
-* context file plus non-root memory files in `.agents/rules/` — so this class
-* follows that same plain-markdown approach but points at the new `.agents/` tree.
-*
-* - Project scope: root `AGENTS.md` (the cross-tool standard, matching
-*   `antigravity-ide`); non-root `.agents/rules/*.md`.
-* - Global scope: a single plain `~/.gemini/GEMINI.md` (shared with the IDE).
-*/
-var AntigravityCliRule = class AntigravityCliRule extends ToolRule {
-	static getSettablePaths({ global, excludeToolDir } = {}) {
-		if (global) return { root: {
-			relativeDirPath: buildToolPath(ANTIGRAVITY_GEMINI_DIR, ".", excludeToolDir),
-			relativeFilePath: ANTIGRAVITY_GLOBAL_RULE_FILE_NAME
-		} };
-		return {
-			root: {
-				relativeDirPath: ".",
-				relativeFilePath: ANTIGRAVITY_RULE_FILE_NAME
-			},
-			nonRoot: { relativeDirPath: buildToolPath(ANTIGRAVITY_AGENTS_DIR, "rules", excludeToolDir) }
-		};
-	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
-		const paths = this.getSettablePaths({ global });
-		if (relativeFilePath === paths.root.relativeFilePath) {
-			const relativePath = paths.root.relativeFilePath;
-			const fileContent = await readFileContent(join(outputRoot, paths.root.relativeDirPath, relativePath));
-			return new AntigravityCliRule({
-				outputRoot,
-				relativeDirPath: paths.root.relativeDirPath,
-				relativeFilePath: paths.root.relativeFilePath,
-				fileContent,
-				validate,
-				root: true
-			});
-		}
-		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const relativePath = join(paths.nonRoot.relativeDirPath, relativeFilePath);
-		const fileContent = await readFileContent(join(outputRoot, relativePath));
-		return new AntigravityCliRule({
-			outputRoot,
-			relativeDirPath: paths.nonRoot.relativeDirPath,
-			relativeFilePath,
-			fileContent,
-			validate,
-			root: false
-		});
-	}
-	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
-		const paths = this.getSettablePaths({ global });
-		return new AntigravityCliRule(this.buildToolRuleParamsDefault({
-			outputRoot,
-			rulesyncRule,
-			validate,
-			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
-		}));
-	}
-	toRulesyncRule() {
-		return this.toRulesyncRuleDefault();
-	}
-	validate() {
-		return {
-			success: true,
-			error: null
-		};
-	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
-		const isRoot = relativeFilePath === this.getSettablePaths({ global }).root.relativeFilePath;
-		return new AntigravityCliRule({
-			outputRoot,
-			relativeDirPath,
-			relativeFilePath,
-			fileContent: "",
-			validate: false,
-			root: isRoot
-		});
-	}
-	static isTargetedByRulesyncRule(rulesyncRule) {
-		return this.isTargetedByRulesyncRuleDefault({
-			rulesyncRule,
-			toolTarget: "antigravity-cli"
-		});
-	}
-};
-//#endregion
 //#region src/features/rules/antigravity-rule.ts
 const AntigravityRuleFrontmatterSchema = z.looseObject({
 	trigger: z.optional(z.union([
@@ -73374,6 +73338,185 @@ const STRATEGIES$1 = [
 	}
 ];
 //#endregion
+//#region src/features/rules/antigravity-cli-rule.ts
+/**
+* Rule generator for the Google Antigravity CLI (`agy`, the Gemini-CLI
+* successor in Antigravity 2.0).
+*
+* The CLI reads the same plain-markdown context files as Gemini CLI — a root
+* context file plus non-root memory files in `.agents/rules/` — so this class
+* follows that same plain-markdown approach but points at the new `.agents/` tree.
+*
+* - Project scope: root `AGENTS.md` (the cross-tool standard, matching
+*   `antigravity-ide`); non-root `.agents/rules/*.md`.
+* - Global scope: root plain `~/.gemini/GEMINI.md` (shared with the IDE);
+*   non-root `~/.gemini/config/rules/*.md`. The CLI truncates each rule file at
+*   24,000 bytes, so keeping non-root rules as separate files stops a large rule
+*   set from being cut off. Every file in that directory must carry a valid
+*   `trigger` frontmatter or the CLI discards it, so these files get the same
+*   trigger-strategy frontmatter as the IDE's non-root rules.
+*
+* @see https://antigravity.google/docs/rules
+*/
+var AntigravityCliRule = class AntigravityCliRule extends ToolRule {
+	static getSettablePaths({ global, excludeToolDir } = {}) {
+		if (global) return {
+			root: {
+				relativeDirPath: buildToolPath(ANTIGRAVITY_GEMINI_DIR, ".", excludeToolDir),
+				relativeFilePath: ANTIGRAVITY_GLOBAL_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_GLOBAL_RULES_SUBDIR, excludeToolDir) }
+		};
+		return {
+			root: {
+				relativeDirPath: ".",
+				relativeFilePath: ANTIGRAVITY_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(ANTIGRAVITY_AGENTS_DIR, "rules", excludeToolDir) }
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		if (relativeFilePath === paths.root.relativeFilePath && (relativeDirPath === void 0 || relativeDirPath === paths.root.relativeDirPath)) {
+			const relativePath = paths.root.relativeFilePath;
+			const fileContent = await readFileContent(join(outputRoot, paths.root.relativeDirPath, relativePath));
+			return new AntigravityCliRule({
+				outputRoot,
+				relativeDirPath: paths.root.relativeDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				fileContent,
+				validate,
+				root: true,
+				global
+			});
+		}
+		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
+		const relativePath = join(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(join(outputRoot, relativePath));
+		const rule = new AntigravityCliRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate,
+			root: false,
+			global
+		});
+		if (validate) {
+			const result = rule.validate();
+			if (!result.success) throw new Error(`Invalid frontmatter in ${relativePath}: ${result.error.message}`);
+		}
+		return rule;
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const params = this.buildToolRuleParamsDefault({
+			outputRoot,
+			rulesyncRule,
+			validate,
+			rootPath: paths.root,
+			nonRootPath: paths.nonRoot
+		});
+		if (!global || params.root) return new AntigravityCliRule({
+			...params,
+			global
+		});
+		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+		const storedAntigravity = rulesyncFrontmatter.antigravity;
+		const storedTrigger = storedAntigravity?.trigger;
+		const strategy = STRATEGIES$1.find((s) => s.canHandle(storedTrigger));
+		if (!strategy) throw new Error(`No strategy found for trigger: ${storedTrigger}`);
+		const frontmatter = strategy.generateFrontmatter(normalizeStoredAntigravity(storedAntigravity), rulesyncFrontmatter);
+		return new AntigravityCliRule({
+			...params,
+			relativeFilePath: params.relativeFilePath.split(/[\\/]/).join("-"),
+			fileContent: stringifyFrontmatter(rulesyncRule.getBody(), frontmatter),
+			global
+		});
+	}
+	toRulesyncRule() {
+		if (!this.global || this.root) return this.toRulesyncRuleDefault();
+		const { frontmatter, body } = this.parseGlobalNonRootContent();
+		const strategy = STRATEGIES$1.find((s) => s.canHandle(frontmatter.trigger));
+		const rulesyncData = strategy ? strategy.exportRulesyncData(frontmatter) : {
+			globs: [],
+			antigravity: frontmatter
+		};
+		return new RulesyncRule({
+			outputRoot: process.cwd(),
+			relativeDirPath: RulesyncRule.getSettablePaths().recommended.relativeDirPath,
+			relativeFilePath: this.getRelativeFilePath(),
+			frontmatter: {
+				root: false,
+				targets: ["*"],
+				...rulesyncData,
+				antigravity: {
+					...rulesyncData.antigravity,
+					globs: frontmatter.globs ? parseGlobsString$1(frontmatter.globs) : void 0
+				}
+			},
+			body
+		});
+	}
+	validate() {
+		if (!this.global || this.root) return {
+			success: true,
+			error: null
+		};
+		try {
+			const { frontmatter } = this.parseGlobalNonRootContent();
+			const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) return {
+				success: false,
+				error: new Error(formatError(result.error))
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+		return {
+			success: true,
+			error: null
+		};
+	}
+	/**
+	* `~/.gemini/config/rules/` is shared with the Antigravity IDE and holds
+	* global rules the user created outside rulesync, which cannot be told apart
+	* from generated ones, so the orphan sweep never removes files there.
+	*/
+	isDeletable() {
+		return !this.global || this.root;
+	}
+	parseGlobalNonRootContent() {
+		const { frontmatter, body } = parseFrontmatter(this.getFileContent(), this.getFilePath());
+		return {
+			frontmatter,
+			body
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath === paths.root.relativeDirPath;
+		return new AntigravityCliRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: isRoot,
+			global
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "antigravity-cli"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/antigravity-ide-rule.ts
 /**
 * Rule generator for the Google Antigravity IDE (Antigravity 2.0).
@@ -79000,7 +79143,9 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			ruleDiscoveryModeGlobal: "auto",
+			sharedGlobalNonRootDir: true
 		}
 	}],
 	["antigravity-ide", {
@@ -80079,7 +80224,7 @@ var RulesProcessor = class extends FeatureProcessor {
 	*/
 	generateReferenceSectionFromMeta(meta, toolRules) {
 		switch (resolveRuleDiscoveryMode({
-			defaultMode: meta.ruleDiscoveryMode,
+			defaultMode: this.global && meta.ruleDiscoveryModeGlobal ? meta.ruleDiscoveryModeGlobal : meta.ruleDiscoveryMode,
 			options: this.featureOptions
 		})) {
 			case "toon": return this.generateToonReferencesSection(toolRules);
@@ -80598,7 +80743,8 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const nonRootToolRules = await (async () => {
 				if (!settablePaths.nonRoot) return [];
 				const nonRootOutputRoot = join(this.outputRoot, settablePaths.nonRoot.relativeDirPath);
-				const nonRootFilePaths = await findFilesByGlobs(`**/*.${factory.meta.extension}`, { cwd: nonRootOutputRoot });
+				const isSharedGlobalNonRootDir = this.global && factory.meta.sharedGlobalNonRootDir === true;
+				const nonRootFilePaths = await findFilesByGlobs(`${isSharedGlobalNonRootDir ? "" : "**/"}*.${factory.meta.extension}`, { cwd: nonRootOutputRoot });
 				if (forDeletion) return buildDeletionRulesFromPaths(nonRootFilePaths, {
 					outputRootOverride: nonRootOutputRoot,
 					relativeDirPathOverride: settablePaths.nonRoot.relativeDirPath
@@ -80611,19 +80757,25 @@ As this project's AI coding tool, you must follow the additional conventions bel
 					if (!ok) this.logger.warn(`Skipping reserved Rovodev path under modular-rules (import): ${join(modularRootRelative, relativeFilePath)}`);
 					return ok;
 				}) : nonRootFilePaths).filter((filePath) => rootFileNameInSameDir === void 0 || relative(nonRootOutputRoot, filePath) !== rootFileNameInSameDir);
-				return await Promise.all(nonRootPathsForImport.map((filePath) => {
+				return (await Promise.all(nonRootPathsForImport.map(async (filePath) => {
 					const relativeFilePath = relative(nonRootOutputRoot, filePath);
 					checkPathTraversal({
 						relativePath: relativeFilePath,
 						intendedRootDir: nonRootOutputRoot
 					});
-					return factory.class.fromFile({
-						outputRoot: this.outputRoot,
-						relativeDirPath: modularRootRelative,
-						relativeFilePath,
-						global: this.global
-					});
-				}));
+					try {
+						return await factory.class.fromFile({
+							outputRoot: this.outputRoot,
+							relativeDirPath: modularRootRelative,
+							relativeFilePath,
+							global: this.global
+						});
+					} catch (error) {
+						if (!isSharedGlobalNonRootDir) throw error;
+						this.logger.warn(`Skipping ${stripControlCharacters(join(modularRootRelative, relativeFilePath))} for ${this.toolTarget}: ${formatError(error)}`);
+						return;
+					}
+				}))).filter((rule) => rule !== void 0);
 			})();
 			this.logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
 			return [
@@ -82017,6 +82169,115 @@ function computeRootFileOwnership(params) {
 	}
 	return ownerByPath;
 }
+function createSkippedRootFileCheck({ rootFileOwner }) {
+	const skippedByRoot = /* @__PURE__ */ new Map();
+	const emittedByRoot = /* @__PURE__ */ new Map();
+	const emittedKey = (toolTarget, relativePath) => `${toolTarget}\0${relativePath}`;
+	const loadOwnerToolFiles = async (processor) => {
+		const rulesyncFiles = await processor.loadRulesyncFiles();
+		return {
+			toolFiles: rulesyncFiles.length > 0 ? await processor.convertRulesyncFilesToToolFiles(rulesyncFiles) : [],
+			sourceLoadFailed: processor.hasRulesyncSourceLoadFailure()
+		};
+	};
+	return {
+		observe: ({ toolTarget, outputRoot, processor, toolFiles, skipFilePaths }) => {
+			if (rootFileOwner.size === 0) return;
+			for (const toolFile of toolFiles) {
+				const relativePath = toolFile.getRelativePathFromCwd();
+				if (!rootFileOwner.has(relativePath)) continue;
+				const emitted = emittedByRoot.get(outputRoot) ?? /* @__PURE__ */ new Set();
+				emittedByRoot.set(outputRoot, emitted);
+				emitted.add(emittedKey(toolTarget, relativePath));
+				if (!skipFilePaths.has(relativePath)) continue;
+				const skipped = skippedByRoot.get(outputRoot) ?? /* @__PURE__ */ new Map();
+				skippedByRoot.set(outputRoot, skipped);
+				skipped.set(relativePath, {
+					processor,
+					toolFile
+				});
+			}
+		},
+		verify: async ({ isOwnerProcessed, createOwnerProcessor }) => {
+			let count = 0;
+			const paths = [];
+			let sourceLoadFailed = false;
+			for (const [outputRoot, skipped] of skippedByRoot) {
+				const ownerOutputs = /* @__PURE__ */ new Map();
+				for (const [relativePath, fallback] of skipped) {
+					const owner = rootFileOwner.get(relativePath);
+					if (owner === void 0) continue;
+					if (emittedByRoot.get(outputRoot)?.has(emittedKey(owner, relativePath))) continue;
+					let expected = fallback;
+					if (!isOwnerProcessed(owner)) {
+						if (!ownerOutputs.has(owner)) {
+							const processor = await createOwnerProcessor({
+								toolTarget: owner,
+								outputRoot
+							});
+							if (processor === void 0) ownerOutputs.set(owner, void 0);
+							else {
+								const loaded = await loadOwnerToolFiles(processor);
+								if (loaded.sourceLoadFailed) sourceLoadFailed = true;
+								ownerOutputs.set(owner, {
+									processor,
+									toolFiles: loaded.toolFiles
+								});
+							}
+						}
+						const ownerOutput = ownerOutputs.get(owner);
+						const ownerFile = ownerOutput?.toolFiles.find((file) => file.getRelativePathFromCwd() === relativePath && file.getFilePath() === fallback.toolFile.getFilePath());
+						if (ownerOutput !== void 0 && ownerFile !== void 0) expected = {
+							processor: ownerOutput.processor,
+							toolFile: ownerFile
+						};
+					}
+					const result = await expected.processor.writeAiFiles([expected.toolFile]);
+					count += result.count;
+					paths.push(...result.paths);
+				}
+			}
+			return {
+				count,
+				paths,
+				hasDiff: count > 0,
+				sourceLoadFailed
+			};
+		}
+	};
+}
+/**
+* The skills a full `rulesync generate` hands to the rules step: what the
+* skills step collects for every config-file target that generates skills, in
+* the same order. Simulated skill sections in a root file list these, so a
+* narrowed check needs them to rebuild another target's root file.
+*/
+async function loadConfigFileSkills({ config, logger }) {
+	const supportedSkillsTargets = SkillsProcessor.getToolTargets({
+		global: config.getGlobal(),
+		includeSimulated: config.getSimulateSkills()
+	});
+	const skills = [];
+	for (const toolTarget of intersection(config.getConfigFileTargets(), supportedSkillsTargets)) {
+		if (!config.getConfigFileFeatures(toolTarget).includes("skills")) continue;
+		for (const outputRoot of config.getOutputRoots(toolTarget)) {
+			const processor = new SkillsProcessor({
+				outputRoot: resolveToolOutputRoot({
+					outputRoot,
+					toolTarget,
+					global: config.getGlobal()
+				}),
+				inputRoots: config.getInputRoots(),
+				toolTarget,
+				global: config.getGlobal(),
+				dryRun: true,
+				logger
+			});
+			for (const rulesyncDir of await processor.loadRulesyncDirs()) if (rulesyncDir instanceof RulesyncSkill) skills.push(rulesyncDir);
+		}
+	}
+	return skills;
+}
 async function generateRulesCore(params) {
 	const { config, logger, sweepPlan, skills } = params;
 	let totalCount = 0;
@@ -82032,32 +82293,47 @@ async function generateRulesCore(params) {
 		logger
 	});
 	const foldRootOverwriteWatch = createFoldRootOverwriteWatch({ logger });
+	let fullRunSkills;
+	const loadFullRunSkills = () => {
+		fullRunSkills ??= loadConfigFileSkills({
+			config,
+			logger
+		});
+		return fullRunSkills;
+	};
+	const createProcessor = ({ toolTarget, outputRoot, featureOptions, skills: processorSkills }) => new RulesProcessor({
+		outputRoot: resolveToolOutputRoot({
+			outputRoot,
+			toolTarget,
+			global: config.getGlobal()
+		}),
+		inputRoots: config.getInputRoots(),
+		toolTarget,
+		global: config.getGlobal(),
+		simulateCommands: config.getSimulateCommands(),
+		simulateSubagents: config.getSimulateSubagents(),
+		simulateSkills: config.getSimulateSkills(),
+		language: config.getLanguage(),
+		deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
+		skills: processorSkills,
+		featureOptions,
+		delete: config.getDelete(),
+		dryRun: config.isPreviewMode(),
+		logger
+	});
 	const isCheck = config.getCheck();
 	const rootFileOwner = isCheck ? computeRootFileOwnership({
-		targets: config.getConfigFileTargets(),
+		targets: config.getConfigFileTargets().filter((target) => (toolTargets.includes(target) ? config.getFeatures(target) : config.getConfigFileFeatures(target)).includes("rules")),
 		global: config.getGlobal()
 	}) : /* @__PURE__ */ new Map();
+	const skippedRootFileCheck = createSkippedRootFileCheck({ rootFileOwner });
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("rules")) continue;
-		const processor = new RulesProcessor({
-			outputRoot: resolveToolOutputRoot({
-				outputRoot,
-				toolTarget,
-				global: config.getGlobal()
-			}),
-			inputRoots: config.getInputRoots(),
+		const processor = createProcessor({
 			toolTarget,
-			global: config.getGlobal(),
-			simulateCommands: config.getSimulateCommands(),
-			simulateSubagents: config.getSimulateSubagents(),
-			simulateSkills: config.getSimulateSkills(),
-			language: config.getLanguage(),
-			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
-			skills,
+			outputRoot,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
-			delete: config.getDelete(),
-			dryRun: config.isPreviewMode(),
-			logger
+			skills
 		});
 		const rulesyncFiles = await processor.loadRulesyncFiles();
 		const skipFilePaths = /* @__PURE__ */ new Set();
@@ -82070,16 +82346,39 @@ async function generateRulesCore(params) {
 			rulesyncFiles,
 			sweepPlan,
 			skipFilePaths: skipFilePaths.size > 0 ? skipFilePaths : void 0,
-			onToolFiles: (toolFiles) => foldRootOverwriteWatch.observe({
-				toolTarget,
-				toolFiles
-			})
+			onToolFiles: (toolFiles) => {
+				foldRootOverwriteWatch.observe({
+					toolTarget,
+					toolFiles
+				});
+				skippedRootFileCheck.observe({
+					toolTarget,
+					outputRoot,
+					processor,
+					toolFiles,
+					skipFilePaths
+				});
+			}
 		});
 		totalCount += result.count;
 		allPaths.push(...result.paths);
 		if (result.hasDiff) hasDiff = true;
 		if (result.sourceLoadFailed) sourceLoadFailed = true;
 	}
+	if (isCheck) {
+		const skippedResult = await skippedRootFileCheck.verify({
+			isOwnerProcessed: (owner) => toolTargets.includes(owner) && config.getFeatures(owner).includes("rules"),
+			createOwnerProcessor: async (ownerParams) => supportedTargets.includes(ownerParams.toolTarget) && config.getOutputRoots(ownerParams.toolTarget).includes(ownerParams.outputRoot) ? createProcessor({
+				...ownerParams,
+				featureOptions: config.getConfigFileFeatureOptions(ownerParams.toolTarget, "rules"),
+				skills: config.getSimulateSkills() && SkillsProcessor.getToolTargetsSimulated().includes(ownerParams.toolTarget) ? await loadFullRunSkills() : void 0
+			}) : void 0
+		});
+		totalCount += skippedResult.count;
+		allPaths.push(...skippedResult.paths);
+		if (skippedResult.hasDiff) hasDiff = true;
+		if (skippedResult.sourceLoadFailed) sourceLoadFailed = true;
+	}
 	foldRootOverwriteWatch.report();
 	return {
 		count: totalCount,
@@ -82846,4 +83145,4 @@ async function importChecksCore(params) {
 //#endregion
 export { RulesyncCommand as $, toPosixPath as $t, CLAUDECODE_MEMORIES_DIR_NAME as A, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as An, checkPathTraversal as At, RulesyncSubagent as B, stripControlCharacters as Bn, listDirectoryEntryNames as Bt, COMMANDCODE_DIR as C, RULESYNC_PERMISSIONS_SCHEMA_URL as Cn, withWarnOnceScope as Ct, CODEXCLI_DIR as D, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, assertDirectoryIfExists as Dt, CODEXCLI_BASH_RULES_FILE_NAME as E, RULESYNC_SKILLS_RELATIVE_DIR_PATH as En, applyFileMode as Et, caseFoldIdentity as F, formatError as Fn, getFileSize as Ft, RulesyncRuleFrontmatterSchema as G, readFileContentOrNull as Gt, RulesyncSkill as H, stripHiddenCharacters as Hn, listSubdirectoryNames as Ht, groupSpellingsByCaseFoldedIdentity as I, truncateText as In, getHomeDirectory as It, RulesyncIgnore as J, removeFile as Jt, RulesyncPermissions as K, removeDirectory as Kt, AUGMENTCODE_DIR as L, hasDeceptiveHiddenCharacters as Ln, isFileNotFoundError as Lt, CLAUDECODE_SKILLS_DIR_PATH as M, ALL_FEATURES as Mn, directoryExists as Mt, FACTORYDROID_DIR as N, ALL_FEATURES_WITH_WILDCARD as Nn, ensureDir as Nt, CLAUDECODE_DIR as O, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as On, assertTreeContainsNoSymlinks as Ot, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as P, DEPRECATED_FEATURE_REPLACEMENTS as Pn, fileExists as Pt, parseJsonc as Q, runWithDirectoryRollback as Qt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as R, hasEnclosingMarkOutsideKeycap as Rn, isFileSystemError as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Sn, resetRunWarningState as St, ChecksProcessor as T, RULESYNC_RULES_RELATIVE_DIR_PATH as Tn, ErrorCodes as Tt, RulesyncSkillFrontmatterSchema as U, pathEscapesRoot as Ut, RulesyncSubagentFrontmatterSchema as V, stripControlCharactersKeepingLineFeeds as Vn, listFilePathsRecursively as Vt, RulesyncRule as W, readFileContent as Wt, getRulesyncSourceCandidates as X, removeTempDirectory as Xt, RulesyncHooks as Y, removeFileStrict as Yt, resolveRulesyncSourceWritePath as Z, resolvePath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, JsonLogger as _t, getProcessorRegistryEntry as a, ToolTargetSchema as an, SHARED_USER_MANAGED_CONFIG_PATHS as at, CommandsProcessor as b, RULESYNC_MCP_SCHEMA_URL as bn, warnOnConflictingFlags as bt, RulesProcessor as c, MAX_FILE_SIZE as cn, mergeInputRootConfigs as ct, CODEBUDDY_DIR as d, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as dn, ConfigFileSchema as dt, writeFileBuffer as en, RulesyncCommandFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CONFIG_RELATIVE_FILE_PATH as fn, GITIGNORE_DESTINATION_KEY as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, ConsoleLogger as gt, shortenToWidth as h, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as hn, findControlCharacter as ht, inspectInputRoots as i, PACKAGING_TOOL_TARGETS as in, loadYaml as it, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as j, parseCommaSeparatedList as jn, createTempDirectory as jt, CLAUDECODE_LOCAL_RULE_FILE_NAME as k, RULESYNC_USER_CONFIG_DIR_NAME as kn, assertWritablePathInsideRoot as kt, SubagentsProcessor as l, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ln, resolveEffectiveInputRoots as lt, displayWidthOf as m, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as mn, assertTargetsFeaturesExclusive as mt, formatSourceLoadFailure as n, ALL_TOOL_TARGETS as nn, RulesyncCheckFrontmatterSchema as nt, convertFromTool as o, CURATED_RULES_FEATURE_SUBDIR as on, SKILL_FILE_NAME as ot, ELLIPSIS_WIDTH as p, RULESYNC_CONFIG_SCHEMA_URL as pn, SourceEntrySchema as pt, RulesyncMcp as q, removeDirectoryStrict as qt, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rn, stringifyFrontmatter as rt, isPackagingToolTarget as s, FEATURE_SOURCE_TREE_ENTRIES as sn, ConfigResolver as st, importFromTool as t, writeFileContent as tn, RulesyncCheck as tt, SkillsProcessor as u, RULESYNC_CHECKS_RELATIVE_DIR_PATH as un, CONFLICTING_TARGET_PAIRS as ut, HooksProcessor as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, WarningCollectingLogger as vt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as w, RULESYNC_RELATIVE_DIR_PATH as wn, CLIError as wt, QWENCODE_DIR as x, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as xn, withFallbackLoggerTarget as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_MCP_RELATIVE_FILE_PATH as yn, fallbackLogger as yt, getLocalSkillDirNames as z, quoteForLog as zn, isSymlink as zt };
 
-//# sourceMappingURL=import-DNDrEvS2.js.map
+//# sourceMappingURL=import-CGIOcUpR.js.map