rulesync 17.0.0 → 18.0.0

package/dist/{import-CEgvxK12.js → import-CA3RFpGB.js}

@@ -44335,7 +44335,7 @@ function addCodexFilesystemRules({ categoryRules, filesystem, workspaceRootFiles
 		});
 		if (access === void 0) continue;
 		if (access === "read" && rule.writeRestriction === "ask") logger?.warn(`Codex CLI cannot express "ask" for filesystem write permissions: pattern "${rule.pattern}" will be emitted as read-only.`);
-		if (access === "read" && rule.writeRestriction === "deny") logger?.warn(`Codex CLI maps a write-side deny to read-only access: pattern "${rule.pattern}" will be emitted as "read". A broader read deny may be overridden by this more-specific path.`);
+		if (access === "read" && rule.writeRestriction === "deny" && rule.readUnspecified) logger?.warn(`Codex CLI maps a write-side deny to read-only access: pattern "${rule.pattern}" will be emitted as "read". A broader read deny may be overridden by this more-specific path.`);
 		addFilesystemRule({
 			filesystem,
 			workspaceRootFilesystem,
@@ -44495,6 +44495,14 @@ function addFilesystemRule({ filesystem, workspaceRootFilesystem, pattern, acces
 	workspaceRootFilesystem[pattern] = access;
 }
 function normalizeCodexFilesystemAccess({ pattern, access, writeRestriction, logger }) {
+	if ((access === "read" || access === "write") && isWindowsDevicePath(pattern)) {
+		if (writeRestriction !== void 0) {
+			logger?.warn(`Codex CLI does not support Windows device paths for read/write access: pattern "${pattern}" will be emitted as "deny" because its write-side ${writeRestriction} restriction cannot be represented as read-only access. Use a plain drive path such as "C:\\..." instead.`);
+			return "deny";
+		}
+		logger?.warn(`Skipping unsupported Codex CLI ${access} filesystem entry for Windows device path "${pattern}"; the base permission profile remains in effect. Use a plain drive path such as "C:\\..." instead.`);
+		return;
+	}
 	if ((access === "read" || access === "write") && hasUnsupportedCodexFilesystemGlob(pattern)) {
 		if (writeRestriction !== void 0) {
 			logger?.warn(`Codex CLI only supports deny access for non-trailing filesystem globs: pattern "${pattern}" will be emitted as "deny" because its write-side ${writeRestriction} restriction cannot be represented as read-only access. Use an exact path or trailing "/**" for read/write access.`);
@@ -44508,6 +44516,9 @@ function normalizeCodexFilesystemAccess({ pattern, access, writeRestriction, log
 function hasCodexFilesystemGlob(pattern) {
 	return pattern.includes("*") || pattern.includes("?") || pattern.includes("[") || pattern.includes("]");
 }
+function isWindowsDevicePath(pattern) {
+	return pattern.startsWith("\\\\?\\") || pattern.startsWith("\\\\.\\");
+}
 function hasUnsupportedCodexFilesystemGlob(pattern) {
 	return hasCodexFilesystemGlob(pattern.endsWith("/**") ? pattern.slice(0, -3) : pattern);
 }
@@ -44649,18 +44660,41 @@ function mapReadAction(action) {
 function mapWriteAction(action) {
 	return action === "allow" ? "write" : "read";
 }
+/**
+* Merge the canonical read/edit/write category rules into one Codex access
+* level per path pattern (Codex models a single `deny` < `read` < `write`
+* level, with no `ask`).
+*
+* - `edit` and `write` collapse onto Codex's write side; when both carry the
+*   same pattern, the more restrictive action wins (`deny` > `ask` > `allow`).
+* - `read: allow` + write-side `allow` → `"write"`.
+* - A write-side non-allow → `"read"` (readable but not writable — exactly
+*   what Codex's `"read"` level expresses). An `ask` action is approximated
+*   this way because Codex has no path-level write approval.
+* - A write-side-only non-allow (no `read` rule for the same pattern) whose
+*   path is covered by a broader `read` deny/ask rule (e.g. `X/**` covering
+*   `X/id_rsa`, or `:root`) → `"deny"`. Codex resolves the most specific
+*   path, so emitting `"read"` there would re-open reads the user denied.
+* - A `read` non-allow on the same pattern → `"deny"` regardless of the
+*   write side; a contradictory write-side `allow` (unreadable but writable
+*   is not expressible in Codex) is warned about.
+* - Single-category patterns keep the existing mapReadAction/mapWriteAction
+*   mappings.
+*
+* Iteration order is read → edit → write with first-seen pattern order, so
+* the emitted table is stable regardless of the authored category order.
+* Note the merge is one-way: `"{path}" = "read"` imports back as
+* `read: allow` only. The write-side restriction is implied by Codex's access
+* level and not re-materialized, so both `read: allow` + write-side
+* `ask`/`deny` and a write-side-only `ask`/`deny` (e.g. `edit: { "/x/**":
+* "deny" }` with no `read` rule) lose their write restriction on
+* `rulesync import`. This is deliberate: importing `"read"` as an extra
+* `edit: deny` would push a restriction to every other tool that the Codex
+* profile alone cannot prove was authored.
+*/
 function mergeFilesystemCategoryRules({ categoryRules, logger }) {
 	const readRules = categoryRules.read ?? {};
-	const writeSideRestrictiveness = {
-		deny: 2,
-		ask: 1,
-		allow: 0
-	};
-	const writeSideRules = {};
-	for (const category of ["edit", "write"]) for (const [pattern, action] of Object.entries(categoryRules[category] ?? {})) {
-		const existing = writeSideRules[pattern];
-		if (existing === void 0 || writeSideRestrictiveness[action] > writeSideRestrictiveness[existing]) writeSideRules[pattern] = action;
-	}
+	const writeSideRules = collapseWriteSideRules(categoryRules);
 	const patterns = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const pattern of [...Object.keys(readRules), ...Object.keys(writeSideRules)]) if (!seen.has(pattern)) {
@@ -44671,37 +44705,74 @@ function mergeFilesystemCategoryRules({ categoryRules, logger }) {
 	for (const pattern of patterns) {
 		const readAction = readRules[pattern];
 		const writeAction = writeSideRules[pattern];
-		if (readAction === void 0) {
+		if (writeAction === void 0) {
 			merged.push({
 				pattern,
-				access: mapWriteAction(writeAction),
-				...writeAction === "ask" || writeAction === "deny" ? { writeRestriction: writeAction } : {}
+				access: mapReadAction(readAction)
 			});
 			continue;
 		}
-		if (writeAction === void 0) {
+		if (readAction !== void 0 && readAction !== "allow") {
+			if (writeAction === "allow") logger?.warn(`Codex CLI cannot express "writable but not readable": pattern "${pattern}" has read: ${readAction} and a write-side allow. Emitting "deny".`);
 			merged.push({
 				pattern,
-				access: mapReadAction(readAction)
+				access: "deny"
 			});
 			continue;
 		}
-		if (readAction === "allow") {
+		const writeRestriction = writeAction === "allow" ? void 0 : writeAction;
+		const readUnspecified = readAction === void 0;
+		if (readUnspecified && writeRestriction !== void 0 && isCoveredByReadRestriction({
+			pattern,
+			readRules
+		})) {
 			merged.push({
 				pattern,
-				access: writeAction === "allow" ? "write" : "read",
-				...writeAction === "ask" || writeAction === "deny" ? { writeRestriction: writeAction } : {}
+				access: "deny"
 			});
 			continue;
 		}
-		if (writeAction === "allow") logger?.warn(`Codex CLI cannot express "writable but not readable": pattern "${pattern}" has read: ${readAction} and a write-side allow. Emitting "deny".`);
 		merged.push({
 			pattern,
-			access: "deny"
+			access: mapWriteAction(writeAction),
+			...writeRestriction !== void 0 ? { writeRestriction } : {},
+			...readUnspecified ? { readUnspecified } : {}
 		});
 	}
 	return merged;
 }
+function collapseWriteSideRules(categoryRules) {
+	const writeSideRestrictiveness = {
+		deny: 2,
+		ask: 1,
+		allow: 0
+	};
+	const writeSideRules = {};
+	for (const category of ["edit", "write"]) for (const [pattern, action] of Object.entries(categoryRules[category] ?? {})) {
+		const existing = writeSideRules[pattern];
+		if (existing === void 0 || writeSideRestrictiveness[action] > writeSideRestrictiveness[existing]) writeSideRules[pattern] = action;
+	}
+	return writeSideRules;
+}
+function isCoveredByReadRestriction({ pattern, readRules }) {
+	const key = stripLeadingDotSlash(pattern);
+	return Object.entries(readRules).some(([readPattern, action]) => {
+		if (action === "allow" || readPattern === pattern) return false;
+		if (readPattern === ":root" || readPattern === "/**") return true;
+		if (readPattern === "**") return !canBeCodexFilesystemRoot(pattern);
+		const withoutTrailingGlob = readPattern.endsWith("/**") ? readPattern.slice(0, -3) : readPattern;
+		if (withoutTrailingGlob.startsWith(":") || hasCodexFilesystemGlob(withoutTrailingGlob)) return false;
+		const base = stripTrailingSlash(stripLeadingDotSlash(withoutTrailingGlob));
+		if (base === "") return false;
+		return key === base || key.startsWith(base.endsWith("/") ? base : `${base}/`);
+	});
+}
+function stripLeadingDotSlash(pattern) {
+	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+function stripTrailingSlash(pattern) {
+	return pattern.length > 1 && pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+}
 function buildCodexBashRulesContent(config) {
 	const bashRules = bashRulesHonoringAllTools(config.permission);
 	const entries = Object.entries(bashRules);
@@ -59546,21 +59617,43 @@ const CodexCliSkillFrontmatterSchema = z.looseObject({
 */
 const CODEX_OPENAI_YAML_RELATIVE_PATH = CODEXCLI_OPENAI_YAML_RELATIVE_PATH;
 /**
-* Build the `agents/openai.yaml` object from a rulesync `codexcli` section.
-* Only produced when the user opts in via `interface`, `policy`, or `dependencies`;
-* a lone legacy `short-description` keeps mapping to `SKILL.md` `metadata` only.
+* Resolve Codex's `policy.allow_implicit_invocation` from the rulesync inputs.
+* An explicit `codexcli.policy.allow_implicit_invocation` wins; otherwise the root
+* `disable-model-invocation: true` maps onto `false`. With neither set the value is
+* left undefined, since Codex already defaults to `true`.
+* @see https://github.com/openai/codex/blob/main/codex-rs/skills/src/model.rs
+*/
+function resolveAllowImplicitInvocation({ codexcli, disableModelInvocation }) {
+	const explicit = codexcli?.policy?.allow_implicit_invocation;
+	if (explicit !== void 0) return explicit;
+	return disableModelInvocation === true ? false : void 0;
+}
+/**
+* Build the `agents/openai.yaml` object from a rulesync `codexcli` section and the
+* root-level `disable-model-invocation` flag.
+* Only produced when the user opts in via `interface`, `policy`, or `dependencies`,
+* or when the root `disable-model-invocation: true` maps onto
+* `policy.allow_implicit_invocation: false`; a lone legacy `short-description` keeps
+* mapping to `SKILL.md` `metadata` only.
 * When the sidecar is produced and `interface.short_description` is absent, the
 * legacy `short-description` is routed there (its canonical home per Codex docs).
 */
-function buildOpenaiYamlObject(codexcli) {
-	if (!codexcli) return;
-	if (!Boolean(codexcli.interface || codexcli.policy || codexcli.dependencies)) return;
-	const interfaceSection = { ...codexcli.interface };
-	if (interfaceSection.short_description === void 0 && codexcli["short-description"] !== void 0) interfaceSection.short_description = codexcli["short-description"];
+function buildOpenaiYamlObject({ codexcli, disableModelInvocation }) {
+	const allowImplicitInvocation = resolveAllowImplicitInvocation({
+		codexcli,
+		disableModelInvocation
+	});
+	const policySection = {
+		...codexcli?.policy,
+		...allowImplicitInvocation !== void 0 && { allow_implicit_invocation: allowImplicitInvocation }
+	};
+	if (!Boolean(codexcli?.interface || codexcli?.policy || codexcli?.dependencies) && Object.keys(policySection).length === 0) return;
+	const interfaceSection = { ...codexcli?.interface };
+	if (interfaceSection.short_description === void 0 && codexcli?.["short-description"] !== void 0) interfaceSection.short_description = codexcli["short-description"];
 	const result = {};
 	if (Object.keys(interfaceSection).length > 0) result.interface = interfaceSection;
-	if (codexcli.policy && Object.keys(codexcli.policy).length > 0) result.policy = codexcli.policy;
-	if (codexcli.dependencies && Object.keys(codexcli.dependencies).length > 0) result.dependencies = codexcli.dependencies;
+	if (Object.keys(policySection).length > 0) result.policy = policySection;
+	if (codexcli?.dependencies && Object.keys(codexcli.dependencies).length > 0) result.dependencies = codexcli.dependencies;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 /**
@@ -59589,6 +59682,11 @@ function extractOpenaiYamlFile(otherFiles) {
 }
 /**
 * Map a parsed `agents/openai.yaml` object back into a rulesync `codexcli` section.
+* `policy.allow_implicit_invocation` stays under `codexcli.policy` rather than being
+* promoted to the root `disable-model-invocation`, matching how every other tool's
+* importer keeps its invocation flags in its own section: promoting it would change
+* the output of every other target on the next generate, while the section value
+* regenerates the same sidecar because it takes precedence over the root flag.
 */
 function openaiYamlToCodexcliSection(parsed) {
 	if (!parsed) return;
@@ -59687,7 +59785,10 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 		};
 		const target = toPosixPath(CODEX_OPENAI_YAML_RELATIVE_PATH);
 		const baseOtherFiles = rulesyncSkill.getOtherFiles().filter((file) => toPosixPath(file.relativeFilePathToDirPath) !== target);
-		const openaiObject = buildOpenaiYamlObject(rulesyncFrontmatter.codexcli);
+		const openaiObject = buildOpenaiYamlObject({
+			codexcli: rulesyncFrontmatter.codexcli,
+			disableModelInvocation: rulesyncFrontmatter["disable-model-invocation"]
+		});
 		const otherFiles = openaiObject ? [...baseOtherFiles, {
 			relativeFilePathToDirPath: CODEX_OPENAI_YAML_RELATIVE_PATH,
 			fileBuffer: Buffer.from(dump(openaiObject, {
@@ -78576,7 +78677,8 @@ const RulesProcessorToolTargetSchema = z.enum(rulesProcessorToolTargetTuple);
 const formatRulePaths = (rules) => rules.map((r) => join(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 const RulesFeatureOptionsSchema = z.looseObject({
 	ruleDiscoveryMode: z.optional(z.enum(["none", "explicit"])),
-	includeLocalRoot: z.optional(z.boolean())
+	includeLocalRoot: z.optional(z.boolean()),
+	includeRoot: z.optional(z.boolean())
 });
 const resolveRuleDiscoveryMode = ({ defaultMode, options }) => {
 	if (defaultMode === "claudecode-legacy") return defaultMode;
@@ -78593,6 +78695,13 @@ const resolveIncludeLocalRoot = (options) => {
 	if (!parsed.success) throw new Error(`Invalid options for rules feature: ${parsed.error.message}. \`includeLocalRoot\` must be a boolean.`);
 	return parsed.data.includeLocalRoot ?? true;
 };
+const IncludeRootSchema = z.looseObject({ includeRoot: z.optional(z.boolean()) });
+const resolveIncludeRoot = (options) => {
+	if (!options) return true;
+	const parsed = IncludeRootSchema.safeParse(options);
+	if (!parsed.success) throw new Error(`Invalid options for rules feature: ${parsed.error.message}. \`includeRoot\` must be a boolean.`);
+	return parsed.data.includeRoot ?? true;
+};
 /**
 * Whether `candidate` is `base` itself or a class that extends it.
 *
@@ -79104,6 +79213,7 @@ const findFilesWithFallback = async (primaryFilePaths, alternativeRoots, buildAl
 * delete generated files it can no longer regenerate and report success.
 */
 const rootRelativeGlob = (...segments) => posix.join(...segments.filter((segment) => segment !== void 0).map(toPosixPath));
+const isRootRule = (rule) => Boolean(rule.getFrontmatter().root || rule.getFrontmatter().localRoot);
 var RulesProcessor = class extends FeatureProcessor {
 	toolTarget;
 	simulateCommands;
@@ -79115,7 +79225,8 @@ var RulesProcessor = class extends FeatureProcessor {
 	getFactory;
 	skills;
 	featureOptions;
-	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, simulateCommands = false, simulateSubagents = false, simulateSkills = false, language, deriveSubprojectPathFromGlobs = false, global = false, getFactory = defaultGetFactory, skills, featureOptions, dryRun = false, logger }) {
+	deleteOrphans;
+	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, simulateCommands = false, simulateSubagents = false, simulateSkills = false, language, deriveSubprojectPathFromGlobs = false, global = false, getFactory = defaultGetFactory, skills, featureOptions, delete: deleteOrphans = false, dryRun = false, logger }) {
 		super({
 			outputRoot,
 			inputRoots,
@@ -79134,15 +79245,17 @@ var RulesProcessor = class extends FeatureProcessor {
 		this.getFactory = getFactory;
 		this.skills = skills;
 		this.featureOptions = featureOptions;
+		this.deleteOrphans = deleteOrphans;
 	}
 	async convertRulesyncFilesToToolFiles(rulesyncFiles) {
 		const rulesyncRules = rulesyncFiles.filter((file) => file instanceof RulesyncRule);
 		const alignedRules = this.alignPiContextFile(rulesyncRules);
-		const localRootRules = alignedRules.filter((rule) => rule.getFrontmatter().localRoot);
-		const nonLocalRootRules = alignedRules.filter((rule) => !rule.getFrontmatter().localRoot);
 		const factory = this.getFactory(this.toolTarget);
 		const { meta } = factory;
-		const convertedRules = nonLocalRootRules.map((rulesyncRule) => {
+		this.warnForIncludeRootOption(meta);
+		const emittedRules = this.omitsRootFiles() ? await this.dropRootRules(alignedRules) : alignedRules;
+		const localRootRules = emittedRules.filter((rule) => rule.getFrontmatter().localRoot);
+		const convertedRules = emittedRules.filter((rule) => !rule.getFrontmatter().localRoot).map((rulesyncRule) => {
 			if (!factory.class.isTargetedByRulesyncRule(rulesyncRule)) return null;
 			return {
 				toolRule: factory.class.fromRulesyncRule({
@@ -79279,6 +79392,92 @@ var RulesProcessor = class extends FeatureProcessor {
 	getPromptBlockLanguage() {
 		return this.isClaudecodeTarget() ? void 0 : this.language;
 	}
+	/**
+	* `includeRoot: false` on the `claudecode` target (project scope only)
+	* drops the root `CLAUDE.md` and the personal `CLAUDE.local.md`, keeping the
+	* non-root `.claude/rules/*.md`. Claude Code falls back to `AGENTS.md` only
+	* when none of `CLAUDE.md`, `.claude/CLAUDE.md` or `CLAUDE.local.md` exists,
+	* so emitting either root file would shadow an `AGENTS.md` written by another
+	* target. With `delete` on, stale root files are swept by the regular orphan
+	* deletion because they are no longer part of the generated output; without
+	* it, conversion warns about them instead. Global scope keeps the
+	* root file: `~/.claude/CLAUDE.md` never shadows `AGENTS.md`, and Claude Code
+	* reads no global `AGENTS.md` to fall back to. `claudecode-legacy` is not
+	* covered: its `.claude/memories/*.md` are only reachable through the
+	* references listed in the root file.
+	* @see https://code.claude.com/docs/en/memory#when-claude-code-reads-agents-md
+	*/
+	omitsRootFiles() {
+		return this.toolTarget === "claudecode" && !this.global && !resolveIncludeRoot(this.featureOptions);
+	}
+	/**
+	* Warn when `includeRoot: false` is set where it has no effect, or where it
+	* silently disables another option that writes into the root file.
+	*/
+	warnForIncludeRootOption(meta) {
+		if (resolveIncludeRoot(this.featureOptions)) return;
+		if (this.toolTarget !== "claudecode") {
+			this.logger.warn(`The rules option \`includeRoot\` is only supported by the claudecode target; ignoring it for ${this.toolTarget}.`);
+			return;
+		}
+		if (this.global) {
+			this.logger.warn("The rules option `includeRoot: false` has no effect in global mode: ~/.claude/CLAUDE.md does not shadow AGENTS.md, so it is still generated.");
+			return;
+		}
+		if (resolveRuleDiscoveryMode({
+			defaultMode: meta.ruleDiscoveryMode,
+			options: this.featureOptions
+		}) !== "auto") this.logger.warn("The rules option `ruleDiscoveryMode` has no effect with `includeRoot: false` on claudecode: the rule references it adds are written into CLAUDE.md, which is not generated.");
+	}
+	/**
+	* Drop the root and local-root rules for `includeRoot: false`, reporting what
+	* would otherwise go unnoticed: a dropped rule no other target emits, and a
+	* root file on disk that keeps shadowing `AGENTS.md`. With `delete` on, the
+	* orphan sweep removes the project-root files and reports the rest itself
+	* (see {@link loadToolFiles}), so conversion only reports them when no sweep
+	* runs.
+	*/
+	async dropRootRules(rules) {
+		this.warnForClaudecodeOnlyRootRules(rules.filter(isRootRule));
+		if (!this.deleteOrphans || this.hasRulesyncSourceLoadFailure()) await this.warnForShadowingRootFiles({ includePrimaryRoots: true });
+		return rules.filter((rule) => !isRootRule(rule));
+	}
+	/**
+	* A root or local-root rule that targets `claudecode` alone is dropped by
+	* `includeRoot: false`, and no other target writes it either, so its content
+	* would end up nowhere without a word.
+	*/
+	warnForClaudecodeOnlyRootRules(rootRules) {
+		for (const rule of rootRules) {
+			const targets = rule.getFrontmatter().targets ?? ["*"];
+			if (targets.length === 0 || !targets.every((target) => target === "claudecode")) continue;
+			this.logger.warn(`${stripControlCharacters(rule.getRelativeFilePath())} is a root rule that targets only claudecode, so \`includeRoot: false\` drops it and no target generates its content. Add the target that writes AGENTS.md to its \`targets\`, or turn it into a non-root rule.`);
+		}
+	}
+	/**
+	* With `includeRoot: false`, a root file still on disk keeps Claude Code
+	* from reading `AGENTS.md`: a project-root `CLAUDE.md` or `CLAUDE.local.md`
+	* (`includePrimaryRoots`), which only the `delete` sweep removes, and a
+	* hand-authored `.claude/CLAUDE.md` at an alternative location, which
+	* Rulesync never writes and so never deletes. `.claude/CLAUDE.local.md` is
+	* not checked: it is not one of the files that shadow `AGENTS.md`.
+	* @see https://code.claude.com/docs/en/memory#when-claude-code-reads-agents-md
+	*/
+	async warnForShadowingRootFiles({ includePrimaryRoots }) {
+		const factory = this.getFactory(this.toolTarget);
+		const settablePaths = factory.class.getSettablePaths({ global: this.global });
+		const primaryDirPath = settablePaths.root?.relativeDirPath ?? ".";
+		const primaryGlobs = (includePrimaryRoots && settablePaths.root ? [settablePaths.root.relativeFilePath, ...factory.meta.localRootFileName ? [factory.meta.localRootFileName] : []] : []).map((fileName) => rootRelativeGlob(primaryDirPath, fileName));
+		const alternativeGlobs = (settablePaths.alternativeRoots ?? []).map((alt) => rootRelativeGlob(alt.relativeDirPath, alt.relativeFilePath));
+		const primaryFilePaths = primaryGlobs.length > 0 ? await findFilesByGlobs(primaryGlobs, { cwd: this.outputRoot }) : [];
+		const alternativeFilePaths = alternativeGlobs.length > 0 ? await findFilesByGlobs(alternativeGlobs, { cwd: this.outputRoot }) : [];
+		const filePaths = [...primaryFilePaths, ...alternativeFilePaths];
+		if (filePaths.length === 0) return;
+		const names = filePaths.map((filePath) => stripControlCharacters(relative(this.outputRoot, filePath)));
+		const one = names.length === 1;
+		const deleteHint = primaryFilePaths.length > 0 ? " Enable `delete` to have Rulesync remove a project-root CLAUDE.md or CLAUDE.local.md itself." : "";
+		this.logger.warn(`${names.join(", ")} still ${one ? "keeps" : "keep"} Claude Code from reading AGENTS.md although \`includeRoot: false\` is set for claudecode. Rulesync leaves ${one ? "it" : "them"} in place; remove ${one ? "it" : "them"} by hand once the content is covered by AGENTS.md.${deleteHint}`);
+	}
 	isClaudecodeTarget() {
 		return this.toolTarget === "claudecode" || this.toolTarget === "claudecode-legacy";
 	}
@@ -79913,9 +80112,14 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			* Resolved once, up front, so the two blocks that need it do not depend
 			* on each other's evaluation order.
 			*/
+			const omitsRootFiles = this.omitsRootFiles();
 			const primaryRootFilePaths = settablePaths.root ? await findFilesByGlobs(rootRelativeGlob(settablePaths.root.relativeDirPath ?? ".", settablePaths.root.relativeFilePath), { cwd: this.outputRoot }) : [];
 			const rootToolRules = await (async () => {
 				if (!settablePaths.root) return [];
+				if (forDeletion && omitsRootFiles) {
+					await this.warnForShadowingRootFiles({ includePrimaryRoots: false });
+					return buildDeletionRulesFromPaths(primaryRootFilePaths);
+				}
 				const uniqueRootFilePaths = await findFilesWithFallback(primaryRootFilePaths, settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, alt.relativeFilePath), this.outputRoot);
 				if (forDeletion) return buildDeletionRulesFromPaths(uniqueRootFilePaths);
 				return await buildImportRulesFromPaths(uniqueRootFilePaths);
@@ -79927,7 +80131,9 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				const filePaths = await (async () => {
 					if (factory.class.getLocalRootFileGlob) return await findFilesByGlobs(factory.class.getLocalRootFileGlob({ fileName }), { cwd: this.outputRoot });
 					if (!settablePaths.root) return [];
-					return await findFilesWithFallback(await findFilesByGlobs(rootRelativeGlob(settablePaths.root.relativeDirPath ?? ".", fileName), { cwd: this.outputRoot }), settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, fileName), this.outputRoot);
+					const primaryLocalFilePaths = await findFilesByGlobs(rootRelativeGlob(settablePaths.root.relativeDirPath ?? ".", fileName), { cwd: this.outputRoot });
+					if (forDeletion && omitsRootFiles) return primaryLocalFilePaths;
+					return await findFilesWithFallback(primaryLocalFilePaths, settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, fileName), this.outputRoot);
 				})();
 				if (forDeletion) return buildDeletionRulesFromPaths(filePaths);
 				return (await Promise.all(filePaths.map(async (filePath) => {
@@ -81473,6 +81679,7 @@ async function generateRulesCore(params) {
 			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
 			skills,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
+			delete: config.getDelete(),
 			dryRun: config.isPreviewMode(),
 			logger
 		});
@@ -82252,4 +82459,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-CEgvxK12.js.map
+//# sourceMappingURL=import-CA3RFpGB.js.map