rulesync 22.0.0 → 23.0.0

package/dist/{import-1vyJw3q0.cjs → import-CeSvBhiv.cjs}

@@ -444,36 +444,36 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$351 } = node_path.posix;
+const { join: join$352 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
 const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$351(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$352(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$351(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$351(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$352(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$352(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$351(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 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.jsonc";
@@ -2728,6 +2728,7 @@ var Config = class Config {
 	*/
 	objectFormTargetKeys;
 	configFileTargets;
+	configFileSelection;
 	verbose;
 	delete;
 	global;
@@ -2762,7 +2763,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
@@ -2787,6 +2788,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;
@@ -2877,17 +2879,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
@@ -2928,7 +2967,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;
@@ -3363,7 +3409,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
+			}
 		});
 	}
 };
@@ -14965,6 +15019,7 @@ const ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GLOBA
 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 = (0, node_path.join)(ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR, "rules");
 //#endregion
 //#region src/features/commands/antigravity-command.ts
 const AntigravityWorkflowFrontmatterSchema = zod_mini.z.looseObject({
@@ -73162,97 +73217,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((0, node_path.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 = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
-		const fileContent = await readFileContent((0, node_path.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 = zod_mini.z.looseObject({
 	trigger: zod_mini.z.optional(zod_mini.z.union([
@@ -73399,6 +73363,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((0, node_path.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 = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.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).
@@ -79025,7 +79168,9 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			ruleDiscoveryModeGlobal: "auto",
+			sharedGlobalNonRootDir: true
 		}
 	}],
 	["antigravity-ide", {
@@ -80104,7 +80249,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);
@@ -80623,7 +80768,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 = (0, node_path.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
@@ -80636,19 +80782,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): ${(0, node_path.join)(modularRootRelative, relativeFilePath)}`);
 					return ok;
 				}) : nonRootFilePaths).filter((filePath) => rootFileNameInSameDir === void 0 || (0, node_path.relative)(nonRootOutputRoot, filePath) !== rootFileNameInSameDir);
-				return await Promise.all(nonRootPathsForImport.map((filePath) => {
+				return (await Promise.all(nonRootPathsForImport.map(async (filePath) => {
 					const relativeFilePath = (0, node_path.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((0, node_path.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 [
@@ -82042,6 +82194,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 (0, es_toolkit.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;
@@ -82057,32 +82318,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();
@@ -82095,16 +82371,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,