rulesync 16.20.0 → 16.21.0

package/dist/{import-1-jjDDAm.js → import-5_n-Y8N6.js}

@@ -1,8 +1,9 @@
 import { ZodError } from "zod";
 import { meta, minLength, nonnegative, optional, refine, z } from "zod/mini";
-import { chmod, cp, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { cp, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rm, stat, writeFile } from "node:fs/promises";
 import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep, win32 } from "node:path";
 import { applyEdits, findNodeAtLocation, getNodeValue, modify, parse, parseTree, printParseErrorCode } from "jsonc-parser";
+import { constants } from "node:fs";
 import os from "node:os";
 import { intersection, kebabCase, uniq } from "es-toolkit";
 import { globbySync, isGitIgnoredSync } from "globby";
@@ -11,7 +12,6 @@ import { format, isDeepStrictEqual } from "node:util";
 import matter from "gray-matter";
 import { YAMLException, dump, load } from "js-yaml";
 import { omit } from "es-toolkit/object";
-import { constants } from "node:fs";
 import { createHash } from "node:crypto";
 import * as smolToml from "smol-toml";
 import { parse as parse$1, stringify } from "smol-toml";
@@ -38,6 +38,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.
 *
@@ -903,9 +923,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 = resolve(intendedRootDir, relativePath);
-	if (relative(intendedRootDir, resolved).startsWith("..") || resolve(resolved) !== resolved) throw new Error(`Path traversal detected: ${JSON.stringify(stripControlCharacters(relativePath))}`);
+	if (relative(intendedRootDir, resolved).startsWith("..") || 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
@@ -965,24 +985,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 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 stat(filepath)).mode & 73) !== 0) return;
+		fileHandle = await openNotFollowingLinks(filepath);
 	} catch {
 		return;
 	}
-	await 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 open(filepath, constants.O_RDONLY | (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(dirname(filepath));
@@ -1193,6 +1249,19 @@ function posixRelativePathEscapesRoot(relativePath) {
 	return relativePath === ".." || relativePath.startsWith("../") || 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
@@ -1202,9 +1271,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++;
@@ -1232,7 +1309,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
@@ -1246,6 +1323,7 @@ async function findFilesByGlobs(globs, options = {}) {
 	const normalizedGlobs = Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/");
 	const results = globbySync(normalizedGlobs, {
 		absolute: true,
+		cwd,
 		followSymbolicLinks,
 		dot,
 		...ignore ? { ignore: ignore.map((pattern) => pattern.replaceAll("\\", "/")) } : {},
@@ -1318,14 +1396,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(join(dirPath, entry.name))
+		mapper: async (entry) => ({
+			entry,
+			identity: await realFileIdentity(join(dirPath, entry.name))
+		})
 	});
 	const entriesByIdentity = /* @__PURE__ */ new Map();
-	for (const [index, entry] of entries.entries()) {
-		const identity = identities[index] ?? nativePathToPosix(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);
@@ -1624,43 +1704,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 AsyncLocalStorage();
-function currentMessages() {
-	return scopedMessages.getStore() ?? processWideMessages;
+const scopedState = new 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
@@ -2034,6 +2147,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 = 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.
@@ -2105,7 +2360,15 @@ const ConfigParamsSchema = z.object({
 	simulateCommands: optional(z.boolean()),
 	simulateSubagents: optional(z.boolean()),
 	simulateSkills: optional(z.boolean()),
+	deriveSubprojectPathFromGlobs: optional(z.boolean()),
 	flattenedCommandNaming: 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: optional(LanguageSchema),
 	gitignoreTargetsOnly: optional(z.boolean()),
 	gitignoreDestination: optional(GitignoreDestinationSchema),
 	dryRun: optional(z.boolean()),
@@ -2245,7 +2508,9 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	deriveSubprojectPathFromGlobs;
 	flattenedCommandNaming;
+	language;
 	gitignoreTargetsOnly;
 	gitignoreDestination;
 	dryRun;
@@ -2269,7 +2534,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
@@ -2301,7 +2566,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;
@@ -2480,12 +2747,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;
 	}
@@ -2546,6 +2823,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	deriveSubprojectPathFromGlobs: false,
 	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
 	gitignoreDestination: "gitignore",
@@ -2593,7 +2871,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,
@@ -2715,7 +2995,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 = resolve(process.cwd());
 		assertInputRootFieldsExclusive({
 			inputRoot,
@@ -2814,6 +3094,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,
@@ -2838,6 +3123,7 @@ var ConfigResolver = class {
 			configFilePath: validatedConfigPath,
 			sources: configByFile.sources ?? getDefaults().sources,
 			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
+			language: configByFile.language,
 			configFileTargets: extractConfigFileTargets(configByFile.targets)
 		});
 	}
@@ -7241,7 +7527,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 = z.object({
 	root: z.optional(z.boolean()),
 	localRoot: z.optional(z.boolean()),
@@ -7293,10 +7652,90 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		facet: z.optional(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 ${join(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(parseResult.error)}`);
 		const parsedFrontmatter = parseResult.success ? parseResult.data : {
@@ -7307,7 +7746,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: join(rest.relativeDirPath, rest.relativeFilePath)
+		});
 		this.body = body;
 	}
 	static getSettablePaths() {
@@ -7316,9 +7760,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,
@@ -7334,7 +7792,7 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${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 = join(outputRoot, dirPath, relativeFilePath);
 		const { frontmatter, body: content, hasFrontmatter } = parseFrontmatter(await readFileContent(filePath), filePath);
@@ -7353,7 +7811,8 @@ var RulesyncRule = class RulesyncRule extends RulesyncFile {
 			relativeFilePath,
 			frontmatter: validatedFrontmatter,
 			body: content.trim(),
-			validate
+			validate,
+			deriveSubprojectPathFromGlobs
 		});
 	}
 	getBody() {
@@ -7381,6 +7840,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.
 */
@@ -8094,6 +8568,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.`);
@@ -8192,12 +8667,15 @@ var AiDir = class AiDir {
 			try {
 				fileHandle = await open(classifiedPath, constants.O_RDONLY | (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;
 				}
@@ -8205,9 +8683,11 @@ var AiDir = class AiDir {
 				carriedBytes += fileBuffer.byteLength;
 				files.push({
 					relativeFilePathToDirPath: 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();
@@ -8240,6 +8720,9 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	targets: z._default(RulesyncTargetsSchema, ["*"]),
 	"disable-model-invocation": z.optional(z.boolean()),
 	"user-invocable": z.optional(z.boolean()),
+	license: z.optional(z.string()),
+	compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
+	metadata: z.optional(z.looseObject({})),
 	claudecode: z.optional(z.looseObject({
 		when_to_use: z.optional(z.string()),
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
@@ -8289,7 +8772,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	kilo: z.optional(z.looseObject({
 		"allowed-tools": z.optional(z.array(z.string())),
 		license: z.optional(z.string()),
-		compatibility: z.optional(z.looseObject({})),
+		compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
 		metadata: z.optional(z.looseObject({}))
 	})),
 	kiro: z.optional(z.looseObject({
@@ -8666,6 +9149,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";
@@ -10610,6 +11148,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 = join(CLAUDECODE_DIR, "commands");
+const CLAUDECODE_AGENTS_DIR_PATH = join(CLAUDECODE_DIR, "agents");
+const CLAUDECODE_SKILLS_DIR_PATH = join(CLAUDECODE_DIR, "skills");
+const CLAUDECODE_SCHEDULED_TASKS_DIR_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 = join(CODEXCLI_DIR, "prompts");
@@ -10630,6 +11202,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.
@@ -10765,39 +11383,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`.
@@ -10978,7 +11592,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
@@ -10991,11 +11606,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 = parseTree(text, [], { allowTrailingComma: true });
 	const object = root === void 0 ? void 0 : 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({
@@ -11012,7 +11627,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
@@ -11035,16 +11650,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) => applyEdits(source, 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) => applyEdits(source, 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({
@@ -11164,7 +11786,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;
@@ -11183,7 +11805,8 @@ function applyJsoncObjectEdits({ text, base, next, path, options }) {
 				base: previous,
 				next: value,
 				path: [...path, key],
-				options
+				options,
+				leadingKeys: []
 			});
 			continue;
 		}
@@ -11197,7 +11820,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({
@@ -11227,7 +11851,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
@@ -11235,26 +11859,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 = 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(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,
@@ -11263,13 +11915,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.
@@ -11307,6 +11971,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";
@@ -11416,9 +12081,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",
@@ -11431,6 +12115,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"]
 			}
 		}
 	},
@@ -11872,17 +12573,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];
@@ -11903,10 +12656,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({
@@ -11914,10 +12669,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";
@@ -12461,7 +13218,10 @@ var ChecksProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const baseDir = join(this.outputRoot, paths.relativeDirPath);
-		const checkFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern));
+		const checkFilePaths = await findFilesByGlobs(factory.meta.filePattern, {
+			cwd: baseDir,
+			followSymbolicLinks: !forDeletion
+		});
 		const toRelativeFilePath = (path) => relative(baseDir, path);
 		if (forDeletion) {
 			const toolChecks = checkFilePaths.map((path) => factory.class.forDeletion({
@@ -13233,7 +13993,7 @@ var AugmentcodeCommand = class AugmentcodeCommand extends ToolCommand {
 	*/
 	static async loadAdditionalImportFiles({ outputRoot = process.cwd(), global = false, logger } = {}) {
 		const rootDir = join(outputRoot, AUGMENTCODE_AGENTS_COMMANDS_DIR_PATH);
-		const filePaths = await findFilesByGlobs(join(rootDir, "**", "*.md"));
+		const filePaths = await findFilesByGlobs("**/*.md", { cwd: rootDir });
 		const imported = (await Promise.all(filePaths.map(async (filePath) => {
 			const relativePath = relative(rootDir, filePath);
 			if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
@@ -13270,33 +14030,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 = join(CLAUDECODE_DIR, "commands");
-const CLAUDECODE_AGENTS_DIR_PATH = join(CLAUDECODE_DIR, "agents");
-const CLAUDECODE_SKILLS_DIR_PATH = join(CLAUDECODE_DIR, "skills");
-const CLAUDECODE_SCHEDULED_TASKS_DIR_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 = z.looseObject({
 	description: z.optional(z.string()),
@@ -13944,7 +14677,7 @@ function commandSlug(relativeFilePath) {
 * it up as a regular orphan.
 */
 async function rulesyncCommandSlugExists({ inputRoots, dirName }) {
-	return (await Promise.all(inputRoots.map((root) => findFilesByGlobs(join(root, COMMANDS_FEATURE_SUBDIR, "**", "*.md"))))).flat().some((filePath) => commandSlug(basename(filePath)) === dirName);
+	return (await Promise.all(inputRoots.map((root) => findFilesByGlobs("**/*.md", { cwd: join(root, COMMANDS_FEATURE_SUBDIR) })))).flat().some((filePath) => commandSlug(basename(filePath)) === dirName);
 }
 //#endregion
 //#region src/features/commands/devin-command.ts
@@ -14907,6 +15640,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
@@ -15054,7 +15822,7 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 		const agentsSkillsFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...toSpecConformantAgentSkillFields(rulesyncFrontmatter.agentsskills)
+			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(rulesyncFrontmatter))
 		};
 		AgentsSkillsSkill.reportSpecViolations({
 			outputRoot,
@@ -15162,7 +15930,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 = {
@@ -17808,7 +18576,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 		const treeName = basename(sourceTree);
 		const treeCommandsDirPath = join(treeName, COMMANDS_FEATURE_SUBDIR);
 		const basePath = join(sourceTree, COMMANDS_FEATURE_SUBDIR);
-		const rulesyncCommandPaths = await directoryExistsStrict(basePath) ? await findFilesByGlobs(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,
@@ -17841,7 +18609,10 @@ var CommandsProcessor = class extends FeatureProcessor {
 		if (factory.meta.skipToolFileScan) return [];
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const outputRootFull = join(this.outputRoot, paths.relativeDirPath);
-		const commandFilePaths = await findFilesByGlobs(factory.meta.supportsSubdirectory ? join(outputRootFull, "**", `*.${factory.meta.extension}`) : 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,
@@ -18190,52 +18961,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;
@@ -24822,6 +25547,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.
 	*
@@ -24864,7 +25600,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
 		});
 	}
@@ -26240,18 +26980,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 = parse(fileContent || "{}", errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const details = errors.map((error) => `${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(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;
@@ -26270,7 +27040,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);
@@ -26314,7 +27084,7 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = 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,
@@ -26329,7 +27099,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 = join(outputRoot, basePaths.relativeDirPath);
 		const { fileContent, relativeFilePath } = await this.resolveSettingsFile(jsonDir);
@@ -26342,7 +27112,8 @@ var AmpMcp = class AmpMcp extends ToolMcp {
 				feature: "mcp",
 				existingContent: fileContent ?? "",
 				patch: { [AMP_MCP_SERVERS_KEY]: filterMcpServers(rulesyncMcp.getMcpServers()) },
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate,
 			global
@@ -26355,17 +27126,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,
@@ -26375,20 +27142,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
@@ -27340,7 +28097,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 = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
@@ -27353,7 +28110,8 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 				feature: "mcp",
 				existingContent,
 				patch: { servers: rulesyncMcp.getMcpServers() },
-				filePath
+				filePath,
+				logger
 			}),
 			validate
 		});
@@ -29484,7 +30242,8 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 					mcp: convertedMcp,
 					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
 				},
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -29502,7 +30261,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 = join(outputRoot, basePaths.relativeDirPath);
 		let fileContent = null;
@@ -29529,7 +30288,8 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 				feature: "rules",
 				existingContent: fileContent ?? "",
 				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -30549,7 +31309,8 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 					mcp: convertedMcp,
 					tools: Object.keys(mcpTools).length > 0 ? mcpTools : void 0
 				},
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -30570,7 +31331,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 = join(outputRoot, basePaths.relativeDirPath);
 		const configDirPrefix = `${toPosixPath(basePaths.relativeDirPath).replace(/\/+$/, "")}/`;
@@ -30602,7 +31363,8 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 				feature: "rules",
 				existingContent: fileContent ?? "",
 				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate
 		});
@@ -33090,16 +33852,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 = parse(fileContent || "{}", errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const details = errors.map((error) => `${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");
@@ -33215,7 +33967,7 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 		const basePaths = AmpPermissions.getSettablePaths({ global });
 		const jsonDir = 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])
@@ -33228,11 +33980,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 = 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;
@@ -33259,13 +34011,14 @@ var AmpPermissions = class AmpPermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch,
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: 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));
@@ -33285,7 +34038,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,
@@ -35335,15 +36088,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
 ]);
 /**
@@ -35715,7 +36468,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,
@@ -36742,7 +37499,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 = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
@@ -36762,7 +37519,8 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent,
 				patch,
-				filePath
+				filePath,
+				logger
 			}),
 			validate: true
 		});
@@ -37482,6 +38240,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,
@@ -40414,7 +41184,8 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch: { permission },
-				filePath: join(jsonDir, relativeFilePath)
+				filePath: join(jsonDir, relativeFilePath),
+				logger
 			}),
 			validate: true
 		});
@@ -42539,18 +43310,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
@@ -42588,6 +43361,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
@@ -42595,7 +43426,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;
@@ -42641,16 +43477,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.
@@ -42674,6 +43522,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
@@ -42684,7 +43546,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 = [];
@@ -45622,7 +46484,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(),
@@ -45748,13 +46610,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,
@@ -45936,7 +46810,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(join(dirPath, file.relativeFilePathToDirPath), file.fileMode);
+				}
+				continue;
+			}
 			const relativeDir = aiDir.getRelativePathFromCwd();
 			if (this.dryRun) {
 				this.logger.info(`[DRY RUN] Would create directory: ${stripControlCharacters(dirPath)}`);
@@ -45955,7 +46834,9 @@ var DirFeatureProcessor = class extends RulesyncSourceConsumer {
 					changedPaths.push(join(relativeDir, mainFile.name));
 				}
 				for (const file of otherFiles) {
-					await writeFileBuffer(join(dirPath, file.relativeFilePathToDirPath), file.fileBuffer);
+					const filePath = join(dirPath, file.relativeFilePathToDirPath);
+					await writeFileBuffer(filePath, file.fileBuffer);
+					if (file.fileMode !== void 0) await applyFileMode(filePath, file.fileMode);
 					changedPaths.push(join(relativeDir, file.relativeFilePathToDirPath));
 				}
 			}
@@ -45973,7 +46854,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({
@@ -45981,14 +46862,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;
 			}
@@ -46004,6 +46885,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 = 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
@@ -46011,7 +47012,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));
@@ -46048,11 +47049,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();
@@ -46061,8 +47062,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;
@@ -46804,9 +47805,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 = z.looseObject({
@@ -46857,9 +47858,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,
@@ -47059,21 +48069,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: join(outputRoot, CLAUDECODE_SKILLS_DIR_PATH)
+		})]);
 		for (const dirPath of filteredDirPaths) {
 			const scannedDirPath = resolve(dirPath);
 			const check = await checkNestedSkillsRoot({
@@ -47081,7 +48095,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;
@@ -47668,11 +48682,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 }
 		};
@@ -47823,11 +48842,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 }
 		};
@@ -47978,13 +49002,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,
@@ -48125,13 +49153,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,
@@ -48483,11 +49523,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 }
 		};
@@ -49079,7 +50134,7 @@ const KiloSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.string(),
 	license: z.optional(z.string()),
-	compatibility: z.optional(z.looseObject({})),
+	compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
 	metadata: z.optional(z.looseObject({})),
 	"allowed-tools": z.optional(z.array(z.string()))
 });
@@ -49154,13 +50209,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({
@@ -49492,10 +50559,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,
@@ -49729,15 +50812,6 @@ const OpenCodeSkillFrontmatterSchema = z.looseObject({
 	metadata: z.optional(z.looseObject({})),
 	"allowed-tools": z.optional(z.array(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({
@@ -49773,9 +50847,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
 	*/
@@ -49789,7 +50870,12 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			outputRoot,
 			global
 		});
-		return skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !isAbsolute(candidate) && !normalize(candidate).startsWith("..")).map((relativeDirPath) => ({
+		const lexicallyContained = skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !isAbsolute(candidate) && !normalize(candidate).startsWith(".."));
+		const escapes = await Promise.all(lexicallyContained.map((candidate) => resolvedPathEscapesRoot({
+			rootPath: configDir,
+			targetPath: join(configDir, candidate)
+		})));
+		return lexicallyContained.filter((_, index) => !escapes[index]).map((relativeDirPath) => ({
 			outputRoot: configDir,
 			relativeDirPath
 		}));
@@ -49843,13 +50929,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,
@@ -50018,11 +51109,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({
@@ -50504,11 +51610,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,
@@ -50861,30 +51982,24 @@ const VibeSkillFrontmatterSchema = z.looseObject({
 	"user-invocable": z.optional(z.boolean()),
 	"allowed-tools": z.optional(z.union([z.string(), z.array(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
@@ -50892,9 +52007,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"] }
 	};
@@ -51874,7 +52989,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({
@@ -52030,7 +53145,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);
@@ -52061,7 +53176,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);
@@ -52089,7 +53204,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 		return names.filter((name) => {
 			if (isAddressableSkillName(kind === "file" ? 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(join(dirPath, name)))}: a ${consequence}`);
+			warnOnceWithFallback(this.logger, `Skipping ${quoteForLog(join(dirPath, name))}: a ${consequence}`);
 			return false;
 		});
 	}
@@ -57025,7 +58140,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: join("*", "AGENTS.md")
+			filePattern: "*/AGENTS.md"
 		}
 	}],
 	["devin", {
@@ -57034,7 +58149,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: join("*", "AGENT.md")
+			filePattern: "*/AGENT.md"
 		}
 	}],
 	["factorydroid", {
@@ -57124,7 +58239,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: join("**", "*.md")
+			filePattern: "**/*.md"
 		}
 	}],
 	["opencode", {
@@ -57151,7 +58266,7 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: join("*", "SKILL.md")
+			filePattern: "*/SKILL.md"
 		}
 	}],
 	["roo", {
@@ -57388,7 +58503,10 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				rootPath: rootOutputRoot,
 				targetPath: baseDir
 			});
-			const subagentFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern), { followSymbolicLinks: !forDeletion });
+			const subagentFilePaths = await findFilesByGlobs(factory.meta.filePattern, {
+				cwd: baseDir,
+				followSymbolicLinks: !forDeletion
+			});
 			const toRelativeFilePath = (path) => relative(baseDir, path);
 			let ownedFilePaths = subagentFilePaths;
 			if (factory.class.isFileOwned) {
@@ -57611,15 +58729,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}/**`)
 			]
 		};
 	}
@@ -57780,11 +58897,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
@@ -58733,6 +59847,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 = 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
@@ -58868,6 +60054,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);
@@ -59573,6 +60768,12 @@ const CursorRuleFrontmatterSchema = z.object({
 	globs: z.optional(z.string()),
 	alwaysApply: z.optional(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;
@@ -59601,7 +60802,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(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);
@@ -59619,11 +60823,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,
@@ -59633,7 +60838,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,
@@ -59643,21 +60848,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`;
@@ -60982,15 +62210,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}/**`)
 			]
 		};
 	}
@@ -61620,8 +62847,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 join(outputRoot, QWENCODE_DIR, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return posix.join(toPosixPath(QWENCODE_DIR), fileName);
 	}
 };
 //#endregion
@@ -61648,11 +62875,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
@@ -61909,9 +63133,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: []
 		};
 	}
@@ -61949,8 +63173,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 join(outputRoot, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return fileName;
 	}
 };
 //#endregion
@@ -62130,15 +63354,15 @@ var RovodevRule = class RovodevRule extends ToolRule {
 					root: true
 				})];
 			},
-			getMirrorDeletionGlobs: ({ outputRoot }) => ({
-				primaryGlob: join(outputRoot, ROVODEV_DIR, ROVODEV_RULE_FILE_NAME),
-				mirrorGlob: join(outputRoot, ROVODEV_RULE_FILE_NAME)
+			getMirrorDeletionGlobs: () => ({
+				primaryGlob: 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 join(outputRoot, fileName);
+	static getLocalRootFileGlob({ fileName }) {
+		return fileName;
 	}
 };
 //#endregion
@@ -62278,11 +63502,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
@@ -63033,21 +64254,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) => 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,
@@ -63061,6 +64295,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;
@@ -63104,8 +64340,10 @@ var RulesProcessor = class extends FeatureProcessor {
 		});
 		this.applyRootRuleSections({
 			toolRules,
-			factory
+			factory,
+			convertedRules
 		});
+		extraFiles.push(...await this.buildLanguageSettingsFiles());
 		const outputFiles = [...toolRules, ...extraFiles];
 		this.warnForOutputPathCollisions({
 			outputFiles,
@@ -63163,7 +64401,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] : [];
 	}
@@ -63172,11 +64411,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({
@@ -63185,6 +64432,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;
@@ -63414,7 +64708,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()) {
@@ -63430,6 +64727,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(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.
@@ -63446,7 +64770,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		const rulesyncOutputRoot = join(sourceTree, RULES_FEATURE_SUBDIR);
 		const curatedOutputRoot = join(sourceTree, CURATED_RULES_FEATURE_SUBDIR);
 		const [rulesDirExists, curatedDirExists] = await Promise.all([directoryExistsStrict(rulesyncOutputRoot), directoryExistsStrict(curatedOutputRoot)]);
-		const [discoveredFiles, discoveredCuratedFiles] = await Promise.all([rulesDirExists ? findFilesByGlobs(join(rulesyncOutputRoot, "**", "*.md")) : [], curatedDirExists ? findFilesByGlobs(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) => !relative(rulesyncOutputRoot, file).startsWith(`.curated${sep}`));
 		const localRelativePathsByIdentity = groupSpellingsByCaseFoldedIdentity(localFiles.map((file) => relative(rulesyncOutputRoot, file)));
@@ -63483,7 +64807,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({
@@ -63632,10 +64957,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(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) => 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);
 			})();
@@ -63644,12 +64969,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(join(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName)), settablePaths.alternativeRoots, (alt) => 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) => {
@@ -63672,15 +64994,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) => 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) => {
@@ -63699,9 +65021,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
@@ -63732,7 +65055,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(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;
@@ -63751,7 +65077,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 = join(this.outputRoot, settablePaths.nonRoot.relativeDirPath);
-				const nonRootFilePaths = await findFilesByGlobs(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
@@ -63894,7 +65220,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;
@@ -63983,7 +65309,8 @@ function buildRulesStrategy(ctx) {
 			toolTarget,
 			global,
 			dryRun,
-			logger
+			logger,
+			language: config.getLanguage()
 		}),
 		loadSource: (p) => p.loadToolFiles(),
 		toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
@@ -64373,6 +65700,9 @@ function createOrphanSweepPlan() {
 			const resolved = resolve(path);
 			return generatedPaths.has(resolved) || isInsideGeneratedTree(resolved);
 		},
+		isGeneratedExactly({ path }) {
+			return generatedPaths.has(resolve(path));
+		},
 		rejectClaimed({ items, getPath }) {
 			return items.filter((item) => !plan.isGenerated({ path: getPath(item) }));
 		},
@@ -64606,13 +65936,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,
@@ -64931,7 +66266,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
@@ -65091,6 +66426,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(),
@@ -65541,7 +66878,7 @@ function getToolOutputRoot({ config, tool }) {
 */
 async function importFromTool(params) {
 	const { config, tool, logger } = params;
-	resetWarnedOnceMessages();
+	resetRunWarningState();
 	await assertPluginRootSafe({
 		toolTarget: tool,
 		outputRoot: getToolOutputRoot({
@@ -65863,6 +67200,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { SHARED_USER_MANAGED_CONFIG_PATHS as $, MAX_FILE_SIZE as $t, groupSpellingsByCaseFoldedIdentity as A, DEPRECATED_FEATURE_REPLACEMENTS as An, isFileSystemError as At, RulesyncPermissions as B, removeFile as Bt, CLAUDECODE_SKILLS_DIR_PATH as C, RULESYNC_RULES_RELATIVE_DIR_PATH as Cn, createTempDirectory as Ct, FACTORYDROID_DIR as D, parseCommaSeparatedList as Dn, getFileSize as Dt, CODEXCLI_DIR as E, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as En, fileExists as Et, RulesyncSubagentFrontmatterSchema as F, stripControlCharactersKeepingLineFeeds as Fn, pathEscapesRoot as Ft, resolveRulesyncSourceWritePath as G, toPosixPath as Gt, RulesyncIgnore as H, removeTempDirectory as Ht, RulesyncSkill as I, stripHiddenCharacters as In, readFileContent as It, RulesyncCommandFrontmatterSchema as J, ALL_TOOL_TARGETS as Jt, parseJsonc as K, writeFileBuffer as Kt, RulesyncSkillFrontmatterSchema as L, readFileContentOrNull as Lt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as M, truncateText as Mn, listDirectoryEntryNames as Mt, getLocalSkillDirNames as N, hasDeceptiveHiddenCharacters as Nn, listFilePathsRecursively as Nt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES as On, getHomeDirectory as Ot, RulesyncSubagent as P, stripControlCharacters as Pn, listSubdirectoryNames as Pt, loadYaml as Q, CURATED_RULES_FEATURE_SUBDIR as Qt, RulesyncRule as R, removeDirectory as Rt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as S, RULESYNC_RELATIVE_DIR_PATH as Sn, checkPathTraversal as St, CODEXCLI_BASH_RULES_FILE_NAME as T, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Tn, ensureDir as Tt, RulesyncHooks as U, resolvePath as Ut, RulesyncMcp as V, removeFileStrict as Vt, getRulesyncSourceCandidates as W, runWithDirectoryRollback as Wt, RulesyncCheckFrontmatterSchema as X, PACKAGING_TOOL_TARGETS as Xt, RulesyncCheck as Y, ALL_TOOL_TARGETS_WITH_WILDCARD as Yt, stringifyFrontmatter as Z, ToolTargetSchema as Zt, QWENCODE_DIR as _, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as _n, CLIError as _t, getProcessorRegistryEntry as a, RULESYNC_CONFIG_SCHEMA_URL as an, ConfigFileSchema as at, CLAUDECODE_LOCAL_RULE_FILE_NAME as b, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as bn, assertTreeContainsNoSymlinks as bt, RulesProcessor as c, RULESYNC_HOOKS_FILE_NAME as cn, findControlCharacter as ct, displayWidthOf as d, RULESYNC_IGNORE_RELATIVE_FILE_PATH as dn, WarningCollectingLogger as dt, RULESYNC_AIIGNORE_FILE_NAME as en, SKILL_FILE_NAME as et, shortenToWidth as f, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as fn, fallbackLogger as ft, CommandsProcessor as g, RULESYNC_MCP_SCHEMA_URL as gn, withWarnOnceScope as gt, HooksProcessor as h, RULESYNC_MCP_RELATIVE_FILE_PATH as hn, resetWarnedOnceMessages as ht, inspectInputRoots as i, RULESYNC_CONFIG_RELATIVE_FILE_PATH as in, CONFLICTING_TARGET_PAIRS as it, AUGMENTCODE_DIR as j, formatError as jn, isSymlink as jt, caseFoldIdentity as k, ALL_FEATURES_WITH_WILDCARD as kn, isFileNotFoundError as kt, SubagentsProcessor as l, RULESYNC_HOOKS_LEGACY_FILE_NAME as ln, ConsoleLogger as lt, IgnoreProcessor as m, RULESYNC_MCP_LEGACY_FILE_NAME as mn, withFallbackLoggerTarget as mt, formatSourceLoadFailure as n, RULESYNC_CHECKS_RELATIVE_DIR_PATH as nn, mergeInputRootConfigs as nt, convertFromTool as o, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as on, GITIGNORE_DESTINATION_KEY as ot, McpProcessor as p, RULESYNC_MCP_FILE_NAME as pn, warnOnConflictingFlags as pt, RulesyncCommand as q, writeFileContent as qt, generate as r, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as rn, resolveEffectiveInputRoots as rt, isPackagingToolTarget as s, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as sn, SourceEntrySchema as st, importFromTool as t, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as tn, ConfigResolver as tt, SkillsProcessor as u, RULESYNC_HOOKS_RELATIVE_FILE_PATH as un, JsonLogger as ut, QWENCODE_LOCAL_RULE_FILE_NAME as v, RULESYNC_PERMISSIONS_FILE_NAME as vn, ErrorCodes as vt, ChecksProcessor as w, RULESYNC_SKILLS_RELATIVE_DIR_PATH as wn, directoryExists as wt, CLAUDECODE_MEMORIES_DIR_NAME as x, RULESYNC_PERMISSIONS_SCHEMA_URL as xn, assertWritablePathInsideRoot as xt, CLAUDECODE_DIR as y, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as yn, assertDirectoryIfExists as yt, RulesyncRuleFrontmatterSchema as z, removeDirectoryStrict as zt };
+export { loadYaml as $, ToolTargetSchema as $t, caseFoldIdentity as A, ALL_FEATURES as An, getHomeDirectory as At, RulesyncRuleFrontmatterSchema as B, removeDirectory as Bt, CLAUDECODE_DIR as C, RULESYNC_PERMISSIONS_SCHEMA_URL as Cn, assertWritablePathInsideRoot as Ct, CLAUDECODE_SKILLS_DIR_PATH as D, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, ensureDir as Dt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as E, RULESYNC_SKILLS_RELATIVE_DIR_PATH as En, directoryExists as Et, RulesyncSubagent as F, hasDeceptiveHiddenCharacters as Fn, listFilePathsRecursively as Ft, getRulesyncSourceCandidates as G, resolvePath as Gt, RulesyncMcp as H, removeFile as Ht, RulesyncSubagentFrontmatterSchema as I, quoteForLog as In, listSubdirectoryNames as It, RulesyncCommand as J, writeFileBuffer as Jt, resolveRulesyncSourceWritePath as K, runWithDirectoryRollback as Kt, RulesyncSkill as L, stripControlCharacters as Ln, pathEscapesRoot as Lt, AUGMENTCODE_DIR as M, DEPRECATED_FEATURE_REPLACEMENTS as Mn, isFileSystemError as Mt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as N, formatError as Nn, isSymlink as Nt, FACTORYDROID_DIR as O, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as On, fileExists as Ot, getLocalSkillDirNames as P, truncateText as Pn, listDirectoryEntryNames as Pt, stringifyFrontmatter as Q, PACKAGING_TOOL_TARGETS as Qt, RulesyncSkillFrontmatterSchema as R, stripControlCharactersKeepingLineFeeds as Rn, readFileContent as Rt, CODEXCLI_DIR as S, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Sn, assertTreeContainsNoSymlinks as St, CLAUDECODE_MEMORIES_DIR_NAME as T, RULESYNC_RULES_RELATIVE_DIR_PATH as Tn, createTempDirectory as Tt, RulesyncIgnore as U, removeFileStrict as Ut, RulesyncPermissions as V, removeDirectoryStrict as Vt, RulesyncHooks as W, removeTempDirectory as Wt, RulesyncCheck as X, ALL_TOOL_TARGETS as Xt, RulesyncCommandFrontmatterSchema as Y, writeFileContent as Yt, RulesyncCheckFrontmatterSchema as Z, ALL_TOOL_TARGETS_WITH_WILDCARD as Zt, CommandsProcessor as _, RULESYNC_MCP_RELATIVE_FILE_PATH as _n, withWarnOnceScope as _t, getProcessorRegistryEntry as a, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as an, CONFLICTING_TARGET_PAIRS as at, ChecksProcessor as b, RULESYNC_PERMISSIONS_FILE_NAME as bn, applyFileMode as bt, RulesProcessor as c, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as cn, SourceEntrySchema as ct, ELLIPSIS_WIDTH as d, RULESYNC_HOOKS_LEGACY_FILE_NAME as dn, JsonLogger as dt, CURATED_RULES_FEATURE_SUBDIR as en, SHARED_USER_MANAGED_CONFIG_PATHS as et, displayWidthOf as f, RULESYNC_HOOKS_RELATIVE_FILE_PATH as fn, WarningCollectingLogger as ft, HooksProcessor as g, RULESYNC_MCP_LEGACY_FILE_NAME as gn, resetRunWarningState as gt, IgnoreProcessor as h, RULESYNC_MCP_FILE_NAME as hn, withFallbackLoggerTarget as ht, inspectInputRoots as i, RULESYNC_CHECKS_RELATIVE_DIR_PATH as in, resolveEffectiveInputRoots as it, groupSpellingsByCaseFoldedIdentity as j, ALL_FEATURES_WITH_WILDCARD as jn, isFileNotFoundError as jt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as k, parseCommaSeparatedList as kn, getFileSize as kt, SubagentsProcessor as l, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ln, findControlCharacter as lt, McpProcessor as m, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as mn, warnOnConflictingFlags as mt, formatSourceLoadFailure as n, RULESYNC_AIIGNORE_FILE_NAME as nn, ConfigResolver as nt, convertFromTool as o, RULESYNC_CONFIG_RELATIVE_FILE_PATH as on, ConfigFileSchema as ot, shortenToWidth as p, RULESYNC_IGNORE_RELATIVE_FILE_PATH as pn, fallbackLogger as pt, parseJsonc as q, toPosixPath as qt, generate as r, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as rn, mergeInputRootConfigs as rt, isPackagingToolTarget as s, RULESYNC_CONFIG_SCHEMA_URL as sn, GITIGNORE_DESTINATION_KEY as st, importFromTool as t, MAX_FILE_SIZE as tn, SKILL_FILE_NAME as tt, SkillsProcessor as u, RULESYNC_HOOKS_FILE_NAME as un, ConsoleLogger as ut, QWENCODE_DIR as v, RULESYNC_MCP_SCHEMA_URL as vn, CLIError as vt, CLAUDECODE_LOCAL_RULE_FILE_NAME as w, RULESYNC_RELATIVE_DIR_PATH as wn, checkPathTraversal as wt, CODEXCLI_BASH_RULES_FILE_NAME as x, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as xn, assertDirectoryIfExists as xt, QWENCODE_LOCAL_RULE_FILE_NAME as y, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as yn, ErrorCodes as yt, RulesyncRule as z, stripHiddenCharacters as zn, readFileContentOrNull as zt };
 
-//# sourceMappingURL=import-1-jjDDAm.js.map
+//# sourceMappingURL=import-5_n-Y8N6.js.map