rulesync 17.0.0 → 18.0.0

package/dist/{import-j-fApVPQ.cjs → import-KY5Q7laH.cjs}

@@ -44360,7 +44360,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,
@@ -44520,6 +44520,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.`);
@@ -44533,6 +44541,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);
 }
@@ -44674,18 +44685,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)) {
@@ -44696,37 +44730,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);
@@ -59571,21 +59642,43 @@ const CodexCliSkillFrontmatterSchema = zod_mini.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;
 }
 /**
@@ -59614,6 +59707,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;
@@ -59712,7 +59810,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((0, js_yaml.dump)(openaiObject, {
@@ -78601,7 +78702,8 @@ const RulesProcessorToolTargetSchema = zod_mini.z.enum(rulesProcessorToolTargetT
 const formatRulePaths = (rules) => rules.map((r) => (0, node_path.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 const RulesFeatureOptionsSchema = zod_mini.z.looseObject({
 	ruleDiscoveryMode: zod_mini.z.optional(zod_mini.z.enum(["none", "explicit"])),
-	includeLocalRoot: zod_mini.z.optional(zod_mini.z.boolean())
+	includeLocalRoot: zod_mini.z.optional(zod_mini.z.boolean()),
+	includeRoot: zod_mini.z.optional(zod_mini.z.boolean())
 });
 const resolveRuleDiscoveryMode = ({ defaultMode, options }) => {
 	if (defaultMode === "claudecode-legacy") return defaultMode;
@@ -78618,6 +78720,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 = zod_mini.z.looseObject({ includeRoot: zod_mini.z.optional(zod_mini.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.
 *
@@ -79129,6 +79238,7 @@ const findFilesWithFallback = async (primaryFilePaths, alternativeRoots, buildAl
 * delete generated files it can no longer regenerate and report success.
 */
 const rootRelativeGlob = (...segments) => node_path.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;
@@ -79140,7 +79250,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,
@@ -79159,15 +79270,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({
@@ -79304,6 +79417,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((0, node_path.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";
 	}
@@ -79938,9 +80137,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);
@@ -79952,7 +80156,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) => {
@@ -81498,6 +81704,7 @@ async function generateRulesCore(params) {
 			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
 			skills,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
+			delete: config.getDelete(),
 			dryRun: config.isPreviewMode(),
 			logger
 		});

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_import = require("./import-j-fApVPQ.cjs");
+const require_import = require("./import-KY5Q7laH.cjs");
 //#region src/index.ts
 async function generate(options = {}) {
 	const { silent = true, verbose = false, ...rest } = options;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Mn as ALL_FEATURES, gt as ConsoleLogger, i as inspectInputRoots, nn as ALL_TOOL_TARGETS, o as convertFromTool$1, r as generate$1, st as ConfigResolver, t as importFromTool$1 } from "./import-CEgvxK12.js";
+import { Mn as ALL_FEATURES, gt as ConsoleLogger, i as inspectInputRoots, nn as ALL_TOOL_TARGETS, o as convertFromTool$1, r as generate$1, st as ConfigResolver, t as importFromTool$1 } from "./import-CA3RFpGB.js";
 //#region src/index.ts
 async function generate(options = {}) {
 	const { silent = true, verbose = false, ...rest } = options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "17.0.0",
+  "version": "18.0.0",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",
@@ -53,46 +53,46 @@
     "@octokit/request-error": "7.1.2",
     "@octokit/rest": "22.0.1",
     "@toon-format/toon": "4.1.1",
-    "@valibot/to-json-schema": "1.7.1",
+    "@valibot/to-json-schema": "1.8.0",
     "chokidar": "5.0.0",
     "commander": "15.0.0",
     "effect": "3.22.2",
     "es-toolkit": "1.52.0",
-    "fastmcp": "4.20.11",
+    "fastmcp": "4.20.14",
     "globby": "16.2.4",
     "gray-matter": "4.0.3",
-    "js-yaml": "5.4.1",
+    "js-yaml": "5.4.2",
     "jsonc-parser": "3.3.1",
     "minisearch": "7.2.0",
     "smol-toml": "1.8.0",
     "sury": "10.0.4",
-    "zod": "4.6.2"
+    "zod": "4.6.5"
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.268",
-    "@openrouter/sdk": "1.2.117",
+    "@anthropic-ai/claude-agent-sdk": "0.3.278",
+    "@openrouter/sdk": "1.3.8",
     "@secretlint/secretlint-rule-preset-recommend": "13.0.5",
     "@tsconfig/node24": "24.0.5",
-    "@types/node": "26.5.1",
+    "@types/node": "26.6.2",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "@vitest/coverage-v8": "5.0.0",
-    "cspell": "10.3.0",
-    "knip": "6.35.1",
+    "@vitest/coverage-v8": "5.0.1",
+    "cspell": "10.3.3",
+    "knip": "6.37.0",
     "lint-staged": "17.5.1",
-    "oxfmt": "0.67.0",
-    "oxlint": "1.82.0",
+    "oxfmt": "0.68.0",
+    "oxlint": "1.83.0",
     "repomix": "1.18.0",
-    "resend": "6.27.0",
+    "resend": "6.28.1",
     "secretlint": "13.0.5",
     "simple-git": "3.36.0",
     "simple-git-hooks": "2.14.0",
     "sort-package-json": "4.0.0",
     "tsdown": "0.23.0",
-    "tsx": "4.23.13",
+    "tsx": "4.23.15",
     "typescript": "7.0.2",
     "vite": "8.3.0",
     "vitepress": "1.6.4",
-    "vitest": "5.0.0"
+    "vitest": "5.0.1"
   },
   "engines": {
     "node": ">=22.0.0",