rulesync 34.0.0 → 35.0.0

package/dist/{import-Bx0zNGBx.cjs → import-D11JFP84.cjs}

@@ -457,36 +457,36 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$418 } = node_path.posix;
+const { join: join$420 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
 const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$418(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$420(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$418(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$418(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$420(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$420(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$420(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -605,6 +605,7 @@ const ignoreProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"tabnine",
+	"trae",
 	"devin",
 	"vibe",
 	"warp",
@@ -714,6 +715,7 @@ const commandsProcessorToolTargetTuple = [
 	"rovodev",
 	"tabnine",
 	"takt",
+	"trae",
 	"devin",
 	"warp",
 	"zcode",
@@ -1405,20 +1407,22 @@ async function fileExists(filepath) {
 		return false;
 	}
 }
-async function getFileSize(filepath) {
+/**
+* The size of a file and whether it carries any execute bit, read with a single
+* `stat`. Windows reports no execute bits, so a file there is never seen as
+* executable.
+*/
+async function getFileSizeAndExecutableBit(filepath) {
 	try {
-		return (await (0, node_fs_promises.stat)(filepath)).size;
+		const stats = await (0, node_fs_promises.stat)(filepath);
+		return {
+			size: stats.size,
+			executable: (stats.mode & 73) !== 0
+		};
 	} catch (error) {
-		throw new Error(`Failed to get file size for "${filepath}": ${formatError(error)}`, { cause: error });
+		throw new Error(`Failed to stat "${filepath}": ${formatError(error)}`, { cause: error });
 	}
 }
-/**
-* Whether a file carries any execute bit. Windows reports none, so a file
-* there is never seen as executable.
-*/
-async function hasExecutableBit(filepath) {
-	return ((await (0, node_fs_promises.stat)(filepath)).mode & 73) !== 0;
-}
 async function isSymlink(filepath) {
 	try {
 		return (await (0, node_fs_promises.lstat)(filepath)).isSymbolicLink();
@@ -5289,7 +5293,7 @@ const JUNIE_HOOK_EVENTS = [
 * `PreToolUse`, and on the end reason for `SessionEnd`. Only `type: "command"`
 * hooks are supported.
 * @see https://docs.gitlab.com/user/gitlab_duo_cli/customize/
-* @see https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/blob/main/packages/core/hooks/src/schema.ts
+* @see https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/blob/v9.28.0/packages/core/hooks/src/schema.ts
 */
 const GITLABDUO_HOOK_EVENTS = [
 	"sessionStart",
@@ -5643,6 +5647,7 @@ const CORTEXCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CA
 *
 * @see https://www.codebuddy.ai/docs/cli/hooks
 * @see https://www.codebuddy.ai/docs/cli/plugins-reference
+* @see https://www.npmjs.com/package/@tencent-ai/codebuddy-code/v/2.167.0
 */
 const CODEBUDDY_HOOK_EVENTS = [
 	"sessionStart",
@@ -23618,6 +23623,157 @@ var TaktCommand = class TaktCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/trae-paths.ts
+/**
+* Trae (ByteDance's AI IDE, "TraeCode" in its current docs) keeps project
+* configuration under `.trae/` and user configuration under `~/.trae/`.
+*
+* @see https://docs.trae.ai/ide/rules?_lang=en
+* @see https://docs.trae.ai/ide/skills?_lang=en
+* @see https://docs.trae.ai/ide/add-mcp-servers?_lang=en
+* @see https://docs.trae.ai/ide/slash-commands?_lang=en
+* @see https://docs.trae.ai/ide/ignore-files?_lang=en
+*/
+const TRAE_DIR = ".trae";
+/** Project MCP servers (`mcpServers` object), project scope only. */
+const TRAE_MCP_FILE_NAME = "mcp.json";
+/** Skills: `.trae/skills/<name>/SKILL.md` (project) and `~/.trae/skills/` (global). */
+const TRAE_SKILLS_DIR_PATH = (0, node_path.join)(TRAE_DIR, "skills");
+/**
+* Custom commands: Markdown files under `.trae/commands/` (project, up to three nested
+* directory levels) and `~/.trae/commands/` (global).
+*/
+const TRAE_COMMANDS_DIR_PATH = (0, node_path.join)(TRAE_DIR, "commands");
+/** Indexing ignore list (gitignore syntax), `.trae/.ignore`, project scope only. */
+const TRAE_IGNORE_FILE_NAME = ".ignore";
+//#endregion
+//#region src/features/commands/trae-command.ts
+const TraeCommandFrontmatterSchema = zod_mini.z.looseObject({
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	name: zod_mini.z.optional(zod_mini.z.string())
+});
+/**
+* Custom command for Trae.
+*
+* Trae reads Markdown command files under `.trae/commands/` (project, up to
+* three levels of nested directories) and `~/.trae/commands/` (global). The
+* YAML frontmatter carries `name` and `description`, and the body below the
+* closing `---` holds the instructions. rulesync writes the rulesync
+* `description`, a `name` equal to the file name stem (as Trae's editor does),
+* plus any fields of the `trae` section (which win over the derived ones), and
+* keeps nested command paths.
+*
+* @see https://docs.trae.ai/ide/slash-commands?_lang=en
+*/
+var TraeCommand = class TraeCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = TraeCommandFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: TRAE_COMMANDS_DIR_PATH };
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	toRulesyncCommand() {
+		const { description, name, ...otherFields } = this.frontmatter;
+		const restFields = name === void 0 || name === (0, node_path.basename)(this.relativeFilePath, ".md") ? otherFields : {
+			name,
+			...otherFields
+		};
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description,
+			...Object.keys(restFields).length > 0 && { trae: restFields }
+		};
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: stringifyFrontmatter(this.body, rulesyncFrontmatter),
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const traeFrontmatter = {
+			name: (0, node_path.basename)(rulesyncCommand.getRelativeFilePath(), ".md"),
+			description: rulesyncFrontmatter.description,
+			...rulesyncFrontmatter.trae
+		};
+		return new TraeCommand({
+			outputRoot,
+			frontmatter: traeFrontmatter,
+			body: rulesyncCommand.getBody(),
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = TraeCommandFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "trae"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = TraeCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new TraeCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new TraeCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/constants/warp-paths.ts
 const WARP_DIR = ".warp";
 const WARP_SKILLS_DIR_PATH = (0, node_path.join)(WARP_DIR, "skills");
@@ -24328,6 +24484,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["trae", {
+		class: TraeCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["devin", {
 		class: DevinCommand,
 		meta: {
@@ -38053,6 +38219,61 @@ var TabnineIgnore = class TabnineIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/ignore/trae-ignore.ts
+/**
+* Trae ignore file implementation.
+*
+* Trae reads `.trae/.ignore` (gitignore syntax) as a supplement to
+* `.gitignore` when it indexes the codebase; ignored files are also left out
+* of `#Workspace` / `#Folder` context. There is no user-level ignore file, so
+* only project scope is supported.
+*
+* @see https://docs.trae.ai/ide/ignore-files?_lang=en
+*/
+var TraeIgnore = class TraeIgnore extends ToolIgnore {
+	static getSettablePaths(_params = {}) {
+		return {
+			relativeDirPath: TRAE_DIR,
+			relativeFilePath: TRAE_IGNORE_FILE_NAME
+		};
+	}
+	toRulesyncIgnore() {
+		return this.toRulesyncIgnoreDefault();
+	}
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		return new TraeIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent(),
+			global
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const { relativeDirPath, relativeFilePath } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
+		return new TraeIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new TraeIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/vibe-ignore.ts
 var VibeIgnore = class VibeIgnore extends ToolIgnore {
 	static getSettablePaths() {
@@ -38281,6 +38502,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["zoocode", { class: RooIgnore }],
 	["devin", { class: DevinIgnore }],
 	["tabnine", { class: TabnineIgnore }],
+	["trae", { class: TraeIgnore }],
 	["vibe", { class: VibeIgnore }],
 	["warp", { class: WarpIgnore }],
 	["zed", { class: ZedIgnore }]
@@ -43633,12 +43855,14 @@ function toGitlabduoTimeout({ serverName, server, logger }) {
 /**
 * Read GitLab Duo's `timeoutMs` back into the canonical `timeout`
 * (milliseconds). A server that already carries a `timeout` is left as is, so
-* both keys round-trip and `timeoutMs` keeps winning on the next generate.
+* both keys round-trip and `timeoutMs` keeps winning on the next generate. A
+* non-number `timeoutMs` is not copied, since the canonical `timeout` must be a
+* number; it is kept verbatim as a passthrough key instead.
 */
 function fromGitlabduoTimeout(server) {
 	if (typeof server !== "object" || server === null || Array.isArray(server)) return server;
 	const { timeoutMs, ...rest } = server;
-	if (timeoutMs === void 0 || rest.timeout !== void 0) return server;
+	if (typeof timeoutMs !== "number" || rest.timeout !== void 0) return server;
 	return {
 		...rest,
 		timeout: timeoutMs
@@ -47111,8 +47335,8 @@ function convertFromPiFormat(mcpServers) {
 * existing file (`autoEnableCodemode`, ...) are preserved. Pi expands `${VAR}`
 * in `env` and `headers` values itself, so those are written unchanged.
 *
-* @see https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/mcp.md
-* @see https://github.com/earendil-works/pi/blob/main/packages/coding-agent/src/core/mcp-servers.ts
+* @see https://github.com/earendil-works/pi/blob/v1.1.0/packages/coding-agent/docs/mcp.md
+* @see https://github.com/earendil-works/pi/blob/v1.1.0/packages/coding-agent/src/core/mcp-servers.ts
 */
 var PiMcp = class PiMcp extends ToolMcp {
 	json;
@@ -49226,21 +49450,6 @@ function deriveTransportAllowlist(servers) {
 	return allowlist;
 }
 //#endregion
-//#region src/constants/trae-paths.ts
-/**
-* Trae (ByteDance's AI IDE, "TraeCode" in its current docs) keeps project
-* configuration under `.trae/` and user configuration under `~/.trae/`.
-*
-* @see https://docs.trae.ai/ide/rules?_lang=en
-* @see https://docs.trae.ai/ide/skills?_lang=en
-* @see https://docs.trae.ai/ide/add-mcp-servers?_lang=en
-*/
-const TRAE_DIR = ".trae";
-/** Project MCP servers (`mcpServers` object), project scope only. */
-const TRAE_MCP_FILE_NAME = "mcp.json";
-/** Skills: `.trae/skills/<name>/SKILL.md` (project) and `~/.trae/skills/` (global). */
-const TRAE_SKILLS_DIR_PATH = (0, node_path.join)(TRAE_DIR, "skills");
-//#endregion
 //#region src/features/mcp/trae-mcp.ts
 /** A `${...}` reference Trae does not expand: anything but `${workspaceFolder}`. */
 const UNEXPANDED_VARIABLE_REGEX = /\$\{(?!workspaceFolder\})[^}]+\}/;
@@ -51850,6 +52059,11 @@ function parsedGlobsIntersect(left, right, budget) {
 * @see https://antigravity.google/docs/permissions?tab=cli
 */
 const REGEX_PREFIX = "regex:";
+/**
+* The Antigravity actions whose target is a command: `command`, and
+* `unsandboxed`, which takes the same word-by-word prefix or `regex:` target.
+*/
+const ANTIGRAVITY_COMMAND_ACTIONS = /* @__PURE__ */ new Set(["command", "unsandboxed"]);
 const TRAILING_ANCHOR = /(?<!\\)\$$/;
 const PLAIN_TARGET_GLOB_CHARACTERS = /[*?[{\\]/;
 const REGEX_METACHARACTERS$1 = /[\\^$.|?*+()[\]{}]/;
@@ -52227,8 +52441,8 @@ function toAntigravityCommandLiteralPrefix(pattern) {
 }
 /**
 * Read one regex word back as a glob, or `undefined` when it uses anything a
-* glob cannot say. Antigravity anchors each word anyway, so `^` and `$` are
-* optional. Only escaped characters and `.*` translate; anything else keeps
+* glob cannot say. Antigravity anchors each word anyway (`^(?:pattern)$`), so
+* `^` and `$` are optional. Only escaped characters and `.*` translate; anything else keeps
 * the rule a regex.
 */
 function regexWordToGlob(word) {
@@ -52254,8 +52468,10 @@ function regexWordToGlob(word) {
 }
 /** Read a per-word regex back as a glob, or `undefined` when it has no glob spelling. */
 function regexToGlob(source) {
+	const words = splitWords(source);
+	if (words.length === 0) return;
 	const globs = [];
-	for (const word of splitWords(source)) {
+	for (const word of words) {
 		const glob = regexWordToGlob(word);
 		if (glob === void 0) return;
 		globs.push(glob);
@@ -52280,36 +52496,23 @@ function fromAntigravityCommandTarget(target) {
 	return `${target} *`;
 }
 /**
-* Whether a regex word means the same anchored or not: each end is either
-* anchored (`^`, an unescaped `$`) or open-ended (`.*`).
-*/
-function isAnchoredWord(word) {
-	const startAnchored = word.startsWith("^") || word.startsWith(".*");
-	const endAnchored = TRAILING_ANCHOR.test(word) || word.endsWith(".*");
-	return startAnchored && endAnchored;
-}
-/**
 * Explain what importing an Antigravity `command` target may lose, or return
 * `undefined` when the import is faithful.
 *
-* - A `regex:` target with a word that is not anchored is imported as a glob
-*   that assumes anchoring. If Antigravity matches such a word unanchored,
-*   the imported rule is narrower (`regex:rm` also matches `rmdir`).
-* - A plain target holding characters that are special in a glob is most
-*   likely the verbatim output of an older rulesync (`command(rm -rf *)`).
-*   Antigravity matches it literally, so it imports as a regex that matches a
-*   literal `*` word and is inert in the other tools it is exported to.
+* A plain target holding characters that are special in a glob is most
+* likely the verbatim output of an older rulesync (`command(rm -rf *)`).
+* Antigravity matches it literally, so it imports as a regex that matches a
+* literal `*` word and is inert in the other tools it is exported to.
+*
+* A `regex:` word without `^...$` (`regex:rm`) is read as anchored, which is
+* faithful: Antigravity documents that each token is evaluated as the
+* anchored regex `^(?:pattern)$`.
+*
+* @see https://antigravity.google/docs/permissions
 */
 function describeAntigravityCommandImportLoss(target) {
-	if (target.startsWith(REGEX_PREFIX)) {
-		const source = target.slice(6);
-		if (splitWords(source).some((word) => !isAnchoredWord(word)) && regexToGlob(source) !== void 0) return {
-			reason: "it has a regex word without `^...$` anchors and is imported as a glob that assumes Antigravity anchors every word, so the imported rule may be narrower than the original",
-			denyConsequence: "The imported deny may block less than it does in Antigravity."
-		};
-		return;
-	}
-	if (target !== "*" && PLAIN_TARGET_GLOB_CHARACTERS.test(target)) return {
+	if (target.startsWith(REGEX_PREFIX) || target === "*") return;
+	if (PLAIN_TARGET_GLOB_CHARACTERS.test(target)) return {
 		reason: "it holds characters that are special in a glob (`*`, `?`, `[`, `{` or `\\`), which Antigravity matches literally (likely output of an older rulesync), so it is imported as a literal-match regex that no other tool enforces",
 		denyConsequence: "This deny is NOT enforced by the other tools it is generated for."
 	};
@@ -52341,17 +52544,20 @@ function importAntigravityCommandTarget({ target, entry, decision, logger, toolL
 *   every file.
 * - `read_url` takes a domain and covers its subdomains. The URL path is
 *   ignored, and `*` covers every domain.
-* - `command` takes literal words or a per-word `regex:`, matched word by
-*   word (see `antigravity-command-patterns.ts`).
+* - `execute_url` takes a domain, like `read_url`.
+* - `command` and `unsandboxed` take literal words or a per-word `regex:`,
+*   matched word by word (see `antigravity-command-patterns.ts`).
 *
 * A glob copied verbatim (`read_file(**\/*.env)`) is a literal path that
 * matches nothing, so a deny written that way blocks nothing. A pattern with
-* no Antigravity spelling is skipped with a warning instead, except a command
-* deny with leading literal words, which is widened to them.
+* no Antigravity spelling is skipped with a warning instead, except a deny
+* with a literal lead (the first words of a command, the leading directories
+* of a path), which is widened to it.
 *
 * @see https://antigravity.google/docs/permissions?tab=cli
 */
 const PATH_ACTIONS = /* @__PURE__ */ new Set(["read_file", "write_file"]);
+const URL_ACTIONS = /* @__PURE__ */ new Set(["read_url", "execute_url"]);
 const MATCH_ALL_PATH_GLOBS = /* @__PURE__ */ new Set([
 	"*",
 	"**",
@@ -52363,7 +52569,8 @@ const HOSTNAME = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/;
 const DENY_HINTS = {
 	read_file: "deny a directory or file path instead",
 	write_file: "deny a directory or file path instead",
-	command: "deny the first words of the command instead"
+	command: "deny the first words of the command instead",
+	unsandboxed: "deny the first words of the command instead"
 };
 function hasGlob(pattern) {
 	return BRACE_ALTERNATIVES.test(pattern) || parseGlobPattern(pattern).steps.some((step) => step.kind !== "literal");
@@ -52414,37 +52621,88 @@ function toUrlTarget(pattern) {
 	};
 }
 function toTarget(action, pattern) {
-	if (action === "command") return toAntigravityCommandTarget(pattern);
+	if (ANTIGRAVITY_COMMAND_ACTIONS.has(action)) return toAntigravityCommandTarget(pattern);
 	if (PATH_ACTIONS.has(action)) return toPathTarget(pattern);
-	if (action === "read_url") return toUrlTarget(pattern);
+	if (URL_ACTIONS.has(action)) return toUrlTarget(pattern);
 	return { target: pattern };
 }
 /**
+* The leading directories of a path glob (`src` for `src/*.ts`), or
+* `undefined` when it has none. A directory target covers everything inside
+* it, so it matches at least as much as the glob. The filesystem root alone
+* (`/*`) is not a lead: a deny of it would block every file. Neither is a lead
+* with `..` in it.
+*/
+function toPathLiteralPrefix(pattern) {
+	const path = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+	const prefix = [];
+	for (const segment of path.split("/").slice(0, -1)) {
+		if (hasGlob(segment) || segment.includes("{") || segment.includes("}")) break;
+		prefix.push(segment);
+	}
+	if (prefix.includes("..") || prefix.every((segment) => segment === "" || segment === ".")) return;
+	return prefix.join("/");
+}
+/** The widened target of a deny that has no exact Antigravity spelling. */
+function toWidenedDenyTarget(action, pattern) {
+	if (ANTIGRAVITY_COMMAND_ACTIONS.has(action)) return toAntigravityCommandLiteralPrefix(pattern);
+	if (PATH_ACTIONS.has(action)) return toPathLiteralPrefix(pattern);
+}
+/**
+* Warn about a path target that is a home or variable reference. Antigravity
+* documents absolute and workspace-relative paths only, so such a reference
+* may be matched literally and never apply. The entry is still written, since
+* dropping a deny would lose it where Antigravity does expand the reference.
+*/
+function warnHomeOrVariablePath({ action, target, rule, decision, logger, toolLabel }) {
+	if (!PATH_ACTIONS.has(action) || !HOME_OR_VARIABLE_PATH.test(target)) return;
+	const consequence = decision === "deny" ? "this deny may block nothing" : decision === "ask" ? `${toolLabel} may fall back to its default, so it may run without a prompt when ${toolLabel} is set to always proceed` : `${toolLabel} may fall back to its default`;
+	logger.warn(`${toolLabel} permissions: ${rule}: \`~\` and environment variables may not be expanded in Antigravity path targets, so ${action}(${target}) may match nothing and ${consequence}; use an absolute path instead.`);
+}
+/**
 * Build the entry for one canonical rule, or return `undefined` when
-* Antigravity cannot express it. A command deny is widened to its leading
-* literal words rather than skipped: Antigravity applies deny over ask and
-* allow, so an overlapping allow that is translated (`git push *`) cannot let
-* through what the deny (`git push * --force`) was meant to block. A skipped
-* deny is warned about loudly, because nothing enforces it.
+* Antigravity cannot express it. A deny is widened to its literal lead rather
+* than skipped (`git push * --force` → `command(git push)`, `src/*.ts` →
+* `read_file(src)`): Antigravity applies deny over ask and allow, so an
+* overlapping allow that is translated (`git push *`) cannot let through what
+* the deny was meant to block. A skipped deny is warned about loudly, because
+* nothing enforces it, and a widened one is warned about too, because it
+* blocks more than it says.
 */
 function buildAntigravityPermissionEntry({ action, category, pattern, decision, logger, toolLabel }) {
 	const result = pattern === "*" ? { target: "*" } : toTarget(action, pattern);
 	const rule = `${category}: { "${pattern}": "${decision}" }`;
 	if ("skipReason" in result) {
-		const prefix = action === "command" && decision === "deny" ? toAntigravityCommandLiteralPrefix(pattern) : void 0;
+		const prefix = decision === "deny" ? toWidenedDenyTarget(action, pattern) : void 0;
 		if (prefix !== void 0) {
-			logger.warn(`${toolLabel} permissions: widening ${rule} to ${action}(${prefix}). ${result.skipReason}. The deny now blocks every command that starts with \`${prefix}\`, overriding any allow or ask for them.`);
+			const scope = PATH_ACTIONS.has(action) ? `every path under \`${prefix}\`` : `every command that starts with \`${prefix}\``;
+			logger.warn(`${toolLabel} permissions: widening ${rule} to ${action}(${prefix}). ${result.skipReason}. The deny now blocks ${scope}, overriding any allow or ask for them.`);
+			warnHomeOrVariablePath({
+				action,
+				target: prefix,
+				rule,
+				decision,
+				logger,
+				toolLabel
+			});
 			return `${action}(${prefix})`;
 		}
 		const consequence = decision === "deny" ? `This deny is NOT enforced in ${toolLabel}; ${DENY_HINTS[action] ?? "write it in a form Antigravity can match"}` : decision === "ask" ? `${toolLabel} falls back to its default for it, so it runs without a prompt when ${toolLabel} is set to always proceed` : `${toolLabel} falls back to its default for it`;
 		logger.warn(`${toolLabel} permissions: skipping ${rule}. ${result.skipReason}. ${consequence}.`);
 		return;
 	}
-	if (result.note !== void 0 && decision !== "deny") logger.warn(`${toolLabel} permissions: ${rule}: ${result.note}.`);
-	if (PATH_ACTIONS.has(action) && HOME_OR_VARIABLE_PATH.test(result.target)) {
-		const consequence = decision === "deny" ? "this deny may block nothing" : `${toolLabel} may fall back to its default`;
-		logger.warn(`${toolLabel} permissions: ${rule}: \`~\` and environment variables may not be expanded in Antigravity path targets, so ${action}(${result.target}) may match nothing and ${consequence}; use an absolute path instead.`);
+	if (result.note !== void 0 && (decision !== "deny" || URL_ACTIONS.has(action))) {
+		const consequence = decision === "deny" ? ", so the deny also overrides any allow or ask there" : "";
+		logger.warn(`${toolLabel} permissions: ${rule}: ${result.note}${consequence}.`);
 	}
+	warnHomeOrVariablePath({
+		action,
+		target: result.target,
+		rule,
+		decision,
+		logger,
+		toolLabel
+	});
 	return result.target === "*" ? action : `${action}(${result.target})`;
 }
 //#endregion
@@ -52778,7 +53036,8 @@ function pickDocumentedValue({ key, value, documented }) {
 * Deliberate mapping from rulesync canonical permission categories to the
 * Antigravity CLI Fine-Grained Permissions Engine action vocabulary
 * (`read_file`, `write_file`, `read_url`, `command`, `mcp`, plus `execute_url` /
-* `unsandboxed` which have no canonical equivalent and pass through). `edit` and
+* `unsandboxed` which have no canonical equivalent and keep their names; their
+* targets are translated like `read_url` / `command` ones). `edit` and
 * `write` both map to `write_file`, and `webfetch` / `websearch` both map to
 * `read_url`; on import those collapse to the canonical `write` / `webfetch`
 * form (a documented, lossy normalization). This shares the action vocabulary of
@@ -53025,7 +53284,7 @@ function convertAntigravityCliToRulesyncPermissions(params) {
 		for (const entry of entries) {
 			const { toolName, pattern: target } = parsePermissionEntry$1(entry);
 			const canonical = toCanonicalToolName$9(toolName);
-			const pattern = toolName === "command" ? importAntigravityCommandTarget({
+			const pattern = ANTIGRAVITY_COMMAND_ACTIONS.has(toolName) ? importAntigravityCommandTarget({
 				target,
 				entry,
 				decision: action,
@@ -53047,7 +53306,8 @@ function convertAntigravityCliToRulesyncPermissions(params) {
 * Deliberate mapping from rulesync canonical permission categories to the
 * Antigravity IDE action vocabulary (`read_file`, `write_file`, `read_url`,
 * `command`, `mcp`, plus `execute_url` / `unsandboxed` which have no canonical
-* equivalent and pass through). `edit` and `write` both map to `write_file`, and
+* equivalent and keep their names; their targets are translated like
+* `read_url` / `command` ones). `edit` and `write` both map to `write_file`, and
 * `webfetch` / `websearch` both map to `read_url`; on import those collapse to
 * the canonical `write` / `webfetch` form (a documented, lossy normalization).
 */
@@ -53249,7 +53509,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 		for (const entry of entries) {
 			const { action: ideAction, pattern: target } = parsePermissionEntry(entry);
 			const canonical = toCanonicalCategory$2(ideAction);
-			const pattern = ideAction === "command" ? importAntigravityCommandTarget({
+			const pattern = ANTIGRAVITY_COMMAND_ACTIONS.has(ideAction) ? importAntigravityCommandTarget({
 				target,
 				entry,
 				decision: action,
@@ -72526,6 +72786,335 @@ var PermissionsProcessor = class extends FeatureProcessor {
 	}
 };
 //#endregion
+//#region src/types/tool-display.ts
+const TOOL_DISPLAY = [
+	{
+		key: "agentsmd",
+		label: "AGENTS.md",
+		group: "standard"
+	},
+	{
+		key: "agentsskills",
+		label: "AgentsSkills",
+		group: "standard"
+	},
+	{
+		key: "amp",
+		label: "Amp",
+		group: "ai"
+	},
+	{
+		key: "bob",
+		label: "IBM Bob",
+		group: "ai"
+	},
+	{
+		key: "claudecode",
+		label: "Claude Code",
+		group: "ai"
+	},
+	{
+		key: "claudecode-plugin",
+		label: "Claude Code plugin",
+		group: "ai"
+	},
+	{
+		key: "codebuddy",
+		label: "CodeBuddy Code",
+		group: "ai"
+	},
+	{
+		key: "codewhale",
+		label: "Codewhale",
+		group: "ai"
+	},
+	{
+		key: "codexcli",
+		label: "Codex CLI",
+		group: "ai"
+	},
+	{
+		key: "commandcode",
+		label: "Command Code",
+		group: "ai"
+	},
+	{
+		key: "copilot",
+		label: "GitHub Copilot",
+		group: "ai"
+	},
+	{
+		key: "copilotcli",
+		label: "GitHub Copilot CLI",
+		group: "ai"
+	},
+	{
+		key: "crush",
+		label: "Crush",
+		group: "ai"
+	},
+	{
+		key: "goose",
+		label: "Goose",
+		group: "ai"
+	},
+	{
+		key: "hermesagent",
+		label: "Hermes Agent",
+		group: "ai"
+	},
+	{
+		key: "grokcli",
+		label: "Grok CLI",
+		group: "ai"
+	},
+	{
+		key: "cursor",
+		label: "Cursor",
+		group: "ai"
+	},
+	{
+		key: "deepagents",
+		label: "deepagents-cli",
+		group: "ai"
+	},
+	{
+		key: "factorydroid",
+		label: "Factory Droid",
+		group: "ai"
+	},
+	{
+		key: "opencode",
+		label: "OpenCode",
+		group: "ai"
+	},
+	{
+		key: "openclaw",
+		label: "OpenClaw",
+		group: "ai"
+	},
+	{
+		key: "mimocode",
+		label: "MiMo Code",
+		group: "ai"
+	},
+	{
+		key: "gitlabduo",
+		label: "GitLab Duo CLI",
+		group: "ai"
+	},
+	{
+		key: "cline",
+		label: "Cline",
+		group: "ai"
+	},
+	{
+		key: "kilo",
+		label: "Kilo Code",
+		group: "ai"
+	},
+	{
+		key: "kimi-code",
+		label: "Kimi Code",
+		group: "ai"
+	},
+	{
+		key: "kimi-code-plugin",
+		label: "Kimi Code plugin",
+		group: "ai"
+	},
+	{
+		key: "roo",
+		label: "Roo Code ⚠️",
+		group: "ai"
+	},
+	{
+		key: "zoocode",
+		label: "Zoo Code",
+		group: "ai"
+	},
+	{
+		key: "rovodev",
+		label: "Rovodev (Atlassian) ⚠️",
+		group: "ai"
+	},
+	{
+		key: "takt",
+		label: "Takt",
+		group: "ai"
+	},
+	{
+		key: "trae",
+		label: "Trae",
+		group: "ai"
+	},
+	{
+		key: "tabnine",
+		label: "Tabnine CLI ⚠️",
+		group: "ai"
+	},
+	{
+		key: "continue",
+		label: "Continue ⚠️",
+		group: "ai"
+	},
+	{
+		key: "cortexcode",
+		label: "Snowflake Cortex Code",
+		group: "ai"
+	},
+	{
+		key: "vibe",
+		label: "Vibe Code",
+		group: "ai"
+	},
+	{
+		key: "vibe-plugin",
+		label: "Vibe Code plugin",
+		group: "ai"
+	},
+	{
+		key: "qoder",
+		label: "Qoder",
+		group: "ai"
+	},
+	{
+		key: "qwencode",
+		label: "Qwen Code",
+		group: "ai"
+	},
+	{
+		key: "musecode",
+		label: "Meta Muse Code",
+		group: "ai"
+	},
+	{
+		key: "reasonix",
+		label: "Reasonix",
+		group: "ai"
+	},
+	{
+		key: "codebuff",
+		label: "Codebuff (Freebuff)",
+		group: "ai"
+	},
+	{
+		key: "kiro",
+		label: "Kiro ⚠️",
+		group: "ai"
+	},
+	{
+		key: "kiro-cli",
+		label: "Kiro CLI",
+		group: "ai"
+	},
+	{
+		key: "kiro-ide",
+		label: "Kiro IDE",
+		group: "ai"
+	},
+	{
+		key: "lettacode",
+		label: "Letta Code",
+		group: "ai"
+	},
+	{
+		key: "antigravity-ide",
+		label: "Google Antigravity IDE",
+		group: "ai"
+	},
+	{
+		key: "antigravity-cli",
+		label: "Google Antigravity CLI",
+		group: "ai"
+	},
+	{
+		key: "antigravity-plugin",
+		label: "Google Antigravity plugin",
+		group: "ai"
+	},
+	{
+		key: "aiassistant",
+		label: "JetBrains AI Assistant",
+		group: "ai"
+	},
+	{
+		key: "junie",
+		label: "JetBrains Junie",
+		group: "ai"
+	},
+	{
+		key: "augmentcode",
+		label: "AugmentCode",
+		group: "ai"
+	},
+	{
+		key: "augmentcode-plugin",
+		label: "AugmentCode plugin",
+		group: "ai"
+	},
+	{
+		key: "devin",
+		label: "Devin Desktop",
+		group: "ai"
+	},
+	{
+		key: "devin-plugin",
+		label: "Devin plugin",
+		group: "ai"
+	},
+	{
+		key: "warp",
+		label: "Warp",
+		group: "ai"
+	},
+	{
+		key: "warpcli",
+		label: "Warp Agent CLI",
+		group: "ai"
+	},
+	{
+		key: "replit",
+		label: "Replit",
+		group: "ai"
+	},
+	{
+		key: "pi",
+		label: "Pi Coding Agent",
+		group: "ai"
+	},
+	{
+		key: "omp",
+		label: "oh-my-pi",
+		group: "ai"
+	},
+	{
+		key: "zed",
+		label: "Zed",
+		group: "ai"
+	},
+	{
+		key: "zcode",
+		label: "ZCode (Z.ai)",
+		group: "ai"
+	},
+	{
+		key: "zcode-plugin",
+		label: "ZCode plugin",
+		group: "ai"
+	},
+	{
+		key: "pool",
+		label: "Pool (Poolside)",
+		group: "ai"
+	},
+	{
+		key: "dsh",
+		label: "DeepSeek Harness",
+		group: "ai"
+	}
+];
+//#endregion
 //#region src/features/skills/simulated-skill.ts
 const SimulatedSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -84871,7 +85460,7 @@ var DeepagentsSubagent = class DeepagentsSubagent extends ToolSubagent {
 //#endregion
 //#region src/features/subagents/devin-subagent.ts
 const DevinSubagentFrontmatterSchema = zod_mini.z.looseObject({
-	name: zod_mini.z.string(),
+	name: zod_mini.z.optional(zod_mini.z.string()),
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	model: zod_mini.z.optional(zod_mini.z.string()),
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
@@ -84924,7 +85513,7 @@ var DevinSubagent = class extends ToolSubagent {
 			outputRoot: ".",
 			frontmatter: {
 				targets: ["*"],
-				name,
+				name: name ?? this.getSubagentName(),
 				description,
 				...Object.keys(devinSection).length > 0 && { devin: devinSection }
 			},
@@ -84998,7 +85587,8 @@ var DevinSubagent = class extends ToolSubagent {
 		const paths = this.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
 		const fileContent = await readFileContent(filePath);
-		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const { frontmatter, body: content, hasFrontmatter } = parseFrontmatter(fileContent, filePath);
+		if (!hasFrontmatter) throw new Error(`Missing frontmatter in ${filePath}`);
 		const result = DevinSubagentFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
 		return new this({
@@ -98646,6 +99236,7 @@ var RulesProcessor = class extends FeatureProcessor {
 	warnForOutputStyleRuleOptions({ rules, factory }) {
 		const toolTarget = this.toolTarget;
 		if (toolTarget !== "factorydroid" && toolTarget !== "qoder") return;
+		const toolLabel = TOOL_DISPLAY.find((entry) => entry.key === toolTarget)?.label ?? toolTarget;
 		for (const rule of rules) {
 			const frontmatter = rule.getFrontmatter();
 			const section = frontmatter[toolTarget];
@@ -98653,7 +99244,7 @@ var RulesProcessor = class extends FeatureProcessor {
 			const { channel, name } = section;
 			const fileName = stripControlCharacters(rule.getRelativeFilePath());
 			const targets = frontmatter.targets ?? ["*"];
-			if (channel === "output-style" && targets.some((target) => target !== toolTarget)) this.logger.warn(`${fileName} sets ${toolTarget}.channel: output-style but also targets other tools, which receive it as an ordinary rule. Set \`targets: ["${toolTarget}"]\` to keep the output style to ${toolTarget === "qoder" ? "Qoder" : "Factory Droid"}.`);
+			if (channel === "output-style" && targets.some((target) => target !== toolTarget)) this.logger.warn(`${fileName} sets ${toolTarget}.channel: output-style but also targets other tools, which receive it as an ordinary rule. Set \`targets: ["${toolTarget}"]\` to keep the output style to ${toolLabel}.`);
 			if (channel !== "output-style" && name !== void 0) this.logger.warn(`${fileName} sets ${toolTarget}.name, which is read only with ${toolTarget}.channel: output-style; ignoring it.`);
 		}
 	}
@@ -103053,10 +103644,10 @@ Object.defineProperty(exports, "generate", {
 		return generate;
 	}
 });
-Object.defineProperty(exports, "getFileSize", {
+Object.defineProperty(exports, "getFileSizeAndExecutableBit", {
 	enumerable: true,
 	get: function() {
-		return getFileSize;
+		return getFileSizeAndExecutableBit;
 	}
 });
 Object.defineProperty(exports, "getHomeDirectory", {
@@ -103101,12 +103692,6 @@ Object.defineProperty(exports, "hasEnclosingMarkOutsideKeycap", {
 		return hasEnclosingMarkOutsideKeycap;
 	}
 });
-Object.defineProperty(exports, "hasExecutableBit", {
-	enumerable: true,
-	get: function() {
-		return hasExecutableBit;
-	}
-});
 Object.defineProperty(exports, "importFromTool", {
 	enumerable: true,
 	get: function() {
@@ -103191,6 +103776,12 @@ Object.defineProperty(exports, "pathEscapesRoot", {
 		return pathEscapesRoot;
 	}
 });
+Object.defineProperty(exports, "posixRelativePathEscapesRoot", {
+	enumerable: true,
+	get: function() {
+		return posixRelativePathEscapesRoot;
+	}
+});
 Object.defineProperty(exports, "quoteForLog", {
 	enumerable: true,
 	get: function() {
@@ -103263,10 +103854,10 @@ Object.defineProperty(exports, "resolveRulesyncSourceWritePath", {
 		return resolveRulesyncSourceWritePath;
 	}
 });
-Object.defineProperty(exports, "resolvedPathEscapesRoot", {
+Object.defineProperty(exports, "resolvedRelativePath", {
 	enumerable: true,
 	get: function() {
-		return resolvedPathEscapesRoot;
+		return resolvedRelativePath;
 	}
 });
 Object.defineProperty(exports, "runWithDirectoryRollback", {