rulesync 16.25.0 → 16.26.0

package/dist/{import-B6p6c3L0.js → import-BlHibyDS.js}

@@ -4705,9 +4705,14 @@ const KIMI_CODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CAN
 * ZCode's configuration-file hooks expose exactly seven PascalCase events, all
 * of which have a clean canonical equivalent: `SessionStart`, `PreToolUse`,
 * `PostToolUse`, `PostToolUseFailure`, `PermissionRequest`, `Stop`, and
-* `UserPromptSubmit` ← `beforeSubmitPrompt`. An optional matcher (a
-* case-sensitive regular expression) is honored on all of them except
-* `UserPromptSubmit` and `Stop`, which expose no value to match against.
+* `UserPromptSubmit` ← `beforeSubmitPrompt`. An optional matcher is honored on
+* all of them except `UserPromptSubmit` and `Stop`, which expose no value to
+* match against. ZCode reads the matcher in one of two ways: a value made up
+* solely of letters, digits, underscores and `|` is an exact name list
+* (`Write|Edit` matches those two tool names, not the regex alternation), and
+* any other character makes the whole value a case-sensitive JavaScript regex.
+* Rulesync passes matchers through verbatim, so an authored value keeps
+* whichever reading ZCode gives it — worth knowing before escaping one.
 * Configuration hooks are read only from the user config
 * `~/.zcode/cli/config.json` (workspace config hooks are never executed) and
 * additionally require `hooks.enabled: true` to run.
@@ -6879,12 +6884,37 @@ const DeepagentsStartupOverrideSchema = z.looseObject({
 	read_project_dotenv: z.optional(z.boolean())
 });
 /**
+* deepagents-cli's Python extension gate under `[extensions]` in
+* `~/.deepagents/config.toml`. `discover_extensions` auto-loads `*.py` from the
+* user's `~/.deepagents/extensions/` and from the checked-out project's
+* `<root>/.deepagents/extensions/`, so these two keys decide whether
+* repository-authored Python is imported into the agent process at all —
+* the same class of knob as `[startup].mode`, and one that ships defaulting to
+* a prompt a user can accept. Loose so a key added upstream passes through
+* verbatim.
+*
+* `extensions.extra_paths` is deliberately absent: it names machine-local files
+* and directories, which do not belong in a committed
+* `.rulesync/permissions.jsonc`, and it only ever widens what loads.
+*
+* @see https://docs.langchain.com/oss/deepagents/code/configuration
+*/
+const DeepagentsExtensionsOverrideSchema = z.looseObject({
+	enabled: z.optional(z.boolean()),
+	trust: z.optional(z.enum([
+		"ask",
+		"always",
+		"never"
+	]))
+});
+/**
 * The `[shell].allow_list` array itself is rulesync-owned, driven by the
 * shared `permission.bash` block, so it has no key here.
 */
 const DeepagentsPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
-	startup: z.optional(DeepagentsStartupOverrideSchema)
+	startup: z.optional(DeepagentsStartupOverrideSchema),
+	extensions: z.optional(DeepagentsExtensionsOverrideSchema)
 });
 /**
 * The actions Junie's allowlist accepts. Verified against the shipped Junie
@@ -7895,8 +7925,9 @@ const RulesyncRuleFrontmatterSchema = z.object({
 	agentsmd: z.optional(z.looseObject({ subprojectPath: z.optional(z.string()) })),
 	claudecode: z.optional(z.looseObject({ paths: z.optional(z.array(z.string())) })),
 	codebuddy: z.optional(z.looseObject({
-		paths: z.optional(z.array(z.string())),
+		paths: z.optional(z.union([z.string(), z.array(z.string())])),
 		alwaysApply: z.optional(z.boolean()),
+		enabled: z.optional(z.boolean()),
 		description: z.optional(z.string())
 	})),
 	cursor: z.optional(z.looseObject({
@@ -9189,6 +9220,11 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		license: z.optional(z.string()),
 		compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
 		metadata: z.optional(z.looseObject({}))
+	})),
+	zcode: z.optional(z.looseObject({
+		when_to_use: z.optional(z.string()),
+		license: z.optional(z.string()),
+		metadata: z.optional(z.looseObject({}))
 	}))
 });
 /**
@@ -17771,6 +17807,20 @@ const ROO_MCP_FILE_NAME = "mcp.json";
 */
 const ROO_MODE_SLUG_PATTERN = /^[a-zA-Z0-9-]+$/;
 /**
+* `~/.roo/rules/AGENTS.md` — where the root rule goes in global scope.
+*
+* Roo/Zoo Code discover the agent-rules files (`AGENTS.md`, `AGENT.md`,
+* `AGENTS.local.md`) in the **workspace only**: `loadAllAgentRulesFiles` reads
+* `cwd`, plus subdirectories holding a `.roo` folder when `enableSubfolderRules`
+* is on. There is no home-directory branch, so a `~/AGENTS.md` is never read.
+* The global rules directory `~/.roo/rules/` *is* loaded, so the root rule is
+* written there alongside the non-root files rather than to an unread path.
+* The basename is kept so the file still reads as the root overview.
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/core/prompts/sections/custom-instructions.ts
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/services/roo-config/index.ts
+*/
+const ROO_GLOBAL_ROOT_RULE_FILE_NAME = "AGENTS.md";
+/**
 * `.roo/rules-{mode}/` — the mode-specific rule directory Roo/Zoo Code load
 * INSTEAD of `.roo/rules/` while that mode is active. The relative path is the
 * same in global scope, where it resolves under `~/.roo/`.
@@ -22830,7 +22880,7 @@ var DevinHooks = class DevinHooks extends ToolHooks {
 * adapter so the settings reader in `src/utils/` can name the same list without
 * importing a feature.
 *
-* @see https://docs.factory.ai/cli/configuration/settings
+* @see https://docs.factory.ai/droid-cli/settings
 */
 const FACTORYDROID_OVERRIDE_KEYS = [
 	"commandBlocklist",
@@ -22838,6 +22888,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"sandbox",
 	"mcpPolicy",
 	"mcpAutonomyOverrides",
+	"mcpAutonomyUrlOverrides",
+	"builtInToolAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
@@ -22845,7 +22897,10 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"interactionMode",
 	"extraKnownMarketplaces",
 	"enabledPlugins",
+	"strictEnabledPlugins",
+	"strictKnownMarketplaces",
 	"hooksDisabled",
+	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
 	"missionPolicy"
@@ -26886,6 +26941,7 @@ var ClineIgnore = class ClineIgnore extends ToolIgnore {
 //#region src/constants/crush-paths.ts
 const CRUSH_RULE_FILE_NAME = "CRUSH.md";
 const CRUSH_GLOBAL_DIR = join(".config", "crush");
+const CRUSH_LOCAL_RULE_FILE_NAME = "CRUSH.local.md";
 const CRUSH_IGNORE_FILE_NAME = ".crushignore";
 const CRUSH_SKILLS_PROJECT_DIR = join(".crush", "skills");
 const CRUSH_SKILLS_GLOBAL_DIR = join(CRUSH_GLOBAL_DIR, "skills");
@@ -33106,9 +33162,16 @@ function lookupTransport(map, key) {
 }
 /**
 * Read the "put this server's own instructions into the agent's prompt" flag
-* off an unfiltered canonical entry, under either spelling. Anything other
-* than a literal `true` reads as not enabled, matching Rovo Dev, where the key
-* is absent by default.
+* off an unfiltered canonical entry, under either spelling. `undefined` means
+* the entry says nothing, which is Rovo Dev's own default.
+*
+* The flag is a **tri-state**, not a switch that only exists when on. Atlassian
+* inverted the default on 2026-09-02: a server's instructions are now surfaced
+* when the key is absent or `true`, and `false` is what suppresses them — the
+* opposite of the opt-in wording this adapter was first written against, where
+* absent and `false` meant the same thing. So `false` has to travel end to end;
+* collapsing it away is what makes a suppression impossible to author, and
+* erases one on import.
 *
 * The canonical key decides whenever it is present, the way codex resolves the
 * same two-spelling conflict for `experimental_environment`. OR-ing the two
@@ -33116,28 +33179,25 @@ function lookupTransport(map, key) {
 * `enable_instructions: true` copied out of Atlassian's docs — fail-open, on
 * the one key whose whole purpose is a trust decision.
 *
+* A non-boolean under either spelling reads as `undefined` rather than as a
+* suppression: Rovo Dev surfaces the instructions for anything that is not
+* `false`, so writing `false` there would invent a restriction the tool is not
+* applying. (The canonical key is a strict boolean in the schema, so only the
+* raw spelling can carry one.)
+*
 * `isPlainObject` rather than `isRecord`: this walks a user-supplied key set,
 * so a `constructor` entry must not resolve up the prototype chain.
 */
 function readEnableInstructions(rawServer) {
-	if (!isPlainObject$1(rawServer)) return false;
-	if (rawServer.rovodevEnableInstructions !== void 0) return rawServer.rovodevEnableInstructions === true;
-	return rawServer.enable_instructions === true;
-}
-/**
-* Names that were emitted with `enable_instructions: true` during one
-* `fromRulesyncMcp` call, so the run can say so once rather than per server.
-* Atlassian gates this key on trust, and it is the only thing generate writes
-* that widens what steers the model — the quietest possible write is the wrong
-* one for it.
-*/
-function warnEnabledInstructions(names, logger) {
-	if (names.length === 0) return;
-	logger?.warn(`Rovo Dev MCP: writing enable_instructions: true for ${names.join(", ")}. Rovo Dev pastes ${names.length === 1 ? "that server's" : "those servers'"} own instructions into the agent's system prompt, so enable it only for servers you trust.`);
+	if (!isPlainObject$1(rawServer)) return;
+	const canonical = rawServer.rovodevEnableInstructions;
+	if (canonical !== void 0) return typeof canonical === "boolean" ? canonical : void 0;
+	const raw = rawServer.enable_instructions;
+	return typeof raw === "boolean" ? raw : void 0;
 }
 function toRovodevServer(name, server, logger) {
 	const { type, transport, disabled: _disabled, rovodevEnableInstructions, ...rest } = server;
-	if (rovodevEnableInstructions === true) rest.enable_instructions = true;
+	if (typeof rovodevEnableInstructions === "boolean") rest.enable_instructions = rovodevEnableInstructions;
 	const declared = typeof transport === "string" ? transport : typeof type === "string" ? type : void 0;
 	if (declared === void 0) return rest;
 	const mapped = lookupTransport(CANONICAL_TO_ROVODEV_TRANSPORT, declared);
@@ -33152,7 +33212,7 @@ function toRovodevServer(name, server, logger) {
 }
 function fromRovodevServer(server) {
 	const { transport, enable_instructions: enableInstructions, ...rest } = server;
-	if (enableInstructions === true) rest.rovodevEnableInstructions = true;
+	if (typeof enableInstructions === "boolean") rest.rovodevEnableInstructions = enableInstructions;
 	if (typeof transport !== "string") return rest;
 	const mapped = lookupTransport(ROVODEV_TO_CANONICAL_TRANSPORT, transport);
 	return mapped === void 0 ? rest : {
@@ -33593,10 +33653,10 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 			canWriteDisableToggle = false;
 		}
 		const mcpServers = Object.fromEntries(Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => {
-			const rawServer = rulesyncMcp.getRawMcpServer(name);
+			const enableInstructions = readEnableInstructions(rulesyncMcp.getRawMcpServer(name));
 			const record = {
 				...server,
-				...readEnableInstructions(rawServer) && { rovodevEnableInstructions: true }
+				...enableInstructions !== void 0 && { rovodevEnableInstructions: enableInstructions }
 			};
 			if (record.disabled === true && !canWriteDisableToggle) {
 				logger?.warn(`Rovo Dev MCP: skipping disabled server "${name}" because config.yml cannot be parsed, so mcp.disabledMcpServers cannot be written to switch it off.`);
@@ -33605,7 +33665,6 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 			const converted = toRovodevServer(name, record, logger);
 			return converted === null ? null : [name, converted];
 		}).filter((entry) => entry !== null));
-		warnEnabledInstructions(Object.entries(mcpServers).filter(([, server]) => server.enable_instructions === true).map(([name]) => name), logger);
 		const rovodevConfig = {
 			...json,
 			mcpServers
@@ -39749,6 +39808,34 @@ const DEEPAGENTS_STARTUP_BOOLEAN_DEFAULTS = {
 	yolo_switcher: true,
 	read_project_dotenv: true
 };
+/**
+* `[extensions]` gates dcode's Python extension system. `discover_extensions`
+* auto-loads `*.py` from the user's `~/.deepagents/extensions/` and from the
+* checked-out project's `<root>/.deepagents/extensions/`, so this table decides
+* whether a cloned repository's Python is imported into the agent process.
+*/
+const EXTENSIONS_TABLE_KEY = "extensions";
+/**
+* Keys lifted back into the override on import. `extensions.extra_paths` is
+* deliberately absent: it names machine-local files and directories, which do
+* not belong in a committed `.rulesync/permissions.jsonc`, and it only ever
+* widens what loads.
+*/
+const DEEPAGENTS_EXTENSIONS_KEYS = ["enabled", "trust"];
+/** `TrustPolicy` in `extensions/settings.py`; dcode reads nothing else. */
+const DEEPAGENTS_EXTENSION_TRUST_POLICIES = [
+	"ask",
+	"always",
+	"never"
+];
+/**
+* `[extensions].enabled` defaults to `true` upstream, so writing `true` on a
+* machine that has not set it changes nothing — the same reasoning as
+* `DEEPAGENTS_STARTUP_BOOLEAN_DEFAULTS`.
+*
+* @see https://github.com/langchain-ai/deepagents `config_manifest.py`
+*/
+const DEEPAGENTS_EXTENSIONS_ENABLED_DEFAULT = true;
 const ALLOW_ALL_SENTINEL = "all";
 const RECOMMENDED_SENTINEL = "recommended";
 const GLOB_CHARACTERS_PATTERN = /[*?[\]]/;
@@ -39818,7 +39905,10 @@ const TRAILING_ARGUMENT_WILDCARD_PATTERN = /:\*$/;
 * `DeepagentsPermissionsOverrideSchema`): `[startup].mode`
 * (`manual` / `auto` / `yolo`), `[startup].yolo_switcher` and
 * `[startup].read_project_dotenv` are merged into the file on generate and
-* lifted back into the override on import.
+* lifted back into the override on import. The same override carries
+* `[extensions].enabled` and `[extensions].trust` (`ask` / `always` / `never`),
+* which decide whether the Python in a checked-out project's
+* `.deepagents/extensions/` is imported into the agent process.
 *
 * On **import** the allowlist comes back as `bash` `allow` rules named by the
 * executable — skipping any entry dcode could not match in the first place, so
@@ -39920,6 +40010,13 @@ var DeepagentsPermissions = class DeepagentsPermissions extends ToolPermissions
 			filePath,
 			logger
 		});
+		const extensionsOverride = config.deepagents?.extensions;
+		if (isPlainObject$1(extensionsOverride) && Object.keys(extensionsOverride).length > 0) mergeExtensionsOverride({
+			settings,
+			extensionsOverride,
+			filePath,
+			logger
+		});
 		return new DeepagentsPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -39944,8 +40041,15 @@ var DeepagentsPermissions = class DeepagentsPermissions extends ToolPermissions
 			startup: isPlainObject$1(settings[STARTUP_TABLE_KEY]) ? settings[STARTUP_TABLE_KEY] : {},
 			selfPath
 		});
+		const extensionsOverride = liftExtensionsOverride({
+			extensions: isPlainObject$1(settings[EXTENSIONS_TABLE_KEY]) ? settings[EXTENSIONS_TABLE_KEY] : {},
+			selfPath
+		});
 		const result = { ...config };
-		if (Object.keys(startupOverride).length > 0) result.deepagents = { startup: startupOverride };
+		const deepagents = {};
+		if (Object.keys(startupOverride).length > 0) deepagents.startup = startupOverride;
+		if (Object.keys(extensionsOverride).length > 0) deepagents.extensions = extensionsOverride;
+		if (Object.keys(deepagents).length > 0) result.deepagents = deepagents;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
 	}
 	validate() {
@@ -40032,57 +40136,192 @@ function warnAboutUnwrittenBashRules({ allowAll, requestedAllowAll, askPatterns,
 	if (willWrite && allowAll) warnWithFallback(logger, "The bash '*' allow rule became allow_list = [\"all\"] for deepagents-cli, which auto-approves every command and skips its dangerous-pattern check (command substitution, redirects, process substitution). List the executables you want instead if that is more than you meant.");
 }
 /**
-* Lift the `[startup]` keys rulesync models back into the `deepagents`
-* override, keeping only values dcode itself accepts.
+* Lift the keys rulesync models from one `config.toml` table back into the
+* `deepagents` override, keeping only values dcode itself accepts.
 *
-* A `mode` outside the three approval modes, or a non-boolean where a switch
-* belongs, is `Invalid` upstream — dcode ignores it and falls back to its
-* default. Importing it anyway would record a setting the tool is not applying
-* and, because the canonical schema is stricter than TOML, would write a
-* `.rulesync/permissions.jsonc` the next `rulesync generate` cannot even read.
+* A value outside what the option's own parser reads is `Invalid` upstream —
+* dcode ignores it and falls back to its default. Importing it anyway would
+* record a setting the tool is not applying and, because the canonical schema
+* is stricter than TOML, would write a `.rulesync/permissions.jsonc` the next
+* `rulesync generate` cannot even read.
+*
+* `normalize` returns the value to keep, or `null` for one dcode would not
+* read — a wrapper rather than the bare value, so a legitimately falsy setting
+* is not mistaken for a rejection.
 */
-function liftStartupOverride({ startup, selfPath }) {
-	const startupOverride = {};
+function liftOverrideTable({ table, tableKey, keys, normalize, selfPath }) {
+	const override = {};
 	const rejected = [];
-	for (const key of DEEPAGENTS_STARTUP_KEYS) {
-		const value = startup[key];
+	for (const key of keys) {
+		const value = table[key];
 		if (value === void 0) continue;
-		if (key === "mode" ? DEEPAGENTS_STARTUP_MODES.includes(value) : typeof value === "boolean") startupOverride[key] = value;
+		const normalized = normalize({
+			key,
+			value
+		});
+		if (normalized) override[key] = normalized.value;
 		else rejected.push(`${key} = ${JSON.stringify(value)}`);
 	}
-	if (rejected.length > 0) warnWithFallback(void 0, `deepagents-cli falls back to its own default for a '[${STARTUP_TABLE_KEY}]' value it cannot read, so ${rejected.join(", ")} in ${selfPath} ${rejected.length === 1 ? "was" : "were"} not imported.`);
-	return startupOverride;
+	if (rejected.length > 0) warnWithFallback(void 0, `deepagents-cli falls back to its own default for a '[${tableKey}]' value it cannot read, so ${rejected.join(", ")} in ${selfPath} ${rejected.length === 1 ? "was" : "were"} not imported.`);
+	return override;
 }
 /**
-* Merge the `deepagents.startup` override into `[startup]`, preserving every
-* other key of that table. A `startup` that is not a table at all is something
-* rulesync did not write and cannot merge into, so it is left exactly as the
-* user has it rather than replaced.
+* Lift the `[startup]` keys rulesync models back into the `deepagents`
+* override. A `mode` outside the three approval modes, or a non-boolean where
+* a switch belongs, is one dcode ignores.
 */
-function mergeStartupOverride({ settings, startupOverride, filePath, logger }) {
-	const existingStartup = settings[STARTUP_TABLE_KEY];
-	if (existingStartup !== void 0 && !isPlainObject$1(existingStartup)) {
-		warnWithFallback(logger, `deepagents-cli: '${STARTUP_TABLE_KEY}' in ${filePath} is not a table, so the deepagents startup override was skipped rather than overwriting it.`);
+function liftStartupOverride({ startup, selfPath }) {
+	return liftOverrideTable({
+		table: startup,
+		tableKey: STARTUP_TABLE_KEY,
+		keys: DEEPAGENTS_STARTUP_KEYS,
+		normalize: ({ key, value }) => {
+			if (key === "mode") return DEEPAGENTS_STARTUP_MODES.includes(value) ? { value } : null;
+			return typeof value === "boolean" ? { value } : null;
+		},
+		selfPath
+	});
+}
+/**
+* Lift the `[extensions]` keys rulesync models back into the `deepagents`
+* override.
+*
+* `trust` is read the way `parse_trust_policy` reads it — trimmed and
+* lowercased — so `"Always"` comes back as the policy dcode is actually
+* applying rather than being dropped, the same courtesy the allowlist
+* sentinels already get. The canonical enum holds only the lowercase
+* spellings, so keeping the value verbatim would write a permissions file the
+* next generate could not parse.
+*/
+function liftExtensionsOverride({ extensions, selfPath }) {
+	return liftOverrideTable({
+		table: extensions,
+		tableKey: EXTENSIONS_TABLE_KEY,
+		keys: DEEPAGENTS_EXTENSIONS_KEYS,
+		normalize: ({ key, value }) => {
+			if (key === "trust") {
+				if (typeof value !== "string") return null;
+				const policy = value.trim().toLowerCase();
+				return DEEPAGENTS_EXTENSION_TRUST_POLICIES.includes(policy) ? { value: policy } : null;
+			}
+			return typeof value === "boolean" ? { value } : null;
+		},
+		selfPath
+	});
+}
+/**
+* Merge one block of the `deepagents` override into its `config.toml` table,
+* preserving every other key of that table. A table that is not a table at all
+* is something rulesync did not write and cannot merge into, so it is left
+* exactly as the user has it rather than replaced.
+*/
+function mergeOverrideTable({ settings, tableKey, override, knownKeys, isDroppedKey, warnAboutRelaxations, filePath, logger }) {
+	const existing = settings[tableKey];
+	if (existing !== void 0 && !isPlainObject$1(existing)) {
+		warnWithFallback(logger, `deepagents-cli: '${tableKey}' in ${filePath} is not a table, so the deepagents ${tableKey} override was skipped rather than overwriting it.`);
 		return;
 	}
-	const startup = isPlainObject$1(existingStartup) ? { ...existingStartup } : {};
-	const previousStartup = { ...startup };
+	const table = isPlainObject$1(existing) ? { ...existing } : {};
+	const previous = { ...table };
 	const writtenKeys = [];
-	for (const [key, value] of Object.entries(startupOverride)) {
+	for (const [key, value] of Object.entries(override)) {
 		if (isPrototypePollutionKey(key)) continue;
-		if (key === STARTUP_RECENT_KEY) continue;
+		if (isDroppedKey?.(key)) continue;
 		if (value === null || value === void 0) continue;
-		startup[key] = value;
+		table[key] = value;
 		writtenKeys.push(key);
 	}
-	warnAboutStartupRelaxations({
-		startupOverride,
-		previousStartup,
+	warnAboutRelaxations({
+		override,
+		previous,
+		filePath,
+		logger
+	});
+	warnAboutUncheckedKeys({
+		tableKey,
+		knownKeys,
 		writtenKeys,
 		filePath,
 		logger
 	});
-	if (Object.keys(startup).length > 0) settings[STARTUP_TABLE_KEY] = startup;
+	if (Object.keys(table).length > 0) settings[tableKey] = table;
+}
+/**
+* Name the keys the merge wrote that rulesync does not model. The override is a
+* loose object so a key added upstream still reaches the config, but this one
+* writes into the machine's global file: what rulesync cannot judge, it at
+* least names.
+*/
+function warnAboutUncheckedKeys({ tableKey, knownKeys, writtenKeys, filePath, logger }) {
+	const known = new Set(knownKeys);
+	const unknownKeys = writtenKeys.filter((key) => !known.has(key));
+	if (unknownKeys.length === 0) return;
+	warnWithFallback(logger, `The deepagents ${tableKey} override wrote ${unknownKeys.join(", ")} into ${filePath} unchecked — rulesync does not know what those keys grant, and that file is your global deepagents-cli config.`);
+}
+/**
+* Merge the `deepagents.startup` override into `[startup]`.
+*/
+function mergeStartupOverride({ settings, startupOverride, filePath, logger }) {
+	mergeOverrideTable({
+		settings,
+		tableKey: STARTUP_TABLE_KEY,
+		override: startupOverride,
+		knownKeys: DEEPAGENTS_STARTUP_KEYS,
+		isDroppedKey: (key) => key === STARTUP_RECENT_KEY,
+		warnAboutRelaxations: warnAboutStartupRelaxations,
+		filePath,
+		logger
+	});
+}
+/**
+* Merge the `deepagents.extensions` override into `[extensions]`. Nothing is
+* dropped here — `extra_paths` is not modeled, but it is a key the user may
+* legitimately want carried, so it passes through as any other unknown key
+* does, named by the unchecked-key warning.
+*/
+function mergeExtensionsOverride({ settings, extensionsOverride, filePath, logger }) {
+	mergeOverrideTable({
+		settings,
+		tableKey: EXTENSIONS_TABLE_KEY,
+		override: extensionsOverride,
+		knownKeys: DEEPAGENTS_EXTENSIONS_KEYS,
+		warnAboutRelaxations: warnAboutExtensionsRelaxations,
+		filePath,
+		logger
+	});
+}
+/**
+* Name the value an override key replaces, so a setting the user had turned
+* down is visible as such rather than reported as a bare new value.
+*/
+function describeOverriddenValue({ key, value, previous }) {
+	const previousValue = previous[key];
+	return previousValue === void 0 || previousValue === value ? `${key} = ${JSON.stringify(value)}` : `${key} = ${JSON.stringify(value)} (was ${JSON.stringify(previousValue)})`;
+}
+/**
+* Warn when the `deepagents` extensions override widens what dcode loads on its
+* own, for the same reason the startup one does: this block is written into the
+* user's **global** config from a `.rulesync/permissions.jsonc` a repository
+* can carry.
+*
+* `trust` decides what happens to the Python in a checked-out project's
+* `.deepagents/extensions/` — `always` imports it into the agent process with
+* no prompt at all — and `enabled` is the switch above it. `never` and `false`
+* restrict, so neither is reported.
+*/
+function warnAboutExtensionsRelaxations({ override, previous, filePath, logger }) {
+	const relaxations = [];
+	if (override.trust === "always") relaxations.push(describeOverriddenValue({
+		key: "trust",
+		value: "always",
+		previous
+	}));
+	if (override.enabled === true && (previous.enabled ?? DEEPAGENTS_EXTENSIONS_ENABLED_DEFAULT) !== true) relaxations.push(describeOverriddenValue({
+		key: "enabled",
+		value: true,
+		previous
+	}));
+	if (relaxations.length > 0) warnWithFallback(logger, `The deepagents extensions override wrote ${relaxations.join(", ")} into ${filePath}, which is your global deepagents-cli config: it decides whether the Python in a checked-out project's .deepagents/extensions/ is imported into dcode, for every project on this machine, not just this one.`);
 }
 /**
 * Warn when the `deepagents` startup override relaxes what dcode may do on its
@@ -40097,12 +40336,13 @@ function mergeStartupOverride({ settings, startupOverride, filePath, logger }) {
 * process environment. The value being replaced is named alongside, so a
 * setting the user had turned down is visible as such.
 */
-function warnAboutStartupRelaxations({ startupOverride, previousStartup, writtenKeys, filePath, logger }) {
+function warnAboutStartupRelaxations({ override: startupOverride, previous: previousStartup, filePath, logger }) {
 	const relaxations = [];
-	const describe = (key, value) => {
-		const previous = previousStartup[key];
-		return previous === void 0 || previous === value ? `${key} = ${JSON.stringify(value)}` : `${key} = ${JSON.stringify(value)} (was ${JSON.stringify(previous)})`;
-	};
+	const describe = (key, value) => describeOverriddenValue({
+		key,
+		value,
+		previous: previousStartup
+	});
 	const mode = startupOverride.mode;
 	if (mode === "auto" || mode === "yolo") relaxations.push(describe("mode", mode));
 	for (const [key, upstreamDefault] of Object.entries(DEEPAGENTS_STARTUP_BOOLEAN_DEFAULTS)) {
@@ -40112,9 +40352,6 @@ function warnAboutStartupRelaxations({ startupOverride, previousStartup, written
 	}
 	if (relaxations.length > 0) warnWithFallback(logger, `The deepagents startup override wrote ${relaxations.join(", ")} into ${filePath}, which is your global deepagents-cli config: it relaxes how much dcode does without asking, for every project on this machine, not just this one.`);
 	if (startupOverride[STARTUP_RECENT_KEY] !== void 0) warnWithFallback(logger, `The deepagents startup override's '${STARTUP_RECENT_KEY}' was not written to ${filePath}: dcode manages that key itself, and with no explicit 'mode' beside it, it is what restores auto-approval at launch. Set 'mode' if switching approval modes is the intent.`);
-	const known = new Set(DEEPAGENTS_STARTUP_KEYS);
-	const unknownKeys = writtenKeys.filter((key) => !known.has(key));
-	if (unknownKeys.length > 0) warnWithFallback(logger, `The deepagents startup override wrote ${unknownKeys.join(", ")} into ${filePath} unchecked — rulesync does not know what those keys grant, and that file is your global deepagents-cli config.`);
 }
 /**
 * Read `[shell].allow_list` the way dcode does: a TOML array is taken element
@@ -54735,7 +54972,10 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 //#region src/features/skills/zcode-skill.ts
 const ZcodeSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
-	description: z.string()
+	description: z.string(),
+	when_to_use: z.optional(z.string()),
+	license: z.optional(z.string()),
+	metadata: z.optional(z.looseObject({}))
 });
 /**
 * Represents a ZCode skill directory.
@@ -54798,10 +55038,16 @@ var ZcodeSkill = class ZcodeSkill extends ToolSkill {
 	}
 	toRulesyncSkill() {
 		const frontmatter = this.getFrontmatter();
+		const zcodeSection = {
+			...frontmatter.when_to_use !== void 0 && { when_to_use: frontmatter.when_to_use },
+			...frontmatter.license !== void 0 && { license: frontmatter.license },
+			...frontmatter.metadata !== void 0 && { metadata: frontmatter.metadata }
+		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
 			description: frontmatter.description,
-			targets: ["*"]
+			targets: ["*"],
+			...Object.keys(zcodeSection).length > 0 && { zcode: zcodeSection }
 		};
 		return new RulesyncSkill({
 			outputRoot: this.outputRoot,
@@ -54816,9 +55062,21 @@ var ZcodeSkill = class ZcodeSkill extends ToolSkill {
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const zcodeSection = rulesyncFrontmatter.zcode;
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: zcodeSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: zcodeSection
+		});
 		const zcodeFrontmatter = {
 			name: rulesyncFrontmatter.name,
-			description: rulesyncFrontmatter.description
+			description: rulesyncFrontmatter.description,
+			...zcodeSection?.when_to_use !== void 0 && { when_to_use: zcodeSection.when_to_use },
+			...license !== void 0 && { license },
+			...metadata !== void 0 && { metadata }
 		};
 		const settablePaths = ZcodeSkill.getSettablePaths({ global });
 		return new ZcodeSkill({
@@ -62919,10 +63177,21 @@ var ClineRule = class ClineRule extends ToolRule {
 */
 const CodebuddyRuleFrontmatterSchema = z.object({
 	description: z.optional(z.string()),
-	paths: z.optional(z.array(z.string())),
-	alwaysApply: z.optional(z.boolean())
+	paths: z.optional(z.union([z.string(), z.array(z.string())])),
+	alwaysApply: z.optional(z.boolean()),
+	enabled: z.optional(z.boolean())
 });
 /**
+* Normalizes the documented `string` / `string[]` shapes of `paths` to the
+* list form the rest of the adapter works with. An empty list and an empty
+* string both mean "no paths".
+*/
+function normalizeCodebuddyPaths(paths) {
+	if (paths === void 0) return;
+	const list = (typeof paths === "string" ? [paths] : paths).filter((path) => path.trim() !== "");
+	return list.length > 0 ? list : void 0;
+}
+/**
 * A universal glob (matching everything) is redundant on an Always Apply
 * rule and, paired with `alwaysApply: true`, is the same semantic conflict
 * `CursorRule.resolveCursorGlobs` avoids for Cursor: `alwaysApply` already
@@ -62940,7 +63209,7 @@ const UNIVERSAL_PATHS = /* @__PURE__ */ new Set(["**/*", "*"]);
 * Rules format:
 * - {project}/CODEBUDDY.md (root: true), also read from {project}/.codebuddy/CODEBUDDY.md
 * - {project}/.codebuddy/rules/*.md (root: false, with optional
-*   `description` / `paths` / `alwaysApply` frontmatter)
+*   `description` / `paths` / `alwaysApply` / `enabled` frontmatter)
 * - Global: ~/.codebuddy/CODEBUDDY.md and ~/.codebuddy/rules/*.md
 *
 * @see https://www.codebuddy.ai/docs/cli/memory
@@ -62982,9 +63251,10 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 		this.body = body;
 	}
 	static generateFileContent(body, frontmatter) {
-		if (frontmatter.description === void 0 && frontmatter.paths === void 0 && frontmatter.alwaysApply === void 0) return body;
+		if (frontmatter.description === void 0 && frontmatter.paths === void 0 && frontmatter.alwaysApply === void 0 && frontmatter.enabled === void 0) return body;
 		return stringifyFrontmatter(body, {
 			description: frontmatter.description,
+			enabled: frontmatter.enabled,
 			alwaysApply: frontmatter.alwaysApply,
 			paths: frontmatter.paths
 		});
@@ -63032,10 +63302,36 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 			root: isRoot
 		});
 	}
-	static resolveCodebuddyPaths({ paths, alwaysApply }) {
-		if (!paths || paths.length === 0) return;
-		if (alwaysApply && paths.every((path) => UNIVERSAL_PATHS.has(path.trim()))) return;
-		return paths;
+	/**
+	* Resolves the `paths` / `alwaysApply` pair against CodeBuddy's Rule Type
+	* Determination table, which reads:
+	*
+	* | `alwaysApply`    | `paths`   | Rule type                          |
+	* | ---------------- | --------- | ---------------------------------- |
+	* | `true` (default) | any       | ALWAYS — always injected            |
+	* | `false`          | has value | MANUAL — triggered on matching file |
+	* | `false`          | none      | not supported; the rule is dropped  |
+	*
+	* The default being `true` is the opposite of Cursor, which the adapter was
+	* modeled on: `paths` alone scopes nothing, so a rule meant to be path
+	* triggered has to carry an explicit `alwaysApply: false` alongside it.
+	*
+	* @see https://www.codebuddy.ai/docs/cli/memory
+	*/
+	static resolveCodebuddyRuleType({ paths, alwaysApply }) {
+		const scopedPaths = paths && paths.length > 0 && !paths.every((path) => UNIVERSAL_PATHS.has(path.trim())) ? paths : void 0;
+		if (alwaysApply === true) return {
+			paths: scopedPaths,
+			alwaysApply: true
+		};
+		if (scopedPaths === void 0) return {
+			paths: void 0,
+			alwaysApply: void 0
+		};
+		return {
+			paths: scopedPaths,
+			alwaysApply: false
+		};
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
@@ -63052,17 +63348,17 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 			root
 		});
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${rulesyncRule.getRelativeFilePath()}`);
-		const codebuddyPaths = rulesyncFrontmatter.codebuddy?.paths;
+		const codebuddyPaths = normalizeCodebuddyPaths(rulesyncFrontmatter.codebuddy?.paths);
 		const globs = rulesyncFrontmatter.globs;
-		const alwaysApply = rulesyncFrontmatter.codebuddy?.alwaysApply;
-		const pathsValue = CodebuddyRule.resolveCodebuddyPaths({
+		const ruleType = CodebuddyRule.resolveCodebuddyRuleType({
 			paths: codebuddyPaths ?? (globs?.length ? globs : void 0),
-			alwaysApply: alwaysApply === true
+			alwaysApply: rulesyncFrontmatter.codebuddy?.alwaysApply
 		});
 		const codebuddyFrontmatter = {
 			description: rulesyncFrontmatter.codebuddy?.description ?? rulesyncFrontmatter.description,
-			paths: pathsValue,
-			alwaysApply
+			paths: ruleType.paths,
+			alwaysApply: ruleType.alwaysApply,
+			enabled: rulesyncFrontmatter.codebuddy?.enabled
 		};
 		return new CodebuddyRule({
 			outputRoot,
@@ -63092,17 +63388,19 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 				validate: true
 			});
 		}
-		const isAlways = this.frontmatter.alwaysApply === true;
-		const sourcePaths = this.frontmatter.paths ?? [];
+		const sourcePaths = normalizeCodebuddyPaths(this.frontmatter.paths) ?? [];
+		const isAlways = this.frontmatter.alwaysApply !== false;
 		const globs = sourcePaths.length === 0 && isAlways ? ["**/*"] : sourcePaths;
+		const alwaysApply = this.frontmatter.alwaysApply ?? (sourcePaths.length > 0 ? true : void 0);
 		const rulesyncFrontmatter = {
 			targets,
 			root: false,
 			description: this.frontmatter.description,
 			globs,
-			...(this.frontmatter.paths !== void 0 || this.frontmatter.alwaysApply !== void 0 || this.frontmatter.description !== void 0) && { codebuddy: {
-				paths: this.frontmatter.paths,
-				alwaysApply: this.frontmatter.alwaysApply,
+			...(this.frontmatter.paths !== void 0 || this.frontmatter.alwaysApply !== void 0 || this.frontmatter.enabled !== void 0 || this.frontmatter.description !== void 0) && { codebuddy: {
+				paths: sourcePaths.length > 0 ? sourcePaths : void 0,
+				alwaysApply,
+				enabled: this.frontmatter.enabled,
 				description: this.frontmatter.description
 			} }
 		};
@@ -65885,33 +66183,49 @@ var ReplitRule = class ReplitRule extends ToolRule {
 * Supports plain Markdown without frontmatter, mode-specific rules,
 * and both directory-based and single-file configurations.
 *
-* - Project scope writes the non-root directory `.roo/rules/`.
+* - Project scope writes the non-root directory `.roo/rules/`, and the root
+*   rule to the workspace-root `AGENTS.md` the extension reads from `cwd`.
 * - Global scope writes the same non-root directory resolved under the home
-*   directory (`~/.roo/rules/`), which Roo loads before workspace rules.
+*   directory (`~/.roo/rules/`), which Roo loads before workspace rules. The
+*   root rule joins it as `~/.roo/rules/AGENTS.md`: agent-rules discovery is
+*   workspace-only, so the default project-scope root would resolve to a
+*   `~/AGENTS.md` nothing ever reads.
 *   @see https://roocodeinc.github.io/Roo-Code/features/custom-instructions
 */
 var RooRule = class RooRule extends ToolRule {
-	static getSettablePaths(_options = {}) {
-		return { nonRoot: { relativeDirPath: buildToolPath(ROO_DIR, "rules", _options.excludeToolDir) } };
+	static getSettablePaths({ global, excludeToolDir } = {}) {
+		const rulesDirPath = buildToolPath(ROO_DIR, "rules", excludeToolDir);
+		if (global) return {
+			root: {
+				relativeDirPath: rulesDirPath,
+				relativeFilePath: ROO_GLOBAL_ROOT_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: rulesDirPath }
+		};
+		return { nonRoot: { relativeDirPath: rulesDirPath } };
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, relativeDirPath: overrideDirPath, validate = true }) {
-		const relativeDirPath = overrideDirPath !== void 0 && RooRule.extractModeFromDirPath(overrideDirPath) !== void 0 ? overrideDirPath : this.getSettablePaths().nonRoot.relativeDirPath;
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, relativeDirPath: overrideDirPath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const relativeDirPath = overrideDirPath !== void 0 && RooRule.extractModeFromDirPath(overrideDirPath) !== void 0 ? overrideDirPath : paths.nonRoot?.relativeDirPath ?? buildToolPath(".roo", "rules");
 		const fileContent = await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath));
+		const isRoot = "root" in paths && relativeDirPath === paths.root.relativeDirPath && relativeFilePath === paths.root.relativeFilePath;
 		return new RooRule({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent,
 			validate,
-			root: false
+			root: isRoot
 		});
 	}
-	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
 		const params = this.buildToolRuleParamsDefault({
 			outputRoot,
 			rulesyncRule,
 			validate,
-			nonRootPath: this.getSettablePaths().nonRoot
+			..."root" in paths && { rootPath: paths.root },
+			nonRootPath: paths.nonRoot
 		});
 		const mode = rulesyncRule.getFrontmatter().roo?.mode;
 		if (!params.root && mode !== void 0 && mode !== "") {
@@ -66834,7 +67148,9 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			extension: "md",
 			supportsGlobal: true,
 			ruleDiscoveryMode: "auto",
-			collisionPolicy: "fold"
+			collisionPolicy: "fold",
+			localRootMode: "separate-local-file",
+			localRootFileName: CRUSH_LOCAL_RULE_FILE_NAME
 		}
 	}],
 	["cursor", {
@@ -67554,6 +67870,34 @@ var RulesProcessor = class extends FeatureProcessor {
 			root: true,
 			localRoot
 		});
+		if (isClassOrSubclassOf({
+			candidate: factory.class,
+			base: CodebuddyRule
+		})) {
+			const paths = CodebuddyRule.getSettablePaths({ global: this.global });
+			return new CodebuddyRule({
+				outputRoot: this.outputRoot,
+				relativeDirPath: relativeDirPath ?? paths.root.relativeDirPath,
+				relativeFilePath: fileName,
+				frontmatter: {},
+				body,
+				validate: true,
+				root: true,
+				localRoot
+			});
+		}
+		if (isClassOrSubclassOf({
+			candidate: factory.class,
+			base: CrushRule
+		})) return new CrushRule({
+			outputRoot: this.outputRoot,
+			relativeDirPath: relativeDirPath ?? ".",
+			relativeFilePath: fileName,
+			fileContent: body,
+			validate: true,
+			root: true,
+			localRoot
+		});
 		if (isClassOrSubclassOf({
 			candidate: factory.class,
 			base: QwencodeRule
@@ -70152,6 +70496,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { RulesyncCheckFrontmatterSchema as $, ALL_TOOL_TARGETS_WITH_WILDCARD as $t, FACTORYDROID_DIR as A, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as An, fileExists as At, RulesyncSkillFrontmatterSchema as B, stripControlCharacters as Bn, readFileContent as Bt, CODEXCLI_BASH_RULES_FILE_NAME as C, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as Cn, assertDirectoryIfExists as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, RULESYNC_RULES_RELATIVE_DIR_PATH as Dn, createTempDirectory as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, RULESYNC_RELATIVE_DIR_PATH as En, checkPathTraversal as Et, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as F, formatError as Fn, isSymlink as Ft, RulesyncIgnore as G, removeFileStrict as Gt, RulesyncRuleFrontmatterSchema as H, stripHiddenCharacters as Hn, removeDirectory as Ht, getLocalSkillDirNames as I, truncateText as In, listDirectoryEntryNames as It, resolveRulesyncSourceWritePath as J, runWithDirectoryRollback as Jt, RulesyncHooks as K, removeTempDirectory as Kt, RulesyncSubagent as L, hasDeceptiveHiddenCharacters as Ln, listFilePathsRecursively as Lt, caseFoldIdentity as M, ALL_FEATURES as Mn, getHomeDirectory as Mt, groupSpellingsByCaseFoldedIdentity as N, ALL_FEATURES_WITH_WILDCARD as Nn, isFileNotFoundError as Nt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, RULESYNC_SKILLS_RELATIVE_DIR_PATH as On, directoryExists as Ot, AUGMENTCODE_DIR as P, DEPRECATED_FEATURE_REPLACEMENTS as Pn, isFileSystemError as Pt, RulesyncCheck as Q, ALL_TOOL_TARGETS as Qt, RulesyncSubagentFrontmatterSchema as R, hasEnclosingMarkOutsideKeycap as Rn, listSubdirectoryNames as Rt, ChecksProcessor as S, RULESYNC_PERMISSIONS_FILE_NAME as Sn, applyFileMode as St, CLAUDECODE_DIR as T, RULESYNC_PERMISSIONS_SCHEMA_URL as Tn, assertWritablePathInsideRoot as Tt, RulesyncPermissions as U, removeDirectoryStrict as Ut, RulesyncRule as V, stripControlCharactersKeepingLineFeeds as Vn, readFileContentOrNull as Vt, RulesyncMcp as W, removeFile as Wt, RulesyncCommand as X, writeFileBuffer as Xt, parseJsonc as Y, toPosixPath as Yt, RulesyncCommandFrontmatterSchema as Z, writeFileContent as Zt, IgnoreProcessor as _, RULESYNC_MCP_FILE_NAME as _n, withFallbackLoggerTarget as _t, getProcessorRegistryEntry as a, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as an, mergeInputRootConfigs as at, QWENCODE_DIR as b, RULESYNC_MCP_SCHEMA_URL as bn, CLIError as bt, RulesProcessor as c, RULESYNC_CONFIG_RELATIVE_FILE_PATH as cn, ConfigFileSchema as ct, CODEBUDDY_DIR as d, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as dn, findControlCharacter as dt, PACKAGING_TOOL_TARGETS as en, stringifyFrontmatter as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_HOOKS_FILE_NAME as fn, ConsoleLogger as ft, McpProcessor as g, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as gn, warnOnConflictingFlags as gt, shortenToWidth as h, RULESYNC_IGNORE_RELATIVE_FILE_PATH as hn, fallbackLogger as ht, inspectInputRoots as i, RULESYNC_AIIGNORE_FILE_NAME as in, ConfigResolver as it, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as j, parseCommaSeparatedList as jn, getFileSize as jt, CLAUDECODE_SKILLS_DIR_PATH as k, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as kn, ensureDir as kt, SubagentsProcessor as l, RULESYNC_CONFIG_SCHEMA_URL as ln, GITIGNORE_DESTINATION_KEY as lt, displayWidthOf as m, RULESYNC_HOOKS_RELATIVE_FILE_PATH as mn, WarningCollectingLogger as mt, formatSourceLoadFailure as n, CURATED_RULES_FEATURE_SUBDIR as nn, SHARED_USER_MANAGED_CONFIG_PATHS as nt, convertFromTool as o, RULESYNC_CHECKS_RELATIVE_DIR_PATH as on, resolveEffectiveInputRoots as ot, ELLIPSIS_WIDTH as p, RULESYNC_HOOKS_LEGACY_FILE_NAME as pn, JsonLogger as pt, getRulesyncSourceCandidates as q, resolvePath as qt, generate as r, MAX_FILE_SIZE as rn, SKILL_FILE_NAME as rt, isPackagingToolTarget as s, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as sn, CONFLICTING_TARGET_PAIRS as st, importFromTool as t, ToolTargetSchema as tn, loadYaml as tt, SkillsProcessor as u, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as un, SourceEntrySchema as ut, HooksProcessor as v, RULESYNC_MCP_LEGACY_FILE_NAME as vn, resetRunWarningState as vt, CODEXCLI_DIR as w, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as wn, assertTreeContainsNoSymlinks as wt, QWENCODE_LOCAL_RULE_FILE_NAME as x, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as xn, ErrorCodes as xt, CommandsProcessor as y, RULESYNC_MCP_RELATIVE_FILE_PATH as yn, withWarnOnceScope as yt, RulesyncSkill as z, quoteForLog as zn, pathEscapesRoot as zt };
+export { RulesyncCheck as $, ALL_TOOL_TARGETS as $t, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as An, ensureDir as At, RulesyncSkill as B, quoteForLog as Bn, pathEscapesRoot as Bt, ChecksProcessor as C, RULESYNC_PERMISSIONS_FILE_NAME as Cn, applyFileMode as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_RELATIVE_DIR_PATH as Dn, checkPathTraversal as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_SCHEMA_URL as En, assertWritablePathInsideRoot as Et, AUGMENTCODE_DIR as F, DEPRECATED_FEATURE_REPLACEMENTS as Fn, isFileSystemError as Ft, RulesyncMcp as G, removeFile as Gt, RulesyncRule as H, stripControlCharactersKeepingLineFeeds as Hn, readFileContentOrNull as Ht, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as I, formatError as In, isSymlink as It, getRulesyncSourceCandidates as J, resolvePath as Jt, RulesyncIgnore as K, removeFileStrict as Kt, getLocalSkillDirNames as L, truncateText as Ln, listDirectoryEntryNames as Lt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as M, parseCommaSeparatedList as Mn, getFileSize as Mt, caseFoldIdentity as N, ALL_FEATURES as Nn, getHomeDirectory as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RULES_RELATIVE_DIR_PATH as On, createTempDirectory as Ot, groupSpellingsByCaseFoldedIdentity as P, ALL_FEATURES_WITH_WILDCARD as Pn, isFileNotFoundError as Pt, RulesyncCommandFrontmatterSchema as Q, writeFileContent as Qt, RulesyncSubagent as R, hasDeceptiveHiddenCharacters as Rn, listFilePathsRecursively as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Sn, ErrorCodes as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Tn, assertTreeContainsNoSymlinks as Tt, RulesyncRuleFrontmatterSchema as U, stripHiddenCharacters as Un, removeDirectory as Ut, RulesyncSkillFrontmatterSchema as V, stripControlCharacters as Vn, readFileContent as Vt, RulesyncPermissions as W, removeDirectoryStrict as Wt, parseJsonc as X, toPosixPath as Xt, resolveRulesyncSourceWritePath as Y, runWithDirectoryRollback as Yt, RulesyncCommand as Z, writeFileBuffer as Zt, IgnoreProcessor as _, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as _n, warnOnConflictingFlags as _t, getProcessorRegistryEntry as a, RULESYNC_AIIGNORE_FILE_NAME as an, ConfigResolver as at, CommandsProcessor as b, RULESYNC_MCP_RELATIVE_FILE_PATH as bn, withWarnOnceScope as bt, RulesProcessor as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as cn, CONFLICTING_TARGET_PAIRS as ct, CODEBUDDY_DIR as d, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as dn, SourceEntrySchema as dt, ALL_TOOL_TARGETS_WITH_WILDCARD as en, RulesyncCheckFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as fn, findControlCharacter as ft, McpProcessor as g, RULESYNC_IGNORE_RELATIVE_FILE_PATH as gn, fallbackLogger as gt, shortenToWidth as h, RULESYNC_HOOKS_RELATIVE_FILE_PATH as hn, WarningCollectingLogger as ht, inspectInputRoots as i, MAX_FILE_SIZE as in, SKILL_FILE_NAME as it, FACTORYDROID_DIR as j, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as jn, fileExists as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_SKILLS_RELATIVE_DIR_PATH as kn, directoryExists as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ln, ConfigFileSchema as lt, displayWidthOf as m, RULESYNC_HOOKS_LEGACY_FILE_NAME as mn, JsonLogger as mt, formatSourceLoadFailure as n, ToolTargetSchema as nn, loadYaml as nt, convertFromTool as o, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as on, mergeInputRootConfigs as ot, ELLIPSIS_WIDTH as p, RULESYNC_HOOKS_FILE_NAME as pn, ConsoleLogger as pt, RulesyncHooks as q, removeTempDirectory as qt, generate as r, CURATED_RULES_FEATURE_SUBDIR as rn, SHARED_USER_MANAGED_CONFIG_PATHS as rt, isPackagingToolTarget as s, RULESYNC_CHECKS_RELATIVE_DIR_PATH as sn, resolveEffectiveInputRoots as st, importFromTool as t, PACKAGING_TOOL_TARGETS as tn, stringifyFrontmatter as tt, SkillsProcessor as u, RULESYNC_CONFIG_SCHEMA_URL as un, GITIGNORE_DESTINATION_KEY as ut, CRUSH_LOCAL_RULE_FILE_NAME as v, RULESYNC_MCP_FILE_NAME as vn, withFallbackLoggerTarget as vt, CODEXCLI_BASH_RULES_FILE_NAME as w, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as wn, assertDirectoryIfExists as wt, QWENCODE_DIR as x, RULESYNC_MCP_SCHEMA_URL as xn, CLIError as xt, HooksProcessor as y, RULESYNC_MCP_LEGACY_FILE_NAME as yn, resetRunWarningState as yt, RulesyncSubagentFrontmatterSchema as z, hasEnclosingMarkOutsideKeycap as zn, listSubdirectoryNames as zt };
 
-//# sourceMappingURL=import-B6p6c3L0.js.map
+//# sourceMappingURL=import-BlHibyDS.js.map