rulesync 16.20.0 → 16.21.0

package/dist/{import-BlhbArzI.cjs → import-7UmDF35I.cjs}

@@ -26,6 +26,7 @@ let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let jsonc_parser = require("jsonc-parser");
+let node_fs = require("node:fs");
 let node_os = require("node:os");
 node_os = __toESM(node_os, 1);
 let es_toolkit = require("es-toolkit");
@@ -36,7 +37,6 @@ let gray_matter = require("gray-matter");
 gray_matter = __toESM(gray_matter, 1);
 let js_yaml = require("js-yaml");
 let es_toolkit_object = require("es-toolkit/object");
-let node_fs = require("node:fs");
 let node_crypto = require("node:crypto");
 let smol_toml = require("smol-toml");
 smol_toml = __toESM(smol_toml, 1);
@@ -63,6 +63,26 @@ function stripControlCharacters(text) {
 	return text.replace(CONTROL_CHARACTERS_PATTERN, "");
 }
 /**
+* Strips the control characters from `text` and then JSON-quotes it, which is
+* the form a remote-derived name — a fetched path, a directory name read off
+* the disk, a branch name chosen by a remote repository — takes in a log line.
+*
+* The two steps do different jobs, and neither is enough on its own. The
+* quoting delimits the untrusted text, so a reader can tell where the name
+* ends and the diagnostic resumes, and it escapes the quotes and backslashes
+* that would blur that edge. But `JSON.stringify` escapes the C0 controls and
+* nothing else: the C1 range, the 8-bit CSI introducer among it, and the bidi
+* overrides pass through it intact, and any one of them reaches the terminal
+* with its power to forge a line or reorder one. The strip is what takes those
+* out. It runs first so that the quoting sees only printable text and the line
+* carries no escaped control characters the reader has to decode — what could
+* do harm is gone rather than spelled out — and so that the rationale for the
+* order lives here, once, rather than at every call site.
+*/
+function quoteForLog(text) {
+	return JSON.stringify(stripControlCharacters(text));
+}
+/**
 * Removes every control character from `text` except the line feed, so a
 * message written to be read over several lines still is.
 *
@@ -395,34 +415,34 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$298 } = node_path.posix;
+const { join: join$299 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$298(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$299(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$298(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$298(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$299(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$299(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$298(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$299(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -928,9 +948,9 @@ function toPosixPath(p) {
 	return p.replace(/\\/g, "/");
 }
 function checkPathTraversal({ relativePath, intendedRootDir }) {
-	if (relativePath.split(/[/\\]/).includes("..")) throw new Error(`Path traversal detected: ${JSON.stringify(stripControlCharacters(relativePath))}`);
+	if (relativePath.split(/[/\\]/).includes("..")) throw new Error(`Path traversal detected: ${quoteForLog(relativePath)}`);
 	const resolved = (0, node_path.resolve)(intendedRootDir, relativePath);
-	if ((0, node_path.relative)(intendedRootDir, resolved).startsWith("..") || (0, node_path.resolve)(resolved) !== resolved) throw new Error(`Path traversal detected: ${JSON.stringify(stripControlCharacters(relativePath))}`);
+	if ((0, node_path.relative)(intendedRootDir, resolved).startsWith("..") || (0, node_path.resolve)(resolved) !== resolved) throw new Error(`Path traversal detected: ${quoteForLog(relativePath)}`);
 }
 /**
 * Resolves a path relative to a base directory, handling both absolute and relative paths
@@ -990,24 +1010,60 @@ async function writeFileContent(filepath, content) {
 * Apply a POSIX mode to an existing file. Windows has no executable bit and
 * `chmod` there only toggles the read-only flag, so the call is skipped rather
 * than writing a mode the platform cannot honor.
+*
+* The mode goes through a handle opened with `O_NOFOLLOW`, so a symbolic link
+* standing where the file should be is left alone rather than having the mode
+* land on whatever it points at -- possibly outside the output tree -- and the
+* file whose mode changes is the very one that was opened, with no path to
+* swap between the check and the `chmod`. The write side refuses to read
+* through links; the mode side refuses to write through them. A link is
+* skipped silently, like Windows; a file that does not exist still throws.
 */
 async function applyFileMode(filepath, mode) {
 	if (process.platform === "win32") return;
-	await (0, node_fs_promises.chmod)(filepath, mode);
+	const fileHandle = await openNotFollowingLinks(filepath);
+	if (fileHandle === void 0) return;
+	try {
+		await fileHandle.chmod(mode);
+	} finally {
+		await fileHandle.close();
+	}
 }
 /**
 * Restore an executable bit that went missing (interrupted run, a copy that
 * dropped the mode). A file whose mode is merely stricter than `mode` — the
-* user chose 0700 over 0755 — is left alone.
+* user chose 0700 over 0755 — is left alone, and so is a symbolic link or a
+* file that cannot be opened: this repairs, it never creates.
 */
 async function restoreMissingExecutableBit(filepath, mode) {
 	if (process.platform === "win32") return;
+	let fileHandle;
 	try {
-		if (((await (0, node_fs_promises.stat)(filepath)).mode & 73) !== 0) return;
+		fileHandle = await openNotFollowingLinks(filepath);
 	} catch {
 		return;
 	}
-	await (0, node_fs_promises.chmod)(filepath, mode);
+	if (fileHandle === void 0) return;
+	try {
+		if (((await fileHandle.stat()).mode & 73) !== 0) return;
+		await fileHandle.chmod(mode);
+	} finally {
+		await fileHandle.close();
+	}
+}
+/**
+* Open a file for its mode without following a symbolic link at the path.
+* Returns `undefined` when the path is a link (`O_NOFOLLOW` fails with
+* `ELOOP`, or `EMLINK` on some BSDs); any other failure is the caller's.
+*/
+async function openNotFollowingLinks(filepath) {
+	try {
+		return await (0, node_fs_promises.open)(filepath, node_fs.constants.O_RDONLY | (node_fs.constants.O_NOFOLLOW ?? 0));
+	} catch (error) {
+		const code = error.code;
+		if (code === "ELOOP" || code === "EMLINK") return;
+		throw error;
+	}
 }
 async function writeFileBuffer(filepath, buffer) {
 	await ensureDir((0, node_path.dirname)(filepath));
@@ -1218,6 +1274,19 @@ function posixRelativePathEscapesRoot(relativePath) {
 	return relativePath === ".." || relativePath.startsWith("../") || node_path.posix.isAbsolute(relativePath);
 }
 /**
+* Whether the file `targetPath` really denotes sits outside `rootPath`. Unlike
+* `pathEscapesRoot`, which reads a path as it is spelled, this resolves every link
+* on both sides first, so a name that sits inside the root but is a link pointing
+* out of it is reported as the escape it is. Both sides fall back to their literal
+* path when they cannot be resolved, which reports an escape rather than hiding one.
+*/
+async function resolvedPathEscapesRoot({ rootPath, targetPath }) {
+	return posixRelativePathEscapesRoot(await resolvedRelativePath({
+		rootPath,
+		targetPath
+	}));
+}
+/**
 * How many trailing segments `filePath` and `identity` have in common.
 *
 * A path that walked through no link at all shares all of its own segments with
@@ -1227,9 +1296,17 @@ function posixRelativePathEscapesRoot(relativePath) {
 * what lets the comparison hold for a path that is not itself resolved: a glob
 * rooted at a directory that is a link of its own gives every candidate the
 * same unresolved prefix, and only the segments below it decide.
+*
+* `filePath` is spelled the way the platform reported it and `identity` is
+* posix-separated, so the two are split on both separators: on Windows a
+* backslash-separated path then shares its segments with the posix identity
+* without being rewritten first, and on a posix platform a backslash inside a
+* name is split the same way on both sides, which keeps the count symmetric.
+*
+* Exported for its tests, which need a Windows-style spelling on any platform.
 */
 function sharedTrailingSegments(filePath, identity) {
-	const left = splitPathSegments(nativePathToPosix(filePath));
+	const left = splitPathSegments(filePath);
 	const right = splitPathSegments(identity);
 	let shared = 0;
 	while (shared < left.length && shared < right.length && left[left.length - 1 - shared] === right[right.length - 1 - shared]) shared++;
@@ -1257,7 +1334,7 @@ function chooseRepresentative(candidates, identity) {
 	});
 }
 async function findFilesByGlobs(globs, options = {}) {
-	const { type = "all", followSymbolicLinks = true, ignore, dot = false } = options;
+	const { cwd, type = "all", followSymbolicLinks = true, ignore, dot = false } = options;
 	const globbyOptions = type === "file" ? {
 		onlyFiles: true,
 		onlyDirectories: false
@@ -1271,6 +1348,7 @@ async function findFilesByGlobs(globs, options = {}) {
 	const normalizedGlobs = Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/");
 	const results = (0, globby.globbySync)(normalizedGlobs, {
 		absolute: true,
+		cwd,
 		followSymbolicLinks,
 		dot,
 		...ignore ? { ignore: ignore.map((pattern) => pattern.replaceAll("\\", "/")) } : {},
@@ -1343,14 +1421,16 @@ async function listEntryNames(params) {
 */
 async function dedupeNamesByFileIdentity(params) {
 	const { dirPath, entries } = params;
-	const identities = await mapWithConcurrency({
+	const identifiedEntries = await mapWithConcurrency({
 		items: entries,
 		limit: ENTRY_CLASSIFY_CONCURRENCY,
-		mapper: async (entry) => await realFileIdentity((0, node_path.join)(dirPath, entry.name))
+		mapper: async (entry) => ({
+			entry,
+			identity: await realFileIdentity((0, node_path.join)(dirPath, entry.name))
+		})
 	});
 	const entriesByIdentity = /* @__PURE__ */ new Map();
-	for (const [index, entry] of entries.entries()) {
-		const identity = identities[index] ?? nativePathToPosix((0, node_path.join)(dirPath, entry.name));
+	for (const { entry, identity } of identifiedEntries) {
 		const group = entriesByIdentity.get(identity);
 		if (group === void 0) entriesByIdentity.set(identity, [entry]);
 		else group.push(entry);
@@ -1649,43 +1729,76 @@ var CLIError = class extends Error {
 };
 //#endregion
 //#region src/utils/warned-once.ts
+function createRunWarningState() {
+	return {
+		messages: /* @__PURE__ */ new Set(),
+		carriedFilesIncomplete: false
+	};
+}
 /**
-* The messages a once-per-run warning has already emitted in this process.
+* The state of a run that opened no scope of its own.
 * This lives in its own module, importing nothing of rulesync's, so the vitest
 * setup file can clear it between tests without pulling `logger.js` into every
 * test's module graph (which would defeat the module mocks some of those tests
 * install).
 */
-const processWideMessages = /* @__PURE__ */ new Set();
+const processWideState = createRunWarningState();
 /**
-* The set an operation that opened its own scope uses instead.
+* The state an operation that opened its own scope uses instead.
 *
 * The MCP server does not serialize requests, so two runs can be in flight at
 * once. Sharing one set between them would let the first run spend the token
 * for a message and leave the second one's result silent about a diagnostic
 * that applies to it just as much. A scope gives each run its own bookkeeping.
 */
-const scopedMessages = new node_async_hooks.AsyncLocalStorage();
-function currentMessages() {
-	return scopedMessages.getStore() ?? processWideMessages;
+const scopedState = new node_async_hooks.AsyncLocalStorage();
+function currentState() {
+	return scopedState.getStore() ?? processWideState;
 }
 /** Whether `message` has not been emitted yet; records it when it has not. */
 function claimWarnOnce(message) {
-	const messages = currentMessages();
+	const { messages } = currentState();
 	if (messages.has(message)) return false;
 	messages.add(message);
 	return true;
 }
-/** Forget which warnings were already emitted, so the next run starts silent. */
-function resetWarnedOnceMessages() {
-	currentMessages().clear();
+/**
+* Record that this run could not read everything a directory carries -- a file
+* it could not open, a walk that hit one of its bounds, a subtree it was denied.
+*
+* Kept here, beside the once-per-run messages, because it shares their lifetime
+* exactly: it is set at the moment such a shortfall is warned about, and cleared
+* when the next run resets its warnings.
+*
+* Deliberate refusals are not shortfalls. A hidden entry, a credential-shaped
+* name, a link into a pseudo-filesystem: those are files Rulesync never carries,
+* on every run, and a run that leaves them out has read its source in full.
+*/
+function recordIncompleteCarriedFiles() {
+	currentState().carriedFilesIncomplete = true;
+}
+/**
+* Whether {@link recordIncompleteCarriedFiles} fired in this run.
+*
+* A caller that deletes what a run did not write has to ask: a run holding an
+* incomplete picture of its source cannot tell a stale file from one whose
+* source it merely failed to read.
+*/
+function hasIncompleteCarriedFiles() {
+	return currentState().carriedFilesIncomplete;
+}
+/** Forget what was already reported, so the next run starts silent. */
+function resetRunWarningState() {
+	const state = currentState();
+	state.messages.clear();
+	state.carriedFilesIncomplete = false;
 }
 /**
 * Run `operation` with its own once-per-run bookkeeping, so a concurrent run
 * neither spends its tokens nor clears its record.
 */
 async function withWarnOnceScope(operation) {
-	return await scopedMessages.run(/* @__PURE__ */ new Set(), operation);
+	return await scopedState.run(createRunWarningState(), operation);
 }
 //#endregion
 //#region src/utils/logger.ts
@@ -2059,6 +2172,148 @@ var WarningCollectingLogger = class extends ConsoleLogger {
 	}
 };
 //#endregion
+//#region src/types/language.ts
+/**
+* Response languages the root `language` key of `rulesync.jsonc` accepts.
+*
+* BCP 47-style codes: a bare ISO 639-1 code where one language name is
+* unambiguous, and a region-qualified code where the written form differs by
+* region (`zh-CN` / `zh-TW`, `pt-BR`). Widening the list is a non-breaking
+* change; respelling an existing code is not, so the code style is fixed here.
+*/
+const LANGUAGE_CODES = [
+	"en",
+	"ja",
+	"zh-CN",
+	"zh-TW",
+	"ko",
+	"fr",
+	"de",
+	"es",
+	"pt-BR",
+	"ru"
+];
+const LanguageSchema = zod_mini.z.enum(LANGUAGE_CODES);
+const LANGUAGE_DISPLAY = {
+	en: {
+		name: "English",
+		claudecode: "english"
+	},
+	ja: {
+		name: "Japanese",
+		claudecode: "japanese"
+	},
+	"zh-CN": {
+		name: "Simplified Chinese",
+		claudecode: "simplified chinese"
+	},
+	"zh-TW": {
+		name: "Traditional Chinese",
+		claudecode: "traditional chinese"
+	},
+	ko: {
+		name: "Korean",
+		claudecode: "korean"
+	},
+	fr: {
+		name: "French",
+		claudecode: "french"
+	},
+	de: {
+		name: "German",
+		claudecode: "german"
+	},
+	es: {
+		name: "Spanish",
+		claudecode: "spanish"
+	},
+	"pt-BR": {
+		name: "Brazilian Portuguese",
+		claudecode: "brazilian portuguese"
+	},
+	ru: {
+		name: "Russian",
+		claudecode: "russian"
+	}
+};
+/** English display name of a language, as used in the appended prompt. */
+function getLanguageName(language) {
+	return LANGUAGE_DISPLAY[language].name;
+}
+/** The value Claude Code's `language` settings key expects for a language. */
+function getClaudecodeLanguageValue(language) {
+	return LANGUAGE_DISPLAY[language].claudecode;
+}
+/**
+* The one sentence rulesync appends to generated root rule files when
+* `language` is set. Every supported language — `en` included — emits it, so
+* the instruction is explicit rather than implied by the absence of a block.
+*/
+function buildLanguageInstruction(language) {
+	return `You must always answer in ${getLanguageName(language)}. On the other hand, reasoning (thinking) should be in English to improve token efficiency.`;
+}
+/**
+* Separator that opens the appended block. A thematic break makes the
+* concatenation visible, so a reader can tell the sentence was appended by
+* rulesync rather than authored as part of the rules.
+*/
+const LANGUAGE_BLOCK_SEPARATOR = "---";
+/**
+* Append the language block to a rule body: a blank line, the separator, a
+* blank line, then the instruction. A body that is empty (or whitespace only)
+* gets the instruction alone, because a file that starts with `---` reads as
+* the opening of a frontmatter block.
+*/
+function appendLanguageBlock({ content, language }) {
+	const instruction = buildLanguageInstruction(language);
+	const body = content.trimEnd();
+	if (body.length === 0) return instruction;
+	return `${body}\n\n${LANGUAGE_BLOCK_SEPARATOR}\n\n${instruction}`;
+}
+const INSTRUCTIONS = LANGUAGE_CODES.map((code) => buildLanguageInstruction(code));
+const isBlank = (value) => value === " " || value === "	";
+/**
+* Remove one trailing block exactly as {@link appendLanguageBlock} writes it,
+* for any supported language: the separator on its own line, blank space
+* with at least one line break, the instruction, trailing whitespace. Only
+* the end of the body is inspected, so a sentence quoted mid-file is left
+* alone. Returns the body unchanged when no block closes it.
+*
+* Walks the body from its end with string operations rather than a regular
+* expression: an unanchored pattern over optional blank lines backtracks in
+* polynomial time, and a rule file padded with a few hundred thousand
+* trailing newlines would hang `rulesync import` on it.
+*/
+function stripOneLanguageBlock(body) {
+	const trimmed = body.trimEnd();
+	const instruction = INSTRUCTIONS.find((candidate) => trimmed.endsWith(candidate));
+	if (instruction === void 0) return body;
+	const beforeInstruction = trimmed.slice(0, trimmed.length - instruction.length);
+	const beforeGap = beforeInstruction.trimEnd();
+	if (beforeGap.length === 0) return "";
+	if (!beforeInstruction.slice(beforeGap.length).includes("\n")) return body;
+	if (!beforeGap.endsWith(LANGUAGE_BLOCK_SEPARATOR)) return body;
+	let lineStart = beforeGap.length - 3;
+	while (lineStart > 0 && isBlank(beforeGap.charAt(lineStart - 1))) lineStart -= 1;
+	if (lineStart > 0 && beforeGap.charAt(lineStart - 1) !== "\n") return body;
+	return body.slice(0, lineStart).trimEnd();
+}
+/**
+* Remove the trailing language block(s) from an imported rule body so that
+* `rulesync import` followed by `rulesync generate` does not stack a second
+* copy. Repeats until nothing more comes off, so a file that already carries
+* two stacked blocks (generated twice by an older flow, say) comes back
+* clean. Returns the body unchanged when no block is present.
+*/
+function stripLanguageBlock(body) {
+	let current = body;
+	for (;;) {
+		const next = stripOneLanguageBlock(current);
+		if (next === current) return current;
+		current = next;
+	}
+}
+//#endregion
 //#region src/utils/validation.ts
 /**
 * Shared validation utilities for input sanitization.
@@ -2130,7 +2385,15 @@ const ConfigParamsSchema = zod_mini.z.object({
 	simulateCommands: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSubagents: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSkills: (0, zod_mini.optional)(zod_mini.z.boolean()),
+	deriveSubprojectPathFromGlobs: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	flattenedCommandNaming: (0, zod_mini.optional)(FlattenedCommandNamingSchema),
+	/**
+	* Response language the generated rules steer the AI toward. Config-file
+	* only (no CLI flag): it is a property of the project, not of one run.
+	* Absent means "say nothing about language", which is why `en` is a real
+	* value rather than the default.
+	*/
+	language: (0, zod_mini.optional)(LanguageSchema),
 	gitignoreTargetsOnly: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	gitignoreDestination: (0, zod_mini.optional)(GitignoreDestinationSchema),
 	dryRun: (0, zod_mini.optional)(zod_mini.z.boolean()),
@@ -2270,7 +2533,9 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	deriveSubprojectPathFromGlobs;
 	flattenedCommandNaming;
+	language;
 	gitignoreTargetsOnly;
 	gitignoreDestination;
 	dryRun;
@@ -2294,7 +2559,7 @@ var Config = class Config {
 	inputRoots;
 	configFilePath;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, flattenedCommandNaming, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -2326,7 +2591,9 @@ var Config = class Config {
 		this.simulateCommands = simulateCommands ?? false;
 		this.simulateSubagents = simulateSubagents ?? false;
 		this.simulateSkills = simulateSkills ?? false;
+		this.deriveSubprojectPathFromGlobs = deriveSubprojectPathFromGlobs ?? false;
 		this.flattenedCommandNaming = flattenedCommandNaming ?? "basename";
+		this.language = language;
 		this.gitignoreTargetsOnly = gitignoreTargetsOnly ?? true;
 		this.gitignoreDestination = gitignoreDestination ?? "gitignore";
 		this.dryRun = dryRun ?? false;
@@ -2505,12 +2772,22 @@ var Config = class Config {
 	getFlattenedCommandNaming() {
 		return this.flattenedCommandNaming;
 	}
+	/**
+	* The configured response language, or `undefined` when `rulesync.jsonc`
+	* does not set one — in which case generation leaves language alone.
+	*/
+	getLanguage() {
+		return this.language;
+	}
 	getSimulateSubagents() {
 		return this.simulateSubagents;
 	}
 	getSimulateSkills() {
 		return this.simulateSkills;
 	}
+	getDeriveSubprojectPathFromGlobs() {
+		return this.deriveSubprojectPathFromGlobs;
+	}
 	getGitignoreTargetsOnly() {
 		return this.gitignoreTargetsOnly;
 	}
@@ -2571,6 +2848,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	deriveSubprojectPathFromGlobs: false,
 	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
 	gitignoreDestination: "gitignore",
@@ -2618,7 +2896,9 @@ const mergeConfigs = (baseConfig, localConfig) => {
 		simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
 		simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
 		simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+		deriveSubprojectPathFromGlobs: localConfig.deriveSubprojectPathFromGlobs ?? baseConfig.deriveSubprojectPathFromGlobs,
 		flattenedCommandNaming: localConfig.flattenedCommandNaming ?? baseConfig.flattenedCommandNaming,
+		language: localConfig.language ?? baseConfig.language,
 		gitignoreTargetsOnly: localConfig.gitignoreTargetsOnly ?? baseConfig.gitignoreTargetsOnly,
 		gitignoreDestination: localConfig.gitignoreDestination ?? baseConfig.gitignoreDestination,
 		dryRun: localConfig.dryRun ?? baseConfig.dryRun,
@@ -2740,7 +3020,7 @@ function resolveEffectiveInputRoots({ cliInputRoot, cliInputRoots, configByFile,
 	};
 }
 var ConfigResolver = class {
-	static async resolve({ targets, features, verbose, delete: isDelete, outputRoots, configPath = getDefaults().configPath, global, silent, simulateCommands, simulateSubagents, simulateSkills, gitignoreTargetsOnly, dryRun, check, gitignoreDestination, inputRoot, inputRoots }, { logger } = {}) {
+	static async resolve({ targets, features, verbose, delete: isDelete, outputRoots, configPath = getDefaults().configPath, global, silent, simulateCommands, simulateSubagents, simulateSkills, deriveSubprojectPathFromGlobs, gitignoreTargetsOnly, dryRun, check, gitignoreDestination, inputRoot, inputRoots }, { logger } = {}) {
 		const cwd = (0, node_path.resolve)(process.cwd());
 		assertInputRootFieldsExclusive({
 			inputRoot,
@@ -2839,6 +3119,11 @@ var ConfigResolver = class {
 				file: configByFile.simulateSkills,
 				fallback: getDefaults().simulateSkills
 			}),
+			deriveSubprojectPathFromGlobs: pick({
+				cli: deriveSubprojectPathFromGlobs,
+				file: configByFile.deriveSubprojectPathFromGlobs,
+				fallback: getDefaults().deriveSubprojectPathFromGlobs
+			}),
 			gitignoreTargetsOnly: pick({
 				cli: gitignoreTargetsOnly,
 				file: configByFile.gitignoreTargetsOnly,
@@ -2863,6 +3148,7 @@ var ConfigResolver = class {
 			configFilePath: validatedConfigPath,
 			sources: configByFile.sources ?? getDefaults().sources,
 			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
+			language: configByFile.language,
 			configFileTargets: extractConfigFileTargets(configByFile.targets)
 		});
 	}
@@ -5043,7 +5329,7 @@ function collectPollutionKeyPaths({ node, path, found }) {
 * configs. Plain JSON is valid JSONC, so this is a drop-in replacement for
 * `JSON.parse` on files that may contain comments or trailing commas.
 */
-function parseJsonc$8(content) {
+function parseJsonc$6(content) {
 	return deepSanitize(parseStrict(content));
 }
 /**
@@ -7216,7 +7502,7 @@ function warnAboutDroppedKeys({ removed, sourcePath, logger }) {
 * are removed here instead, and reported.
 */
 function withoutBlankPermissionKeys({ fileContent, sourcePath, logger }) {
-	const parsed = parseJsonc$8(fileContent);
+	const parsed = parseJsonc$6(fileContent);
 	if (!isRecord$1(parsed)) return fileContent;
 	const { config, removed } = stripBlankPermissionKeys(parsed);
 	if (removed.patterns.size === 0 && removed.categories.size === 0) return fileContent;
@@ -7266,7 +7552,80 @@ const PERMISSION_OVERRIDE_KEY_ALIASES = {
 	hermesagent: "hermes"
 };
 //#endregion
+//#region src/utils/glob-static-prefix.ts
+/**
+* Characters that make a path segment a pattern rather than a literal name.
+*
+* `(` `)` and `!` are included because extglob syntax (`+(a|b)`, `!(x)`) uses
+* them; treating a segment that carries one as static could name a directory
+* that no matched file actually lives under.
+*/
+const GLOB_METACHARACTERS = /[*?[\]{}()!]/;
+/**
+* The directory every file matched by `glob` lives under, or `undefined` when
+* the pattern pins down no such directory.
+*
+* The result is the longest leading run of POSIX path segments that contain no
+* glob metacharacter, minus the final segment when the pattern ends in one that
+* is static: `packages/api/**\/*.ts` yields `packages/api`, while
+* `packages/api/README.md` names a file and yields `packages/api` as well, and
+* a bare `README.md` yields nothing. A leading `./` is stripped. The following
+* patterns are rejected outright because the directory they would name is
+* either not inside the output root or not a single directory at all:
+*
+* - negation patterns (`!packages/**`), which exclude rather than select;
+* - absolute paths (`/etc/**`, `C:/x/**`) and backslash-separated patterns;
+* - patterns with a `..` segment anywhere;
+* - patterns with a brace expansion or any other metacharacter in their first
+*   segment (`{a,b}/**`), which have no static prefix.
+*
+* Brace expansion elsewhere ends the prefix without rejecting the pattern:
+* `packages/{api,web}/**` yields `packages`, the directory both alternatives
+* share, exactly as `packages/*\/**` would.
+*/
+function getGlobStaticPrefix(glob) {
+	if (glob.startsWith("!") || glob.includes("\\")) return;
+	let pattern = glob;
+	while (pattern.startsWith("./")) pattern = pattern.slice(2);
+	if (pattern.startsWith("/") || /^[A-Za-z]:/.test(pattern)) return;
+	const segments = pattern.split("/");
+	if (segments.includes("..")) return;
+	const lastIndex = segments.length - 1;
+	const prefix = [];
+	for (const [index, segment] of segments.entries()) {
+		if (segment === "" || GLOB_METACHARACTERS.test(segment)) break;
+		if (segment === ".") continue;
+		if (index === lastIndex) break;
+		prefix.push(segment);
+	}
+	return prefix.length > 0 ? prefix.join("/") : void 0;
+}
+/**
+* The single directory every one of `globs` scopes, or `undefined` when the
+* list is empty, any pattern yields no prefix, or the patterns disagree.
+*
+* Several globs derive a directory only when each of them yields the same one:
+* picking the first pattern's prefix, or the common ancestor of all of them,
+* would place the rule somewhere the author never named.
+*/
+function getGlobsStaticPrefix(globs) {
+	let shared;
+	for (const glob of globs) {
+		const prefix = getGlobStaticPrefix(glob);
+		if (prefix === void 0 || shared !== void 0 && prefix !== shared) return;
+		shared = prefix;
+	}
+	return shared;
+}
+//#endregion
 //#region src/features/rules/rulesync-rule.ts
+/**
+* The `agentsmd.subprojectPath` value that asks for the path to be derived from
+* the rule's `globs` (see {@link resolveSubprojectPath}). It is a request, not a
+* path: the constructor replaces it with the derived directory, or drops it,
+* before any consumer reads the frontmatter.
+*/
+const AUTO_SUBPROJECT_PATH = "auto";
 const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 	root: zod_mini.z.optional(zod_mini.z.boolean()),
 	localRoot: zod_mini.z.optional(zod_mini.z.boolean()),
@@ -7318,10 +7677,90 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 		facet: zod_mini.z.optional(zod_mini.z.enum(["policies", "output-contracts"]))
 	}))
 });
+/**
+* The `agentsmd.subprojectPath` every consumer should act on, resolved once so
+* that no target has to know how it came about:
+*
+* 1. an explicit directory in the frontmatter wins, and an explicit `""` is an
+*    opt-out: the rule keeps its default placement and nothing is derived;
+* 2. otherwise, when the rule says `"auto"` or `deriveFromGlobs` is on, the
+*    directory the rule's `globs` share (see `getGlobsStaticPrefix`);
+* 3. otherwise none, which keeps the rule in the target's modular directory.
+*
+* A root rule never nests, so it never derives. When a derivation yields
+* nothing the rule falls back to step 3, and only a rule that asked with
+* `"auto"` is told, once: it named a placement it did not get, so a warning
+* names the file to fix (an error would stop every other rule from
+* generating). The config option applies to every non-root rule, most of
+* which are general guidance whose globs, if any, were written as activation
+* hints (`["src/**\/*.ts", "test/**\/*.ts"]`) rather than as a directory;
+* warning about each of those on every generate would drown out real ones,
+* so config-driven derivation falls back silently.
+*/
+function resolveSubprojectPath({ frontmatter, deriveFromGlobs, rulePath }) {
+	const authored = frontmatter.agentsmd?.subprojectPath;
+	if (authored === "") return;
+	if (typeof authored === "string" && authored !== "auto") return authored;
+	const requested = authored === AUTO_SUBPROJECT_PATH;
+	if (!requested && !deriveFromGlobs) return;
+	if (frontmatter.root) {
+		if (requested) warnOnceWithFallback(void 0, `Ignoring agentsmd.subprojectPath: "${AUTO_SUBPROJECT_PATH}" on the root rule ${rulePath}: a root rule is never written as a nested AGENTS.md.`);
+		return;
+	}
+	const globs = Array.isArray(frontmatter.globs) ? frontmatter.globs : [];
+	const derived = getGlobsStaticPrefix(globs);
+	if (derived === void 0 && requested) warnOnceWithFallback(void 0, `Could not derive agentsmd.subprojectPath for ${rulePath} from globs ${JSON.stringify(globs)}: every glob must start with the same wildcard-free directory (e.g. "packages/api/**/*"). The rule is generated without a nested AGENTS.md; set agentsmd.subprojectPath explicitly to nest it.`);
+	return derived;
+}
+/**
+* `frontmatter` with `agentsmd.subprojectPath` replaced by its resolved value,
+* or removed when there is none, so the `"auto"` request never reaches a
+* consumer as if it were a directory name. An `agentsmd` block that held
+* nothing but the request goes with it, so a consumer sees the same shape it
+* would for a rule that never mentioned `agentsmd`. An authored `""` is left
+* as written: every consumer already reads it as "no nesting".
+*/
+function withResolvedSubprojectPath({ frontmatter, deriveFromGlobs, rulePath }) {
+	const authored = frontmatter.agentsmd?.subprojectPath;
+	const resolved = resolveSubprojectPath({
+		frontmatter,
+		deriveFromGlobs,
+		rulePath
+	});
+	if (resolved === authored || resolved === void 0 && authored !== "auto") return frontmatter;
+	const { subprojectPath: _authored, ...agentsmd } = frontmatter.agentsmd ?? {};
+	if (resolved !== void 0) return {
+		...frontmatter,
+		agentsmd: {
+			...agentsmd,
+			subprojectPath: resolved
+		}
+	};
+	if (Object.keys(agentsmd).length === 0) {
+		const { agentsmd: _empty, ...rest } = frontmatter;
+		return rest;
+	}
+	return {
+		...frontmatter,
+		agentsmd
+	};
+}
 var RulesyncRule = class RulesyncRule extends RulesyncFile {
+	/**
+	* The frontmatter consumers read. It differs from what the file says in one
+	* place: `agentsmd.subprojectPath` holds the resolved directory (see
+	* `resolveSubprojectPath`), while `authoredFrontmatter` and
+	* `getFileContent()` keep the authored value, so a rule written back out
+	* still says `"auto"`.
+	*/
 	frontmatter;
+	/**
+	* The frontmatter as written, after schema defaults but before
+	* `agentsmd.subprojectPath` resolution: what `getFileContent()` serializes.
+	*/
+	authoredFrontmatter;
 	body;
-	constructor({ frontmatter, body, ...rest }) {
+	constructor({ frontmatter, body, deriveSubprojectPathFromGlobs = false, ...rest }) {
 		const parseResult = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
 		if (!parseResult.success && rest.validate !== false) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(parseResult.error)}`);
 		const parsedFrontmatter = parseResult.success ? parseResult.data : {
@@ -7332,7 +7771,12 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			...rest,
 			fileContent: stringifyFrontmatter(body, parsedFrontmatter)
 		});
-		this.frontmatter = parsedFrontmatter;
+		this.authoredFrontmatter = parsedFrontmatter;
+		this.frontmatter = withResolvedSubprojectPath({
+			frontmatter: parsedFrontmatter,
+			deriveFromGlobs: deriveSubprojectPathFromGlobs,
+			rulePath: (0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)
+		});
 		this.body = body;
 	}
 	static getSettablePaths() {
@@ -7341,9 +7785,23 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			legacy: { relativeDirPath: RULESYNC_RELATIVE_DIR_PATH }
 		};
 	}
+	/**
+	* The frontmatter to act on: `agentsmd.subprojectPath` is the resolved
+	* placement, never `"auto"`.
+	*/
 	getFrontmatter() {
 		return this.frontmatter;
 	}
+	/**
+	* The frontmatter as the file states it, `agentsmd.subprojectPath: "auto"`
+	* included. This is the view to hand back to whoever edits the file (the
+	* MCP rule tools): returning the resolved placement instead would make a
+	* get → edit → put round trip hardcode the derived directory, or drop the
+	* request when nothing could be derived.
+	*/
+	getAuthoredFrontmatter() {
+		return this.authoredFrontmatter;
+	}
 	validate() {
 		if (!this.frontmatter) return {
 			success: true,
@@ -7359,7 +7817,7 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
 		};
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true }) {
+	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true, deriveSubprojectPathFromGlobs = false }) {
 		const dirPath = relativeDirPath ?? this.getSettablePaths().recommended.relativeDirPath;
 		const filePath = (0, node_path.join)(outputRoot, dirPath, relativeFilePath);
 		const { frontmatter, body: content, hasFrontmatter } = parseFrontmatter(await readFileContent(filePath), filePath);
@@ -7378,7 +7836,8 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			relativeFilePath,
 			frontmatter: validatedFrontmatter,
 			body: content.trim(),
-			validate
+			validate,
+			deriveSubprojectPathFromGlobs
 		});
 	}
 	getBody() {
@@ -7406,6 +7865,21 @@ function containsPathSeparator(name) {
 	return name.includes("/") || name.includes("\\");
 }
 /**
+* The permission bits worth carrying from a source file: only an executable
+* one has a mode the copy must keep, and only its read and execute bits plus
+* the owner's write bit are kept. Group and world write bits are dropped the
+* way a umask would drop them, so a source sitting on a mount that reports
+* everything as 0777 does not turn the generated copy world-writable; setuid,
+* setgid and sticky are never carried. Windows reports no executable bit, so
+* nothing is carried there and the copy takes the platform default, as it
+* always has.
+*/
+function carriedFileMode(mode) {
+	const permissionBits = mode & 493;
+	if ((permissionBits & 73) === 0) return {};
+	return { fileMode: permissionBits };
+}
+/**
 * Directories that hold credentials. Excluding these protects something, so
 * their exclusion is reported rather than silent.
 */
@@ -8119,6 +8593,7 @@ var AiDir = class AiDir {
 	* files says so rather than generating a directory that is quietly short.
 	*/
 	static warnOnCarriedWalkLimits({ reportedDirPath, truncations, unreadablePaths }) {
+		if (truncations.size > 0 || unreadablePaths.length > 0) recordIncompleteCarriedFiles();
 		if (truncations.has("depth")) warnOnceWithFallback(void 0, `Not carrying the entries more than 12 directories below ${reportedDirPath}: a skill directory is walked to that depth only. A symbolic link that reaches a large tree is the usual cause.`);
 		if (truncations.has("count")) warnOnceWithFallback(void 0, `Not carrying the entries under ${reportedDirPath} beyond the first ${MAX_CARRIED_FILES}: a directory may carry at most that many files. A symbolic link that reaches a large tree is the usual cause.`);
 		if (truncations.has("directories")) warnOnceWithFallback(void 0, `Not carrying the entries under ${reportedDirPath} below the first ${MAX_CARRIED_DIRECTORIES} directories: a directory may carry files from at most that many directories. A symbolic link that reaches a large tree is the usual cause.`);
@@ -8217,12 +8692,15 @@ var AiDir = class AiDir {
 			try {
 				fileHandle = await (0, node_fs_promises.open)(classifiedPath, node_fs.constants.O_RDONLY | (node_fs.constants.O_NOFOLLOW ?? 0));
 			} catch (error) {
+				recordIncompleteCarriedFiles();
 				warnOnceWithFallback(void 0, `Not carrying ${stripControlCharacters(toPosixPath(filePath))}: ${stripControlCharacters(formatError(error))}.`);
 				continue;
 			}
 			try {
-				const fileSize = (await fileHandle.stat()).size;
+				const fileStats = await fileHandle.stat();
+				const fileSize = fileStats.size;
 				if (carriedBytes + fileSize > 104857600) {
+					recordIncompleteCarriedFiles();
 					warnOnceWithFallback(void 0, `Not carrying ${filteredPaths.length - index} of the ${filteredPaths.length} entries under ${reportedDirPath}: a directory may carry at most ${MAX_CARRIED_BYTES / 1024 / 1024}MB. A symbolic link that reaches a large tree is the usual cause.`);
 					break;
 				}
@@ -8230,9 +8708,11 @@ var AiDir = class AiDir {
 				carriedBytes += fileBuffer.byteLength;
 				files.push({
 					relativeFilePathToDirPath: (0, node_path.relative)(dirPath, filePath),
-					fileBuffer
+					fileBuffer,
+					...carriedFileMode(fileStats.mode)
 				});
 			} catch (error) {
+				recordIncompleteCarriedFiles();
 				warnOnceWithFallback(void 0, `Not carrying ${stripControlCharacters(toPosixPath(filePath))}: ${stripControlCharacters(formatError(error))}.`);
 			} finally {
 				await fileHandle.close();
@@ -8265,6 +8745,9 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	targets: zod_mini.z._default(RulesyncTargetsSchema, ["*"]),
 	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+	license: zod_mini.z.optional(zod_mini.z.string()),
+	compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
+	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	claudecode: zod_mini.z.optional(zod_mini.z.looseObject({
 		when_to_use: zod_mini.z.optional(zod_mini.z.string()),
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
@@ -8314,7 +8797,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	kilo: zod_mini.z.optional(zod_mini.z.looseObject({
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 		license: zod_mini.z.optional(zod_mini.z.string()),
-		compatibility: zod_mini.z.optional(zod_mini.z.looseObject({})),
+		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 	})),
 	kiro: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -8691,6 +9174,61 @@ function resolveDisableModelInvocation({ rootFrontmatter, section }) {
 function resolveUserInvocable({ rootFrontmatter, section }) {
 	return section?.["user-invocable"] ?? rootFrontmatter["user-invocable"];
 }
+/**
+* Resolve the effective `license` value for a tool skill.
+*
+* The rulesync skill frontmatter exposes a root-level `license` default that
+* applies to every tool modelling the Agent Skills standard field; the list of
+* those tools lives in `docs/reference/file-formats.md`. Each tool's own
+* section may override that default with a per-target value. A defined section
+* value always wins over the root default.
+*
+* The section value type is generic because `factorydroid` deliberately types
+* the packaging fields as `unknown` (Droid never validates them).
+*
+* @returns The resolved value, or `undefined` when neither value is set.
+*/
+function resolveLicense({ rootFrontmatter, section }) {
+	return section?.license ?? rootFrontmatter.license;
+}
+/**
+* Resolve the effective `compatibility` value for a tool skill.
+*
+* The rulesync skill frontmatter exposes a root-level `compatibility` default
+* that applies to every tool modelling the Agent Skills standard field; the
+* list of those tools lives in `docs/reference/file-formats.md`. Each tool's
+* own section may override that default with a per-target value. A defined
+* section value always wins over the root default.
+*
+* The root value keeps the rulesync shape (a string, or the legacy object
+* form); any per-target normalization — such as the Agent Skills spec's string
+* coercion — stays with the adapter.
+* The section value type is generic because `factorydroid` deliberately types
+* the packaging fields as `unknown` (Droid never validates them).
+*
+* @returns The resolved value, or `undefined` when neither value is set.
+*/
+function resolveCompatibility({ rootFrontmatter, section }) {
+	return section?.compatibility ?? rootFrontmatter.compatibility;
+}
+/**
+* Resolve the effective `metadata` value for a tool skill.
+*
+* The rulesync skill frontmatter exposes a root-level `metadata` default that
+* applies to every tool modelling the Agent Skills standard field; the list of
+* those tools lives in `docs/reference/file-formats.md`. Each tool's own
+* section may override that default with a per-target value. A defined section
+* value always wins over the root default; the two maps are never merged key
+* by key.
+*
+* The section value type is generic because `factorydroid` deliberately types
+* the packaging fields as `unknown` (Droid never validates them).
+*
+* @returns The resolved value, or `undefined` when neither value is set.
+*/
+function resolveMetadata({ rootFrontmatter, section }) {
+	return section?.metadata ?? rootFrontmatter.metadata;
+}
 //#endregion
 //#region src/constants/augmentcode-paths.ts
 const AUGMENTCODE_DIR = ".augment";
@@ -10635,6 +11173,40 @@ var RovodevCheck = class extends AggregatedToolCheck {
 	}
 };
 //#endregion
+//#region src/constants/claudecode-paths.ts
+/**
+* Claude Code configuration-layout conventions.
+*
+* Single source of truth for where Claude Code expects its files
+* (directories, file names, scope-specific paths). Every feature module
+* (rules, commands, skills, subagents, ignore, mcp, permissions, hooks)
+* and the gitignore entry registry import from here, so a change in the
+* Claude Code conventions is a change to this file only.
+*/
+/** Root directory for Claude Code configuration, relative to the scope root. */
+const CLAUDECODE_DIR = ".claude";
+const CLAUDECODE_RULE_FILE_NAME = "CLAUDE.md";
+const CLAUDECODE_LOCAL_RULE_FILE_NAME = "CLAUDE.local.md";
+/** Modular rules directory name under `.claude/` (current format). */
+const CLAUDECODE_RULES_DIR_NAME = "rules";
+/** Memories directory name under `.claude/` (legacy format). */
+const CLAUDECODE_MEMORIES_DIR_NAME = "memories";
+const CLAUDECODE_COMMANDS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "commands");
+const CLAUDECODE_AGENTS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "agents");
+const CLAUDECODE_SKILLS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "skills");
+const CLAUDECODE_SCHEDULED_TASKS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "scheduled-tasks");
+const CLAUDECODE_SETTINGS_FILE_NAME = "settings.json";
+const CLAUDECODE_SETTINGS_LOCAL_FILE_NAME = "settings.local.json";
+/**
+* The published JSON Schema for both settings files (SchemaStore). Written as
+* the `$schema` key of every settings file rulesync generates, when the file
+* does not already state one, so editors offer completion, hover
+* documentation and validation for the keys around the ones rulesync writes.
+*/
+const CLAUDECODE_SETTINGS_SCHEMA_URL = "https://json.schemastore.org/claude-code-settings.json";
+const CLAUDECODE_MCP_FILE_NAME = ".mcp.json";
+const CLAUDECODE_GLOBAL_MCP_FILE_NAME = ".claude.json";
+//#endregion
 //#region src/constants/codexcli-paths.ts
 const CODEXCLI_DIR = ".codex";
 const CODEXCLI_PROMPTS_DIR_PATH = (0, node_path.join)(CODEXCLI_DIR, "prompts");
@@ -10655,6 +11227,52 @@ const CODEXCLI_OVERRIDE_KEYS = [
 	"tui"
 ];
 //#endregion
+//#region src/utils/quote-value.ts
+/**
+* How much of a value read off disk a diagnostic quotes.
+*
+* Enough to recognize which entry is meant, and no more. A warning names the
+* offending value so the reader can find it, but the values these warnings
+* quote come from files rulesync did not write — a tool's own settings, a
+* machine-local overrides file, a repository fetched from elsewhere — and they
+* no longer stop at a terminal: they travel into a `--json` document another
+* program parses and into an MCP result an agent reads as context. A command
+* line or a header is the shape most likely to carry a credential, and a long
+* value is the shape most likely to carry instructions aimed at the agent.
+*/
+const MAX_QUOTED_VALUE_LENGTH = 60;
+/**
+* A short, quotable rendering of a value for a diagnostic.
+*
+* Serialized rather than interpolated, because an unquoted value is what lets a
+* crafted one read as a second line; stripped of the control characters
+* `JSON.stringify` leaves intact (it escapes C0 only, not the C1 range or the
+* bidirectional overrides); and truncated.
+*/
+function quoteValueForWarning(value) {
+	return truncateText({
+		text: stripControlCharacters(serialize(value)),
+		maxLength: MAX_QUOTED_VALUE_LENGTH,
+		suffix: "…(truncated)"
+	});
+}
+function serialize(value) {
+	try {
+		return JSON.stringify(value, stripStrings) ?? String(value);
+	} catch {
+		return `[unserializable ${typeof value}]`;
+	}
+}
+/**
+* Strip the control characters out of every string before `JSON.stringify`
+* sees it, not only out of the document it produces: `JSON.stringify` escapes
+* a C0 character into the six literal characters `\u001b`, which no later pass
+* over the output can recognize as a control character again.
+*/
+function stripStrings(_key, value) {
+	return typeof value === "string" ? stripControlCharacters(value) : value;
+}
+//#endregion
 //#region src/features/shared/shared-config-gateway.ts
 /**
 * Rebuild a parsed document without its prototype-pollution keys.
@@ -10790,39 +11408,35 @@ function detectJsoncFormattingOptions({ text, root }) {
 		eol
 	};
 }
-/**
-* Whether the document states a key no edit-based write can be trusted with.
-*
-* Two kinds, both answered from the syntax tree because the parsed value no
-* longer knows about either:
-*
-* - A key stated twice. That is legal JSON text which every reader resolves
-*   last-wins, while `modify` edits the *first* occurrence — so an edit-based
-*   write would land on the dead copy and leave the live one saying whatever
-*   it said before. For an owned key that is a silent ownership failure: a
-*   `deny` rulesync just wrote would sit above the `allow` the tool reads.
-* - `__proto__`, `constructor` or `prototype`. None survives into the parsed
-*   document — a nested one is dropped, a root-level `__proto__` replaces the
-*   root's prototype — so an edit-based write would find no difference to
-*   apply and leave the key in the file.
-*
-* The whole-document writer resolves duplicates last-wins and drops pollution
-* keys, which is what it has always done, so those files go to it.
-*/
-function statesUneditableKeys(node) {
-	if (node.type === "array") return (node.children ?? []).some((child) => statesUneditableKeys(child));
-	if (node.type !== "object") return false;
+function uneditableKeyOf(node) {
+	if (node.type === "array") {
+		for (const child of node.children ?? []) {
+			const found = uneditableKeyOf(child);
+			if (found !== void 0) return found;
+		}
+		return;
+	}
+	if (node.type !== "object") return void 0;
 	const seen = /* @__PURE__ */ new Set();
 	for (const property of node.children ?? []) {
 		const key = property.children?.[0]?.value;
 		if (typeof key === "string") {
-			if (seen.has(key) || isPrototypePollutionKey(key)) return true;
+			if (isPrototypePollutionKey(key)) return {
+				kind: "prototype-pollution",
+				key
+			};
+			if (seen.has(key)) return {
+				kind: "duplicate",
+				key
+			};
 			seen.add(key);
 		}
 		const value = property.children?.[1];
-		if (value !== void 0 && statesUneditableKeys(value)) return true;
+		if (value !== void 0) {
+			const found = uneditableKeyOf(value);
+			if (found !== void 0) return found;
+		}
 	}
-	return false;
 }
 /**
 * The offset just past the whitespace and comments starting at `from`.
@@ -11003,7 +11617,8 @@ function notesAt({ text, from }) {
 /**
 * Detach the notes written at the point where the object at `path` will take a
 * new key: after its last property (and around the comma a trailing-comma file
-* spells there), or just inside the `{` when it has no properties yet.
+* spells there), or just inside the `{` when it has no properties yet or when
+* the key is to be written first (`at: "start"`).
 *
 * `modify` computes its insert from exactly that point — in front of a note
 * written there — so applying the edit unchanged re-emits the note *after* the
@@ -11016,11 +11631,11 @@ function notesAt({ text, from }) {
 *
 * Returns `undefined` when there is no such note, which is the common case.
 */
-function detachTrailingNote({ text, path }) {
+function detachInsertionNote({ text, path, at }) {
 	const root = (0, jsonc_parser.parseTree)(text, [], { allowTrailingComma: true });
 	const object = root === void 0 ? void 0 : (0, jsonc_parser.findNodeAtLocation)(root, [...path]);
 	if (object?.type !== "object") return void 0;
-	const property = object.children?.at(-1);
+	const property = at === "end" ? object.children?.at(-1) : void 0;
 	const anchorKey = property?.children?.[0]?.value;
 	if (property !== void 0 && typeof anchorKey !== "string") return void 0;
 	const spans = notesAt({
@@ -11037,7 +11652,7 @@ function detachTrailingNote({ text, path }) {
 	};
 }
 /**
-* Put a note detached by {@link detachTrailingNote} back where it was: after
+* Put a note detached by {@link detachInsertionNote} back where it was: after
 * the property it describes (behind the comma the insert gave that property),
 * or just inside the `{` of the object it was written in when there was no
 * property to describe. Returns `undefined` if that place can no longer be
@@ -11060,16 +11675,23 @@ function reattachTrailingNote({ text, path, anchorKey, note }) {
 	return text.slice(0, cursor) + note + text.slice(cursor);
 }
 /**
-* Write `value` at `[...path, key]`, keeping the trailing note of the property
-* the new key is inserted after (see {@link detachTrailingNote}). Replacing an
-* existing key needs none of this: `modify` rewrites the value's own span and
-* leaves every comment where it is.
-*/
-function insertJsoncProperty({ text, path, key, value, options }) {
-	const write = (source) => (0, jsonc_parser.applyEdits)(source, (0, jsonc_parser.modify)(source, [...path, key], value, options));
-	const detached = detachTrailingNote({
+* Write `value` at `[...path, key]`, keeping the note written at the point of
+* insertion where its author put it (see {@link detachInsertionNote}): the
+* trailing note of the property the new key is appended after, or — for a
+* `leading` key, which `modify` places before every other property — the note
+* written just inside the `{`. Replacing an existing key needs none of this:
+* `modify` rewrites the value's own span and leaves every comment where it is.
+*/
+function insertJsoncProperty({ text, path, key, value, options, leading = false }) {
+	const modification = leading ? {
+		...options,
+		getInsertionIndex: () => 0
+	} : options;
+	const write = (source) => (0, jsonc_parser.applyEdits)(source, (0, jsonc_parser.modify)(source, [...path, key], value, modification));
+	const detached = detachInsertionNote({
 		text,
-		path
+		path,
+		at: leading ? "start" : "end"
 	});
 	if (detached === void 0) return write(text);
 	return reattachTrailingNote({
@@ -11189,7 +11811,7 @@ function countJsoncEdits({ base, next, depth }) {
 * large enough and enough of it changing, the product of the two is what
 * {@link JSONC_EDIT_BUDGET_BYTES} keeps off this path.
 */
-function applyJsoncObjectEdits({ text, base, next, path, options }) {
+function applyJsoncObjectEdits({ text, base, next, path, options, leadingKeys }) {
 	let result = text;
 	for (const [key, value] of Object.entries(next)) {
 		if (isPrototypePollutionKey(key)) continue;
@@ -11208,7 +11830,8 @@ function applyJsoncObjectEdits({ text, base, next, path, options }) {
 				base: previous,
 				next: value,
 				path: [...path, key],
-				options
+				options,
+				leadingKeys: []
 			});
 			continue;
 		}
@@ -11222,7 +11845,8 @@ function applyJsoncObjectEdits({ text, base, next, path, options }) {
 			path,
 			key,
 			value,
-			options
+			options,
+			leading: leadingKeys.includes(key)
 		});
 	}
 	for (const key of Object.keys(base)) if (!Object.hasOwn(next, key)) result = removeJsoncProperty({
@@ -11252,7 +11876,7 @@ function applyJsoncObjectEdits({ text, base, next, path, options }) {
 *   here have already decided (via `invalidRootPolicy`) that such a file is
 *   replaced;
 * - a file stating the same key twice, or using `__proto__`, `constructor` or
-*   `prototype` as a key (see {@link statesUneditableKeys});
+*   `prototype` as a key (see {@link uneditableKeyOf});
 * - a file so large, with so much of it changing, that editing it key by key
 *   would take longer than a user would wait (see
 *   {@link JSONC_EDIT_BUDGET_BYTES}), or changed keys that write more new text
@@ -11260,26 +11884,54 @@ function applyJsoncObjectEdits({ text, base, next, path, options }) {
 *   {@link JSONC_EDIT_WRITTEN_BYTES});
 * - a file the editor itself refuses, which it answers with an exception
 *   rather than a result.
+*
+* Every one of those fallbacks except the empty file is reported once per run
+* through `logger` (or the fallback logger when none is given): the author's
+* comments are what the edit path exists to keep, and a `generate` that drops
+* them should say so rather than let the loss show up in the next diff.
+* `filePath` names the file in that warning; callers that know it should pass
+* it, since the once-per-run token is the message itself and two nameless
+* files would share one.
+*
+* `leadingKeys` names the root keys that go in front of every other property
+* when the edit path inserts them (the whole-document writer keeps the order
+* `document` states, so the caller places them there itself). A key the file
+* already has stays where the file put it.
 */
-function serializeSharedConfig({ format, document, existingContent }) {
+function serializeSharedConfig({ format, document, existingContent, leadingKeys = [], filePath, logger }) {
 	const whole = stringifySharedConfig({
 		format,
 		document
 	});
 	if (format !== "jsonc" || existingContent.trim() === "") return whole;
+	const wholeBecause = (reason) => {
+		warnAboutWholeJsoncRewrite({
+			filePath,
+			reason,
+			logger
+		});
+		return whole;
+	};
 	try {
 		const errors = [];
 		const root = (0, jsonc_parser.parseTree)(existingContent, errors, { allowTrailingComma: true });
-		if (root === void 0 || errors.length > 0 || root.type !== "object" || statesUneditableKeys(root)) return whole;
+		if (root === void 0 || errors.length > 0) return wholeBecause("it could not be parsed");
+		if (root.type !== "object") return wholeBecause("its root is not an object");
+		const uneditable = uneditableKeyOf(root);
+		if (uneditable !== void 0) {
+			const key = quoteValueForWarning(uneditable.key);
+			return wholeBecause(uneditable.kind === "duplicate" ? `it states the key ${key} twice` : `it uses the key ${key}, which rulesync drops from every document it parses`);
+		}
 		const base = sanitizeSharedConfigValue((0, jsonc_parser.getNodeValue)(root));
-		if (!isPlainObject$1(base)) return whole;
+		if (!isPlainObject$1(base)) return wholeBecause("its root is not an object");
 		const span = Math.max(existingContent.length, whole.length);
 		const cost = countJsoncEdits({
 			base,
 			next: document,
 			depth: 0
 		});
-		if (cost.written > JSONC_EDIT_WRITTEN_BYTES || cost.edits * span > JSONC_EDIT_BUDGET_BYTES) return whole;
+		if (cost.written > JSONC_EDIT_WRITTEN_BYTES) return wholeBecause("its changed keys write more new text than editing in place can afford");
+		if (cost.edits * span > JSONC_EDIT_BUDGET_BYTES) return wholeBecause("it is too large, with too much of it changing, to edit key by key");
 		return applyJsoncObjectEdits({
 			text: existingContent,
 			base,
@@ -11288,13 +11940,25 @@ function serializeSharedConfig({ format, document, existingContent }) {
 			options: { formattingOptions: detectJsoncFormattingOptions({
 				text: existingContent,
 				root
-			}) }
+			}) },
+			leadingKeys
 		});
-	} catch {
-		return whole;
+	} catch (error) {
+		return wholeBecause(`the editor refused it (${stripControlCharacters(formatError(error))})`);
 	}
 }
 /**
+* Report, once per run and file, that a JSONC file is being written whole
+* instead of edited in place. Named by `filePath` when the caller knows it;
+* a caller serializing text it never read from disk has no name to give.
+*/
+function warnAboutWholeJsoncRewrite({ filePath, reason, logger }) {
+	const subject = filePath === void 0 ? "A shared JSONC config file" : quoteForLog(filePath);
+	try {
+		warnOnceWithFallback(logger, `${subject} is rewritten whole rather than edited in place because ${reason}; comments, blank lines and key order in the existing file are not preserved.`);
+	} catch {}
+}
+/**
 * Shallow merge: every top-level key in `patch` replaces the base key
 * wholesale; all other base keys are preserved. The policy for a feature that
 * owns a fixed set of top-level keys.
@@ -11332,6 +11996,7 @@ function mergeSharedConfigDeep({ base, patch }) {
 	return result;
 }
 const CLAUDE_SETTINGS_SHARED_FILE_KEY = ".claude/settings.json";
+const CLAUDE_SETTINGS_LOCAL_SHARED_FILE_KEY = ".claude/settings.local.json";
 const HERMES_CONFIG_SHARED_FILE_KEY = ".hermes/config.yaml";
 const HERMES_WIN32_CONFIG_SHARED_FILE_KEY = "AppData/Local/hermes/config.yaml";
 const HERMES_HOME_CONFIG_SHARED_FILE_KEY = "config.yaml";
@@ -11441,9 +12106,28 @@ const ZCODE_CONFIG_DECLARATION = {
 		ownedKeys: ["mcp"]
 	} }
 };
+/**
+* What the two Claude Code settings files have in common: both are plain JSON,
+* and both validate against the one published schema, which the gateway
+* points every file it writes at. `.claude/settings.local.json` is the same
+* file with fewer writers — the ignore feature's `fileMode: "local"` and the
+* project-scope `language` setting go there — so the shape is declared once
+* and the feature sets separately.
+*
+* `language` is the rules feature's: the root `language` key of
+* `rulesync.jsonc` is written natively for Claude Code instead of as a prompt
+* block in CLAUDE.md. At project scope it lands in the local file (a
+* per-developer preference, not a team commitment); at global scope it lands
+* in `~/.claude/settings.json`, because Claude Code reads no
+* `~/.claude/settings.local.json`.
+*/
+const CLAUDE_SETTINGS_FILE_SHAPE = {
+	format: "json",
+	ensuredKeys: { $schema: CLAUDECODE_SETTINGS_SCHEMA_URL }
+};
 const SHARED_CONFIG_OWNERSHIP = {
 	[CLAUDE_SETTINGS_SHARED_FILE_KEY]: {
-		format: "json",
+		...CLAUDE_SETTINGS_FILE_SHAPE,
 		features: {
 			ignore: {
 				kind: "custom",
@@ -11456,6 +12140,23 @@ const SHARED_CONFIG_OWNERSHIP = {
 			permissions: {
 				kind: "custom",
 				policyFunction: "applyPermissions"
+			},
+			rules: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["language"]
+			}
+		}
+	},
+	[CLAUDE_SETTINGS_LOCAL_SHARED_FILE_KEY]: {
+		...CLAUDE_SETTINGS_FILE_SHAPE,
+		features: {
+			ignore: {
+				kind: "custom",
+				policyFunction: "applyIgnoreReadDenies"
+			},
+			rules: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["language"]
 			}
 		}
 	},
@@ -11897,17 +12598,69 @@ const SHARED_CONFIG_OWNERSHIP = {
 	}
 };
 /**
+* The keys a declaration ensures, added to `document` when it lacks them and
+* placed in front of every key it has. A document that states all of them —
+* with whatever value — comes back as it is, and no key of the document
+* moves: the whole-document writer emits keys in this order, and the JSONC
+* edit path is told which keys lead (see {@link serializeSharedConfig}).
+*/
+function withEnsuredKeys({ document, ensuredKeys }) {
+	const missing = Object.entries(ensuredKeys).filter(([key]) => !isPrototypePollutionKey(key) && !Object.hasOwn(document, key));
+	if (missing.length === 0) return document;
+	return {
+		...Object.fromEntries(missing),
+		...document
+	};
+}
+function serializeDeclaredSharedConfig({ declaration, document, existingContent, filePath, logger }) {
+	const ensuredKeys = declaration.ensuredKeys ?? {};
+	return serializeSharedConfig({
+		format: declaration.format,
+		document: withEnsuredKeys({
+			document,
+			ensuredKeys
+		}),
+		existingContent,
+		leadingKeys: Object.keys(ensuredKeys),
+		filePath,
+		logger
+	});
+}
+/**
+* Serialize a merged document back over a gateway-managed shared file, under
+* that file's declaration: its format, and the keys the gateway ensures on it
+* (see {@link SharedConfigFileDeclaration.ensuredKeys}). This is the one
+* write path of the gateway — {@link applySharedConfigPatch} ends in it, and a
+* feature whose policy is `custom` serializes its own merge through it — so a
+* key the gateway ensures is emitted whichever feature writes the file.
+* Throws when the file is undeclared. A JSONC file that had to be written
+* whole is warned about through `logger`, named by `filePath` when given and
+* by `fileKey` otherwise (see {@link serializeSharedConfig}).
+*/
+function serializeSharedConfigFile({ fileKey, document, existingContent, filePath, logger }) {
+	const declaration = SHARED_CONFIG_OWNERSHIP[fileKey];
+	if (!declaration) throw new Error(`Shared config file '${fileKey}' has no SHARED_CONFIG_OWNERSHIP declaration; declare its writers and policies before writing it through the gateway.`);
+	return serializeDeclaredSharedConfig({
+		declaration,
+		document,
+		existingContent,
+		filePath: filePath ?? fileKey,
+		logger
+	});
+}
+/**
 * Execute a feature's declared write to a gateway-managed shared file: parse
 * the existing content, merge the patch under the feature's declared policy,
 * and serialize it back over the existing content (see
-* {@link serializeSharedConfig}, which keeps a JSONC file's comments and
-* formatting outside the spans the merge actually changed). Throws when the
+* {@link serializeSharedConfigFile}, which adds the keys the file's declaration
+* ensures and keeps a JSONC file's comments and formatting outside the spans
+* the merge actually changed). Throws when the
 * file or feature is undeclared, when a
 * `replace-owned-keys` patch strays outside its owned keys, or when the
 * feature's policy is `custom` (those calls go to the named policy function
 * instead).
 */
-function applySharedConfigPatch({ fileKey, feature, existingContent, patch, filePath }) {
+function applySharedConfigPatch({ fileKey, feature, existingContent, patch, filePath, logger }) {
 	const declaration = SHARED_CONFIG_OWNERSHIP[fileKey];
 	if (!declaration) throw new Error(`Shared config file '${fileKey}' has no SHARED_CONFIG_OWNERSHIP declaration; declare its writers and policies before writing it through the gateway.`);
 	const policy = declaration.features[feature];
@@ -11928,10 +12681,12 @@ function applySharedConfigPatch({ fileKey, feature, existingContent, patch, file
 			patch
 		});
 		for (const [key, value] of Object.entries(patch)) if (value === void 0) delete document[key];
-		return serializeSharedConfig({
-			format: declaration.format,
+		return serializeDeclaredSharedConfig({
+			declaration,
 			document,
-			existingContent
+			existingContent,
+			filePath: filePath ?? fileKey,
+			logger
 		});
 	}
 	const merged = mergeSharedConfigDeep({
@@ -11939,10 +12694,12 @@ function applySharedConfigPatch({ fileKey, feature, existingContent, patch, file
 		patch
 	});
 	for (const key of policy.replaceKeys ?? []) if (patch[key] !== void 0) merged[key] = sanitizeSharedConfigValue(patch[key]);
-	return serializeSharedConfig({
-		format: declaration.format,
+	return serializeDeclaredSharedConfig({
+		declaration,
 		document: merged,
-		existingContent
+		existingContent,
+		filePath: filePath ?? fileKey,
+		logger
 	});
 }
 const READ_TOOL_NAME = "Read";
@@ -12486,7 +13243,10 @@ var ChecksProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const baseDir = (0, node_path.join)(this.outputRoot, paths.relativeDirPath);
-		const checkFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern));
+		const checkFilePaths = await findFilesByGlobs(factory.meta.filePattern, {
+			cwd: baseDir,
+			followSymbolicLinks: !forDeletion
+		});
 		const toRelativeFilePath = (path) => (0, node_path.relative)(baseDir, path);
 		if (forDeletion) {
 			const toolChecks = checkFilePaths.map((path) => factory.class.forDeletion({
@@ -13258,7 +14018,7 @@ var AugmentcodeCommand = class AugmentcodeCommand extends ToolCommand {
 	*/
 	static async loadAdditionalImportFiles({ outputRoot = process.cwd(), global = false, logger } = {}) {
 		const rootDir = (0, node_path.join)(outputRoot, AUGMENTCODE_AGENTS_COMMANDS_DIR_PATH);
-		const filePaths = await findFilesByGlobs((0, node_path.join)(rootDir, "**", "*.md"));
+		const filePaths = await findFilesByGlobs("**/*.md", { cwd: rootDir });
 		const imported = (await Promise.all(filePaths.map(async (filePath) => {
 			const relativePath = (0, node_path.relative)(rootDir, filePath);
 			if (relativePath.startsWith("..") || (0, node_path.isAbsolute)(relativePath)) {
@@ -13295,33 +14055,6 @@ var AugmentcodeCommand = class AugmentcodeCommand extends ToolCommand {
 	}
 };
 //#endregion
-//#region src/constants/claudecode-paths.ts
-/**
-* Claude Code configuration-layout conventions.
-*
-* Single source of truth for where Claude Code expects its files
-* (directories, file names, scope-specific paths). Every feature module
-* (rules, commands, skills, subagents, ignore, mcp, permissions, hooks)
-* and the gitignore entry registry import from here, so a change in the
-* Claude Code conventions is a change to this file only.
-*/
-/** Root directory for Claude Code configuration, relative to the scope root. */
-const CLAUDECODE_DIR = ".claude";
-const CLAUDECODE_RULE_FILE_NAME = "CLAUDE.md";
-const CLAUDECODE_LOCAL_RULE_FILE_NAME = "CLAUDE.local.md";
-/** Modular rules directory name under `.claude/` (current format). */
-const CLAUDECODE_RULES_DIR_NAME = "rules";
-/** Memories directory name under `.claude/` (legacy format). */
-const CLAUDECODE_MEMORIES_DIR_NAME = "memories";
-const CLAUDECODE_COMMANDS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "commands");
-const CLAUDECODE_AGENTS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "agents");
-const CLAUDECODE_SKILLS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "skills");
-const CLAUDECODE_SCHEDULED_TASKS_DIR_PATH = (0, node_path.join)(CLAUDECODE_DIR, "scheduled-tasks");
-const CLAUDECODE_SETTINGS_FILE_NAME = "settings.json";
-const CLAUDECODE_SETTINGS_LOCAL_FILE_NAME = "settings.local.json";
-const CLAUDECODE_MCP_FILE_NAME = ".mcp.json";
-const CLAUDECODE_GLOBAL_MCP_FILE_NAME = ".claude.json";
-//#endregion
 //#region src/features/commands/claudecode-command.ts
 const ClaudecodeCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
@@ -13969,7 +14702,7 @@ function commandSlug(relativeFilePath) {
 * it up as a regular orphan.
 */
 async function rulesyncCommandSlugExists({ inputRoots, dirName }) {
-	return (await Promise.all(inputRoots.map((root) => findFilesByGlobs((0, node_path.join)(root, COMMANDS_FEATURE_SUBDIR, "**", "*.md"))))).flat().some((filePath) => commandSlug((0, node_path.basename)(filePath)) === dirName);
+	return (await Promise.all(inputRoots.map((root) => findFilesByGlobs("**/*.md", { cwd: (0, node_path.join)(root, COMMANDS_FEATURE_SUBDIR) })))).flat().some((filePath) => commandSlug((0, node_path.basename)(filePath)) === dirName);
 }
 //#endregion
 //#region src/features/commands/devin-command.ts
@@ -14932,6 +15665,41 @@ function toStringMetadata(metadata) {
 	return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, stringifyValue(value)]));
 }
 /**
+* The `agentsskills` block with the three Agent Skills standard fields resolved
+* against the root-level rulesync defaults (a defined section value wins).
+*
+* Every writer of an Agent Skills `SKILL.md` — the native target, Hermes Agent
+* and the simulated `agentsmd` — reads the block through this helper so a
+* root-authored value goes through exactly the same normalization and
+* spec-violation reporting as a section value. `allowed-tools` has no root
+* counterpart and is carried through untouched.
+*
+* @returns The merged block. It is empty when neither the section nor any
+*   root-level field is set, which `toSpecConformantAgentSkillFields` emits as
+*   nothing.
+*/
+function resolveAgentsSkillsSection(rulesyncFrontmatter) {
+	const section = rulesyncFrontmatter.agentsskills;
+	const license = resolveLicense({
+		rootFrontmatter: rulesyncFrontmatter,
+		section
+	});
+	const compatibility = resolveCompatibility({
+		rootFrontmatter: rulesyncFrontmatter,
+		section
+	});
+	const metadata = resolveMetadata({
+		rootFrontmatter: rulesyncFrontmatter,
+		section
+	});
+	return {
+		...section,
+		...license !== void 0 && { license },
+		...compatibility !== void 0 && { compatibility },
+		...metadata !== void 0 && { metadata }
+	};
+}
+/**
 * Convert the rulesync `agentsskills` block into the shapes the specification
 * requires. Shared with `HermesagentSkill`, which writes the same fields to its
 * own skill location, so one rulesync input can never produce two different
@@ -15079,7 +15847,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 		const agentsSkillsFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...toSpecConformantAgentSkillFields(rulesyncFrontmatter.agentsskills)
+			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(rulesyncFrontmatter))
 		};
 		AgentsSkillsSkill.reportSpecViolations({
 			outputRoot,
@@ -15187,7 +15955,7 @@ var HermesagentSkill = class HermesagentSkill extends AgentsSkillsSkill {
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false, logger }) {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-		const shared = toSpecConformantAgentSkillFields(rulesyncFrontmatter.agentsskills, { coerceMetadata: false });
+		const shared = toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(rulesyncFrontmatter), { coerceMetadata: false });
 		const hermes = rulesyncFrontmatter.hermesagent ?? {};
 		const dirName = rulesyncSkill.getDirName();
 		const frontmatter = {
@@ -17833,7 +18601,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 		const treeName = (0, node_path.basename)(sourceTree);
 		const treeCommandsDirPath = (0, node_path.join)(treeName, COMMANDS_FEATURE_SUBDIR);
 		const basePath = (0, node_path.join)(sourceTree, COMMANDS_FEATURE_SUBDIR);
-		const rulesyncCommandPaths = await directoryExistsStrict(basePath) ? await findFilesByGlobs((0, node_path.join)(basePath, "**", "*.md")) : [];
+		const rulesyncCommandPaths = await directoryExistsStrict(basePath) ? await findFilesByGlobs("**/*.md", { cwd: basePath }) : [];
 		return await Promise.all(rulesyncCommandPaths.map((path) => RulesyncCommand.fromFile({
 			outputRoot: treeParent,
 			relativeDirPath: treeCommandsDirPath,
@@ -17866,7 +18634,10 @@ var CommandsProcessor = class extends FeatureProcessor {
 		if (factory.meta.skipToolFileScan) return [];
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const outputRootFull = (0, node_path.join)(this.outputRoot, paths.relativeDirPath);
-		const commandFilePaths = await findFilesByGlobs(factory.meta.supportsSubdirectory ? (0, node_path.join)(outputRootFull, "**", `*.${factory.meta.extension}`) : (0, node_path.join)(outputRootFull, `*.${factory.meta.extension}`), { followSymbolicLinks: !forDeletion });
+		const commandFilePaths = await findFilesByGlobs(factory.meta.supportsSubdirectory ? `**/*.${factory.meta.extension}` : `*.${factory.meta.extension}`, {
+			cwd: outputRootFull,
+			followSymbolicLinks: !forDeletion
+		});
 		if (forDeletion) {
 			const toolCommands = commandFilePaths.map((path) => factory.class.forDeletion({
 				outputRoot: this.outputRoot,
@@ -18215,52 +18986,6 @@ function compact(obj) {
 	return result;
 }
 //#endregion
-//#region src/utils/quote-value.ts
-/**
-* How much of a value read off disk a diagnostic quotes.
-*
-* Enough to recognize which entry is meant, and no more. A warning names the
-* offending value so the reader can find it, but the values these warnings
-* quote come from files rulesync did not write — a tool's own settings, a
-* machine-local overrides file, a repository fetched from elsewhere — and they
-* no longer stop at a terminal: they travel into a `--json` document another
-* program parses and into an MCP result an agent reads as context. A command
-* line or a header is the shape most likely to carry a credential, and a long
-* value is the shape most likely to carry instructions aimed at the agent.
-*/
-const MAX_QUOTED_VALUE_LENGTH = 60;
-/**
-* A short, quotable rendering of a value for a diagnostic.
-*
-* Serialized rather than interpolated, because an unquoted value is what lets a
-* crafted one read as a second line; stripped of the control characters
-* `JSON.stringify` leaves intact (it escapes C0 only, not the C1 range or the
-* bidirectional overrides); and truncated.
-*/
-function quoteValueForWarning(value) {
-	return truncateText({
-		text: stripControlCharacters(serialize(value)),
-		maxLength: MAX_QUOTED_VALUE_LENGTH,
-		suffix: "…(truncated)"
-	});
-}
-function serialize(value) {
-	try {
-		return JSON.stringify(value, stripStrings) ?? String(value);
-	} catch {
-		return `[unserializable ${typeof value}]`;
-	}
-}
-/**
-* Strip the control characters out of every string before `JSON.stringify`
-* sees it, not only out of the document it produces: `JSON.stringify` escapes
-* a C0 character into the six literal characters `\u001b`, which no later pass
-* over the output can recognize as a control character again.
-*/
-function stripStrings(_key, value) {
-	return typeof value === "string" ? stripControlCharacters(value) : value;
-}
-//#endregion
 //#region src/features/hooks/tool-hooks-converter.ts
 function isToolMatcherEntry(x) {
 	if (x === null || typeof x !== "object") return false;
@@ -24847,6 +25572,17 @@ var ClaudecodeIgnore = class ClaudecodeIgnore extends ToolIgnore {
 		};
 	}
 	/**
+	* The `fileMode: "local"` twin, `.claude/settings.local.json`: a settable
+	* path only under that option, so the default `getSettablePaths` does not
+	* report it, and the gateway would otherwise not know the file has a writer.
+	*/
+	static getExtraSharedWritePaths() {
+		return [{
+			relativeDirPath: CLAUDECODE_DIR,
+			relativeFilePath: CLAUDECODE_SETTINGS_LOCAL_FILE_NAME
+		}];
+	}
+	/**
 	* ClaudecodeIgnore uses settings.json (or settings.local.json), which can
 	* include non-ignore settings. It should not be deleted by rulesync.
 	*
@@ -24889,7 +25625,11 @@ var ClaudecodeIgnore = class ClaudecodeIgnore extends ToolIgnore {
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: JSON.stringify(jsonValue, null, 2),
+			fileContent: serializeSharedConfigFile({
+				fileKey: sharedConfigFileKey(paths),
+				document: jsonValue,
+				existingContent: existingFileContent
+			}),
 			validate: true
 		});
 	}
@@ -26265,18 +27005,48 @@ var AiassistantMcp = class AiassistantMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/features/mcp/amp-mcp.ts
-const AMP_MCP_SERVERS_KEY = "amp.mcpServers";
-function parseAmpSettingsJsonc(fileContent) {
-	const errors = [];
-	const parsed = (0, jsonc_parser.parse)(fileContent || "{}", errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const details = errors.map((error) => `${(0, jsonc_parser.printParseErrorCode)(error.error)} at offset ${error.offset}`).join(", ");
-		throw new Error(`Failed to parse Amp settings: ${details}`);
+//#region src/features/shared/amp-settings.ts
+/**
+* Parse an Amp `settings.json` / `settings.jsonc` document.
+*
+* Shared by the MCP and permissions adapters because both read the very same
+* file. Two separately maintained copies drifted once already: the permissions
+* side was hardened while the MCP side kept calling `jsonc-parser` directly,
+* which left it importing MCP servers reachable only through an injected
+* `__proto__`.
+*
+* {@link parseJsonc} is the strict, sanitizing parser: it throws on any syntax
+* error instead of returning `jsonc-parser`'s best-effort value, and it
+* rebuilds every object from its own enumerable entries, so a root `__proto__`
+* cannot swap the returned object's prototype and `constructor` / `prototype`
+* never survive as own keys, at any depth.
+*
+* Removal is silent, matching every other tool-side adapter (opencode, kilo,
+* copilot). Reporting the removed keys through `droppedPollutionKeysError` is
+* reserved for the three files a user authors under `.rulesync/`, whose whole
+* purpose is to be turned into tool config — a key that vanishes there needs
+* explaining, whereas here the surrounding settings are the user's own file
+* and are left alone.
+*
+* Note the consequence for a root `__proto__`: sanitizing runs before the
+* plain-object check, so such a document parses successfully with the key
+* stripped rather than failing that check. That is deliberate — dropping the
+* one poisoned key keeps the user's unrelated settings — and matches the
+* sanitize-before-the-root-check design the shared config gateway documents.
+*/
+function parseAmpSettings({ fileContent }) {
+	let parsed;
+	try {
+		parsed = parseJsonc$6(fileContent || "{}");
+	} catch (error) {
+		throw new Error(`Failed to parse Amp settings: ${formatError(error)}`, { cause: error });
 	}
 	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
 	return parsed;
 }
+//#endregion
+//#region src/features/mcp/amp-mcp.ts
+const AMP_MCP_SERVERS_KEY = "amp.mcpServers";
 function filterMcpServers(mcpServers) {
 	const filtered = {};
 	if (!isRecord$1(mcpServers)) return filtered;
@@ -26295,7 +27065,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 	json;
 	constructor(params) {
 		super(params);
-		this.json = parseAmpSettingsJsonc(this.fileContent);
+		this.json = parseAmpSettings({ fileContent: this.fileContent });
 	}
 	getJson() {
 		return structuredClone(this.json);
@@ -26339,7 +27109,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
-		const json = fileContent ? parseAmpSettingsJsonc(fileContent) : {};
+		const json = fileContent ? parseAmpSettings({ fileContent }) : {};
 		const mcpServers = json[AMP_MCP_SERVERS_KEY];
 		const newJson = {
 			...json,
@@ -26354,7 +27124,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 			global
 		});
 	}
-	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
@@ -26367,7 +27137,8 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 				feature: "mcp",
 				existingContent: fileContent ?? "",
 				patch: { [AMP_MCP_SERVERS_KEY]: filterMcpServers(rulesyncMcp.getMcpServers()) },
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate,
 			global
@@ -26380,17 +27151,13 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 	validate() {
 		let json;
 		try {
-			json = parseAmpSettingsJsonc(this.fileContent);
+			json = parseAmpSettings({ fileContent: this.fileContent });
 		} catch (error) {
 			return {
 				success: false,
 				error: error instanceof Error ? error : new Error(String(error))
 			};
 		}
-		for (const key of Object.keys(json)) if (isPrototypePollutionKey(key)) return {
-			success: false,
-			error: /* @__PURE__ */ new Error(`Prototype pollution key "${key}" is not allowed`)
-		};
 		const mcpServers = json[AMP_MCP_SERVERS_KEY];
 		if (mcpServers === void 0) return {
 			success: true,
@@ -26400,20 +27167,10 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 			success: false,
 			error: /* @__PURE__ */ new Error(`${AMP_MCP_SERVERS_KEY} must be a JSON object`)
 		};
-		for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
-			if (isPrototypePollutionKey(serverName)) return {
-				success: false,
-				error: /* @__PURE__ */ new Error(`Server name "${serverName}" is a prototype pollution key and is not allowed`)
-			};
-			if (!isRecord$1(serverConfig)) return {
-				success: false,
-				error: /* @__PURE__ */ new Error(`MCP server "${serverName}" must be a JSON object`)
-			};
-			for (const key of Object.keys(serverConfig)) if (isPrototypePollutionKey(key)) return {
-				success: false,
-				error: /* @__PURE__ */ new Error(`Config key "${key}" in server "${serverName}" is a prototype pollution key and is not allowed`)
-			};
-		}
+		for (const [serverName, serverConfig] of Object.entries(mcpServers)) if (!isRecord$1(serverConfig)) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`MCP server "${serverName}" must be a JSON object`)
+		};
 		return {
 			success: true,
 			error: null
@@ -27344,7 +28101,7 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 	json;
 	constructor(params) {
 		super(params);
-		this.json = this.fileContent !== void 0 ? parseJsonc$8(this.fileContent) : {};
+		this.json = this.fileContent !== void 0 ? parseJsonc$6(this.fileContent) : {};
 	}
 	getJson() {
 		return this.json;
@@ -27365,7 +28122,7 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 			validate
 		});
 	}
-	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true }) {
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, logger }) {
 		const paths = this.getSettablePaths();
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
@@ -27378,7 +28135,8 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 				feature: "mcp",
 				existingContent,
 				patch: { servers: rulesyncMcp.getMcpServers() },
-				filePath
+				filePath,
+				logger
 			}),
 			validate
 		});
@@ -29509,7 +30267,8 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 					mcp: convertedMcp,
 					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
 				},
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -29527,7 +30286,7 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 	*
 	* @see https://kilo.ai/docs/automate/mcp/using-in-kilo-code
 	*/
-	static async fromInstructions({ outputRoot = process.cwd(), instructions, validate = true, global = false }) {
+	static async fromInstructions({ outputRoot = process.cwd(), instructions, validate = true, global = false, logger }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		let fileContent = null;
@@ -29554,7 +30313,8 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 				feature: "rules",
 				existingContent: fileContent ?? "",
 				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -29567,7 +30327,7 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 		}, null, 2) });
 	}
 	validate() {
-		const json = parseJsonc$8(this.fileContent || "{}");
+		const json = parseJsonc$6(this.fileContent || "{}");
 		const result = KiloConfigSchema.safeParse(json);
 		if (!result.success) return {
 			success: false,
@@ -30574,7 +31334,8 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 					mcp: convertedMcp,
 					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
 				},
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -30595,7 +31356,7 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 	* @see https://opencode.ai/docs/rules/
 	* @see https://opencode.ai/docs/config/
 	*/
-	static async fromInstructions({ outputRoot = process.cwd(), instructions, validate = true, global = false }) {
+	static async fromInstructions({ outputRoot = process.cwd(), instructions, validate = true, global = false, logger }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		const configDirPrefix = `${toPosixPath(basePaths.relativeDirPath).replace(/\/+$/, "")}/`;
@@ -30627,7 +31388,8 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 				feature: "rules",
 				existingContent: fileContent ?? "",
 				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -30643,7 +31405,7 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 		}, null, 2) });
 	}
 	validate() {
-		const json = parseJsonc$8(this.fileContent || "{}");
+		const json = parseJsonc$6(this.fileContent || "{}");
 		const result = OpencodeConfigSchema.safeParse(json);
 		if (!result.success) return {
 			success: false,
@@ -33115,16 +33877,6 @@ function isCanonicalAmpEntry(entry) {
 	const keys = Object.keys(matches);
 	return keys.length === 0 || keys.length === 1 && typeof matches.cmd === "string";
 }
-function parseAmpSettings(fileContent) {
-	const errors = [];
-	const parsed = (0, jsonc_parser.parse)(fileContent || "{}", errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const details = errors.map((error) => `${(0, jsonc_parser.printParseErrorCode)(error.error)} at offset ${error.offset}`).join(", ");
-		throw new Error(`Failed to parse Amp settings: ${details}`);
-	}
-	if (!isPlainObject$1(parsed)) throw new Error("Amp settings must be a JSON object");
-	return parsed;
-}
 function toDisableList(value) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((entry) => typeof entry === "string");
@@ -33240,7 +33992,7 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 		const basePaths = AmpPermissions.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
-		const json = fileContent ? parseAmpSettings(fileContent) : {};
+		const json = fileContent ? parseAmpSettings({ fileContent }) : {};
 		const newJson = {
 			...json,
 			[AMP_TOOLS_DISABLE_KEY]: toDisableList(json[AMP_TOOLS_DISABLE_KEY])
@@ -33253,11 +34005,11 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 			validate
 		});
 	}
-	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, global = false }) {
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, global = false, logger }) {
 		const basePaths = AmpPermissions.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
-		const json = fileContent ? parseAmpSettings(fileContent) : {};
+		const json = fileContent ? parseAmpSettings({ fileContent }) : {};
 		const config = rulesyncPermissions.getJson();
 		const { disable, permissions } = convertRulesyncToAmp(config);
 		const override = config.amp;
@@ -33284,13 +34036,14 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch,
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate: true
 		});
 	}
 	toRulesyncPermissions() {
-		const json = parseAmpSettings(this.getFileContent());
+		const json = parseAmpSettings({ fileContent: this.getFileContent() });
 		const allPermissions = toPermissionsList(json[AMP_PERMISSIONS_KEY]);
 		const canonicalEntries = allPermissions.filter(isCanonicalAmpEntry);
 		const overrideEntries = allPermissions.filter((entry) => !isCanonicalAmpEntry(entry));
@@ -33310,7 +34063,7 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 	}
 	validate() {
 		try {
-			const json = parseAmpSettings(this.fileContent);
+			const json = parseAmpSettings({ fileContent: this.fileContent });
 			const disable = json[AMP_TOOLS_DISABLE_KEY];
 			if (disable !== void 0 && !Array.isArray(disable)) return {
 				success: false,
@@ -35360,15 +36113,15 @@ const CLAUDECODE_FEATURE_OWNED_SETTINGS_KEYS = Object.entries(SHARED_CONFIG_OWNE
 * passthrough must not carry. `permissions` and `sandbox` have their own merge
 * branches (the managed `allow`/`ask`/`deny` arrays and the scope filtering
 * respectively), `permission` is rulesync's own canonical tool-scoped block
-* rather than a settings key, `$schema` is an editor pointer rather than a
-* Claude Code setting, and the rest belong to the other features writing this
-* shared file.
+* rather than a settings key, the keys the gateway ensures on the file
+* (`$schema`) are editor pointers rather than Claude Code settings, and the
+* rest belong to the other features writing this shared file.
 */
 const CLAUDECODE_NON_PASSTHROUGH_OVERRIDE_KEYS = /* @__PURE__ */ new Set([
 	"permission",
 	"permissions",
 	"sandbox",
-	"$schema",
+	...Object.keys(SHARED_CONFIG_OWNERSHIP[".claude/settings.json"]?.ensuredKeys ?? {}),
 	...CLAUDECODE_FEATURE_OWNED_SETTINGS_KEYS
 ]);
 /**
@@ -35740,7 +36493,11 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 			deny,
 			logger
 		});
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = serializeSharedConfigFile({
+			fileKey: CLAUDE_SETTINGS_SHARED_FILE_KEY,
+			document: merged,
+			existingContent
+		});
 		return new ClaudecodePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -36767,7 +37524,7 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 			validate
 		});
 	}
-	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions }) {
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger }) {
 		const paths = CopilotPermissions.getSettablePaths();
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
@@ -36787,7 +37544,8 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent,
 				patch,
-				filePath
+				filePath,
+				logger
 			}),
 			validate: true
 		});
@@ -37507,6 +38265,18 @@ var DeepagentsPermissions = class DeepagentsPermissions extends ToolPermissions
 	isDeletable() {
 		return false;
 	}
+	/**
+	* `config.toml` is dcode's file, not one rulesync owns: rulesync merges into
+	* it when it exists but has no business bringing it into existence to hold
+	* nothing. When no rule maps, `[shell]` is dropped and
+	* `smolToml.stringify({})` leaves a lone newline, which would otherwise be
+	* written as a fresh `~/.deepagents/config.toml` that says nothing. An
+	* existing file is still rewritten as before, so user content is never
+	* dropped — the skip only applies when there is no file yet.
+	*/
+	shouldSkipCreationWhenPayloadEmpty() {
+		return true;
+	}
 	static getSettablePaths(_options) {
 		return {
 			relativeDirPath: DEEPAGENTS_DIR,
@@ -40439,7 +41209,8 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch: { permission },
-				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
+				filePath: (0, node_path.join)(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate: true
 		});
@@ -40465,7 +41236,7 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 	}
 	validate() {
 		try {
-			const json = parseJsonc$8(this.fileContent || "{}");
+			const json = parseJsonc$6(this.fileContent || "{}");
 			const result = OpencodePermissionsConfigSchema.safeParse(json);
 			if (!result.success) return {
 				success: false,
@@ -42564,18 +43335,20 @@ function pickSecurityPolicies(source, report) {
 * not emoji at all are named beside it: the angle brackets, the trigrams and
 * digrams, and the hexagrams of U+4DC0–U+4DFF.
 *
-* The ranges are the standard ones rather than a lookup of the full property
-* table, which Unicode revises with every release and which is not worth
-* carrying for the one thing it is used for here — deciding when a label is
-* long enough to wrap. Where a range is coarse it is coarse in the safe
-* direction: the whole of U+1F000–U+1FAFF is counted as wide, which overstates
-* the few narrow symbols in it, because overstating a width shortens a label
-* that did not need it while understating one lets a label wrap. That is also
-* why an emoji built from a chain of joiners is counted per component: two
-* columns each rather than the two the whole chain draws.
-*
-* Ambiguous-width characters are counted as one column, which is what a
-* terminal running a Latin font does.
+* The ranges are the standard blocks rather than the full `East_Asian_Width`
+* property, because the wide characters sit in blocks and a block is coarse in
+* the safe direction: the whole of U+1F000–U+1FAFF is counted as wide, which
+* overstates the few narrow symbols in it, because overstating a width shortens
+* a label that did not need it while understating one lets a label wrap. That
+* is also why an emoji built from a chain of joiners is counted per component:
+* two columns each rather than the two the whole chain draws.
+*
+* The East Asian Ambiguous class is counted at two columns as well, by the
+* table below this one rather than by these ranges, and that table is the
+* whole of its property: the class is scattered among the Neutral characters
+* rather than gathered in blocks, so a block list over it would either miss
+* members or take in characters that are not wide anywhere. The reason for
+* counting it, and how the table is kept in step with Unicode, is given there.
 *
 * Two of the ranges are here for a narrower reason: a name the skill prompt can
 * offer may not be counted narrower here than the prompt's own renderer counts
@@ -42613,6 +43386,64 @@ function pickSecurityPolicies(source, report) {
 */
 const WIDE_CHARACTERS_PATTERN = /\p{Emoji_Presentation}|\p{Emoji_Modifier_Base}|[\u2329\u232a\u2630-\u2637\u268a-\u268f\u4dc0-\u4dff]|[\u1100-\u11ff\u2e80-\u303e\u3041-\u33ff\u3400-\u4dbf\u4e00-\u9fff\ua000-\ua4cf\ua960-\ua97f\uac00-\ud7a3\ud7b0-\ud7fb\uf900-\ufaff\ufe10-\ufe19\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]|[\u{16fe0}-\u{16ff6}]|[\u{17000}-\u{18dff}]|[\u{1aff0}-\u{1b2ff}]|[\u{1f000}-\u{1faff}]|[\u{20000}-\u{3fffd}]/u;
 /**
+* The East Asian Ambiguous class of UAX #11: the characters a terminal draws
+* one column wide under a Latin font and two columns wide where it is set to
+* draw the ambiguous class wide, which is a common setting in CJK locales. The
+* box-drawing characters, the geometric shapes, the Greek and Cyrillic
+* alphabets, and the accented letters of the Latin-1 supplement are all here.
+*
+* Counted at two columns, which is the wider of the two answers, because the
+* two ways of being wrong are not the same size. Overstating a width shortens
+* a label that did not need it: a name carrying a Greek letter or an accented
+* letter is cut a little earlier on a Latin terminal than it had to be.
+* Understating one lets a forged row wrap: a name of sixty box-drawing
+* characters and `● pdf-tools` measures 71 columns at one column apiece,
+* inside the prompt's budget, and draws at 132 in a terminal that draws the
+* class wide, so the terminal breaks the row itself and puts `● pdf-tools` at
+* the left margin of a continuation line that carries no pointer and no
+* checkbox.
+*
+* The prompt's own renderer, `fast-string-width`, counts the class at one
+* column and never sees the wrap coming either; the terminal is what breaks
+* the row, and only the budget can keep the row short enough not to be broken.
+*
+* One width model rather than two — a wide one for bounding an untrusted name
+* and a narrow one for laying out the tool's own text — because the second
+* model would buy a column or two of alignment in the tool's own output at the
+* price of two measurements that have to be kept from being confused for each
+* other. Where this is used to lay out text of the tool's own, the cost of the
+* single model is a line cut a little earlier than it needed to be.
+*
+* The ranges are the `East_Asian_Width=A` property of Unicode 17.0, taken from
+* the table `get-east-asian-width` 1.6.0 carries and merged where two are
+* adjacent. The table is written out here rather than read from the package so
+* that the one lookup adds no dependency of its own, and the drift test in
+* `display-width.test.ts` is what keeps it honest: it loads the package through
+* the prompt renderer that already depends on it, walks every code point, and
+* fails when this table and the property disagree in either direction. When
+* the renderer's copy moves to a newer Unicode, that test is what fails, and
+* the table is regenerated from the new property — its ranges, marks aside,
+* merged where adjacent and written as escapes — with the version named here.
+*
+* Three stretches of the property are left out because they never reach this
+* pattern: the combining diacritical marks of U+0300–U+036F and the variation
+* selectors of U+FE00–U+FE0F and U+E0100–U+E01EF are marks by category and are
+* counted by the mark rule before the width of a character is looked up.
+* Leaving them out is also what keeps the class from holding a combining
+* character, which `no-misleading-character-class` is there to catch, and they
+* are the one exception the drift test allows. U+00AD SOFT HYPHEN never reaches
+* this pattern either — it is a format character, and the zero-width rule
+* counts it at nothing first — but it is kept, as the property has it, so that
+* the test holds the table to the property exactly rather than to a list of
+* exceptions. The private use areas are in it, as the property says they are: a
+* name is free to carry them and a terminal is free to draw them wide.
+*
+* Escapes rather than the characters themselves, for the reason given above.
+* Exported for the drift test alone; the width of a string is asked for
+* through `displayWidthOf`.
+*/
+const AMBIGUOUS_CHARACTERS_PATTERN = /[\u00a1\u00a4\u00a7-\u00a8\u00aa\u00ad-\u00ae\u00b0-\u00b4\u00b6-\u00ba\u00bc-\u00bf\u00c6\u00d0\u00d7-\u00d8\u00de-\u00e1\u00e6\u00e8-\u00ea\u00ec-\u00ed\u00f0\u00f2-\u00f3\u00f7-\u00fa\u00fc\u00fe\u0101\u0111\u0113\u011b\u0126-\u0127\u012b\u0131-\u0133\u0138\u013f-\u0142\u0144\u0148-\u014b\u014d\u0152-\u0153\u0166-\u0167\u016b\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u0251\u0261\u02c4\u02c7\u02c9-\u02cb\u02cd\u02d0\u02d8-\u02db\u02dd\u02df\u0391-\u03a1\u03a3-\u03a9\u03b1-\u03c1\u03c3-\u03c9\u0401\u0410-\u044f\u0451\u2010\u2013-\u2016\u2018-\u2019\u201c-\u201d\u2020-\u2022\u2024-\u2027\u2030\u2032-\u2033\u2035\u203b\u203e\u2074\u207f\u2081-\u2084\u20ac\u2103\u2105\u2109\u2113\u2116\u2121-\u2122\u2126\u212b\u2153-\u2154\u215b-\u215e\u2160-\u216b\u2170-\u2179\u2189\u2190-\u2199\u21b8-\u21b9\u21d2\u21d4\u21e7\u2200\u2202-\u2203\u2207-\u2208\u220b\u220f\u2211\u2215\u221a\u221d-\u2220\u2223\u2225\u2227-\u222c\u222e\u2234-\u2237\u223c-\u223d\u2248\u224c\u2252\u2260-\u2261\u2264-\u2267\u226a-\u226b\u226e-\u226f\u2282-\u2283\u2286-\u2287\u2295\u2299\u22a5\u22bf\u2312\u2460-\u24e9\u24eb-\u254b\u2550-\u2573\u2580-\u258f\u2592-\u2595\u25a0-\u25a1\u25a3-\u25a9\u25b2-\u25b3\u25b6-\u25b7\u25bc-\u25bd\u25c0-\u25c1\u25c6-\u25c8\u25cb\u25ce-\u25d1\u25e2-\u25e5\u25ef\u2605-\u2606\u2609\u260e-\u260f\u261c\u261e\u2640\u2642\u2660-\u2661\u2663-\u2665\u2667-\u266a\u266c-\u266d\u266f\u269e-\u269f\u26bf\u26c6-\u26cd\u26cf-\u26d3\u26d5-\u26e1\u26e3\u26e8-\u26e9\u26eb-\u26f1\u26f4\u26f6-\u26f9\u26fb-\u26fc\u26fe-\u26ff\u273d\u2776-\u277f\u2b56-\u2b59\u3248-\u324f\ue000-\uf8ff\ufffd\u{1f100}-\u{1f10a}\u{1f110}-\u{1f12d}\u{1f130}-\u{1f169}\u{1f170}-\u{1f18d}\u{1f18f}-\u{1f190}\u{1f19b}-\u{1f1ac}\u{f0000}-\u{ffffd}\u{100000}-\u{10fffd}]/u;
+/**
 * U+FE0F VARIATION SELECTOR-16, which takes no width of its own but asks the
 * character before it to be drawn as an emoji — that is, in two columns rather
 * than one. Counting it as a column of its own is how that promotion is paid
@@ -42620,7 +43451,12 @@ const WIDE_CHARACTERS_PATTERN = /\p{Emoji_Presentation}|\p{Emoji_Modifier_Base}|
 * draws rather than the one the heart alone would.
 */
 const EMOJI_PRESENTATION_SELECTOR = "️";
-/** Combining marks are drawn on top of the character before them, not beside it. */
+/**
+* Combining marks are drawn on top of the character before them, not beside it.
+*
+* Exported for the drift test on the ambiguous table, which has to leave out
+* exactly the characters this rule catches first.
+*/
 const COMBINING_MARK_PATTERN = /[\p{Mn}\p{Me}]/u;
 /** The characters that take no width at all, marks aside. */
 const ZERO_WIDTH_CHARACTERS_PATTERN = /[\p{Cf}\p{Default_Ignorable_Code_Point}]/u;
@@ -42666,16 +43502,28 @@ function isCombiningMark(character) {
 	return character !== EMOJI_PRESENTATION_SELECTOR && COMBINING_MARK_PATTERN.test(character);
 }
 /**
+* A lone surrogate, which is no character at all: a string can carry one — a
+* `"\ud800"` escape in JSON is enough — and the encoder that writes stdout
+* replaces it with U+FFFD on the way out, so the replacement character is what
+* the terminal draws and what has to be measured. U+FFFD is East Asian
+* Ambiguous, so the difference is a column apiece: 72 of them measured as
+* themselves fit a 72-column budget and are drawn in 144.
+*/
+const LONE_SURROGATE_PATTERN = /\p{Cs}/u;
+/** What the stdout encoder writes in place of a lone surrogate. */
+const REPLACEMENT_CHARACTER = "�";
+/**
 * The width of one character, given how many marks already sit on the character
 * before it.
 */
 function widthInContext(params) {
-	const { character, precedingMarks } = params;
+	const { precedingMarks } = params;
+	const character = LONE_SURROGATE_PATTERN.test(params.character) ? REPLACEMENT_CHARACTER : params.character;
 	if (character === EMOJI_PRESENTATION_SELECTOR) return 1;
 	if (isCombiningMark(character)) return precedingMarks < FREE_MARKS_PER_CHARACTER ? 0 : 1;
 	if (RENDERER_COUNTED_JOINERS.test(character)) return 1;
 	if (ZERO_WIDTH_CHARACTERS_PATTERN.test(character)) return 0;
-	return WIDE_CHARACTERS_PATTERN.test(character) ? 2 : 1;
+	return WIDE_CHARACTERS_PATTERN.test(character) || AMBIGUOUS_CHARACTERS_PATTERN.test(character) ? 2 : 1;
 }
 /**
 * How many terminal columns a string occupies.
@@ -42699,6 +43547,20 @@ function displayWidthOf(text) {
 /** The mark a cut string ends in. */
 const SHORTENING_ELLIPSIS = "…";
 /**
+* The columns a cut string is drawn in at the very least: what is left when
+* the budget has room for the mark of the cut and nothing before it. Two, since
+* the ellipsis is itself East Asian Ambiguous and is measured the way every
+* other such character is, so that a shortened label is not wider than it was
+* measured to be on the terminal the measurement is for.
+*
+* Exported because a caller composing several shortened pieces into one line
+* has to leave room for it to decide which of them gives way, and the width of
+* the mark is this module's business rather than something to be counted again
+* at the other end. Leaving room for it is not what bounds the line: cutting
+* the composed line is.
+*/
+const ELLIPSIS_WIDTH = displayWidthOf(SHORTENING_ELLIPSIS);
+/**
 * Cut `text` down to at most `budget` columns, marking the cut with an ellipsis.
 *
 * The ellipsis is paid for out of the budget rather than added on top of it, so
@@ -42709,7 +43571,7 @@ const SHORTENING_ELLIPSIS = "…";
 function shortenToWidth(params) {
 	const { text, budget } = params;
 	if (displayWidthOf(text) <= budget) return text;
-	const target = budget - 1;
+	const target = budget - ELLIPSIS_WIDTH;
 	let width = 0;
 	let marks = 0;
 	const kept = [];
@@ -45647,7 +46509,7 @@ var AgentsmdSkill = class AgentsmdSkill extends SimulatedSkill {
 		const relativeDirPath = this.getSettablePaths().relativeDirPath;
 		const frontmatter = {
 			...defaults.frontmatter,
-			...toSpecConformantAgentSkillFields(params.rulesyncSkill.getFrontmatter().agentsskills)
+			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(params.rulesyncSkill.getFrontmatter()))
 		};
 		AgentsSkillsSkill.reportSpecViolations({
 			outputRoot: params.outputRoot ?? process.cwd(),
@@ -45773,13 +46635,25 @@ var RovodevSkill = class RovodevSkill extends ToolSkill {
 		const settablePaths = RovodevSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const rovodevSection = rulesyncFrontmatter.rovodev;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: rovodevSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: rovodevSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: rovodevSection
+		});
 		const rovodevFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...rovodevSection?.["allowed-tools"] !== void 0 && { "allowed-tools": rovodevSection["allowed-tools"] },
-			...rovodevSection?.license !== void 0 && { license: rovodevSection.license },
-			...rovodevSection?.compatibility !== void 0 && { compatibility: rovodevSection.compatibility },
-			...rovodevSection?.metadata !== void 0 && { metadata: rovodevSection.metadata }
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata }
 		};
 		return new RovodevSkill({
 			outputRoot,
@@ -45961,7 +46835,12 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 					composed: file.composed
 				})) dirHasChanges = true;
 			}
-			if (!dirHasChanges) continue;
+			if (!dirHasChanges) {
+				if (!this.dryRun) {
+					for (const file of otherFiles) if (file.fileMode !== void 0) await restoreMissingExecutableBit((0, node_path.join)(dirPath, file.relativeFilePathToDirPath), file.fileMode);
+				}
+				continue;
+			}
 			const relativeDir = aiDir.getRelativePathFromCwd();
 			if (this.dryRun) {
 				this.logger.info(`[DRY RUN] Would create directory: ${stripControlCharacters(dirPath)}`);
@@ -45980,7 +46859,9 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 					changedPaths.push((0, node_path.join)(relativeDir, mainFile.name));
 				}
 				for (const file of otherFiles) {
-					await writeFileBuffer((0, node_path.join)(dirPath, file.relativeFilePathToDirPath), file.fileBuffer);
+					const filePath = (0, node_path.join)(dirPath, file.relativeFilePathToDirPath);
+					await writeFileBuffer(filePath, file.fileBuffer);
+					if (file.fileMode !== void 0) await applyFileMode(filePath, file.fileMode);
 					changedPaths.push((0, node_path.join)(relativeDir, file.relativeFilePathToDirPath));
 				}
 			}
@@ -45998,7 +46879,7 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 	async removeOrphanAiDirs(existingDirs, generatedDirs) {
 		const generatedPaths = new Set(generatedDirs.map((d) => d.getDirPath()));
 		const orphanPaths = /* @__PURE__ */ new Set();
-		const quotedOutputRoot = JSON.stringify(stripControlCharacters(this.outputRoot));
+		const quotedOutputRoot = quoteForLog(this.outputRoot);
 		for (const aiDir of existingDirs) {
 			const dirPath = aiDir.getDirPath();
 			const { verdict, root } = locateInOwnRoot({
@@ -46006,14 +46887,14 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 				dirPath,
 				outputRoot: this.outputRoot
 			});
-			const quotedDirPath = JSON.stringify(stripControlCharacters(dirPath));
-			const quotedRoot = JSON.stringify(stripControlCharacters(root));
+			const quotedDirPath = quoteForLog(dirPath);
+			const quotedRoot = quoteForLog(root);
 			if (verdict === "root-outside") {
 				this.logger.warn(`Refusing to delete ${quotedDirPath}: the root ${quotedRoot} it was found in is not inside ${quotedOutputRoot}, the directory this run writes to`);
 				continue;
 			}
 			if (!aiDir.ownsDirTree()) {
-				if (verdict === "equal") this.logger.debug(`Skipping orphan sweep for ${JSON.stringify(stripControlCharacters(aiDir.getDirName()))}: ${quotedDirPath} is a shared root, not a directory of its own`);
+				if (verdict === "equal") this.logger.debug(`Skipping orphan sweep for ${quoteForLog(aiDir.getDirName())}: ${quotedDirPath} is a shared root, not a directory of its own`);
 				else this.logger.warn(`Refusing to delete ${quotedDirPath}: it does not own that directory, and it is not the shared root ${quotedRoot} it was found in either`);
 				continue;
 			}
@@ -46029,6 +46910,126 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 		});
 	}
 	/**
+	* Remove the files left inside a directory this run still generates, but
+	* which the run no longer writes.
+	*
+	* The directory sweep above cannot see them: it removes a directory that no
+	* longer corresponds to any generated entry, and never looks inside one that
+	* does. So deleting a companion file from a source directory that is
+	* otherwise kept left the generated copy in place — and, because change
+	* detection compares only the files the run will write, the run reported
+	* itself up to date while an agent went on reading the stale file. The same
+	* gap left any file that was never rulesync's sitting inside a directory the
+	* user now believes rulesync owns.
+	*
+	* Only a directory that owns its whole tree is swept, and only when this run
+	* generated it. That is the same claim the directory sweep already acts on,
+	* one level down: a directory whose entry disappears is deleted outright,
+	* companion files and all, so a file inside one whose entry is still here and
+	* which no source produces is stale by exactly the same reasoning.
+	*
+	* Two kinds of file are left alone:
+	*
+	* - **Hidden entries.** The loader does carry a hidden companion — a
+	*   `.env.example` beside the script that reads it is skill content — so a
+	*   hidden file here may be rulesync's. But a hidden name is also where a
+	*   user's own files live: a `.gitkeep`, a `.env` with real values in it. The
+	*   sweep cannot tell the two apart by name, and deleting the user's is the
+	*   worse mistake, so a stale hidden companion is the one leftover it
+	*   knowingly keeps.
+	* - **Symbolic links**, which the writer never creates. The walk neither
+	*   follows nor reports them, so a link is never removed and never resolved
+	*   into a deletion somewhere outside the tree.
+	*
+	* Nothing is swept at all by a run that could not read its sources in full.
+	* `AiDir` drops a companion file it cannot open, and stops short of a subtree
+	* it is denied or that runs past one of its bounds -- warning each time, but
+	* carrying on, because a skill that is short one file is still worth writing.
+	* The output copy of such a file is then indistinguishable here from a file
+	* whose source was deleted, and the wrong guess deletes something the next
+	* readable run would put straight back. So a shortfall anywhere in the run
+	* calls the whole sweep off: it is the sweeps that are optional, not the
+	* files.
+	*
+	* @param isClaimed - Whether some other target or feature in this run wrote
+	*   this exact path. A shared output root -- `.agents/skills/`, written by
+	*   several targets at once -- is a directory whose entry here lists only
+	*   *this* target's files, so without the run's own record a sibling's fresh
+	*   output reads as an orphan. Asked per path rather than per tree: a tree
+	*   claim covers the directory this sweep is looking inside of, and would
+	*   answer yes to every file in it.
+	*/
+	async removeOrphanFilesInAiDirs({ generatedDirs, isClaimed }) {
+		if (hasIncompleteCarriedFiles()) {
+			warnOnceWithFallback(this.logger, "Not sweeping the files inside generated directories: this run could not read every file its sources carry, so a file it did not write may still be one it wants. The warnings above name what it could not read.");
+			return 0;
+		}
+		const orphanPaths = /* @__PURE__ */ new Set();
+		const quotedOutputRoot = quoteForLog(this.outputRoot);
+		for (const aiDir of generatedDirs) {
+			const dirPath = aiDir.getDirPath();
+			const { verdict, root } = locateInOwnRoot({
+				aiDir,
+				dirPath,
+				outputRoot: this.outputRoot
+			});
+			const quotedDirPath = quoteForLog(dirPath);
+			const quotedRoot = quoteForLog(root);
+			if (verdict === "root-outside") {
+				this.logger.warn(`Refusing to sweep ${quotedDirPath}: the root ${quotedRoot} it was found in is not inside ${quotedOutputRoot}, the directory this run writes to`);
+				continue;
+			}
+			if (!aiDir.ownsDirTree()) {
+				if (verdict === "equal") this.logger.debug(`Skipping orphan sweep for ${quoteForLog(aiDir.getDirName())}: ${quotedDirPath} is a shared root, not a directory of its own`);
+				else this.logger.warn(`Refusing to sweep ${quotedDirPath}: it does not own that directory, and it is not the shared root ${quotedRoot} it was found in either`);
+				continue;
+			}
+			if (verdict !== "inside") {
+				this.logger.warn(`Refusing to sweep ${quotedDirPath}: it is not a directory inside ${quotedRoot}, the root it was found in`);
+				continue;
+			}
+			try {
+				await assertWritablePathInsideRoot({
+					rootPath: this.outputRoot,
+					targetPath: dirPath
+				});
+			} catch (error) {
+				this.logger.warn(`Refusing to sweep ${quotedDirPath}: ${stripControlCharacters(formatError(error))}`);
+				continue;
+			}
+			const generatedNames = /* @__PURE__ */ new Set();
+			const mainFile = aiDir.getMainFile();
+			if (mainFile) generatedNames.add(toPosixPath(mainFile.name));
+			for (const file of aiDir.getOtherFiles()) generatedNames.add(toPosixPath(file.relativeFilePathToDirPath));
+			const generatedNamesFolded = new Set([...generatedNames].map((name) => name.toLowerCase()));
+			let existingNames;
+			try {
+				existingNames = await listFilePathsRecursively(dirPath, {
+					followSymbolicLinks: false,
+					includeHidden: false
+				});
+			} catch (error) {
+				this.logger.warn(`Refusing to sweep ${quotedDirPath}: ${stripControlCharacters(formatError(error))}`);
+				continue;
+			}
+			for (const existingName of existingNames) {
+				const posixName = toPosixPath(existingName);
+				if (generatedNames.has(posixName)) continue;
+				const filePath = (0, node_path.join)(dirPath, existingName);
+				if (generatedNamesFolded.has(posixName.toLowerCase())) {
+					this.logger.warn(`Refusing to delete ${quoteForLog(filePath)}: this run wrote a file whose path differs from it only in case, which on a case-insensitive filesystem is the very file it wrote`);
+					continue;
+				}
+				if (isClaimed(filePath)) continue;
+				orphanPaths.add(filePath);
+			}
+		}
+		return await this.deleteOrphanPaths({
+			paths: orphanPaths,
+			kind: "file"
+		});
+	}
+	/**
 	* Delete the paths the sweeps decided on, or report what a real run would
 	* have deleted. Shared by both halves so the dry-run wording, the quoting of
 	* a name that came off disk, and the count they return stay one behavior
@@ -46036,7 +47037,7 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 	*/
 	async deleteOrphanPaths({ paths, kind }) {
 		for (const targetPath of paths) {
-			const loggedPath = JSON.stringify(stripControlCharacters(targetPath));
+			const loggedPath = quoteForLog(targetPath);
 			if (this.dryRun) this.logger.info(`[DRY RUN] Would delete ${kind}: ${loggedPath}`);
 			else {
 				await (kind === "directory" ? removeDirectory(targetPath) : removeFile(targetPath));
@@ -46073,11 +47074,11 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 		}
 		const generatedPathsFolded = new Set([...generatedPaths].map((generatedPath) => generatedPath.toLowerCase()));
 		const orphanPaths = /* @__PURE__ */ new Set();
-		const quotedOutputRoot = JSON.stringify(stripControlCharacters(this.outputRoot));
+		const quotedOutputRoot = quoteForLog(this.outputRoot);
 		for (const aiDir of existingFlatFiles) {
 			const filePath = aiDir.getFlatFilePath();
 			if (filePath === void 0) {
-				this.logger.warn(`Refusing to sweep ${JSON.stringify(stripControlCharacters(aiDir.getDirName()))}: it owns a directory of its own, or names no file directly under the root it was found in`);
+				this.logger.warn(`Refusing to sweep ${quoteForLog(aiDir.getDirName())}: it owns a directory of its own, or names no file directly under the root it was found in`);
 				continue;
 			}
 			const dirPath = aiDir.getDirPath();
@@ -46086,8 +47087,8 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 				dirPath,
 				outputRoot: this.outputRoot
 			});
-			const quotedFilePath = JSON.stringify(stripControlCharacters(filePath));
-			const quotedRoot = JSON.stringify(stripControlCharacters(root));
+			const quotedFilePath = quoteForLog(filePath);
+			const quotedRoot = quoteForLog(root);
 			if (verdict === "root-outside") {
 				this.logger.warn(`Refusing to delete ${quotedFilePath}: the root ${quotedRoot} it was found in is not inside ${quotedOutputRoot}, the directory this run writes to`);
 				continue;
@@ -46829,9 +47830,9 @@ async function checkNestedSkillsRoot({ outputRoot, dirPath }) {
 	if (posixRelativePathEscapesRoot(realRelativeDirPath)) return { reason: "it resolves outside the project." };
 	const segments = realRelativeDirPath.split("/");
 	const aboveTailSegments = segments.slice(0, -CLAUDECODE_SKILLS_DIR_SEGMENTS.length);
-	if (segments.slice(-CLAUDECODE_SKILLS_DIR_SEGMENTS.length).join("/") !== CLAUDECODE_SKILLS_DIR_POSIX_PATH) return { reason: `it resolves to ${realRelativeDirPath === "" ? "the project root" : JSON.stringify(stripControlCharacters(realRelativeDirPath))}, which is not a ${CLAUDECODE_SKILLS_DIR_POSIX_PATH} directory.` };
+	if (segments.slice(-CLAUDECODE_SKILLS_DIR_SEGMENTS.length).join("/") !== CLAUDECODE_SKILLS_DIR_POSIX_PATH) return { reason: `it resolves to ${realRelativeDirPath === "" ? "the project root" : quoteForLog(realRelativeDirPath)}, which is not a ${CLAUDECODE_SKILLS_DIR_POSIX_PATH} directory.` };
 	const excludedSegment = excludedNestedScanSegment(aboveTailSegments);
-	if (excludedSegment !== void 0) return { reason: `it resolves inside ${JSON.stringify(stripControlCharacters(excludedSegment))}, which the nested scan excludes.` };
+	if (excludedSegment !== void 0) return { reason: `it resolves inside ${quoteForLog(excludedSegment)}, which the nested scan excludes.` };
 	return { realRelativeDirPath };
 }
 const ClaudecodeSkillFrontmatterSchema = zod_mini.z.looseObject({
@@ -46882,9 +47883,18 @@ function buildClaudecodeSkillFrontmatter({ rulesyncFrontmatter, resolvedDisableM
 		"disable-model-invocation": resolvedDisableModelInvocation,
 		"user-invocable": resolvedUserInvocable,
 		paths: section.paths,
-		license: section.license,
-		compatibility: section.compatibility,
-		metadata: section.metadata
+		license: resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section
+		}),
+		compatibility: resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section
+		}),
+		metadata: resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section
+		})
 	};
 	const frontmatter = {
 		name: rulesyncFrontmatter.name,
@@ -47084,21 +48094,25 @@ var ClaudecodeSkill = class extends ToolSkill {
 	*/
 	static async getConfiguredImportRoots({ outputRoot, global = false, logger }) {
 		if (global) return [];
-		const root = toPosixPath(outputRoot);
+		const skillsDirPath = toPosixPath(CLAUDECODE_SKILLS_DIR_PATH);
 		const filteredDirPaths = filterOutPathsInGitIgnoredDirectories({
 			rootDir: outputRoot,
-			filePaths: await findFilesByGlobs([`${root}/*/**/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}`], {
+			filePaths: await findFilesByGlobs([`*/**/${skillsDirPath}`], {
+				cwd: outputRoot,
 				type: "dir",
 				followSymbolicLinks: false,
 				ignore: [
-					`${root}/**/.*/**/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}`,
-					...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `${root}/**/${dir}/**`),
-					...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${root}/${dir}/**`)
+					`**/.*/**/${skillsDirPath}`,
+					...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `**/${dir}/**`),
+					...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${dir}/**`)
 				]
 			})
 		}).toSorted();
 		const roots = [];
-		const seenRealRelativeDirPaths = /* @__PURE__ */ new Set([CLAUDECODE_SKILLS_DIR_POSIX_PATH]);
+		const seenRealRelativeDirPaths = /* @__PURE__ */ new Set([CLAUDECODE_SKILLS_DIR_POSIX_PATH, await resolvedRelativePath({
+			rootPath: outputRoot,
+			targetPath: (0, node_path.join)(outputRoot, CLAUDECODE_SKILLS_DIR_PATH)
+		})]);
 		for (const dirPath of filteredDirPaths) {
 			const scannedDirPath = (0, node_path.resolve)(dirPath);
 			const check = await checkNestedSkillsRoot({
@@ -47106,7 +48120,7 @@ var ClaudecodeSkill = class extends ToolSkill {
 				dirPath: scannedDirPath
 			});
 			if ("reason" in check) {
-				logger?.warn(`Skipping the nested Claude Code skills directory ${JSON.stringify(stripControlCharacters(scannedDirPath))}: ${check.reason} Its skills are not imported.`);
+				logger?.warn(`Skipping the nested Claude Code skills directory ${quoteForLog(scannedDirPath)}: ${check.reason} Its skills are not imported.`);
 				continue;
 			}
 			if (seenRealRelativeDirPaths.has(check.realRelativeDirPath)) continue;
@@ -47693,11 +48707,16 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 			rootFrontmatter: rulesyncFrontmatter,
 			section: copilotSection
 		});
-		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, ...copilotFields } = copilotSection ?? {};
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
+		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotFields } = copilotSection ?? {};
 		const copilotFrontmatter = {
 			...copilotFields,
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
+			...license !== void 0 && { license },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
@@ -47848,11 +48867,16 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			rootFrontmatter: rulesyncFrontmatter,
 			section: copilotcliSection
 		});
-		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, ...copilotcliFields } = copilotcliSection ?? {};
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotcliSection
+		});
+		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotcliFields } = copilotcliSection ?? {};
 		const copilotcliFrontmatter = {
 			...copilotcliFields,
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
+			...license !== void 0 && { license },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
@@ -48003,13 +49027,17 @@ var CursorSkill = class CursorSkill extends ToolSkill {
 			rootFrontmatter: rulesyncFrontmatter,
 			section: cursorSection
 		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: cursorSection
+		});
 		const cursorFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...cursorSection?.paths !== void 0 && { paths: cursorSection.paths },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
-			...cursorSection?.metadata !== void 0 && { metadata: cursorSection.metadata }
+			...metadata !== void 0 && { metadata }
 		};
 		return new CursorSkill({
 			outputRoot,
@@ -48150,13 +49178,25 @@ var DeepagentsSkill = class DeepagentsSkill extends ToolSkill {
 		const deepagentsSection = rulesyncFrontmatter.deepagents;
 		const allowedTools = deepagentsSection?.["allowed-tools"];
 		const allowedToolsString = Array.isArray(allowedTools) ? allowedTools.join(" ") : allowedTools;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: deepagentsSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: deepagentsSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: deepagentsSection
+		});
 		const deepagentsFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...allowedToolsString && { "allowed-tools": allowedToolsString },
-			...deepagentsSection?.license !== void 0 && { license: deepagentsSection.license },
-			...deepagentsSection?.compatibility !== void 0 && { compatibility: deepagentsSection.compatibility },
-			...deepagentsSection?.metadata !== void 0 && { metadata: deepagentsSection.metadata }
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata }
 		};
 		return new DeepagentsSkill({
 			outputRoot,
@@ -48508,11 +49548,26 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 			rootFrontmatter: rulesyncFrontmatter,
 			section: factorydroidSection
 		});
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: factorydroidSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: factorydroidSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: factorydroidSection
+		});
 		const { name: _sectionName, description: _sectionDescription, ...section } = factorydroidSection ?? {};
 		const factorydroidFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...section,
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable }
 		};
@@ -49104,7 +50159,7 @@ const KiloSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	license: zod_mini.z.optional(zod_mini.z.string()),
-	compatibility: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
@@ -49179,13 +50234,25 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const kiloSection = rulesyncFrontmatter.kilo;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiloSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiloSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiloSection
+		});
 		const kiloFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...kiloSection?.["allowed-tools"] !== void 0 && { "allowed-tools": kiloSection["allowed-tools"] },
-			...kiloSection?.license !== void 0 && { license: kiloSection.license },
-			...kiloSection?.compatibility !== void 0 && { compatibility: kiloSection.compatibility },
-			...kiloSection?.metadata !== void 0 && { metadata: kiloSection.metadata }
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata }
 		};
 		const settablePaths = KiloSkill.getSettablePaths({ global });
 		return new KiloSkill({
@@ -49517,10 +50584,26 @@ var KiroSkill = class KiroSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const settablePaths = KiroSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const kiroSection = rulesyncFrontmatter.kiro;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiroSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiroSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: kiroSection
+		});
 		const kiroFrontmatter = {
-			...rulesyncFrontmatter.kiro,
+			...kiroSection,
 			name: rulesyncFrontmatter.name,
-			description: rulesyncFrontmatter.description
+			description: rulesyncFrontmatter.description,
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata }
 		};
 		return new KiroSkill({
 			outputRoot,
@@ -49754,15 +50837,6 @@ const OpenCodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
-/**
-* Reads a top-level `compatibility` value from rulesync frontmatter, accepting
-* both the documented string form (e.g. `compatibility: opencode`) and the
-* legacy object form. Returns `undefined` for any other shape.
-*/
-function readTopLevelCompatibility(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "object" && value !== null) return value;
-}
 var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = OPENCODE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
 		super({
@@ -49798,9 +50872,16 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 	* configured path is read but never generated into. `skills.urls` is a
 	* remote-fetch surface and is out of scope for a file-based generator.
 	*
-	* Absolute paths and paths escaping the output root are dropped — an import
-	* root is joined onto `outputRoot`, and reaching outside it is not something
-	* a project config should be able to ask for.
+	* Absolute paths and paths escaping the config directory are dropped — an
+	* import root is joined onto that directory, and reaching outside it is not
+	* something a project config should be able to ask for. A path is judged by
+	* where it resolves, not by how it is spelled: a relative name that is a
+	* symbolic link pointing out of the directory is an escape all the same and
+	* is dropped too. A path that does not exist has nothing to resolve and is
+	* compared as spelled against the resolved config directory, so it survives
+	* only when that directory resolves to its own spelling and is dropped when
+	* the directory is itself reached through a link. Either way it yields no
+	* skills — the scan finds no directory under it.
 	*
 	* @see https://opencode.ai/config.json
 	*/
@@ -49814,7 +50895,12 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			outputRoot,
 			global
 		});
-		return skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !(0, node_path.isAbsolute)(candidate) && !(0, node_path.normalize)(candidate).startsWith("..")).map((relativeDirPath) => ({
+		const lexicallyContained = skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !(0, node_path.isAbsolute)(candidate) && !(0, node_path.normalize)(candidate).startsWith(".."));
+		const escapes = await Promise.all(lexicallyContained.map((candidate) => resolvedPathEscapesRoot({
+			rootPath: configDir,
+			targetPath: (0, node_path.join)(configDir, candidate)
+		})));
+		return lexicallyContained.filter((_, index) => !escapes[index]).map((relativeDirPath) => ({
 			outputRoot: configDir,
 			relativeDirPath
 		}));
@@ -49868,13 +50954,18 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const opencodeSection = rulesyncFrontmatter.opencode;
-		const looseTopLevel = rulesyncFrontmatter;
-		const topLevelLicense = typeof looseTopLevel.license === "string" ? looseTopLevel.license : void 0;
-		const topLevelCompatibility = readTopLevelCompatibility(looseTopLevel.compatibility);
-		const topLevelMetadata = typeof looseTopLevel.metadata === "object" && looseTopLevel.metadata !== null ? looseTopLevel.metadata : void 0;
-		const license = opencodeSection?.license ?? topLevelLicense;
-		const compatibility = opencodeSection?.compatibility ?? topLevelCompatibility;
-		const metadata = opencodeSection?.metadata ?? topLevelMetadata;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: opencodeSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: opencodeSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: opencodeSection
+		});
 		const opencodeFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
@@ -50043,11 +51134,26 @@ var PiSkill = class PiSkill extends ToolSkill {
 		});
 		const { "allowed-tools": allowedTools, ...piSectionRest } = piSection ?? {};
 		const allowedToolsString = Array.isArray(allowedTools) ? allowedTools.join(" ") : allowedTools;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: piSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: piSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: piSection
+		});
 		const piFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...allowedToolsString && { "allowed-tools": allowedToolsString },
 			...piSectionRest,
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
 		return new PiSkill({
@@ -50529,11 +51635,26 @@ var ReplitSkill = class ReplitSkill extends ToolSkill {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const { "allowed-tools": allowedTools, ...replitSection } = rulesyncFrontmatter.replit ?? {};
 		const allowedToolsString = Array.isArray(allowedTools) ? allowedTools.join(" ") : allowedTools;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: replitSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: replitSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: replitSection
+		});
 		const replitFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...allowedToolsString && { "allowed-tools": allowedToolsString },
-			...replitSection
+			...replitSection,
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata }
 		};
 		return new ReplitSkill({
 			outputRoot,
@@ -50886,30 +52007,24 @@ const VibeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 });
-/** Resolve the top-level `license` field, if present as a string. */
-function resolveTopLevelLicense(looseTopLevel) {
-	return typeof looseTopLevel.license === "string" ? looseTopLevel.license : void 0;
-}
-/** Resolve the top-level `compatibility` field (string or object), if present. */
-function resolveTopLevelCompatibility(looseTopLevel) {
-	const value = looseTopLevel.compatibility;
-	if (typeof value === "string" || typeof value === "object" && value !== null) return value;
-}
-/** Resolve the top-level `metadata` field (object), if present. */
-function resolveTopLevelMetadata(looseTopLevel) {
-	const value = looseTopLevel.metadata;
-	return typeof value === "object" && value !== null ? value : void 0;
-}
 /**
 * Build the Vibe frontmatter from a rulesync skill frontmatter, preferring the
-* dedicated `vibe` section over any loosely-typed top-level fields.
+* dedicated `vibe` section over the shared root-level fields.
 */
 function buildVibeFrontmatter(rulesyncFrontmatter) {
 	const vibeSection = rulesyncFrontmatter.vibe;
-	const looseTopLevel = rulesyncFrontmatter;
-	const topLevelLicense = resolveTopLevelLicense(looseTopLevel);
-	const topLevelCompatibility = resolveTopLevelCompatibility(looseTopLevel);
-	const topLevelMetadata = resolveTopLevelMetadata(looseTopLevel);
+	const license = resolveLicense({
+		rootFrontmatter: rulesyncFrontmatter,
+		section: vibeSection
+	});
+	const compatibility = resolveCompatibility({
+		rootFrontmatter: rulesyncFrontmatter,
+		section: vibeSection
+	});
+	const metadata = resolveMetadata({
+		rootFrontmatter: rulesyncFrontmatter,
+		section: vibeSection
+	});
 	const resolvedUserInvocable = resolveUserInvocable({
 		rootFrontmatter: rulesyncFrontmatter,
 		section: vibeSection
@@ -50917,9 +52032,9 @@ function buildVibeFrontmatter(rulesyncFrontmatter) {
 	return {
 		name: rulesyncFrontmatter.name,
 		description: rulesyncFrontmatter.description,
-		...vibeSection?.license !== void 0 || topLevelLicense !== void 0 ? { license: vibeSection?.license ?? topLevelLicense } : {},
-		...vibeSection?.compatibility !== void 0 || topLevelCompatibility !== void 0 ? { compatibility: vibeSection?.compatibility ?? topLevelCompatibility } : {},
-		...vibeSection?.metadata !== void 0 || topLevelMetadata !== void 0 ? { metadata: vibeSection?.metadata ?? topLevelMetadata } : {},
+		...license !== void 0 && { license },
+		...compatibility !== void 0 && { compatibility },
+		...metadata !== void 0 && { metadata },
 		...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
 		...vibeSection?.["allowed-tools"] !== void 0 && { "allowed-tools": vibeSection["allowed-tools"] }
 	};
@@ -51899,7 +53014,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				global: this.global
 			});
 			if (dirWriteBlockReason !== void 0 && dirWriteBlockReason !== null) {
-				this.logger.warn(`Skipping skill ${JSON.stringify(stripControlCharacters(dirName))} for '${this.toolTarget}': ${dirWriteBlockReason}`);
+				this.logger.warn(`Skipping skill ${quoteForLog(dirName)} for '${this.toolTarget}': ${dirWriteBlockReason}`);
 				return null;
 			}
 			return factory.class.fromRulesyncSkill({
@@ -52055,7 +53170,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 					};
 				} catch (error) {
 					if (!isLenientRoot) throw error;
-					this.logger.warn(`Skipping ${JSON.stringify(stripControlCharacters(sourcePath))}: ` + stripControlCharacters(formatError(error)));
+					this.logger.warn(`Skipping ${quoteForLog(sourcePath)}: ` + stripControlCharacters(formatError(error)));
 					return null;
 				}
 			}))).filter((loaded) => loaded !== null);
@@ -52086,7 +53201,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 					};
 				} catch (error) {
 					if (!isLenientRoot) throw error;
-					this.logger.warn(`Skipping ${JSON.stringify(stripControlCharacters(sourcePath))}: ` + stripControlCharacters(formatError(error)));
+					this.logger.warn(`Skipping ${quoteForLog(sourcePath)}: ` + stripControlCharacters(formatError(error)));
 					return null;
 				}
 			}))).filter((loaded) => loaded !== null);
@@ -52114,7 +53229,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 		return names.filter((name) => {
 			if (isAddressableSkillName(kind === "file" ? (0, node_path.basename)(name, ".md") : name)) return true;
 			const consequence = kind === "file" ? "skill name cannot contain a path separator, so this file is neither imported nor swept as an orphan. Rename it by hand." : "skill directory name cannot contain a path separator, so this directory is neither generated from nor swept as an orphan. Rename or remove it by hand.";
-			warnOnceWithFallback(this.logger, `Skipping ${JSON.stringify(stripControlCharacters((0, node_path.join)(dirPath, name)))}: a ${consequence}`);
+			warnOnceWithFallback(this.logger, `Skipping ${quoteForLog((0, node_path.join)(dirPath, name))}: a ${consequence}`);
 			return false;
 		});
 	}
@@ -57050,7 +58165,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: (0, node_path.join)("*", "AGENTS.md")
+			filePattern: "*/AGENTS.md"
 		}
 	}],
 	["devin", {
@@ -57059,7 +58174,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: (0, node_path.join)("*", "AGENT.md")
+			filePattern: "*/AGENT.md"
 		}
 	}],
 	["factorydroid", {
@@ -57149,7 +58264,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: (0, node_path.join)("**", "*.md")
+			filePattern: "**/*.md"
 		}
 	}],
 	["opencode", {
@@ -57176,7 +58291,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: (0, node_path.join)("*", "SKILL.md")
+			filePattern: "*/SKILL.md"
 		}
 	}],
 	["roo", {
@@ -57413,7 +58528,10 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				rootPath: rootOutputRoot,
 				targetPath: baseDir
 			});
-			const subagentFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern), { followSymbolicLinks: !forDeletion });
+			const subagentFilePaths = await findFilesByGlobs(factory.meta.filePattern, {
+				cwd: baseDir,
+				followSymbolicLinks: !forDeletion
+			});
 			const toRelativeFilePath = (path) => (0, node_path.relative)(baseDir, path);
 			let ownedFilePaths = subagentFilePaths;
 			if (factory.class.isFileOwned) {
@@ -57636,15 +58754,14 @@ var ToolRule = class extends ToolFile {
 	* than files under a rulesync-owned directory, so enumerating them for
 	* `--delete` would sweep away work rulesync never wrote.
 	*/
-	static buildNestedFilePatterns({ outputRoot, fileName }) {
-		const root = toPosixPath(outputRoot);
+	static buildNestedFilePatterns({ fileName }) {
 		return {
-			include: [`${root}/**/${fileName}`],
+			include: [`**/${fileName}`],
 			ignore: [
-				`${root}/${fileName}`,
-				`${root}/**/.*/**`,
-				...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `${root}/**/${dir}/**`),
-				...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${root}/${dir}/**`)
+				fileName,
+				"**/.*/**",
+				...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `**/${dir}/**`),
+				...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${dir}/**`)
 			]
 		};
 	}
@@ -57805,11 +58922,8 @@ var AgentsMdRule = class AgentsMdRule extends ToolRule {
 	*
 	* @see https://agents.md/
 	*/
-	static getNestedFilePatterns({ outputRoot }) {
-		return this.buildNestedFilePatterns({
-			outputRoot,
-			fileName: AGENTSMD_RULE_FILE_NAME
-		});
+	static getNestedFilePatterns() {
+		return this.buildNestedFilePatterns({ fileName: AGENTSMD_RULE_FILE_NAME });
 	}
 	/**
 	* The subproject directory this rule scopes, or `undefined` for the project
@@ -58758,6 +59872,78 @@ var AugmentcodeRule = class AugmentcodeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/claudecode-language-settings.ts
+/**
+* Claude Code's native home for the root `language` key of `rulesync.jsonc`.
+*
+* Claude Code reads a top-level `language` setting, so for this target the
+* rules feature writes the preference there instead of appending a prompt
+* block to CLAUDE.md. The key is patched into the existing settings file
+* through the shared config gateway (the `rules` feature owns `language`
+* there and nothing else), so hooks, permissions, and deny lists written by
+* sibling features — and everything the user authored — are left alone.
+*
+* Removing `language` from `rulesync.jsonc` later does not retract the key
+* already written: the settings file is shared with the user's own
+* configuration, so nothing is ever deleted from it, and the value stays
+* until the user removes it by hand.
+*/
+var ClaudecodeLanguageSettings = class ClaudecodeLanguageSettings extends ToolFile {
+	/**
+	* Project scope goes to `.claude/settings.local.json`: a response language
+	* is a per-developer preference, and the local file is the one Claude Code
+	* keeps out of version control. Global scope goes to `~/.claude/settings.json`
+	* because Claude Code reads no `~/.claude/settings.local.json`.
+	*/
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: CLAUDECODE_DIR,
+			relativeFilePath: global ? CLAUDECODE_SETTINGS_FILE_NAME : CLAUDECODE_SETTINGS_LOCAL_FILE_NAME
+		};
+	}
+	static async fromLanguage({ outputRoot = process.cwd(), language, global = false, validate = true }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		return new ClaudecodeLanguageSettings({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "rules",
+				existingContent,
+				patch: { language: getClaudecodeLanguageValue(language) },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	/**
+	* A settings file the user (and other features) share: never swept as an
+	* orphan, even though the rules feature stops writing it when `language`
+	* is unset again.
+	*/
+	isDeletable() {
+		return false;
+	}
+	validate() {
+		try {
+			JSON.parse(this.fileContent);
+			return {
+				success: true,
+				error: null
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: new Error(`Invalid JSON in ${this.getRelativePathFromCwd()}: ${formatError(error)}`, { cause: error })
+			};
+		}
+	}
+};
+//#endregion
 //#region src/features/rules/claudecode-legacy-rule.ts
 /**
 * Legacy rule generator for Claude Code AI assistant
@@ -58893,6 +60079,15 @@ var ClaudecodeRule = class ClaudecodeRule extends ToolRule {
 			nonRoot: { relativeDirPath: buildToolPath(CLAUDECODE_DIR, CLAUDECODE_RULES_DIR_NAME, excludeToolDir) }
 		};
 	}
+	/**
+	* The settings file the rules feature patches `language` into (see
+	* {@link ClaudecodeLanguageSettings}): not a rule path, so `getSettablePaths`
+	* does not report it, but the shared-config gateway must know the rules
+	* feature writes there.
+	*/
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		return [ClaudecodeLanguageSettings.getSettablePaths({ global })];
+	}
 	constructor({ frontmatter, body, ...rest }) {
 		if (rest.validate) {
 			const result = ClaudecodeRuleFrontmatterSchema.safeParse(frontmatter);
@@ -59598,6 +60793,12 @@ const CursorRuleFrontmatterSchema = zod_mini.z.object({
 	globs: zod_mini.z.optional(zod_mini.z.string()),
 	alwaysApply: zod_mini.z.optional(zod_mini.z.boolean())
 });
+/**
+* Globs that match the whole project, and so say nothing `alwaysApply: true`
+* does not already say. Same pair the Cline and Qwen Code adapters treat as
+* universal.
+*/
+const UNIVERSAL_GLOBS = /* @__PURE__ */ new Set(["**/*", "*"]);
 var CursorRule = class CursorRule extends ToolRule {
 	frontmatter;
 	body;
@@ -59626,7 +60827,10 @@ var CursorRule = class CursorRule extends ToolRule {
 		const rawDescription = frontmatter.description;
 		const description = typeof rawDescription === "string" ? rawDescription.replace(/\n+/g, " ").trim() : rawDescription;
 		if (description) lines.push((0, js_yaml.dump)({ description }, { lineWidth: -1 }).trimEnd());
-		if (frontmatter.globs !== void 0) lines.push(`globs: ${frontmatter.globs}`);
+		if (frontmatter.globs !== void 0) {
+			const globs = String(frontmatter.globs).replace(/[\r\n\u0085\u2028\u2029]+/g, " ").trim();
+			lines.push(`globs: ${globs}`);
+		}
 		lines.push("---");
 		lines.push("");
 		if (body) lines.push(body);
@@ -59644,11 +60848,12 @@ var CursorRule = class CursorRule extends ToolRule {
 	toRulesyncRule() {
 		const targets = ["*"];
 		const isAlways = this.frontmatter.alwaysApply === true;
-		const hasGlobs = this.frontmatter.globs && this.frontmatter.globs.trim() !== "";
-		let globs;
-		if (hasGlobs && this.frontmatter.globs) globs = this.frontmatter.globs.split(",").map((g) => g.trim()).filter((g) => g.length > 0);
-		else if (isAlways) globs = ["**/*"];
-		else globs = [];
+		const rawGlobs = this.frontmatter.globs;
+		const sourceGlobs = rawGlobs && rawGlobs.trim() !== "" ? rawGlobs.split(",").map((g) => g.trim()).filter((g) => g.length > 0) : [];
+		const globs = sourceGlobs.length === 0 && isAlways ? ["**/*"] : sourceGlobs;
+		let cursorGlobs;
+		if (sourceGlobs.length > 0) cursorGlobs = sourceGlobs;
+		else if (isAlways) cursorGlobs = [];
 		return new RulesyncRule({
 			frontmatter: {
 				targets,
@@ -59658,7 +60863,7 @@ var CursorRule = class CursorRule extends ToolRule {
 				cursor: {
 					alwaysApply: this.frontmatter.alwaysApply,
 					description: this.frontmatter.description,
-					globs: globs.length > 0 ? globs : void 0
+					globs: cursorGlobs
 				}
 			},
 			body: this.body,
@@ -59668,21 +60873,44 @@ var CursorRule = class CursorRule extends ToolRule {
 		});
 	}
 	/**
-	* Resolve cursor globs with priority: cursor-specific > parent
-	* Returns comma-separated string for Cursor format, or undefined if no globs
-	* @param cursorSpecificGlobs - Cursor-specific globs (takes priority if defined)
-	* @param parentGlobs - Parent globs (used if cursorSpecificGlobs is undefined)
+	* Resolve the Cursor `globs` string with priority: cursor-specific > parent.
+	*
+	* The two ways `cursorSpecificGlobs` can be absent are deliberately different
+	* and must stay that way: `undefined` means "no Cursor-specific opinion", so
+	* the canonical globs are used, while an explicit `[]` means "this rule has
+	* no Cursor globs" and wins over them. Collapsing the two -- say, to
+	* `cursorSpecificGlobs?.length ? … : parentGlobs` -- would put a universal
+	* canonical glob back onto every Always Apply rule.
+	*
+	* A universal glob (see {@link UNIVERSAL_GLOBS}) is dropped outright when the
+	* rule is Always Apply. `alwaysApply: true` already applies the rule
+	* everywhere, Cursor's docs say globs are ignored once it is set, and
+	* Cursor's own staff describe the two together as a semantic conflict that
+	* some versions resolve by classifying the rule as a glob rule instead of an
+	* Always one. Dropping it here is what heals, on the next generate, both a
+	* `.rulesync` file an older version wrote with the invented universal glob in
+	* `cursor.globs` and a rule hand-written with a universal canonical glob
+	* beside `cursor.alwaysApply: true`. Specific globs are left alone: they say
+	* something a flag cannot, so they are the author's to keep even alongside
+	* it.
 	*/
-	static resolveCursorGlobs(cursorSpecificGlobs, parentGlobs) {
+	static resolveCursorGlobs({ cursorSpecificGlobs, parentGlobs, alwaysApply }) {
 		const targetGlobs = cursorSpecificGlobs !== void 0 ? cursorSpecificGlobs : parentGlobs;
-		return targetGlobs && targetGlobs.length > 0 ? targetGlobs.join(",") : void 0;
+		if (!targetGlobs || targetGlobs.length === 0) return;
+		if (alwaysApply && targetGlobs.every((glob) => UNIVERSAL_GLOBS.has(glob.trim()))) return;
+		return targetGlobs.join(",");
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
 		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+		const alwaysApply = rulesyncFrontmatter.cursor?.alwaysApply;
 		const cursorFrontmatter = {
 			description: rulesyncFrontmatter.description,
-			globs: this.resolveCursorGlobs(rulesyncFrontmatter.cursor?.globs, rulesyncFrontmatter.globs),
-			alwaysApply: rulesyncFrontmatter.cursor?.alwaysApply ?? void 0
+			globs: this.resolveCursorGlobs({
+				cursorSpecificGlobs: rulesyncFrontmatter.cursor?.globs,
+				parentGlobs: rulesyncFrontmatter.globs,
+				alwaysApply: alwaysApply === true
+			}),
+			alwaysApply
 		};
 		const body = rulesyncRule.getBody();
 		const newFileName = `${rulesyncRule.getRelativeFilePath().replace(/\.md$/, "")}.mdc`;
@@ -61007,15 +62235,14 @@ var KiroRule = class KiroRule extends ToolRule {
 	* never wrote.
 	* @see https://kiro.dev/docs/steering/
 	*/
-	static getNestedFilePatterns({ outputRoot }) {
-		const root = toPosixPath(outputRoot);
+	static getNestedFilePatterns() {
 		return {
-			include: [`${root}/**/${KIRO_NESTED_STEERING_FILE_NAME}`],
+			include: [`**/${KIRO_NESTED_STEERING_FILE_NAME}`],
 			ignore: [
-				`${root}/${KIRO_NESTED_STEERING_FILE_NAME}`,
-				`${root}/**/.*/**`,
-				...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `${root}/**/${dir}/**`),
-				...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${root}/${dir}/**`)
+				KIRO_NESTED_STEERING_FILE_NAME,
+				"**/.*/**",
+				...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `**/${dir}/**`),
+				...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${dir}/**`)
 			]
 		};
 	}
@@ -61645,8 +62872,8 @@ var QwencodeRule = class QwencodeRule extends ToolRule {
 	* The personal local context file lives under `.qwen/`, not at the project
 	* root where the settable root path points, so override the deletion glob.
 	*/
-	static getLocalRootFileGlob({ outputRoot, fileName }) {
-		return (0, node_path.join)(outputRoot, QWENCODE_DIR, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return node_path.posix.join(toPosixPath(QWENCODE_DIR), fileName);
 	}
 };
 //#endregion
@@ -61673,11 +62900,8 @@ var ReasonixRule = class ReasonixRule extends ToolRule {
 	* (same exclusions, import-only, project scope).
 	* @see https://github.com/esengine/DeepSeek-Reasonix/blob/v1.18.0/docs/SESSION_MEMORY_RETRIEVAL.md
 	*/
-	static getNestedFilePatterns({ outputRoot }) {
-		return this.buildNestedFilePatterns({
-			outputRoot,
-			fileName: REASONIX_RULE_FILE_NAME
-		});
+	static getNestedFilePatterns() {
+		return this.buildNestedFilePatterns({ fileName: REASONIX_RULE_FILE_NAME });
 	}
 	/**
 	* The subproject directory this rule scopes, or `undefined` for the root
@@ -61934,9 +63158,9 @@ var RooRule = class RooRule extends ToolRule {
 	* generic directory is the only one the deletion sweep enumerates, because a
 	* `rules-*` glob would also match mode rules a user wrote by hand.
 	*/
-	static getNestedFilePatterns({ outputRoot }) {
+	static getNestedFilePatterns() {
 		return {
-			include: [`${toPosixPath(outputRoot)}/${toPosixPath(ROO_DIR)}/rules-*/**/*.md`],
+			include: [`${toPosixPath(ROO_DIR)}/rules-*/**/*.md`],
 			ignore: []
 		};
 	}
@@ -61974,8 +63198,8 @@ var RooRule = class RooRule extends ToolRule {
 	* Glob for the `separate-local-file` deletion; Roo reads `AGENTS.local.md`
 	* at the project root, not under `.roo/` (mirrors rovodev).
 	*/
-	static getLocalRootFileGlob({ outputRoot, fileName }) {
-		return (0, node_path.join)(outputRoot, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return fileName;
 	}
 };
 //#endregion
@@ -62155,15 +63379,15 @@ var RovodevRule = class RovodevRule extends ToolRule {
 					root: true
 				})];
 			},
-			getMirrorDeletionGlobs: ({ outputRoot }) => ({
-				primaryGlob: (0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_RULE_FILE_NAME),
-				mirrorGlob: (0, node_path.join)(outputRoot, ROVODEV_RULE_FILE_NAME)
+			getMirrorDeletionGlobs: () => ({
+				primaryGlob: node_path.posix.join(toPosixPath(ROVODEV_DIR), ROVODEV_RULE_FILE_NAME),
+				mirrorGlob: ROVODEV_RULE_FILE_NAME
 			})
 		};
 	}
 	/** Glob for the `separate-local-file` deletion; rovodev writes it at project root, not under `.rovodev/`. */
-	static getLocalRootFileGlob({ outputRoot, fileName }) {
-		return (0, node_path.join)(outputRoot, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return fileName;
 	}
 };
 //#endregion
@@ -62303,11 +63527,8 @@ var VibeRule = class VibeRule extends ToolRule {
 	* literally the same files.
 	* @see https://github.com/mistralai/mistral-vibe/blob/main/vibe/core/config/harness_files/_harness_manager.py
 	*/
-	static getNestedFilePatterns({ outputRoot }) {
-		return this.buildNestedFilePatterns({
-			outputRoot,
-			fileName: AGENTSMD_RULE_FILE_NAME
-		});
+	static getNestedFilePatterns() {
+		return this.buildNestedFilePatterns({ fileName: AGENTSMD_RULE_FILE_NAME });
 	}
 	/**
 	* The subproject directory this rule scopes, or `undefined` for the root file
@@ -63058,21 +64279,34 @@ const MAX_LISTED_SKIPPED_IMPORT_ONLY_PATHS = 10;
 * the tool will read" — can keep the two apart. A legacy root is a file
 * Rulesync reads but never writes, and the difference matters to them.
 */
-const findFilesWithFallback = async (primaryFilePaths, alternativeRoots, buildAltGlob) => {
+const findFilesWithFallback = async (primaryFilePaths, alternativeRoots, buildAltGlob, outputRoot) => {
 	if (primaryFilePaths.length > 0) return primaryFilePaths;
-	if (alternativeRoots) return await findFilesByGlobs(alternativeRoots.map(buildAltGlob));
+	if (alternativeRoots) return await findFilesByGlobs(alternativeRoots.map(buildAltGlob), { cwd: outputRoot });
 	return [];
 };
+/**
+* A project-root-relative glob for a file a tool keeps at a fixed path, joined
+* with `/` because a glob is always posix-separated.
+*
+* Relative because the root goes to `findFilesByGlobs` as `cwd` rather than into
+* the pattern: a project directory named `project(a)` or `project{a,b}` would
+* otherwise be read as a glob and match nothing at all — and on a `--delete`
+* sweep an empty result reads as "every source was removed", so rulesync would
+* 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));
 var RulesProcessor = class extends FeatureProcessor {
 	toolTarget;
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	language;
+	deriveSubprojectPathFromGlobs;
 	global;
 	getFactory;
 	skills;
 	featureOptions;
-	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, simulateCommands = false, simulateSubagents = false, simulateSkills = false, global = false, getFactory = defaultGetFactory, skills, featureOptions, dryRun = false, logger }) {
+	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, simulateCommands = false, simulateSubagents = false, simulateSkills = false, language, deriveSubprojectPathFromGlobs = false, global = false, getFactory = defaultGetFactory, skills, featureOptions, dryRun = false, logger }) {
 		super({
 			outputRoot,
 			inputRoots,
@@ -63086,6 +64320,8 @@ var RulesProcessor = class extends FeatureProcessor {
 		this.simulateCommands = simulateCommands;
 		this.simulateSubagents = simulateSubagents;
 		this.simulateSkills = simulateSkills;
+		this.language = language;
+		this.deriveSubprojectPathFromGlobs = deriveSubprojectPathFromGlobs;
 		this.getFactory = getFactory;
 		this.skills = skills;
 		this.featureOptions = featureOptions;
@@ -63129,8 +64365,10 @@ var RulesProcessor = class extends FeatureProcessor {
 		});
 		this.applyRootRuleSections({
 			toolRules,
-			factory
+			factory,
+			convertedRules
 		});
+		extraFiles.push(...await this.buildLanguageSettingsFiles());
 		const outputFiles = [...toolRules, ...extraFiles];
 		this.warnForOutputPathCollisions({
 			outputFiles,
@@ -63188,7 +64426,8 @@ var RulesProcessor = class extends FeatureProcessor {
 			outputRoot: this.outputRoot,
 			instructions: instructionPaths,
 			validate: true,
-			global: this.global
+			global: this.global,
+			logger: this.logger
 		});
 		return registered ? [registered] : [];
 	}
@@ -63197,11 +64436,19 @@ var RulesProcessor = class extends FeatureProcessor {
 	* reference and conventions sections to the root rule content. Mutates the
 	* root rule in place.
 	*/
-	applyRootRuleSections({ toolRules, factory }) {
+	applyRootRuleSections({ toolRules, factory, convertedRules }) {
 		const { meta } = factory;
 		const rootRule = toolRules.find((rule) => rule.isRoot());
-		if (!rootRule) return;
-		const newContent = this.generateReferenceSectionFromMeta(meta, toolRules) + (!meta.createsSeparateConventionsRule && meta.additionalConventions ? this.generateAdditionalConventionsSectionFromMeta(meta) : "") + rootRule.getFileContent();
+		if (!rootRule) {
+			this.appendLanguageBlockToRootSourceRules({ convertedRules });
+			return;
+		}
+		const assembledContent = this.generateReferenceSectionFromMeta(meta, toolRules) + (!meta.createsSeparateConventionsRule && meta.additionalConventions ? this.generateAdditionalConventionsSectionFromMeta(meta) : "") + rootRule.getFileContent();
+		const promptLanguage = this.getPromptBlockLanguage();
+		const newContent = promptLanguage === void 0 ? assembledContent : appendLanguageBlock({
+			content: assembledContent,
+			language: promptLanguage
+		});
 		rootRule.setFileContent(newContent);
 		const rootMirror = factory.class.getRootMirror?.();
 		if (rootMirror && !this.global) toolRules.push(...rootMirror.getMirrorFiles({
@@ -63210,6 +64457,53 @@ var RulesProcessor = class extends FeatureProcessor {
 			content: newContent
 		}));
 	}
+	/**
+	* The language delivered as a prompt block, or `undefined` when none is:
+	* `language` is unset, or the target is Claude Code, which has a native
+	* `language` setting (see {@link ClaudecodeLanguageSettings}) and so gets
+	* no block in its root file.
+	*/
+	getPromptBlockLanguage() {
+		return this.isClaudecodeTarget() ? void 0 : this.language;
+	}
+	isClaudecodeTarget() {
+		return this.toolTarget === "claudecode" || this.toolTarget === "claudecode-legacy";
+	}
+	/**
+	* The language block for targets whose adapters never mark a ToolRule as
+	* root: Cursor emits every rule as `.cursor/rules/*.mdc`, and the fixed-name
+	* targets (Cline, Roo, Kiro, ...) file the `root: true` source beside the
+	* others. The file produced from the `root: true` source is still the root
+	* rule from the user's point of view, so it is the one that gets the block.
+	* Nested rules never do. When several sources are marked `root: true`, only
+	* the file built from the first one (in conversion order, which follows the
+	* source order) carries the block: one instruction per target is the
+	* contract, and a root-marking target gets exactly one as well.
+	*/
+	appendLanguageBlockToRootSourceRules({ convertedRules }) {
+		const language = this.getPromptBlockLanguage();
+		if (language === void 0) return;
+		const firstRootSource = convertedRules.find(({ rulesyncRule }) => rulesyncRule.getFrontmatter().root === true);
+		if (firstRootSource === void 0) return;
+		const { toolRule } = firstRootSource;
+		toolRule.setFileContent(appendLanguageBlock({
+			content: toolRule.getFileContent(),
+			language
+		}));
+	}
+	/**
+	* Claude Code's native delivery of `language`: a patch to the settings file
+	* instead of a prompt block. Empty for every other target and when
+	* `language` is unset, so an unset key never touches the settings file.
+	*/
+	async buildLanguageSettingsFiles() {
+		if (this.language === void 0 || !this.isClaudecodeTarget()) return [];
+		return [await ClaudecodeLanguageSettings.fromLanguage({
+			outputRoot: this.outputRoot,
+			language: this.language,
+			global: this.global
+		})];
+	}
 	buildSkillList(skillClass) {
 		if (!this.skills) return [];
 		const toolRelativeDirPath = skillClass.getSettablePaths({ global: this.global }).relativeDirPath;
@@ -63439,7 +64733,10 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		const toolRules = toolFiles.filter((file) => file instanceof ToolRule);
 		const rulesyncRules = toolRules.map((toolRule) => {
 			if (toolRule.isLocalRoot()) return toolRule.toLocalRootRulesyncRule({ targets: [this.toolTarget] });
-			return toolRule.toRulesyncRule();
+			return this.withoutLanguageBlock({
+				toolRule,
+				rulesyncRule: toolRule.toRulesyncRule()
+			});
 		});
 		const claimedBy = /* @__PURE__ */ new Map();
 		for (const [index, rulesyncRule] of rulesyncRules.entries()) {
@@ -63455,6 +64752,33 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		return rulesyncRules;
 	}
 	/**
+	* Drop the language block a previous `generate` appended, so that importing
+	* a generated root file and generating again yields one block, not two.
+	* Every imported rule is checked, not just root ones: Cursor and the
+	* fixed-name targets import their root file as a non-root rule. The
+	* `language` key itself lives in `rulesync.jsonc`, so nothing about the
+	* detected language is carried into the rulesync rule — which is why the
+	* strip is reported: a user who imports a file carrying the block and has
+	* not set `language` would otherwise lose the instruction without a trace.
+	* Once per file per run, since an import over several targets reads the
+	* same root file for each of them.
+	*/
+	withoutLanguageBlock({ toolRule, rulesyncRule }) {
+		const body = rulesyncRule.getBody();
+		const stripped = stripLanguageBlock(body);
+		if (stripped === body) return rulesyncRule;
+		const source = stripControlCharacters((0, node_path.join)(toolRule.getRelativeDirPath(), toolRule.getRelativeFilePath()));
+		warnOnceWithFallback(this.logger, `Removed the answer-language block rulesync appends from ${source} on import; it is not kept in .rulesync/rules/. Set "language" in rulesync.jsonc to keep generating it.`);
+		return new RulesyncRule({
+			outputRoot: rulesyncRule.getOutputRoot(),
+			relativeDirPath: rulesyncRule.getRelativeDirPath(),
+			relativeFilePath: rulesyncRule.getRelativeFilePath(),
+			frontmatter: rulesyncRule.getFrontmatter(),
+			body: stripped,
+			validate: false
+		});
+	}
+	/**
 	* Load rulesync rule files from a single source-tree's `rules/` (and
 	* `rules/.curated/`) subtree. `sourceTree` is the source tree itself
 	* (e.g. `/repo/.rulesync` or `/repo/.rulesync.local`), NOT its parent.
@@ -63471,7 +64795,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		const rulesyncOutputRoot = (0, node_path.join)(sourceTree, RULES_FEATURE_SUBDIR);
 		const curatedOutputRoot = (0, node_path.join)(sourceTree, CURATED_RULES_FEATURE_SUBDIR);
 		const [rulesDirExists, curatedDirExists] = await Promise.all([directoryExistsStrict(rulesyncOutputRoot), directoryExistsStrict(curatedOutputRoot)]);
-		const [discoveredFiles, discoveredCuratedFiles] = await Promise.all([rulesDirExists ? findFilesByGlobs((0, node_path.join)(rulesyncOutputRoot, "**", "*.md")) : [], curatedDirExists ? findFilesByGlobs((0, node_path.join)(curatedOutputRoot, "**", "*.md")) : []]);
+		const [discoveredFiles, discoveredCuratedFiles] = await Promise.all([rulesDirExists ? findFilesByGlobs("**/*.md", { cwd: rulesyncOutputRoot }) : [], curatedDirExists ? findFilesByGlobs("**/*.md", { cwd: curatedOutputRoot }) : []]);
 		const files = [.../* @__PURE__ */ new Set([...discoveredFiles, ...discoveredCuratedFiles])];
 		const localFiles = files.filter((file) => !(0, node_path.relative)(rulesyncOutputRoot, file).startsWith(`.curated${node_path.sep}`));
 		const localRelativePathsByIdentity = groupSpellingsByCaseFoldedIdentity(localFiles.map((file) => (0, node_path.relative)(rulesyncOutputRoot, file)));
@@ -63508,7 +64832,8 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const rule = await RulesyncRule.fromFile({
 				outputRoot: treeParent,
 				relativeDirPath: treeRulesDirPath,
-				relativeFilePath: sourceRelativeFilePath
+				relativeFilePath: sourceRelativeFilePath,
+				deriveSubprojectPathFromGlobs: this.deriveSubprojectPathFromGlobs
 			});
 			if (sourceRelativeFilePath === relativeFilePath) return rule;
 			return new RulesyncRule({
@@ -63657,10 +64982,10 @@ 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 primaryRootFilePaths = settablePaths.root ? await findFilesByGlobs((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", settablePaths.root.relativeFilePath)) : [];
+			const primaryRootFilePaths = settablePaths.root ? await findFilesByGlobs(rootRelativeGlob(settablePaths.root.relativeDirPath ?? ".", settablePaths.root.relativeFilePath), { cwd: this.outputRoot }) : [];
 			const rootToolRules = await (async () => {
 				if (!settablePaths.root) return [];
-				const uniqueRootFilePaths = await findFilesWithFallback(primaryRootFilePaths, settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, alt.relativeFilePath));
+				const uniqueRootFilePaths = await findFilesWithFallback(primaryRootFilePaths, settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, alt.relativeFilePath), this.outputRoot);
 				if (forDeletion) return buildDeletionRulesFromPaths(uniqueRootFilePaths);
 				return await buildImportRulesFromPaths(uniqueRootFilePaths);
 			})();
@@ -63669,12 +64994,9 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				if (this.global || factory.meta.localRootMode !== "separate-local-file" || !factory.meta.localRootFileName) return [];
 				const fileName = factory.meta.localRootFileName;
 				const filePaths = await (async () => {
-					if (factory.class.getLocalRootFileGlob) return await findFilesByGlobs(factory.class.getLocalRootFileGlob({
-						outputRoot: this.outputRoot,
-						fileName
-					}));
+					if (factory.class.getLocalRootFileGlob) return await findFilesByGlobs(factory.class.getLocalRootFileGlob({ fileName }), { cwd: this.outputRoot });
 					if (!settablePaths.root) return [];
-					return await findFilesWithFallback(await findFilesByGlobs((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName)), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName));
+					return await findFilesWithFallback(await findFilesByGlobs(rootRelativeGlob(settablePaths.root.relativeDirPath ?? ".", fileName), { cwd: this.outputRoot }), settablePaths.alternativeRoots, (alt) => rootRelativeGlob(alt.relativeDirPath, fileName), this.outputRoot);
 				})();
 				if (forDeletion) return buildDeletionRulesFromPaths(filePaths);
 				return (await Promise.all(filePaths.map(async (filePath) => {
@@ -63697,15 +65019,15 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const rootMirrorDeletionRules = await (async () => {
 				const rootMirror = factory.class.getRootMirror?.();
 				if (!forDeletion || this.global || !rootMirror) return [];
-				const { primaryGlob, mirrorGlob } = rootMirror.getMirrorDeletionGlobs({ outputRoot: this.outputRoot });
-				if ((await findFilesByGlobs(primaryGlob)).length === 0) return [];
-				const mirrorPaths = await findFilesByGlobs(mirrorGlob);
+				const { primaryGlob, mirrorGlob } = rootMirror.getMirrorDeletionGlobs();
+				if ((await findFilesByGlobs(primaryGlob, { cwd: this.outputRoot })).length === 0) return [];
+				const mirrorPaths = await findFilesByGlobs(mirrorGlob, { cwd: this.outputRoot });
 				return buildDeletionRulesFromPaths(mirrorPaths);
 			})();
 			const extraFixedToolRules = await (async () => {
 				const extraFiles = factory.class.getExtraFixedFiles?.({ global: this.global });
 				if (!extraFiles || extraFiles.length === 0) return [];
-				const filePaths = await findFilesByGlobs(extraFiles.map((file) => (0, node_path.join)(this.outputRoot, file.relativeDirPath, file.relativeFilePath)));
+				const filePaths = await findFilesByGlobs(extraFiles.map((file) => rootRelativeGlob(file.relativeDirPath, file.relativeFilePath)), { cwd: this.outputRoot });
 				if (filePaths.length === 0) return [];
 				if (forDeletion) return buildDeletionRulesFromPaths(filePaths);
 				return await Promise.all(filePaths.map((filePath) => {
@@ -63724,9 +65046,10 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			})();
 			this.logger.debug(`Found ${extraFixedToolRules.length} extra fixed tool rule files`);
 			const nestedToolRules = await (async () => {
-				const patterns = this.global ? void 0 : factory.class.getNestedFilePatterns?.({ outputRoot: this.outputRoot });
+				const patterns = this.global ? void 0 : factory.class.getNestedFilePatterns?.();
 				if (forDeletion || !patterns || patterns.include.length === 0) return [];
 				const matchedPaths = await findFilesByGlobs(patterns.include, {
+					cwd: this.outputRoot,
 					type: "file",
 					followSymbolicLinks: false,
 					ignore: patterns.ignore
@@ -63757,7 +65080,10 @@ As this project's AI coding tool, you must follow the additional conventions bel
 				const scannedPaths = [];
 				const skippedPaths = [];
 				for (const importOnlyRoot of importOnlyRoots) {
-					const matchedPaths = await findFilesByGlobs((0, node_path.join)(this.outputRoot, importOnlyRoot.relativeDirPath, importOnlyRoot.relativeFilePath ?? `*.${factory.meta.extension}`), { type: "file" });
+					const matchedPaths = await findFilesByGlobs(rootRelativeGlob(importOnlyRoot.relativeDirPath, importOnlyRoot.relativeFilePath ?? `*.${factory.meta.extension}`), {
+						cwd: this.outputRoot,
+						type: "file"
+					});
 					if (importOnlyRoot.onlyWhenRootAbsent === true && rootFilePath !== void 0) {
 						skippedPaths.push(...matchedPaths);
 						continue;
@@ -63776,7 +65102,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			const nonRootToolRules = await (async () => {
 				if (!settablePaths.nonRoot) return [];
 				const nonRootOutputRoot = (0, node_path.join)(this.outputRoot, settablePaths.nonRoot.relativeDirPath);
-				const nonRootFilePaths = await findFilesByGlobs((0, node_path.join)(nonRootOutputRoot, "**", `*.${factory.meta.extension}`));
+				const nonRootFilePaths = await findFilesByGlobs(`**/*.${factory.meta.extension}`, { cwd: nonRootOutputRoot });
 				if (forDeletion) return buildDeletionRulesFromPaths(nonRootFilePaths, {
 					outputRootOverride: nonRootOutputRoot,
 					relativeDirPathOverride: settablePaths.nonRoot.relativeDirPath
@@ -63919,7 +65245,7 @@ function resolveToolOutputRoot({ outputRoot, toolTarget, global }) {
 * `.rulesync/` files to disk. Rulesync file instances live in memory only.
 */
 async function convertFromTool(params) {
-	resetWarnedOnceMessages();
+	resetRunWarningState();
 	const packagingTarget = [params.fromTool, ...params.toTools].find(isPackagingToolTarget);
 	if (packagingTarget) throw new Error(`Plugin packaging target '${packagingTarget}' is not supported by convert. Use import and generate with explicit plugin directories.`);
 	const ctx = params;
@@ -64008,7 +65334,8 @@ function buildRulesStrategy(ctx) {
 			toolTarget,
 			global,
 			dryRun,
-			logger
+			logger,
+			language: config.getLanguage()
 		}),
 		loadSource: (p) => p.loadToolFiles(),
 		toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
@@ -64398,6 +65725,9 @@ function createOrphanSweepPlan() {
 			const resolved = (0, node_path.resolve)(path);
 			return generatedPaths.has(resolved) || isInsideGeneratedTree(resolved);
 		},
+		isGeneratedExactly({ path }) {
+			return generatedPaths.has((0, node_path.resolve)(path));
+		},
 		rejectClaimed({ items, getPath }) {
 			return items.filter((item) => !plan.isGenerated({ path: getPath(item) }));
 		},
@@ -64631,13 +65961,18 @@ async function processDirFeatureGeneration(params) {
 			getPath: (d) => d.getDirPath()
 		}), toolDirs);
 		const existingFlatFiles = await processor.loadToolFlatFilesToDelete();
-		return orphanDirCount + await processor.removeOrphanFlatFiles({
+		const orphanFileCount = await processor.removeOrphanFlatFiles({
 			existingFlatFiles: sweepPlan.rejectClaimed({
 				items: existingFlatFiles,
 				getPath: (d) => d.getFlatFilePath() ?? d.getDirPath()
 			}),
 			generatedDirs: toolDirs
-		}) > 0;
+		});
+		const orphanInDirCount = await processor.removeOrphanFilesInAiDirs({
+			generatedDirs: toolDirs,
+			isClaimed: (path) => sweepPlan.isGeneratedExactly({ path })
+		});
+		return orphanDirCount + orphanFileCount + orphanInDirCount > 0;
 	} });
 	return {
 		count: totalCount,
@@ -64956,7 +66291,7 @@ async function collectHermesProjectPluginNames({ config, resultsById }) {
 async function generate(params) {
 	const { config, logger } = params;
 	resetRootShadowingWarnings({ logger });
-	resetWarnedOnceMessages();
+	resetRunWarningState();
 	for (const toolTarget of config.getTargets()) for (const outputRoot of config.getOutputRoots(toolTarget)) await assertPluginRootSafe({
 		toolTarget,
 		outputRoot
@@ -65116,6 +66451,8 @@ async function generateRulesCore(params) {
 			simulateCommands: config.getSimulateCommands(),
 			simulateSubagents: config.getSimulateSubagents(),
 			simulateSkills: config.getSimulateSkills(),
+			language: config.getLanguage(),
+			deriveSubprojectPathFromGlobs: config.getDeriveSubprojectPathFromGlobs(),
 			skills,
 			featureOptions: config.getFeatureOptions(toolTarget, "rules"),
 			dryRun: config.isPreviewMode(),
@@ -65566,7 +66903,7 @@ function getToolOutputRoot({ config, tool }) {
 */
 async function importFromTool(params) {
 	const { config, tool, logger } = params;
-	resetWarnedOnceMessages();
+	resetRunWarningState();
 	await assertPluginRootSafe({
 		toolTarget: tool,
 		outputRoot: getToolOutputRoot({
@@ -66020,6 +67357,12 @@ Object.defineProperty(exports, "DEPRECATED_FEATURE_REPLACEMENTS", {
 		return DEPRECATED_FEATURE_REPLACEMENTS;
 	}
 });
+Object.defineProperty(exports, "ELLIPSIS_WIDTH", {
+	enumerable: true,
+	get: function() {
+		return ELLIPSIS_WIDTH;
+	}
+});
 Object.defineProperty(exports, "ErrorCodes", {
 	enumerable: true,
 	get: function() {
@@ -66392,6 +67735,12 @@ Object.defineProperty(exports, "__toESM", {
 		return __toESM;
 	}
 });
+Object.defineProperty(exports, "applyFileMode", {
+	enumerable: true,
+	get: function() {
+		return applyFileMode;
+	}
+});
 Object.defineProperty(exports, "assertDirectoryIfExists", {
 	enumerable: true,
 	get: function() {
@@ -66605,7 +67954,7 @@ Object.defineProperty(exports, "parseCommaSeparatedList", {
 Object.defineProperty(exports, "parseJsonc", {
 	enumerable: true,
 	get: function() {
-		return parseJsonc$8;
+		return parseJsonc$6;
 	}
 });
 Object.defineProperty(exports, "pathEscapesRoot", {
@@ -66614,6 +67963,12 @@ Object.defineProperty(exports, "pathEscapesRoot", {
 		return pathEscapesRoot;
 	}
 });
+Object.defineProperty(exports, "quoteForLog", {
+	enumerable: true,
+	get: function() {
+		return quoteForLog;
+	}
+});
 Object.defineProperty(exports, "readFileContent", {
 	enumerable: true,
 	get: function() {
@@ -66656,10 +68011,10 @@ Object.defineProperty(exports, "removeTempDirectory", {
 		return removeTempDirectory;
 	}
 });
-Object.defineProperty(exports, "resetWarnedOnceMessages", {
+Object.defineProperty(exports, "resetRunWarningState", {
 	enumerable: true,
 	get: function() {
-		return resetWarnedOnceMessages;
+		return resetRunWarningState;
 	}
 });
 Object.defineProperty(exports, "resolveEffectiveInputRoots", {