rulesync 21.0.0 → 23.0.0

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

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