rulesync 21.0.0 → 23.0.0

package/dist/{import-CGT8v9bO.cjs → import-CeSvBhiv.cjs}

@@ -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
+			}
 		});
 	}
 };
@@ -12295,7 +12349,7 @@ const CODEXCLI_AGENTS_DIR_PATH = (0, node_path.join)(CODEXCLI_DIR, "agents");
 const CODEXCLI_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
 const CODEXCLI_HOOKS_FILE_NAME = "hooks.json";
 const CODEXCLI_MCP_FILE_NAME = "config.toml";
-const CODEXCLI_RULE_FILE_NAME = "AGENTS.md";
+const CODEXCLI_PROJECT_DOC_MAX_BYTES = 32768;
 const CODEXCLI_BASH_RULES_FILE_NAME = "rulesync.rules";
 const CODEXCLI_OPENAI_YAML_RELATIVE_PATH = (0, node_path.join)("agents", "openai.yaml");
 const CODEXCLI_OVERRIDE_KEYS = [
@@ -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({
@@ -15480,12 +15535,50 @@ var BobCommand = class BobCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/features/shared/claudecode-argument-hint.ts
+/**
+* Turns a YAML-list `argument-hint` back into the bracketed string form Claude
+* Code documents (`[issue-number]`, `[filename] [format]`), one bracketed
+* placeholder per list entry. The per-entry form is chosen over re-joining with
+* commas because it is the shape every Claude Code example uses. An empty list
+* carries no hint, so it yields `undefined` and the key is dropped.
+*/
+function joinArgumentHint(value) {
+	if (typeof value === "string") return value;
+	if (value.length === 0) return;
+	return value.map((entry) => `[${String(entry)}]`).join(" ");
+}
+/**
+* `argument-hint` as Claude Code reads it from skill and command frontmatter.
+*
+* The documented examples (`[issue-number]`) are written unquoted, and YAML
+* parses an unquoted `[issue-number]` as a one-element list. Claude Code
+* accepts that form, so it is accepted here too and normalized to the
+* bracketed string, keeping the parsed value (and everything downstream of it)
+* a plain string. A scalar entry YAML did not read as a string (`[1]`,
+* `[true]`, `[~]`) is stringified rather than rejected.
+* https://code.claude.com/docs/en/skills
+*
+* A list entry is stringified from the value YAML produced, so its original
+* spelling is not kept (`[1.0]` becomes `[1]`), and an entry YAML reads as a
+* date (`[2026-01-01]`) is rejected.
+*
+* The unquoted multi-placeholder form (`argument-hint: [filename] [format]`)
+* is not valid YAML at all, so it fails before this schema is reached.
+*/
+const ClaudecodeArgumentHintSchema = zod_mini.z.pipe(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.union([
+	zod_mini.z.string(),
+	zod_mini.z.number(),
+	zod_mini.z.boolean(),
+	zod_mini.z.null()
+]))]), zod_mini.z.transform(joinArgumentHint));
+//#endregion
 //#region src/features/commands/claudecode-command.ts
 const ClaudecodeCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	"disallowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
-	"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+	"argument-hint": zod_mini.z.optional(ClaudecodeArgumentHintSchema),
 	model: zod_mini.z.optional(zod_mini.z.string()),
 	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -15514,7 +15607,8 @@ var ClaudecodeCommand = class ClaudecodeCommand extends ToolCommand {
 		return this.frontmatter;
 	}
 	toRulesyncCommand() {
-		const { description, ...restFields } = this.frontmatter;
+		const { description, ...extraFields } = this.frontmatter;
+		const restFields = Object.fromEntries(Object.entries(extraFields).filter(([, value]) => value !== void 0));
 		const rulesyncFrontmatter = {
 			targets: ["*"],
 			description,
@@ -33147,6 +33241,74 @@ function translateCanonicalKeyToCodex({ key, value, isStdio, serverName }) {
 	}
 }
 /**
+* A header value that is exactly one canonical `${VAR}` reference. Anchored and
+* without the `g` flag, so `.exec()` carries no `lastIndex` state between
+* calls. `${VAR:-default}` does not match (the name excludes `:`), because
+* Codex has no way to express the fallback.
+*/
+const WHOLE_ENV_VAR_REF_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+/**
+* An `Authorization` value that is exactly `Bearer ${VAR}`. The scheme is
+* matched case-insensitively, as HTTP authentication schemes are.
+*/
+const BEARER_ENV_VAR_REF_PATTERN = /^Bearer \$\{([A-Za-z_][A-Za-z0-9_]*)\}$/i;
+const AUTHORIZATION_HEADER_NAME = "authorization";
+/**
+* Whether a string still contains an unexpanded `${…}` reference. Codex writes
+* `url` and `http_headers` values as-is and never expands them, so such a value
+* reaches the server literally.
+*/
+function hasUnexpandedEnvVarRef(value) {
+	return value.includes("${");
+}
+/**
+* Rewrite canonical `${VAR}` header references into the keys Codex reads them
+* from, since Codex sends `http_headers` values verbatim:
+* - `Authorization: Bearer ${VAR}` → `bearer_token_env_var = "VAR"`
+* - a header whose whole value is `${VAR}` → `env_http_headers.<name> = "VAR"`
+*
+* Runs after every key is translated, so a `bearer_token_env_var` or
+* `env_http_headers` the source already carries (they pass through under their
+* own names) is seen regardless of key order. Those explicit values win: a
+* derived bearer is not written over an existing one, and an existing
+* `env_http_headers` entry for the same header is kept. Any value the rewrite
+* cannot express — a partial reference, a `${VAR:-default}` fallback — stays in
+* `http_headers` verbatim with a warning, as does a `${…}` in `url`, for which
+* Codex has no environment-sourced counterpart at all.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+function convertEnvVarRefsForCodex({ converted, serverName }) {
+	const url = converted["url"];
+	if (typeof url === "string" && hasUnexpandedEnvVarRef(url)) warnWithFallback(void 0, `[CodexCliMcp] MCP server "${serverName}": 'url' contains an environment variable reference that Codex does not expand, so it is written verbatim and the server will likely fail to start.`);
+	const httpHeaders = converted["http_headers"];
+	if (!isHeadersRecord(httpHeaders)) return;
+	const existingEnvHeaders = converted["env_http_headers"];
+	const canWriteEnvHeaders = existingEnvHeaders === void 0 || isHeadersRecord(existingEnvHeaders);
+	const envHeaders = {};
+	const staticHeaders = {};
+	let bearerTokenEnvVar;
+	for (const [name, value] of Object.entries(httpHeaders)) {
+		const bearerMatch = BEARER_ENV_VAR_REF_PATTERN.exec(value);
+		if (bearerMatch?.[1] && name.toLowerCase() === AUTHORIZATION_HEADER_NAME) {
+			if (converted["bearer_token_env_var"] === void 0 && bearerTokenEnvVar === void 0) bearerTokenEnvVar = bearerMatch[1];
+			continue;
+		}
+		const wholeMatch = WHOLE_ENV_VAR_REF_PATTERN.exec(value);
+		if (wholeMatch?.[1] && canWriteEnvHeaders) {
+			envHeaders[name] = wholeMatch[1];
+			continue;
+		}
+		if (hasUnexpandedEnvVarRef(value)) warnWithFallback(void 0, `[CodexCliMcp] MCP server "${serverName}": header '${name}' contains an environment variable reference that Codex cannot source from the environment, so it is written verbatim to 'http_headers' and sent literally. Only 'Authorization: Bearer \${VAR}' and a whole-value '\${VAR}' are converted.`);
+		staticHeaders[name] = value;
+	}
+	converted["http_headers"] = staticHeaders;
+	if (bearerTokenEnvVar !== void 0) converted["bearer_token_env_var"] = bearerTokenEnvVar;
+	if (Object.keys(envHeaders).length > 0) converted["env_http_headers"] = {
+		...envHeaders,
+		...isHeadersRecord(existingEnvHeaders) ? existingEnvHeaders : {}
+	};
+}
+/**
 * Codex states no transport of its own — it infers one from `command` versus
 * `url`, which is why generate drops the canonical `type`. Restate it for a url
 * server on the way back, so a config imported from Codex reaches the adapters
@@ -33233,6 +33395,10 @@ function convertToCodexFormat(mcpServers) {
 				}
 			} else converted[key] = value;
 		}
+		convertEnvVarRefsForCodex({
+			converted,
+			serverName: name
+		});
 		const previousName = originalNames.get(codexName);
 		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);
@@ -59232,7 +59398,7 @@ const ClaudecodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	"disallowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	model: zod_mini.z.optional(zod_mini.z.string()),
 	effort: zod_mini.z.optional(zod_mini.z.string()),
-	"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+	"argument-hint": zod_mini.z.optional(ClaudecodeArgumentHintSchema),
 	arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	context: zod_mini.z.optional(zod_mini.z.string()),
 	agent: zod_mini.z.optional(zod_mini.z.string()),
@@ -65388,7 +65554,8 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: true
+			supportsGlobal: true,
+			lenientImport: true
 		}
 	}],
 	["claudecode-plugin", {
@@ -72337,7 +72504,7 @@ var ToolRule = class extends ToolFile {
 	static buildToolRuleParamsAgentsmd({ outputRoot = process.cwd(), rulesyncRule, validate = true, rootPath = {
 		relativeDirPath: ".",
 		relativeFilePath: "AGENTS.md"
-	}, nonRootPath = { relativeDirPath: AGENTSMD_MEMORIES_DIR_PATH } }) {
+	}, nonRootPath = { relativeDirPath: AGENTSMD_MEMORIES_DIR_PATH }, global = false }) {
 		const params = this.buildToolRuleParamsDefault({
 			outputRoot,
 			rulesyncRule,
@@ -72346,7 +72513,7 @@ var ToolRule = class extends ToolFile {
 			nonRootPath
 		});
 		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
-		if (!rulesyncFrontmatter.root && rulesyncFrontmatter.agentsmd?.subprojectPath) {
+		if (!global && !rulesyncFrontmatter.root && rulesyncFrontmatter.agentsmd?.subprojectPath) {
 			params.relativeDirPath = (0, node_path.join)(rulesyncFrontmatter.agentsmd.subprojectPath);
 			params.relativeFilePath = "AGENTS.md";
 		}
@@ -73003,7 +73170,8 @@ var AmpRule = class AmpRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		});
 		if (!params.root && params.globs !== void 0 && params.globs.length > 0) params.fileContent = stringifyFrontmatter(params.fileContent, { globs: params.globs });
 		return new AmpRule(params);
@@ -73049,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([
@@ -73286,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).
@@ -74298,7 +74554,8 @@ var ClineRule = class ClineRule extends ToolRule {
 				outputRoot,
 				rulesyncRule,
 				validate,
-				rootPath: paths.root
+				rootPath: paths.root,
+				global
 			}));
 		}
 		if (isRoot) return new ClineRule({
@@ -74718,26 +74975,62 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 	}
 };
 //#endregion
-//#region src/features/rules/codexcli-rule.ts
-var CodexcliRule = class CodexcliRule extends ToolRule {
-	constructor({ fileContent, root, ...rest }) {
-		super({
-			...rest,
-			fileContent,
-			root: root ?? false
-		});
+//#region src/features/rules/nested-agentsmd-rule.ts
+/**
+* Shared adapter for the targets that read instructions exactly the way the
+* AGENTS.md standard describes them and nothing more: a root `AGENTS.md` at the
+* project root, nested per-directory `AGENTS.md` files loaded only while working
+* under that directory, and a single personal root file under a tool-specific
+* home directory. Such a target has no modular non-root instruction directory,
+* so every other non-root rule folds into the root file.
+*
+* Concrete targets (Codex CLI, Pool, Vibe, DeepSeek Harness) only supply the global
+* directory and their tool target through {@link getFamily}; the vendor docs
+* describing each one's discovery walk live on the subclass.
+*
+* The nested-file scan mirrors the AGENTS.md standard's nested discovery —
+* same file name, same exclusions, import-only, project scope — because it
+* discovers literally the same files.
+*/
+var NestedAgentsmdRule = class extends ToolRule {
+	static getFamily() {
+		throw new Error("Please implement this method in the subclass.");
 	}
 	static getSettablePaths({ global = false } = {}) {
+		if (global) return { root: {
+			relativeDirPath: this.getFamily().globalDir,
+			relativeFilePath: AGENTSMD_RULE_FILE_NAME
+		} };
 		return { root: {
-			relativeDirPath: global ? CODEXCLI_DIR : ".",
-			relativeFilePath: CODEXCLI_RULE_FILE_NAME
+			relativeDirPath: ".",
+			relativeFilePath: AGENTSMD_RULE_FILE_NAME
 		} };
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+	static getNestedFilePatterns() {
+		return this.buildNestedFilePatterns({ fileName: AGENTSMD_RULE_FILE_NAME });
+	}
+	/**
+	* The subproject directory this rule scopes, or `undefined` for the root file
+	* (project or global).
+	*/
+	getSubprojectPath() {
+		return this.getNestedSubprojectPath({ fileName: AGENTSMD_RULE_FILE_NAME });
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, relativeDirPath: overrideDirPath, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
-		return new CodexcliRule({
+		if (overrideDirPath !== void 0 && overrideDirPath !== root.relativeDirPath && overrideDirPath !== ".") {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, overrideDirPath, AGENTSMD_RULE_FILE_NAME));
+			return new this({
+				outputRoot,
+				relativeDirPath: overrideDirPath,
+				relativeFilePath: AGENTSMD_RULE_FILE_NAME,
+				fileContent,
+				validate,
+				root: false
+			});
+		}
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, root.relativeDirPath, root.relativeFilePath));
+		return new this({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
 			relativeFilePath: root.relativeFilePath,
@@ -74748,8 +75041,18 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
-		return new CodexcliRule({
+		const frontmatter = rulesyncRule.getFrontmatter();
+		const isRoot = frontmatter.root ?? false;
+		const subprojectPath = frontmatter.agentsmd?.subprojectPath;
+		if (!global && !isRoot && subprojectPath) return new this({
+			outputRoot,
+			relativeDirPath: (0, node_path.join)(subprojectPath),
+			relativeFilePath: AGENTSMD_RULE_FILE_NAME,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: false
+		});
+		return new this({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
 			relativeFilePath: root.relativeFilePath,
@@ -74759,7 +75062,9 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 		});
 	}
 	toRulesyncRule() {
-		return this.toRulesyncRuleDefault();
+		const subprojectPath = this.getSubprojectPath();
+		if (subprojectPath === void 0) return this.toRulesyncRuleDefault();
+		return this.toRulesyncRuleNestedAgentsmd({ subprojectPath });
 	}
 	validate() {
 		return {
@@ -74768,23 +75073,54 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new CodexcliRule({
+		const isRoot = relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === this.getFamily().globalDir);
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			root: relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === ".codex")
+			root: isRoot
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
 		return this.isTargetedByRulesyncRuleDefault({
 			rulesyncRule,
-			toolTarget: "codexcli"
+			toolTarget: this.getFamily().toolTarget
 		});
 	}
 };
 //#endregion
+//#region src/features/rules/codexcli-rule.ts
+/**
+* Rule generator for OpenAI Codex CLI.
+*
+* Codex CLI loads instructions only from the `AGENTS.md` family: the global
+* `~/.codex/AGENTS.md` (or `AGENTS.override.md`), then one file per directory
+* level from the project root down to the current working directory, joined
+* root-first so deeper files take precedence. Nested per-directory files are
+* therefore a real scoping surface, and Codex's docs recommend splitting large
+* instruction sets across nested directories. It does NOT scan a
+* `.codex/memories/` directory for instruction files — that directory belongs
+* to Codex's separate SQLite-backed auto-memory system.
+*
+* A non-root rule carrying `agentsmd.subprojectPath` is emitted as a nested
+* `<subprojectPath>/AGENTS.md` (project scope only); every other non-root rule
+* folds into the root `AGENTS.md`, since Codex has no modular rules directory.
+* The project files on the root-to-cwd chain share one `project_doc_max_bytes`
+* budget (32 KiB by default), which the RulesProcessor warns about.
+*
+* @see https://learn.chatgpt.com/docs/agent-configuration/agents-md
+*/
+var CodexcliRule = class extends NestedAgentsmdRule {
+	static getFamily() {
+		return {
+			globalDir: CODEXCLI_DIR,
+			toolTarget: "codexcli"
+		};
+	}
+};
+//#endregion
 //#region src/features/rules/commandcode-rule.ts
 var CommandcodeRule = class CommandcodeRule extends ToolRule {
 	constructor({ fileContent, root, ...rest }) {
@@ -76089,122 +76425,6 @@ var DevinRule = class DevinRule extends ToolRule {
 	}
 };
 //#endregion
-//#region src/features/rules/nested-agentsmd-rule.ts
-/**
-* Shared adapter for the targets that read instructions exactly the way the
-* AGENTS.md standard describes them and nothing more: a root `AGENTS.md` at the
-* project root, nested per-directory `AGENTS.md` files loaded only while working
-* under that directory, and a single personal root file under a tool-specific
-* home directory. Such a target has no modular non-root instruction directory,
-* so every other non-root rule folds into the root file.
-*
-* Concrete targets (Pool, Vibe, DeepSeek Harness) only supply the global
-* directory and their tool target through {@link getFamily}; the vendor docs
-* describing each one's discovery walk live on the subclass.
-*
-* The nested-file scan mirrors the AGENTS.md standard's nested discovery —
-* same file name, same exclusions, import-only, project scope — because it
-* discovers literally the same files.
-*/
-var NestedAgentsmdRule = class extends ToolRule {
-	static getFamily() {
-		throw new Error("Please implement this method in the subclass.");
-	}
-	static getSettablePaths({ global = false } = {}) {
-		if (global) return { root: {
-			relativeDirPath: this.getFamily().globalDir,
-			relativeFilePath: AGENTSMD_RULE_FILE_NAME
-		} };
-		return { root: {
-			relativeDirPath: ".",
-			relativeFilePath: AGENTSMD_RULE_FILE_NAME
-		} };
-	}
-	static getNestedFilePatterns() {
-		return this.buildNestedFilePatterns({ fileName: AGENTSMD_RULE_FILE_NAME });
-	}
-	/**
-	* The subproject directory this rule scopes, or `undefined` for the root file
-	* (project or global).
-	*/
-	getSubprojectPath() {
-		return this.getNestedSubprojectPath({ fileName: AGENTSMD_RULE_FILE_NAME });
-	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, relativeDirPath: overrideDirPath, validate = true, global = false }) {
-		const { root } = this.getSettablePaths({ global });
-		if (overrideDirPath !== void 0 && overrideDirPath !== root.relativeDirPath && overrideDirPath !== ".") {
-			const fileContent = await readFileContent((0, node_path.join)(outputRoot, overrideDirPath, AGENTSMD_RULE_FILE_NAME));
-			return new this({
-				outputRoot,
-				relativeDirPath: overrideDirPath,
-				relativeFilePath: AGENTSMD_RULE_FILE_NAME,
-				fileContent,
-				validate,
-				root: false
-			});
-		}
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, root.relativeDirPath, root.relativeFilePath));
-		return new this({
-			outputRoot,
-			relativeDirPath: root.relativeDirPath,
-			relativeFilePath: root.relativeFilePath,
-			fileContent,
-			validate,
-			root: true
-		});
-	}
-	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
-		const { root } = this.getSettablePaths({ global });
-		const frontmatter = rulesyncRule.getFrontmatter();
-		const isRoot = frontmatter.root ?? false;
-		const subprojectPath = frontmatter.agentsmd?.subprojectPath;
-		if (!global && !isRoot && subprojectPath) return new this({
-			outputRoot,
-			relativeDirPath: (0, node_path.join)(subprojectPath),
-			relativeFilePath: AGENTSMD_RULE_FILE_NAME,
-			fileContent: rulesyncRule.getBody(),
-			validate,
-			root: false
-		});
-		return new this({
-			outputRoot,
-			relativeDirPath: root.relativeDirPath,
-			relativeFilePath: root.relativeFilePath,
-			fileContent: rulesyncRule.getBody(),
-			validate,
-			root: isRoot
-		});
-	}
-	toRulesyncRule() {
-		const subprojectPath = this.getSubprojectPath();
-		if (subprojectPath === void 0) return this.toRulesyncRuleDefault();
-		return this.toRulesyncRuleNestedAgentsmd({ subprojectPath });
-	}
-	validate() {
-		return {
-			success: true,
-			error: null
-		};
-	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		const isRoot = relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === this.getFamily().globalDir);
-		return new this({
-			outputRoot,
-			relativeDirPath,
-			relativeFilePath,
-			fileContent: "",
-			validate: false,
-			root: isRoot
-		});
-	}
-	static isTargetedByRulesyncRule(rulesyncRule) {
-		return this.isTargetedByRulesyncRuleDefault({
-			rulesyncRule,
-			toolTarget: this.getFamily().toolTarget
-		});
-	}
-};
-//#endregion
 //#region src/features/rules/dsh-rule.ts
 /**
 * DeepSeek Harness (`dsh`) rules.
@@ -76416,7 +76636,8 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -76883,7 +77104,8 @@ var KiloRule = class KiloRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -77387,7 +77609,8 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -78856,6 +79079,14 @@ var ZoocodeRule = class extends RooRule {
 //#endregion
 //#region src/features/rules/rules-processor.ts
 const RulesProcessorToolTargetSchema = zod_mini.z.enum(rulesProcessorToolTargetTuple);
+/**
+* Normalizes a relative directory path for comparison: POSIX separators, no
+* `./` segments and no trailing slash, with the current directory as `"."`
+* (so `"./"`, `"a/"` and `"a"` compare the way `join()` groups them).
+*/
+const normalizeRelativeDir = (dir) => node_path.posix.normalize(toPosixPath(dir)).replace(/\/+$/, "") || ".";
+/** A tool rule's output path relative to its output root, for comparison. */
+const toolOutputPath = (toolRule) => node_path.posix.join(normalizeRelativeDir(toolRule.getRelativeDirPath()), toolRule.getRelativeFilePath());
 const formatRulePaths = (rules) => rules.map((r) => (0, node_path.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 const RulesFeatureOptionsSchema = zod_mini.z.looseObject({
 	ruleDiscoveryMode: zod_mini.z.optional(zod_mini.z.enum(["none", "explicit"])),
@@ -78937,7 +79168,9 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 		meta: {
 			extension: "md",
 			supportsGlobal: true,
-			ruleDiscoveryMode: "toon"
+			ruleDiscoveryMode: "toon",
+			ruleDiscoveryModeGlobal: "auto",
+			sharedGlobalNonRootDir: true
 		}
 	}],
 	["antigravity-ide", {
@@ -79024,7 +79257,11 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			collisionPolicy: "fold"
+			collisionPolicy: "fold",
+			projectInstructionBudget: {
+				bytes: CODEXCLI_PROJECT_DOC_MAX_BYTES,
+				remedy: "Codex CLI stops reading project `AGENTS.md` files once their combined size on the root-to-working-directory chain reaches `project_doc_max_bytes` (32 KiB by default) and silently drops the rest. Move directory-scoped rules into nested `AGENTS.md` files with `agentsmd.subprojectPath` (or `deriveSubprojectPathFromGlobs: true` in rulesync.jsonc), trim the rules, or raise `project_doc_max_bytes` in `.codex/config.toml` (ignore this warning if you already have)."
+			}
 		}
 	}],
 	["commandcode", {
@@ -79482,9 +79719,61 @@ var RulesProcessor = class extends FeatureProcessor {
 			toolRules,
 			factory
 		});
+		this.warnForInstructionBudget({
+			toolRules,
+			meta
+		});
 		return outputFiles;
 	}
 	/**
+	* Warn when a generated project instruction chain exceeds the tool's byte
+	* budget (`meta.projectInstructionBudget`).
+	*
+	* Codex CLI concatenates the project `AGENTS.md` files from the project root
+	* down to the cwd and stops once their combined size reaches
+	* `project_doc_max_bytes`, truncating the file that crosses it — silently, so
+	* without this warning the rules past the limit simply never reach the model.
+	* Each generated file is measured together with the generated files in its
+	* ancestor directories, since that is the chain Codex loads while working
+	* there. When the root file alone is over the budget every chain is, so only
+	* the root is reported; likewise each over-budget nested chain is reported
+	* once, at its shallowest directory. With several output roots the warning
+	* names the root it refers to. An output root below the git root is measured
+	* without the parent directories' files Codex would also load, so the
+	* estimate can come out low there. The budget checked is the tool's default: a value
+	* raised by hand in the tool's own config is not read. Global scope is not
+	* checked because Codex loads the personal `~/.codex/AGENTS.md` outside the
+	* project budget.
+	*/
+	warnForInstructionBudget({ toolRules, meta }) {
+		const budget = meta.projectInstructionBudget;
+		if (budget === void 0 || this.global) return;
+		const files = toolRules.map((rule) => ({
+			dir: normalizeRelativeDir(rule.getRelativeDirPath()),
+			path: toPosixPath((0, node_path.join)(rule.getRelativeDirPath(), rule.getRelativeFilePath())),
+			bytes: Buffer.byteLength(addTrailingNewline(rule.getFileContent()), "utf8")
+		}));
+		const isAncestorOrSelf = (ancestor, dir) => ancestor === "." || ancestor === dir || dir.startsWith(`${ancestor}/`);
+		const location = this.outputRoot === process.cwd() ? "" : ` under '${this.outputRoot}'`;
+		const rootFiles = files.filter(({ dir }) => dir === ".");
+		const rootBytes = rootFiles.reduce((sum, { bytes }) => sum + bytes, 0);
+		if (rootBytes > budget.bytes) {
+			this.logger.warn(`The generated ${this.toolTarget} root instruction file${location} (${rootFiles.map(({ path }) => path).join(", ")}) is ${rootBytes} bytes, over the ${budget.bytes}-byte limit. ${budget.remedy}`);
+			return;
+		}
+		const reportedDirs = [];
+		const nestedFiles = files.filter(({ dir }) => dir !== ".").toSorted((a, b) => a.dir.split("/").length - b.dir.split("/").length);
+		for (const file of nestedFiles) {
+			if (reportedDirs.some((dir) => isAncestorOrSelf(dir, file.dir))) continue;
+			const chain = files.filter(({ dir }) => isAncestorOrSelf(dir, file.dir));
+			const chainBytes = chain.reduce((sum, { bytes }) => sum + bytes, 0);
+			if (chainBytes > budget.bytes) {
+				reportedDirs.push(file.dir);
+				this.logger.warn(`The generated ${this.toolTarget} instruction files${location} loaded while working in '${file.dir}' (${chain.map(({ path }) => path).join(", ")}) total ${chainBytes} bytes, over the ${budget.bytes}-byte limit (as is every directory below it). ${budget.remedy}`);
+			}
+		}
+	}
+	/**
 	* Handle localRoot rules (only in non-global mode and when enabled). Mutates
 	* `toolRules` in place.
 	*/
@@ -79960,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);
@@ -80156,14 +80445,14 @@ As this project's AI coding tool, you must follow the additional conventions bel
 	* decides for all of them: its `pi.contextFile` is copied onto the non-root
 	* rules, and the flag set only on a non-root rule is dropped with a warning.
 	*/
-	alignPiContextFile(rules) {
+	alignPiContextFile(rules, { warn = true } = {}) {
 		if (this.toolTarget !== "pi") return rules;
 		const factory = this.getFactory(this.toolTarget);
 		const targeted = rules.filter((rule) => factory.class.isTargetedByRulesyncRule(rule));
 		const rootContextFile = targeted.some((rule) => rule.getFrontmatter().root === true && rule.getFrontmatter().pi?.contextFile === "override") ? "override" : void 0;
 		const mismatched = targeted.filter((rule) => rule.getFrontmatter().pi?.contextFile !== rootContextFile);
 		if (mismatched.length === 0) return rules;
-		if (rootContextFile === void 0) this.logger.warn(`pi.contextFile is set on ${mismatched.length} non-root rule(s) but not on the root rule, so it is ignored: Pi folds every rule body into the root context file, and emitting AGENTS.override.md for some of them would hide the rest. Set it on the root rule instead: ${formatRulePaths(mismatched)}`);
+		if (warn && rootContextFile === void 0) this.logger.warn(`pi.contextFile is set on ${mismatched.length} non-root rule(s) but not on the root rule, so it is ignored: Pi folds every rule body into the root context file, and emitting AGENTS.override.md for some of them would hide the rest. Set it on the root rule instead: ${formatRulePaths(mismatched)}`);
 		const mismatchedSet = new Set(mismatched);
 		return rules.map((rule) => {
 			if (!mismatchedSet.has(rule)) return rule;
@@ -80217,14 +80506,72 @@ As this project's AI coding tool, you must follow the additional conventions bel
 	* duplication check the same way `loadRulesyncFiles`'s global-mode branch
 	* excludes it from `nonRootRules`: `generate` ignores `localRoot` entirely
 	* in global mode, so such a rule is never actually folded into the global
-	* root output and warning about it here would be inaccurate.
+	* root output and warning about it here would be inaccurate. The same goes
+	* for a tool that writes `localRoot` to a dedicated local file.
+	*
+	* Non-root rules written to a file other than the root (nested
+	* per-directory files, Pi's `APPEND_SYSTEM.md`) get a separate warning when
+	* that file already exists and would import under a different name.
 	*/
 	async warnForFoldImportDuplicationRisk() {
 		const factory = this.getFactory(this.toolTarget);
 		if (factory.meta.collisionPolicy !== "fold") return;
-		const nonRootRules = (await this.loadMergedRulesyncRules()).filter((rule) => !rule.getFrontmatter().root && (!this.global || !rule.getFrontmatter().localRoot) && factory.class.isTargetedByRulesyncRule(rule));
-		if (nonRootRules.length === 0) return;
-		this.logger.warn(`Importing ${this.toolTarget}'s root file will re-add content already folded from ${formatRulePaths(nonRootRules)}: ${this.toolTarget} concatenates every non-root rule into its single root output file, so the imported copy duplicates them the next time you run \`rulesync generate --targets ${this.toolTarget}\`. Review the imported rule and remove the duplicated content, or remove the original non-root rule files, before generating again.`);
+		const targetedRules = this.alignPiContextFile(await this.loadMergedRulesyncRules(), { warn: false }).filter((rule) => factory.class.isTargetedByRulesyncRule(rule));
+		let includeLocalRoot = !this.global;
+		try {
+			includeLocalRoot &&= resolveIncludeLocalRoot(this.featureOptions);
+		} catch {}
+		const targetedNonRootRules = targetedRules.filter((rule) => !rule.getFrontmatter().root && !(rule.getFrontmatter().localRoot && (!includeLocalRoot || factory.meta.localRootMode === "separate-local-file")));
+		const rootPaths = /* @__PURE__ */ new Set();
+		const { root } = factory.class.getSettablePaths({ global: this.global });
+		if (root) rootPaths.add(node_path.posix.join(normalizeRelativeDir(root.relativeDirPath), root.relativeFilePath));
+		for (const rulesyncRule of targetedRules.filter((rule) => rule.getFrontmatter().root)) {
+			const toolRule = this.toToolRuleForImportCheck({
+				factory,
+				rulesyncRule
+			});
+			rootPaths.add(toolOutputPath(toolRule));
+		}
+		const separateRules = [];
+		const foldedRules = [];
+		let localRootCounted = false;
+		for (const rulesyncRule of targetedNonRootRules) {
+			if (rulesyncRule.getFrontmatter().localRoot) {
+				if (!localRootCounted) {
+					foldedRules.push(rulesyncRule);
+					localRootCounted = true;
+				}
+				continue;
+			}
+			const toolRule = this.toToolRuleForImportCheck({
+				factory,
+				rulesyncRule
+			});
+			if (rootPaths.size === 0 || rootPaths.has(toolOutputPath(toolRule))) foldedRules.push(rulesyncRule);
+			else separateRules.push({
+				toolRule,
+				rulesyncRule
+			});
+		}
+		if (foldedRules.length > 0) this.logger.warn(`Importing ${this.toolTarget}'s root file will re-add content already folded from ${formatRulePaths(foldedRules)}: ${this.toolTarget} concatenates every non-root rule into its single root output file, so the imported copy duplicates them the next time you run \`rulesync generate --targets ${this.toolTarget}\`. Review the imported rule and remove the duplicated content, or remove the original non-root rule files, before generating again.`);
+		const duplicated = [];
+		for (const conversion of separateRules) {
+			const { toolRule, rulesyncRule } = conversion;
+			if (toolRule.toRulesyncRule().getRelativeFilePath().toLowerCase() === rulesyncRule.getRelativeFilePath().toLowerCase()) continue;
+			if (await fileExists(toolRule.getFilePath())) duplicated.push(conversion);
+		}
+		if (duplicated.length > 0) {
+			const fileNames = [...new Set(duplicated.map(({ toolRule }) => toolRule.getRelativeFilePath()))].join(", ");
+			this.logger.warn(`Importing ${this.toolTarget}'s ${fileNames} files outside the root file will re-add content already written from ${formatRulePaths(duplicated.map(({ rulesyncRule }) => rulesyncRule))}: each such file is imported as its own rule under a name derived from its path, so the imported copy and the original rule resolve to the same file and are concatenated the next time you run \`rulesync generate --targets ${this.toolTarget}\`. Remove one of the two copies before generating again.`);
+		}
+	}
+	toToolRuleForImportCheck({ factory, rulesyncRule }) {
+		return factory.class.fromRulesyncRule({
+			outputRoot: this.outputRoot,
+			rulesyncRule,
+			validate: false,
+			global: this.global
+		});
 	}
 	/**
 	* Implementation of abstract method from FeatureProcessor
@@ -80421,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
@@ -80434,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 [
@@ -80518,6 +80872,14 @@ As this project's AI coding tool, you must follow the additional conventions bel
 function isPackagingToolTarget(toolTarget) {
 	return PACKAGING_TOOL_TARGETS.includes(toolTarget);
 }
+/**
+* Packaging targets write into a plugin directory and support project scope
+* only. In global mode their output root would be the home directory, so
+* callers reject or skip them up front instead of checking all of $HOME.
+*/
+function formatPackagingTargetGlobalMessage(toolTarget) {
+	return `Target '${toolTarget}' is a plugin packaging target and supports only project scope. Re-run without '--global'.`;
+}
 async function assertPluginRootSafe(params) {
 	if (!isPackagingToolTarget(params.toolTarget)) return;
 	await assertDirectoryIfExists(params.outputRoot);
@@ -81437,14 +81799,17 @@ function warnUnsupportedTargets(params) {
 	} catch {
 		oppositeScopeTargets = [];
 	}
-	for (const target of config.getTargets()) if (!supportedTargets.includes(target) && config.getFeatures(target).includes(featureName)) {
-		const simulateOption = SIMULATE_OPTION_MAP[featureName];
-		if (simulateOption && simulatedTargets.includes(target)) logger.warn(`Target '${target}' only supports simulated '${featureName}'. Use '${simulateOption}' to enable it. Skipping.`);
-		else if (oppositeScopeTargets.includes(target)) {
-			const supportedScope = config.getGlobal() ? "project" : "global";
-			const retry = config.getGlobal() ? "without '--global'" : "with '--global'";
-			logger.warn(`Target '${target}' supports the feature '${featureName}' only in ${supportedScope} scope. Re-run ${retry}. Skipping.`);
-		} else logger.warn(`Target '${target}' does not support the feature '${featureName}'. Skipping.`);
+	for (const target of config.getTargets()) {
+		if (config.getGlobal() && isPackagingToolTarget(target)) continue;
+		if (!supportedTargets.includes(target) && config.getFeatures(target).includes(featureName)) {
+			const simulateOption = SIMULATE_OPTION_MAP[featureName];
+			if (simulateOption && simulatedTargets.includes(target)) logger.warn(`Target '${target}' only supports simulated '${featureName}'. Use '${simulateOption}' to enable it. Skipping.`);
+			else if (oppositeScopeTargets.includes(target)) {
+				const supportedScope = config.getGlobal() ? "project" : "global";
+				const retry = config.getGlobal() ? "without '--global'" : "with '--global'";
+				logger.warn(`Target '${target}' supports the feature '${featureName}' only in ${supportedScope} scope. Re-run ${retry}. Skipping.`);
+			} else logger.warn(`Target '${target}' does not support the feature '${featureName}'. Skipping.`);
+		}
 	}
 }
 /**
@@ -81697,10 +82062,16 @@ async function generate(params) {
 	const { config, logger } = params;
 	resetRootShadowingWarnings({ logger });
 	resetRunWarningState();
-	for (const toolTarget of config.getTargets()) for (const outputRoot of config.getOutputRoots(toolTarget)) await assertPluginRootSafe({
-		toolTarget,
-		outputRoot
-	});
+	for (const toolTarget of config.getTargets()) {
+		if (config.getGlobal() && isPackagingToolTarget(toolTarget)) {
+			logger.warn(`${formatPackagingTargetGlobalMessage(toolTarget)} Skipping.`);
+			continue;
+		}
+		for (const outputRoot of config.getOutputRoots(toolTarget)) await assertPluginRootSafe({
+			toolTarget,
+			outputRoot
+		});
+	}
 	await warnSkillSubagentNameCollisions({
 		config,
 		logger
@@ -81823,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;
@@ -81838,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();
@@ -81876,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,
@@ -82317,6 +82835,7 @@ function getToolOutputRoot({ config, tool }) {
 async function importFromTool(params) {
 	const { config, tool, logger } = params;
 	resetRunWarningState();
+	if (config.getGlobal() && isPackagingToolTarget(tool)) throw new Error(formatPackagingTargetGlobalMessage(tool));
 	await assertPluginRootSafe({
 		toolTarget: tool,
 		outputRoot: getToolOutputRoot({
@@ -82377,7 +82896,7 @@ async function importRulesCore(params) {
 	if (!config.getFeatures(tool).includes("rules")) return 0;
 	const global = config.getGlobal();
 	if (!RulesProcessor.getToolTargets({ global }).includes(tool)) return 0;
-	const rulesProcessor = new RulesProcessor({
+	const baseParams = {
 		outputRoot: getToolOutputRoot({
 			config,
 			tool
@@ -82385,13 +82904,23 @@ async function importRulesCore(params) {
 		toolTarget: tool,
 		global,
 		logger
-	});
+	};
+	const rulesProcessor = new RulesProcessor(baseParams);
 	const toolFiles = await rulesProcessor.loadToolFiles();
 	if (toolFiles.length === 0) {
 		logger.warn(`No rule files found for ${tool}. Skipping import.`);
 		return 0;
 	}
-	await rulesProcessor.warnForFoldImportDuplicationRisk();
+	try {
+		await new RulesProcessor({
+			...baseParams,
+			inputRoots: config.getInputRoots(),
+			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
+			featureOptions: config.getFeatureOptions(tool, "rules")
+		}).warnForFoldImportDuplicationRisk();
+	} catch (error) {
+		logger.warn(`Skipped the ${tool} import duplication check: ${formatError(error)}`);
+	}
 	const rulesyncFiles = await rulesProcessor.convertToolFilesToRulesyncFiles(toolFiles);
 	const { count: writtenCount } = await rulesProcessor.writeAiFiles(rulesyncFiles);
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} rule files`);