rulesync 17.1.0 → 19.0.0

package/dist/{import-Csmx6n4n.js → import-C-Jsxedt.js}

@@ -44086,6 +44086,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";
@@ -44306,7 +44307,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;
 	}
@@ -44323,9 +44332,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,
@@ -44335,7 +44348,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,
@@ -44492,9 +44505,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.`);
@@ -44508,6 +44579,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);
 }
@@ -44524,7 +44598,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";
 	}
 }
@@ -44649,18 +44725,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)) {
@@ -44671,37 +44773,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);
@@ -59546,21 +59742,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 +59807,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 +59910,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, {
@@ -79112,6 +79338,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;
@@ -79123,7 +79350,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,
@@ -79142,6 +79370,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);
@@ -79149,7 +79378,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;
@@ -79294,8 +79523,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
@@ -79325,19 +79555,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(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";
@@ -79978,7 +80242,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);
@@ -81540,6 +81804,7 @@ async function generateRulesCore(params) {
 			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
 			skills,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
+			delete: config.getDelete(),
 			dryRun: config.isPreviewMode(),
 			logger
 		});
@@ -82319,4 +82584,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-Csmx6n4n.js.map
+//# sourceMappingURL=import-C-Jsxedt.js.map