rulesync 21.0.0 → 22.0.0

package/dist/{import-CGT8v9bO.cjs → import-1vyJw3q0.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$352 } = node_path.posix;
+const { join: join$351 } = 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$352(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$351(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$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 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 RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$352(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$351(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$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_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_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";
@@ -12295,7 +12295,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 = [
@@ -15480,12 +15480,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 +15552,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 +33186,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 +33340,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 +59343,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 +65499,8 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: true
+			supportsGlobal: true,
+			lenientImport: true
 		}
 	}],
 	["claudecode-plugin", {
@@ -72337,7 +72449,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 +72458,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 +73115,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);
@@ -74298,7 +74411,8 @@ var ClineRule = class ClineRule extends ToolRule {
 				outputRoot,
 				rulesyncRule,
 				validate,
-				rootPath: paths.root
+				rootPath: paths.root,
+				global
 			}));
 		}
 		if (isRoot) return new ClineRule({
@@ -74718,26 +74832,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 +74898,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 +74919,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 +74930,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 +76282,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 +76493,8 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -76883,7 +76961,8 @@ var KiloRule = class KiloRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -77387,7 +77466,8 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -78856,6 +78936,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"])),
@@ -79024,7 +79112,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 +79574,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.
 	*/
@@ -80156,14 +80300,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 +80361,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
@@ -80518,6 +80720,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 +81647,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 +81910,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
@@ -82317,6 +82536,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 +82597,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 +82605,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`);