rulesync 17.1.0 → 19.0.0

package/dist/{import-BtKWW__v.cjs → import-BFhL78qW.cjs}

@@ -44111,6 +44111,7 @@ var ClinePermissions = class ClinePermissions extends ToolPermissions {
 //#region src/features/permissions/codexcli-permissions.ts
 const RULESYNC_PROFILE_NAME = "rulesync";
 const CODEX_WORKSPACE_ROOTS_KEY = ":workspace_roots";
+const CODEX_WORKSPACE_ROOT_SUBPATH = ".";
 const CODEX_WORKSPACE_BASELINE = ":workspace";
 const CODEX_READ_ONLY_BASELINE = ":read-only";
 const CODEX_DANGER_FULL_ACCESS_BASELINE = ":danger-full-access";
@@ -44331,7 +44332,15 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 		workspaceRootFilesystem
 	});
 	if (Object.keys(workspaceRootFilesystem).length > 0) {
-		if (typeof filesystem[CODEX_WORKSPACE_ROOTS_KEY] === "string") logger?.warn(`"${CODEX_WORKSPACE_ROOTS_KEY}" is set as a direct filesystem access rule in the permissions, but it will be overwritten by workspace-root rules. Consider removing the direct "${CODEX_WORKSPACE_ROOTS_KEY}" entry.`);
+		const directWorkspaceRootsAccess = filesystem[CODEX_WORKSPACE_ROOTS_KEY];
+		if (isCodexFilesystemAccess(directWorkspaceRootsAccess)) {
+			mergeIntoWorkspaceRootTable({
+				workspaceRootFilesystem,
+				pattern: CODEX_WORKSPACE_ROOT_SUBPATH,
+				access: directWorkspaceRootsAccess
+			});
+			logger?.warn(`"${CODEX_WORKSPACE_ROOTS_KEY}" is set as a direct filesystem access rule in the permissions alongside workspace-relative rules; it is emitted as the "${CODEX_WORKSPACE_ROOT_SUBPATH}" entry of the "${CODEX_WORKSPACE_ROOTS_KEY}" table.`);
+		}
 		if (Object.keys(workspaceRootFilesystem).some((pattern) => pattern.includes("**"))) filesystem.glob_scan_max_depth = CODEX_GLOB_SCAN_MAX_DEPTH;
 		filesystem[CODEX_WORKSPACE_ROOTS_KEY] = workspaceRootFilesystem;
 	}
@@ -44348,9 +44357,13 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 	};
 }
 function addCodexFilesystemRules({ categoryRules, filesystem, workspaceRootFilesystem, logger }) {
-	for (const rule of mergeFilesystemCategoryRules({
+	const normalizedCategoryRules = normalizeWorkspaceRelativeCategoryRules({
 		categoryRules,
 		logger
+	});
+	for (const rule of mergeFilesystemCategoryRules({
+		categoryRules: normalizedCategoryRules,
+		logger
 	})) {
 		const access = normalizeCodexFilesystemAccess({
 			pattern: rule.pattern,
@@ -44360,7 +44373,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,
@@ -44517,9 +44530,67 @@ function addFilesystemRule({ filesystem, workspaceRootFilesystem, pattern, acces
 		filesystem[pattern] = access;
 		return;
 	}
-	workspaceRootFilesystem[pattern] = access;
+	mergeIntoWorkspaceRootTable({
+		workspaceRootFilesystem,
+		pattern,
+		access
+	});
+}
+const PERMISSION_ACTION_RESTRICTIVENESS = {
+	deny: 2,
+	ask: 1,
+	allow: 0
+};
+function normalizeWorkspaceRelativeCategoryRules({ categoryRules, logger }) {
+	const result = {};
+	for (const category of [
+		"read",
+		"edit",
+		"write"
+	]) {
+		const rules = categoryRules[category];
+		if (rules === void 0) continue;
+		const normalized = {};
+		for (const [pattern, action] of Object.entries(rules)) {
+			const key = pattern.trim() === "" || canBeCodexFilesystemRoot(pattern) ? pattern : toWorkspaceRootSubpath(pattern);
+			if (key === void 0) {
+				logger?.warn(`Skipping Codex CLI ${category} filesystem entry for workspace-relative pattern "${pattern}": Codex rejects a ":workspace_roots" subpath containing a ".." segment or an empty leading segment and would refuse the whole config, so the rule is dropped entirely — even a deny — and the path is NOT protected by the generated profile. Use a normalized relative path instead.`);
+				continue;
+			}
+			const existing = normalized[key];
+			normalized[key] = existing === void 0 || PERMISSION_ACTION_RESTRICTIVENESS[action] > PERMISSION_ACTION_RESTRICTIVENESS[existing] ? action : existing;
+		}
+		result[category] = normalized;
+	}
+	return result;
+}
+function toWorkspaceRootSubpath(pattern) {
+	let subpath = pattern;
+	while (subpath.startsWith("./")) subpath = subpath.slice(2);
+	if (subpath === "" || subpath === "**" && subpath !== pattern) return CODEX_WORKSPACE_ROOT_SUBPATH;
+	if (subpath.startsWith("/") || subpath.split(/[\\/]/).some((segment) => segment === "..")) return;
+	return subpath;
+}
+function mergeIntoWorkspaceRootTable({ workspaceRootFilesystem, pattern, access }) {
+	const existing = workspaceRootFilesystem[pattern];
+	workspaceRootFilesystem[pattern] = existing === void 0 ? access : moreRestrictiveCodexAccess({
+		a: existing,
+		b: access
+	});
 }
 function normalizeCodexFilesystemAccess({ pattern, access, writeRestriction, logger }) {
+	if (isWindowsDevicePath(pattern) && !canBeCodexFilesystemRoot(pattern)) {
+		logger?.warn(`Skipping Codex CLI ${access} filesystem entry for Windows device path "${pattern}": Codex cannot express it as a workspace-root entry (it is rejected on Windows and matches nothing elsewhere), so the rule is dropped entirely — even a deny — and the path is NOT protected by the generated profile. Use a plain drive path such as "C:\\..." instead.`);
+		return;
+	}
+	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 +44604,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);
 }
@@ -44549,7 +44623,9 @@ function addRulesyncFilesystemRule(permission, pattern, access) {
 		permission.read ??= {};
 		permission.read[pattern] = "allow";
 	} else {
+		permission.read ??= {};
 		permission.edit ??= {};
+		permission.read[pattern] = "allow";
 		permission.edit[pattern] = "allow";
 	}
 }
@@ -44674,18 +44750,44 @@ 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 rule (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"`, for a write-side `allow` too (with a
+*   warning). Codex resolves the most specific path, so emitting `"read"` or
+*   `"write"` there would re-open reads the user denied. Only the most
+*   specific covering read rule counts: a narrower `read: allow` between the
+*   broad deny and the path keeps the path readable.
+* - 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 +44798,131 @@ 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 && isCoveredByReadRestriction({
+			pattern,
+			readRules
+		})) {
+			if (writeRestriction === void 0) logger?.warn(`Codex CLI cannot express "writable but not readable": pattern "${pattern}" has a write-side allow but is covered by a broader read deny/ask rule. Emitting "deny".`);
 			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 writeSideRules = {};
+	for (const category of ["edit", "write"]) for (const [pattern, action] of Object.entries(categoryRules[category] ?? {})) {
+		const existing = writeSideRules[pattern];
+		if (existing === void 0 || PERMISSION_ACTION_RESTRICTIVENESS[action] > PERMISSION_ACTION_RESTRICTIVENESS[existing]) writeSideRules[pattern] = action;
+	}
+	return writeSideRules;
+}
+function isCoveredByReadRestriction({ pattern, readRules }) {
+	const key = normalizeCoverageKey(pattern);
+	const isWorkspaceRelative = !canBeCodexFilesystemRoot(pattern);
+	const keyHasDotSegment = hasDotPathSegment(pattern);
+	let best;
+	for (const [readPattern, action] of Object.entries(readRules)) {
+		if (readPattern === pattern) continue;
+		const specificity = coverageSpecificity({
+			readPattern,
+			key,
+			isWorkspaceRelative
+		});
+		if (specificity === void 0) continue;
+		const restrictive = action !== "allow";
+		if (!restrictive && isSkippedCodexGrant(readPattern)) continue;
+		if (!restrictive && (keyHasDotSegment || hasDotPathSegment(readPattern))) continue;
+		if (best === void 0 || specificity > best.specificity || specificity === best.specificity && restrictive) best = {
+			specificity,
+			restrictive
+		};
+	}
+	return best?.restrictive ?? false;
+}
+function coverageSpecificity({ readPattern, key, isWorkspaceRelative }) {
+	if (readPattern === ":root" || readPattern === "/**") return 0;
+	if (readPattern === CODEX_WORKSPACE_ROOTS_KEY) return isWorkspaceRelative ? 1 : void 0;
+	if (canBeCodexFilesystemRoot(readPattern) === isWorkspaceRelative) return;
+	const normalized = normalizeCoverageKey(readPattern);
+	if (normalized === "**" || normalized === ".") return isWorkspaceRelative ? 1 : void 0;
+	const withoutTrailingGlob = normalized.endsWith("/**") ? normalized.slice(0, -3) : normalized;
+	if (withoutTrailingGlob.startsWith(":") || hasCodexFilesystemGlob(withoutTrailingGlob)) return;
+	const base = stripTrailingSlash(withoutTrailingGlob);
+	if (base === "") return;
+	return key === base || key.startsWith(base.endsWith("/") ? base : `${base}/`) ? 2 + base.length : void 0;
+}
+function normalizeCoverageKey(pattern) {
+	const form = toCoverageForm(pattern);
+	return canBeCodexFilesystemRoot(pattern) && !pattern.startsWith(":") ? resolveDotSegments(form) : form;
+}
+function resolveDotSegments(path) {
+	const [anchor = "", ...rest] = path.split("/");
+	const stack = [];
+	for (const segment of rest) {
+		if (segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0 && stack[stack.length - 1] !== "..") stack.pop();
+			else if (anchor === "~") stack.push(segment);
+			continue;
+		}
+		stack.push(segment);
+	}
+	const resolved = [anchor, ...stack].join("/");
+	return resolved === "" ? "/" : stripTrailingSlash(resolved);
+}
+function toCoverageForm(pattern) {
+	let normalized = /^[A-Za-z]:[\\/]/.test(pattern) ? `${pattern.charAt(0).toLowerCase()}${pattern.slice(1).replaceAll("\\", "/")}` : pattern;
+	while (normalized.startsWith("./")) normalized = normalized.slice(2);
+	normalized = stripTrailingSlash(normalized);
+	return normalized === "" && pattern !== "" ? "." : normalized;
+}
+function hasDotPathSegment(pattern) {
+	const form = toCoverageForm(pattern);
+	if (form === ".") return false;
+	return form.split(/[\\/]/).some((segment) => segment === "." || segment === "..");
+}
+function isSkippedCodexGrant(pattern) {
+	return isWindowsDevicePath(pattern) || hasUnsupportedCodexFilesystemGlob(pattern);
+}
+function moreRestrictiveCodexAccess({ a, b }) {
+	const rank = {
+		deny: 0,
+		none: 0,
+		read: 1,
+		write: 2
+	};
+	return rank[a] <= rank[b] ? a : b;
+}
+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 +59767,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 +59832,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 +59935,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, {
@@ -79137,6 +79363,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;
@@ -79148,7 +79375,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,
@@ -79167,6 +79395,7 @@ 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);
@@ -79174,7 +79403,7 @@ var RulesProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		const { meta } = factory;
 		this.warnForIncludeRootOption(meta);
-		const emittedRules = this.omitsRootFiles() ? alignedRules.filter((rule) => !rule.getFrontmatter().root && !rule.getFrontmatter().localRoot) : alignedRules;
+		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;
@@ -79319,8 +79548,9 @@ var RulesProcessor = class extends FeatureProcessor {
 	* 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. Stale root files are swept by the regular orphan deletion because
-	* they are no longer part of the generated output. Global scope keeps the
+	* 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
@@ -79350,19 +79580,53 @@ var RulesProcessor = class extends FeatureProcessor {
 		}) !== "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.");
 	}
 	/**
-	* With `includeRoot: false`, a hand-authored root file at an alternative
-	* location (`.claude/CLAUDE.md`, `.claude/CLAUDE.local.md`) still keeps
-	* Claude Code from reading `AGENTS.md`. Rulesync never writes those files, so
-	* it leaves them in place and tells the user instead of deleting them.
+	* 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 warnForShadowingAlternativeRoots(alternativeRoots) {
-		const localRootFileName = this.getFactory(this.toolTarget).meta.localRootFileName;
-		const globs = alternativeRoots.flatMap((alt) => [rootRelativeGlob(alt.relativeDirPath, alt.relativeFilePath), ...localRootFileName ? [rootRelativeGlob(alt.relativeDirPath, localRootFileName)] : []]);
-		if (globs.length === 0) return;
-		const filePaths = await findFilesByGlobs(globs, { cwd: this.outputRoot });
+	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)));
-		this.logger.warn(`${names.join(", ")} still ${names.length === 1 ? "keeps" : "keep"} Claude Code from reading AGENTS.md although \`includeRoot: false\` is set for claudecode. Rulesync does not delete ${names.length === 1 ? "it" : "them"}; remove ${names.length === 1 ? "it" : "them"} by hand once the content is covered by AGENTS.md.`);
+		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";
@@ -80003,7 +80267,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const rootToolRules = await (async () => {
 				if (!settablePaths.root) return [];
 				if (forDeletion && omitsRootFiles) {
-					await this.warnForShadowingAlternativeRoots(settablePaths.alternativeRoots ?? []);
+					await this.warnForShadowingRootFiles({ includePrimaryRoots: false });
 					return buildDeletionRulesFromPaths(primaryRootFilePaths);
 				}
 				const uniqueRootFilePaths = await findFilesWithFallback(primaryRootFilePaths, settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, alt.relativeFilePath), this.outputRoot);
@@ -81565,6 +81829,7 @@ async function generateRulesCore(params) {
 			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
 			skills,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
+			delete: config.getDelete(),
 			dryRun: config.isPreviewMode(),
 			logger
 		});