rulesync 20.0.0 → 22.0.0

package/dist/{import-Cp3q904n.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);
@@ -45011,14 +45122,14 @@ const COMMANDCODE_TOOL_TO_CATEGORY = {
 	web_fetch: "webfetch",
 	web_search: "websearch"
 };
-const ACTION_RANK$1 = {
+const ACTION_RANK$2 = {
 	allow: 0,
 	ask: 1,
 	deny: 2
 };
 /** Whether `action` outranks `existing` (deny > ask > allow). */
 function isStricterAction({ action, existing }) {
-	return existing === void 0 || ACTION_RANK$1[action] > ACTION_RANK$1[existing];
+	return existing === void 0 || ACTION_RANK$2[action] > ACTION_RANK$2[existing];
 }
 /**
 * Why a padded `Shell( * )` cannot stand in for the bare `Shell` in `allow`:
@@ -48366,20 +48477,22 @@ function convertFactorydroidToRulesyncPermissions({ allow, deny }) {
 const GOOSE_GLOBAL_ONLY_MESSAGE = "Goose permissions are global-only; use --global to sync ~/.config/goose/permission.yaml";
 const GOOSE_USER_KEY = "user";
 const CATCH_ALL_PATTERN$4 = "*";
-const RULESYNC_TO_GOOSE_TOOL_NAME = {
-	bash: "developer__shell",
-	edit: "developer__text_editor",
-	write: "developer__text_editor"
-};
-const GOOSE_TO_RULESYNC_TOOL_NAME = {
-	developer__shell: "bash",
-	developer__text_editor: "edit"
+const RULESYNC_TO_GOOSE_TOOL_NAME = { bash: "shell" };
+const GOOSE_TO_RULESYNC_TOOL_NAMES = {
+	shell: ["bash"],
+	developer__shell: ["bash"],
+	developer__text_editor: ["edit", "write"]
 };
 const ACTION_TO_GOOSE_LIST = {
 	allow: "always_allow",
 	ask: "ask_before",
 	deny: "never_allow"
 };
+const ACTION_RANK$1 = {
+	allow: 0,
+	ask: 1,
+	deny: 2
+};
 const GOOSE_LIST_TO_ACTION = {
 	always_allow: "allow",
 	ask_before: "ask",
@@ -48404,10 +48517,11 @@ const GOOSE_PERMISSION_LIST_KEYS = [
 *
 * Mapping (rulesync canonical -> Goose):
 *   - Action: `allow` -> `always_allow`, `ask` -> `ask_before`, `deny` -> `never_allow`.
-*   - Tool name: `bash` -> `developer__shell`, `edit` -> `developer__text_editor`;
-*     any other category passes through verbatim as the Goose tool name (mirrors
-*     the Gemini CLI adapter). `write` collapses onto `developer__text_editor`
-*     too, so a conflicting `edit`/`write` catch-all is reported and `edit` wins.
+*   - Tool name: `bash` -> `shell`; any other category (including `edit` and
+*     `write`) passes through verbatim as the Goose tool name (mirrors the
+*     Gemini CLI adapter). The legacy `developer__shell` /
+*     `developer__text_editor` names are still accepted on import, the latter
+*     as both `edit` and `write`.
 *   - Granularity: Goose lists hold whole tool names, so only a category's
 *     catch-all `*` pattern is representable. Non-catch-all patterns cannot be
 *     expressed per-tool and are reported via `logger.warn` and skipped.
@@ -48523,8 +48637,7 @@ function convertRulesyncToGoosePermissionConfig({ config, logger }) {
 		never_allow: []
 	};
 	const assigned = /* @__PURE__ */ new Map();
-	const orderedEntries = Object.entries(honorAllToolsOnBash(config.permission)).toSorted(([a], [b]) => (a === "edit" ? 1 : 0) - (b === "edit" ? 1 : 0));
-	for (const [category, rules] of orderedEntries) {
+	for (const [category, rules] of Object.entries(honorAllToolsOnBash(config.permission))) {
 		const toolName = RULESYNC_TO_GOOSE_TOOL_NAME[category] ?? category;
 		for (const [pattern, action] of Object.entries(rules)) {
 			if (pattern !== CATCH_ALL_PATTERN$4) {
@@ -48532,12 +48645,15 @@ function convertRulesyncToGoosePermissionConfig({ config, logger }) {
 				continue;
 			}
 			const previous = assigned.get(toolName);
-			if (previous !== void 0 && previous !== action) {
-				logger?.warn(`Goose maps "${category}" onto the "${toolName}" tool, which already has a conflicting permission ("${previous}"). The "${action}" value takes precedence.`);
+			if (previous === action) continue;
+			if (previous !== void 0) {
+				const stricter = ACTION_RANK$1[action] > ACTION_RANK$1[previous] ? action : previous;
+				logger?.warn(`Goose maps "${category}" onto the "${toolName}" tool, which already has a conflicting permission ("${previous}"). Keeping the stricter "${stricter}" (deny > ask > allow).`);
+				if (stricter === previous) continue;
 				const previousList = lists[ACTION_TO_GOOSE_LIST[previous]];
 				const index = previousList.indexOf(toolName);
 				if (index !== -1) previousList.splice(index, 1);
-			} else if (previous === action) continue;
+			}
 			lists[ACTION_TO_GOOSE_LIST[action]].push(toolName);
 			assigned.set(toolName, action);
 		}
@@ -48553,8 +48669,7 @@ function convertGoosePermissionConfigToRulesync(userPermission) {
 	for (const key of GOOSE_PERMISSION_LIST_KEYS) {
 		const toolNames = isStringArray$2(userPermission[key]) ? userPermission[key] : [];
 		const action = GOOSE_LIST_TO_ACTION[key];
-		for (const toolName of toolNames) {
-			const category = GOOSE_TO_RULESYNC_TOOL_NAME[toolName] ?? toolName;
+		for (const toolName of toolNames) for (const category of GOOSE_TO_RULESYNC_TOOL_NAMES[toolName] ?? [toolName]) {
 			permission[category] ??= {};
 			permission[category][CATCH_ALL_PATTERN$4] = action;
 		}
@@ -59228,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()),
@@ -65384,7 +65499,8 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: true
+			supportsGlobal: true,
+			lenientImport: true
 		}
 	}],
 	["claudecode-plugin", {
@@ -72333,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,
@@ -72342,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";
 		}
@@ -72999,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);
@@ -74294,7 +74411,8 @@ var ClineRule = class ClineRule extends ToolRule {
 				outputRoot,
 				rulesyncRule,
 				validate,
-				rootPath: paths.root
+				rootPath: paths.root,
+				global
 			}));
 		}
 		if (isRoot) return new ClineRule({
@@ -74714,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,
@@ -74744,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,
@@ -74755,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 {
@@ -74764,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 }) {
@@ -76085,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.
@@ -76412,7 +76493,8 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -76879,7 +76961,8 @@ var KiloRule = class KiloRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -77383,7 +77466,8 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 			rulesyncRule,
 			validate,
 			rootPath: paths.root,
-			nonRootPath: paths.nonRoot
+			nonRootPath: paths.nonRoot,
+			global
 		}));
 	}
 	toRulesyncRule() {
@@ -78852,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"])),
@@ -79020,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", {
@@ -79478,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.
 	*/
@@ -80152,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;
@@ -80213,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
@@ -80514,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);
@@ -81433,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.`);
+		}
 	}
 }
 /**
@@ -81693,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
@@ -82313,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({
@@ -82373,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
@@ -82381,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`);