rulesync 16.24.1 → 16.26.0

package/dist/{import-CI0pN6s5.cjs → import-BAnifHej.cjs}

@@ -444,34 +444,34 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$304 } = node_path.posix;
+const { join: join$305 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$304(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$305(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$304(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$304(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$305(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$305(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$305(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$304(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$305(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";
@@ -738,7 +738,8 @@ const hooksProcessorToolTargetTuple = [
 	"vibe",
 	"qwencode",
 	"reasonix",
-	"grokcli"
+	"grokcli",
+	"zcode"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -2418,6 +2419,7 @@ const ConfigParamsSchema = zod_mini.z.object({
 	simulateCommands: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSubagents: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSkills: (0, zod_mini.optional)(zod_mini.z.boolean()),
+	preserveUnownedHooks: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	deriveSubprojectPathFromGlobs: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	flattenedCommandNaming: (0, zod_mini.optional)(FlattenedCommandNamingSchema),
 	/**
@@ -2566,6 +2568,7 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	preserveUnownedHooks;
 	deriveSubprojectPathFromGlobs;
 	flattenedCommandNaming;
 	language;
@@ -2592,7 +2595,7 @@ var Config = class Config {
 	inputRoots;
 	configFilePath;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, preserveUnownedHooks, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -2624,6 +2627,7 @@ var Config = class Config {
 		this.simulateCommands = simulateCommands ?? false;
 		this.simulateSubagents = simulateSubagents ?? false;
 		this.simulateSkills = simulateSkills ?? false;
+		this.preserveUnownedHooks = preserveUnownedHooks ?? false;
 		this.deriveSubprojectPathFromGlobs = deriveSubprojectPathFromGlobs ?? false;
 		this.flattenedCommandNaming = flattenedCommandNaming ?? "basename";
 		this.language = language;
@@ -2802,6 +2806,9 @@ var Config = class Config {
 	getSimulateCommands() {
 		return this.simulateCommands;
 	}
+	getPreserveUnownedHooks() {
+		return this.preserveUnownedHooks;
+	}
 	getFlattenedCommandNaming() {
 		return this.flattenedCommandNaming;
 	}
@@ -2881,6 +2888,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	preserveUnownedHooks: false,
 	deriveSubprojectPathFromGlobs: false,
 	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
@@ -2929,6 +2937,7 @@ const mergeConfigs = (baseConfig, localConfig) => {
 		simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
 		simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
 		simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+		preserveUnownedHooks: localConfig.preserveUnownedHooks ?? baseConfig.preserveUnownedHooks,
 		deriveSubprojectPathFromGlobs: localConfig.deriveSubprojectPathFromGlobs ?? baseConfig.deriveSubprojectPathFromGlobs,
 		flattenedCommandNaming: localConfig.flattenedCommandNaming ?? baseConfig.flattenedCommandNaming,
 		language: localConfig.language ?? baseConfig.language,
@@ -3152,6 +3161,11 @@ var ConfigResolver = class {
 				file: configByFile.simulateSkills,
 				fallback: getDefaults().simulateSkills
 			}),
+			preserveUnownedHooks: pick({
+				cli: void 0,
+				file: configByFile.preserveUnownedHooks,
+				fallback: getDefaults().preserveUnownedHooks
+			}),
 			deriveSubprojectPathFromGlobs: pick({
 				cli: deriveSubprojectPathFromGlobs,
 				file: configByFile.deriveSubprojectPathFromGlobs,
@@ -4711,6 +4725,48 @@ const KIMI_CODE_NATIVE_HOOK_EVENTS = [
 ];
 const KIMI_CODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_KIMI_CODE_EVENT_NAMES).map(([canonical, kimiCode]) => [kimiCode, canonical]));
 /**
+* Hook events supported by ZCode.
+*
+* 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 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.
+*
+* ZCode also accepts a native `process` hook type (an argv run without a
+* shell) which has no canonical equivalent; see ZcodeHooks.
+*
+* @see https://zcode.z.ai/en/docs
+*/
+const ZCODE_HOOK_EVENTS = [
+	"sessionStart",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionRequest",
+	"stop"
+];
+const CANONICAL_TO_ZCODE_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionRequest: "PermissionRequest",
+	stop: "Stop"
+};
+const ZCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_ZCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
 *
 * Hermes validates hook events against a fixed `VALID_HOOKS` set — 37 entries as
@@ -4862,6 +4918,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"kimi-code": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	zcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -6852,12 +6909,37 @@ const DeepagentsStartupOverrideSchema = zod_mini.z.looseObject({
 	read_project_dotenv: zod_mini.z.optional(zod_mini.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 = zod_mini.z.looseObject({
+	enabled: zod_mini.z.optional(zod_mini.z.boolean()),
+	trust: zod_mini.z.optional(zod_mini.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 = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	startup: zod_mini.z.optional(DeepagentsStartupOverrideSchema)
+	startup: zod_mini.z.optional(DeepagentsStartupOverrideSchema),
+	extensions: zod_mini.z.optional(DeepagentsExtensionsOverrideSchema)
 });
 /**
 * The actions Junie's allowlist accepts. Verified against the shipped Junie
@@ -7868,8 +7950,9 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 	agentsmd: zod_mini.z.optional(zod_mini.z.looseObject({ subprojectPath: zod_mini.z.optional(zod_mini.z.string()) })),
 	claudecode: zod_mini.z.optional(zod_mini.z.looseObject({ paths: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) })),
 	codebuddy: zod_mini.z.optional(zod_mini.z.looseObject({
-		paths: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+		paths: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 		alwaysApply: zod_mini.z.optional(zod_mini.z.boolean()),
+		enabled: zod_mini.z.optional(zod_mini.z.boolean()),
 		description: zod_mini.z.optional(zod_mini.z.string())
 	})),
 	cursor: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -9162,6 +9245,11 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
 		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
+	})),
+	zcode: zod_mini.z.optional(zod_mini.z.looseObject({
+		when_to_use: zod_mini.z.optional(zod_mini.z.string()),
+		license: zod_mini.z.optional(zod_mini.z.string()),
+		metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 	}))
 });
 /**
@@ -12412,14 +12500,15 @@ const KIMI_CODE_CONFIG_DECLARATION = {
 };
 /**
 * ZCode's settings file, which also carries model/theme/permission keys
-* rulesync does not own. The workspace copy (`<project>/.zcode/config.json`)
-* and the user copy (`~/.zcode/cli/config.json`) are the same file with the
-* same owners, so the declaration is written once and shared — a policy edit
-* cannot land on one scope only. `mcp` is owned as a whole key because the
-* writer recomputes it from the existing file (non-`servers` siblings carried
-* over) before applying the patch.
-*/
-const ZCODE_CONFIG_DECLARATION = {
+* rulesync does not own. Both copies are the user's primary ZCode config, so
+* every writer refuses to read-modify-write a file it could not parse rather
+* than replacing it with generated output. `mcp` and `hooks` are owned as
+* whole keys because their writers recompute each from the existing file
+* (non-owned siblings carried over) before applying the patch. ZCode never
+* executes workspace config hooks, so the workspace copy is declared with
+* `mcp` alone and the user copy adds `hooks`.
+*/
+const ZCODE_WORKSPACE_CONFIG_DECLARATION = {
 	format: "json",
 	invalidRootPolicy: "error",
 	features: { mcp: {
@@ -12427,6 +12516,16 @@ const ZCODE_CONFIG_DECLARATION = {
 		ownedKeys: ["mcp"]
 	} }
 };
+const ZCODE_USER_CONFIG_DECLARATION = {
+	...ZCODE_WORKSPACE_CONFIG_DECLARATION,
+	features: {
+		...ZCODE_WORKSPACE_CONFIG_DECLARATION.features,
+		hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		}
+	}
+};
 /**
 * What the two Claude Code settings files have in common: both are plain JSON,
 * and both validate against the one published schema, which the gateway
@@ -12684,8 +12783,8 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: ["mcp_servers", "schema_version"]
 		} }
 	},
-	".zcode/config.json": ZCODE_CONFIG_DECLARATION,
-	".zcode/cli/config.json": ZCODE_CONFIG_DECLARATION,
+	".zcode/config.json": ZCODE_WORKSPACE_CONFIG_DECLARATION,
+	".zcode/cli/config.json": ZCODE_USER_CONFIG_DECLARATION,
 	".kiro/agents/default.json": {
 		format: "json",
 		features: {
@@ -17733,6 +17832,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/`.
@@ -18349,6 +18462,8 @@ const ZCODE_SKILLS_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "skills");
 const ZCODE_CONFIG_FILE_NAME = "config.json";
 const ZCODE_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "cli");
 const ZCODE_MCP_SERVERS_KEY = "servers";
+const ZCODE_HOOKS_CONFIG_KEY = "hooks";
+const ZCODE_HOOKS_EVENTS_KEY = "events";
 const ZCODE_AGENTS_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "agents");
 //#endregion
 //#region src/features/commands/zcode-command.ts
@@ -19221,19 +19336,124 @@ function generateAmpPluginCode({ config, supportedEvents, eventMap }) {
 	lines.push("}", "");
 	return lines.join("\n");
 }
+/**
+* Name of the ownership record written next to the hooks destination it
+* describes (e.g. `.claude/.rulesync-hooks-lock.json`). Only written when hook
+* preservation is enabled, so a project that never opts in never sees it.
+*/
+const HOOKS_OWNERSHIP_LOCK_FILE_NAME = ".rulesync-hooks-lock.json";
+const OwnedHookRefSchema = zod_mini.z.object({
+	event: zod_mini.z.string(),
+	matcher: zod_mini.z.optional(zod_mini.z.string()),
+	identity: zod_mini.z.string()
+});
+const HooksOwnershipLockSchema = zod_mini.z.object({
+	lockfileVersion: zod_mini.z.number(),
+	owned: zod_mini.z.array(OwnedHookRefSchema)
+});
+/**
+* The comparable form of a hook entry: identical keys mean "the same hook, in
+* the same place". Encoded as JSON so no separator can collide with a matcher
+* or an identity that happens to contain one.
+*/
+function ownedHookKey({ event, matcher, identity }) {
+	return JSON.stringify([
+		event,
+		matcher ?? null,
+		identity
+	]);
+}
+/**
+* Read the previous run's owned set. Anything unreadable — missing, empty,
+* malformed, or written by a different lock version — yields an empty set,
+* which makes every existing handler look third-party and therefore preserved.
+*/
+function parseHooksOwnershipLock(content) {
+	if (content === null || content.trim() === "") return /* @__PURE__ */ new Set();
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+	const result = HooksOwnershipLockSchema.safeParse(parsed);
+	if (!result.success || result.data.lockfileVersion !== 1) return /* @__PURE__ */ new Set();
+	return new Set(result.data.owned.map((ref) => ownedHookKey(ref)));
+}
+function compareOwnedHookRefs(a, b) {
+	const left = ownedHookKey(a);
+	const right = ownedHookKey(b);
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+/** Serialize the owned set in a stable order so regenerating produces no diff. */
+function serializeHooksOwnershipLock(owned) {
+	return `${JSON.stringify({
+		lockfileVersion: 1,
+		owned: [...owned].toSorted(compareOwnedHookRefs)
+	}, null, 2)}\n`;
+}
+/**
+* The ownership record itself. It is a rulesync by-product rather than tool
+* configuration, so it is deletable: dropping the target should take it along.
+*/
+var HooksOwnershipLockFile = class extends ToolFile {
+	isDeletable() {
+		return true;
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+};
+/** Build the lock file that records what this run generated. */
+function buildHooksOwnershipLockFile({ outputRoot, relativeDirPath, owned }) {
+	return new HooksOwnershipLockFile({
+		outputRoot,
+		relativeDirPath,
+		relativeFilePath: HOOKS_OWNERSHIP_LOCK_FILE_NAME,
+		fileContent: serializeHooksOwnershipLock(owned),
+		validate: false
+	});
+}
 //#endregion
 //#region src/features/hooks/tool-hooks.ts
 var ToolHooks = class extends ToolFile {
+	ownedHookRefs;
 	constructor(params) {
 		super({
 			...params,
 			validate: true
 		});
+		this.ownedHookRefs = params.ownedHookRefs;
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
 		}
 	}
+	/**
+	* The ownership record for this destination, or nothing when preservation is
+	* off — in which case rulesync owns the whole list and needs no record.
+	*/
+	getOwnershipLockFiles() {
+		if (this.ownedHookRefs === void 0) return [];
+		return [buildHooksOwnershipLockFile({
+			outputRoot: this.getOutputRoot(),
+			relativeDirPath: this.getRelativeDirPath(),
+			owned: this.ownedHookRefs
+		})];
+	}
+	/**
+	* Whether the adapter can keep handlers it did not generate. Destinations
+	* rulesync owns outright (plugin bundles) must answer `false`: there is no
+	* third party writing into them, and preserving there would only make
+	* removals impossible.
+	*/
+	static supportsPreserveUnowned() {
+		return false;
+	}
 	static getSettablePaths(_options) {
 		throw new Error("Please implement this method in the subclass.");
 	}
@@ -20670,6 +20890,292 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/preserve-unowned-hook-commands.ts
+/**
+* Read the `hooks` value from a destination JSON file.
+*
+* `malformed` separates "the file has no hooks" from "the file could not be
+* read", so a caller that is about to preserve content can say out loud that
+* it is replacing a file it failed to parse.
+*/
+function parseExistingHooksValue(existingContent) {
+	if (existingContent.trim() === "") return {
+		hooks: void 0,
+		malformed: false
+	};
+	try {
+		const parsed = JSON.parse(existingContent);
+		return {
+			hooks: isPlainObject$1(parsed) ? parsed.hooks : void 0,
+			malformed: false
+		};
+	} catch {
+		return {
+			hooks: void 0,
+			malformed: true
+		};
+	}
+}
+/**
+* Produce the destination hooks list, optionally keeping handlers rulesync does
+* not own.
+*
+* Ownership is decided by `previouslyOwned` — the identities recorded in the
+* destination's ownership lock on the previous run — and never by guessing from
+* the command text. That is what makes removal work: a handler rulesync wrote
+* before and no longer generates is retracted, while a handler rulesync has
+* never written is left alone. Without a lock (the first run after opting in)
+* nothing is retracted, which is the non-destructive direction.
+*
+* Callers must pass the destination's shape. Plugin destinations are fully
+* owned by rulesync and must not call this.
+*/
+function mergeGeneratedHookLists({ existingContent, generatedHooks, shape, preserveUnowned, previouslyOwned, logger }) {
+	const owned = collectOwnedRefs({
+		generatedHooks,
+		shape
+	});
+	if (!preserveUnowned) return {
+		hooks: generatedHooks,
+		owned
+	};
+	const { hooks: existingHooks, malformed } = parseExistingHooksValue(existingContent);
+	if (malformed) logger?.warn("Replacing hooks wholesale: the existing file is not valid JSON, so no third-party hook in it can be preserved.");
+	return {
+		hooks: preserveUnownedHookCommands({
+			existingHooks,
+			generatedHooks,
+			shape,
+			owned,
+			previouslyOwned: previouslyOwned ?? /* @__PURE__ */ new Set(),
+			logger
+		}),
+		owned
+	};
+}
+/**
+* Merge the destination's existing handlers into the generated set.
+*
+* Each existing handler falls into exactly one of three cases:
+* - this run generates it → the generated copy stands, the existing one is dropped;
+* - a previous run generated it and this one does not → it is retracted, with a warning;
+* - neither → it is unowned, and kept.
+*/
+function preserveUnownedHookCommands({ existingHooks, generatedHooks, shape, owned, previouslyOwned, logger }) {
+	const result = cloneGeneratedHooks({
+		generatedHooks,
+		shape
+	});
+	if (!isPlainObject$1(existingHooks)) return result;
+	const seen = new Set(owned.map((ref) => ownedHookKey(ref)));
+	for (const [event, existingValue] of Object.entries(existingHooks)) {
+		if (isPrototypePollutionKey(event)) continue;
+		if (!Array.isArray(existingValue)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "an array of hook entries"
+			});
+			continue;
+		}
+		const merged = shape === "matcher-groups" ? mergeMatcherGroups({
+			existing: existingValue,
+			generated: result[event] ?? [],
+			event,
+			seen,
+			previouslyOwned,
+			logger
+		}) : mergeFlatHandlers({
+			existing: existingValue,
+			generated: result[event] ?? [],
+			event,
+			seen,
+			previouslyOwned,
+			logger
+		});
+		if (merged.length === 0) delete result[event];
+		else result[event] = merged;
+	}
+	return result;
+}
+function cloneGeneratedHooks({ generatedHooks, shape }) {
+	const result = Object.create(null);
+	for (const [event, value] of Object.entries(generatedHooks)) {
+		if (isPrototypePollutionKey(event) || !Array.isArray(value)) continue;
+		result[event] = shape === "matcher-groups" ? value.map((group) => cloneMatcherGroup(group)) : value.map((handler) => cloneHandler(handler));
+	}
+	return result;
+}
+/** The identities of every handler in the generated set, in destination order. */
+function collectOwnedRefs({ generatedHooks, shape }) {
+	const owned = [];
+	for (const [event, value] of Object.entries(generatedHooks)) {
+		if (isPrototypePollutionKey(event) || !Array.isArray(value)) continue;
+		if (shape === "flat") {
+			for (const handler of value) if (isPlainObject$1(handler)) owned.push({
+				event,
+				identity: handlerIdentity(handler)
+			});
+			continue;
+		}
+		for (const group of value) {
+			if (!isMatcherGroup(group)) continue;
+			const matcher = matcherKey(group.matcher);
+			for (const handler of group.hooks) if (isPlainObject$1(handler)) owned.push({
+				event,
+				matcher,
+				identity: handlerIdentity(handler)
+			});
+		}
+	}
+	return owned;
+}
+function mergeMatcherGroups({ existing, generated, event, seen, previouslyOwned, logger }) {
+	const merged = [...generated];
+	for (const group of existing) {
+		if (!isMatcherGroup(group)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "a matcher group"
+			});
+			continue;
+		}
+		const matcher = matcherKey(group.matcher);
+		const preserved = group.hooks.filter((handler) => shouldPreserve({
+			handler,
+			event,
+			matcher,
+			seen,
+			previouslyOwned,
+			logger
+		})).map((handler) => cloneHandler(handler));
+		if (preserved.length === 0) continue;
+		const target = merged.find((candidate) => isMatcherGroup(candidate) && matcherKey(candidate.matcher) === matcher);
+		if (target !== void 0 && isMatcherGroup(target)) target.hooks.push(...preserved);
+		else merged.push({
+			...omitPrototypePollutionKeys(group),
+			hooks: preserved
+		});
+	}
+	return merged;
+}
+function mergeFlatHandlers({ existing, generated, event, seen, previouslyOwned, logger }) {
+	const preserved = [];
+	for (const handler of existing) {
+		if (isMatcherGroup(handler)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "a flat handler"
+			});
+			continue;
+		}
+		if (!shouldPreserve({
+			handler,
+			event,
+			matcher: void 0,
+			seen,
+			previouslyOwned,
+			logger
+		})) continue;
+		preserved.push(cloneHandler(handler));
+	}
+	return [...generated, ...preserved];
+}
+function isMatcherGroup(value) {
+	return isPlainObject$1(value) && Array.isArray(value.hooks);
+}
+function cloneMatcherGroup(group) {
+	if (!isMatcherGroup(group)) return cloneHandler(group);
+	return {
+		...group,
+		hooks: group.hooks.map((handler) => cloneHandler(handler))
+	};
+}
+function cloneHandler(handler) {
+	return isPlainObject$1(handler) ? omitPrototypePollutionKeys(handler) : handler;
+}
+/**
+* Decide one existing handler, and remember it so an exact duplicate later in
+* the same event is not appended twice.
+*/
+function shouldPreserve({ handler, event, matcher, seen, previouslyOwned, logger }) {
+	if (!isPlainObject$1(handler)) {
+		warnSkip({
+			logger,
+			event,
+			expected: "a hook object"
+		});
+		return false;
+	}
+	const identity = handlerIdentity(handler);
+	const key = ownedHookKey({
+		event,
+		matcher,
+		identity
+	});
+	if (seen.has(key)) return false;
+	if (previouslyOwned.has(key)) {
+		logger?.warn(`Removing hook rulesync no longer generates on ${event}: ${identity}`);
+		return false;
+	}
+	seen.add(key);
+	logger?.warn(`Preserving unowned hook on ${event}: ${identity}`);
+	return true;
+}
+/**
+* A handler's identity is its action, not its whole shape: two entries running
+* the same command are the same hook even if their timeouts differ, so the
+* generated one replaces the existing one instead of doubling it. Shapes with
+* no recognizable action fall back to their full structure, which keeps them
+* comparable across runs — the alternative, no identity at all, made them
+* accumulate on every generate.
+*/
+function handlerIdentity(handler) {
+	const type = typeof handler.type === "string" ? handler.type : inferredType(handler);
+	switch (type) {
+		case "http": return taggedIdentity("http", handler.url) ?? structuralIdentity(handler);
+		case "mcp_tool": return mcpToolIdentity(handler) ?? structuralIdentity(handler);
+		case "prompt":
+		case "agent": return taggedIdentity(type, handler.prompt) ?? structuralIdentity(handler);
+		case "function": return taggedIdentity("function", handler.name) ?? structuralIdentity(handler);
+		default: return taggedIdentity("command", handler.command) ?? taggedIdentity("prompt", handler.prompt) ?? structuralIdentity(handler);
+	}
+}
+function inferredType(handler) {
+	return typeof handler.url === "string" ? "http" : "command";
+}
+function taggedIdentity(kind, value) {
+	return typeof value === "string" && value !== "" ? `${kind}:${value}` : void 0;
+}
+function mcpToolIdentity(handler) {
+	const server = typeof handler.server === "string" ? handler.server : "";
+	const tool = typeof handler.tool === "string" ? handler.tool : "";
+	if (server === "" && tool === "") return;
+	return `mcp_tool:${server}:${tool}:${stableStringify$1(handler.input)}`;
+}
+function structuralIdentity(handler) {
+	return `json:${stableStringify$1(handler)}`;
+}
+/** Key-order-independent JSON, so an identity survives a rewritten file. */
+function stableStringify$1(value) {
+	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify$1(entry)).join(",")}]`;
+	if (isPlainObject$1(value)) return `{${Object.entries(value).filter(([key]) => !isPrototypePollutionKey(key)).toSorted(([left], [right]) => left === right ? 0 : left < right ? -1 : 1).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify$1(entry)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/**
+* Matcher groups are matched by the whole matcher value, not just strings: a
+* non-string matcher is a shape rulesync does not emit, and collapsing every
+* such group onto one key would merge unrelated third-party groups together.
+*/
+function matcherKey(matcher) {
+	return matcher === void 0 ? "" : stableStringify$1(matcher);
+}
+function warnSkip({ logger, event, expected }) {
+	logger?.warn(`Skipping existing hook entry on ${event}: expected ${expected}`);
+}
+//#endregion
 //#region src/features/hooks/claudecode-hooks.ts
 const CLAUDE_CONVERTER_CONFIG = {
 	supportedEvents: CLAUDE_HOOK_EVENTS,
@@ -20738,7 +21244,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		commandOnly: true
 	}]
 };
-var ClaudecodeHooks = class extends ToolHooks {
+var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -20773,7 +21279,13 @@ var ClaudecodeHooks = class extends ToolHooks {
 			validate
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ toolHooks } = {}) {
+		return toolHooks instanceof ClaudecodeHooks ? toolHooks.getOwnershipLockFiles() : [];
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const paths = this.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
@@ -20784,11 +21296,20 @@ var ClaudecodeHooks = class extends ToolHooks {
 			converterConfig: this.getConverterConfig(),
 			logger
 		});
+		const preserving = preserveUnowned && this.supportsPreserveUnowned();
+		const merged = mergeGeneratedHookLists({
+			existingContent,
+			generatedHooks: claudeHooks,
+			shape: "matcher-groups",
+			preserveUnowned: preserving,
+			previouslyOwned: preserving ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
+			logger
+		});
 		const fileContent = applySharedConfigPatch({
 			fileKey: CLAUDE_SETTINGS_SHARED_FILE_KEY,
 			feature: "hooks",
 			existingContent,
-			patch: { hooks: claudeHooks },
+			patch: { hooks: merged.hooks },
 			filePath
 		});
 		return new this({
@@ -20796,6 +21317,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserving ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -20853,6 +21375,14 @@ var ClaudecodePluginHooks = class extends ClaudecodeHooks {
 			projectDirVar: "$CLAUDE_PLUGIN_ROOT"
 		};
 	}
+	/**
+	* The plugin bundle is generated in full by rulesync — nothing else writes
+	* into it — so preserving there would buy nothing and cost the ability to
+	* remove a hook.
+	*/
+	static supportsPreserveUnowned() {
+		return false;
+	}
 	static getSettablePaths() {
 		return {
 			relativeDirPath: CLAUDECODE_PLUGIN_HOOKS_DIR,
@@ -21283,21 +21813,30 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			validate
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const paths = CodexcliHooks.getSettablePaths({ global });
+		const existingContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		const config = rulesyncHooks.getJson();
-		const codexHooks = canonicalToToolHooks({
-			config,
-			toolOverrideHooks: config.codexcli?.hooks,
-			converterConfig: CODEXCLI_CONVERTER_CONFIG,
+		const merged = mergeGeneratedHookLists({
+			existingContent,
+			generatedHooks: canonicalToToolHooks({
+				config,
+				toolOverrideHooks: config.codexcli?.hooks,
+				converterConfig: CODEXCLI_CONVERTER_CONFIG,
+				logger
+			}),
+			shape: "matcher-groups",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
 			logger
 		});
-		const fileContent = JSON.stringify({ hooks: codexHooks }, null, 2);
+		const fileContent = JSON.stringify({ hooks: merged.hooks }, null, 2);
 		return new CodexcliHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserveUnowned ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -21333,8 +21872,11 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			validate: false
 		});
 	}
-	static async getAuxiliaryFiles({ outputRoot = process.cwd() } = {}) {
-		return [await CodexcliConfigToml.fromOutputRoot({ outputRoot })];
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ outputRoot = process.cwd(), toolHooks } = {}) {
+		return [await CodexcliConfigToml.fromOutputRoot({ outputRoot }), ...toolHooks instanceof CodexcliHooks ? toolHooks.getOwnershipLockFiles() : []];
 	}
 };
 //#endregion
@@ -21939,7 +22481,7 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			validate
 		});
 	}
-	static fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const config = rulesyncHooks.getJson();
 		const cursorSupported = new Set(CURSOR_HOOK_EVENTS);
 		const sharedHooks = {};
@@ -21966,21 +22508,36 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			}));
 			if (mappedDefs.length > 0) mappedHooks[cursorEventName] = mappedDefs;
 		}
+		const paths = CursorHooks.getSettablePaths({ global });
+		const merged = mergeGeneratedHookLists({
+			existingContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "",
+			generatedHooks: mappedHooks,
+			shape: "flat",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
+			logger
+		});
 		const cursorConfig = {
 			version: config.version ?? 1,
-			hooks: mappedHooks
+			hooks: merged.hooks
 		};
 		const fileContent = JSON.stringify(cursorConfig, null, 2);
-		const paths = CursorHooks.getSettablePaths({ global });
 		return new CursorHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserveUnowned ? merged.owned : void 0,
 			validate,
 			rulesyncHooks
 		});
 	}
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ toolHooks } = {}) {
+		return toolHooks instanceof CursorHooks ? toolHooks.getOwnershipLockFiles() : [];
+	}
 	toRulesyncHooks() {
 		const content = this.getFileContent();
 		const parsed = JSON.parse(content);
@@ -22348,7 +22905,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",
@@ -22356,6 +22913,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"sandbox",
 	"mcpPolicy",
 	"mcpAutonomyOverrides",
+	"mcpAutonomyUrlOverrides",
+	"builtInToolAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
@@ -22363,7 +22922,10 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"interactionMode",
 	"extraKnownMarketplaces",
 	"enabledPlugins",
+	"strictEnabledPlugins",
+	"strictKnownMarketplaces",
 	"hooksDisabled",
+	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
 	"missionPolicy"
@@ -25220,6 +25782,186 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/zcode-hooks.ts
+/**
+* Single spelling of the config.json codec/policy, matching the one in
+* ZcodeMcp: fail closed on an unparseable root rather than replacing the
+* user's primary ZCode config with generated output.
+*/
+function parseZcodeConfig$1(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Drop ZCode's native `process` hooks from an `events` map before the shared
+* import converter runs. The converter would coerce the unknown type to
+* `command` and import the executable alone — losing the `args` vector that
+* *is* the process hook's command line — so the imported hook would run
+* something else than the file states. Matcher groups left without hooks are
+* dropped with them.
+*/
+function stripProcessHooks({ events, logger }) {
+	if (!isRecord$1(events)) return events;
+	const result = Object.create(null);
+	for (const [eventName, entries] of Object.entries(events)) {
+		if (!Array.isArray(entries)) {
+			result[eventName] = entries;
+			continue;
+		}
+		const kept = [];
+		for (const entry of entries) {
+			if (!isRecord$1(entry) || !Array.isArray(entry.hooks)) {
+				kept.push(entry);
+				continue;
+			}
+			const hooks = entry.hooks.filter((hook) => {
+				if (isRecord$1(hook) && hook.type === "process") {
+					logger?.warn(`Skipping a ZCode "process" hook on "${eventName}" while importing: it has no canonical equivalent, and importing its executable alone would change what it runs.`);
+					return false;
+				}
+				return true;
+			});
+			if (hooks.length > 0) kept.push({
+				...entry,
+				hooks
+			});
+		}
+		result[eventName] = kept;
+	}
+	return result;
+}
+const ZCODE_CONVERTER_CONFIG = {
+	supportedEvents: ZCODE_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_ZCODE_EVENT_NAMES,
+	toolToCanonicalEventNames: ZCODE_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	booleanPassthroughFields: [{
+		canonical: "async",
+		tool: "async"
+	}, {
+		canonical: "enabled",
+		tool: "enabled"
+	}],
+	stringPassthroughFields: [{
+		canonical: "statusMessage",
+		tool: "statusMessage"
+	}, {
+		canonical: "shell",
+		tool: "shell",
+		commandOnly: true
+	}],
+	wildcardMatcherMeansAll: true
+};
+/**
+* ZCode hooks.
+*
+* ZCode reads configuration-file hooks from the `hooks` block of its user
+* config file, `~/.zcode/cli/config.json`. Workspace config hooks are never
+* executed — the workspace file is ignored regardless of `hooks.enabled` — so
+* rulesync treats ZCode hooks as global-only. The event map is nested under
+* `hooks.events` beside the user-tunable `enabled` and `timeoutMs` siblings,
+* which are carried over while `events` is replaced.
+*
+* @see https://zcode.z.ai/en/docs
+*/
+var ZcodeHooks = class ZcodeHooks extends ToolHooks {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = parseZcodeConfig$1(this.fileContent ?? "{}", (0, node_path.join)(this.relativeDirPath, this.relativeFilePath));
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: ZCODE_GLOBAL_CONFIG_DIR_PATH,
+			relativeFilePath: ZCODE_CONFIG_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const existing = parseZcodeConfig$1(existingContent, filePath);
+		const config = rulesyncHooks.getJson();
+		const events = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.zcode?.hooks,
+			converterConfig: ZCODE_CONVERTER_CONFIG,
+			logger
+		});
+		const existingHooks = isRecord$1(existing["hooks"]) ? existing[ZCODE_HOOKS_CONFIG_KEY] : {};
+		const shouldStateEnabled = Object.keys(events).length > 0 && existingHooks.enabled === void 0;
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "hooks",
+				existingContent,
+				patch: { [ZCODE_HOOKS_CONFIG_KEY]: {
+					...existingHooks,
+					...shouldStateEnabled ? { enabled: true } : {},
+					[ZCODE_HOOKS_EVENTS_KEY]: events
+				} },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncHooks({ logger } = {}) {
+		const hooks = toolHooksToCanonical({
+			hooks: stripProcessHooks({
+				events: (isRecord$1(this.json["hooks"]) ? this.json[ZCODE_HOOKS_CONFIG_KEY] : {})[ZCODE_HOOKS_EVENTS_KEY],
+				logger
+			}),
+			converterConfig: ZCODE_CONVERTER_CONFIG,
+			logger
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "zcode"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ [ZCODE_HOOKS_CONFIG_KEY]: { [ZCODE_HOOKS_EVENTS_KEY]: {} } }, null, 2),
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/hooks-processor.ts
 const HooksProcessorToolTargetSchema = zod_mini.z.enum(hooksProcessorToolTargetTuple);
 /**
@@ -25291,8 +26033,12 @@ const HOOKS_OVERRIDE_KEY_ALIASES = {
 	"kiro-cli": KIRO_HOOKS_OVERRIDE_KEY,
 	"kiro-ide": KIRO_HOOKS_OVERRIDE_KEY
 };
-/** The targets writing the standalone `.kiro/hooks/*.json` v1 format. */
-const KIRO_STANDALONE_HOOKS_TARGETS = /* @__PURE__ */ new Set(["kiro-cli", "kiro-ide"]);
+/** The targets whose hooks format carries a per-hook on-disk enable flag. */
+const PER_HOOK_ENABLED_TARGETS = /* @__PURE__ */ new Set([
+	"kiro-cli",
+	"kiro-ide",
+	"zcode"
+]);
 const toolHooksFactories = /* @__PURE__ */ new Map([
 	["amp", {
 		class: AmpHooks,
@@ -25641,6 +26387,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedEvents: GROKCLI_HOOK_EVENTS,
 		supportedHookTypes: ["command", "http"],
 		supportsMatcher: true
+	}],
+	["zcode", {
+		class: ZcodeHooks,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: ZCODE_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
 	}]
 ]);
 const hooksProcessorToolTargets = [...toolHooksFactories.entries()].filter(([, f]) => f.meta.supportsProject).map(([t]) => t);
@@ -25650,7 +26407,8 @@ const hooksProcessorToolTargetsGlobalImportable = [...toolHooksFactories.entries
 var HooksProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
-	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, dryRun = false, logger }) {
+	preserveUnownedHooks;
+	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, dryRun = false, preserveUnownedHooks = false, logger }) {
 		super({
 			outputRoot,
 			inputRoots,
@@ -25661,6 +26419,7 @@ var HooksProcessor = class extends FeatureProcessor {
 		if (!result.success) throw new Error(`Invalid tool target for HooksProcessor: ${toolTarget}. ${formatError(result.error)}`);
 		this.toolTarget = result.data;
 		this.global = global;
+		this.preserveUnownedHooks = preserveUnownedHooks;
 	}
 	async loadRulesyncFiles() {
 		const relativePaths = getRulesyncSourceCandidates({ paths: RulesyncHooks.getSettablePaths() }).map((candidate) => candidate.relativeFilePath);
@@ -25752,14 +26511,14 @@ var HooksProcessor = class extends FeatureProcessor {
 			}
 			for (const [hookType, events] of unsupportedTypeToEvents) this.logger.warn(`Skipped ${hookType}-type hook(s) for ${this.toolTarget} (not supported): ${Array.from(events).join(", ")}`);
 		}
-		if (!KIRO_STANDALONE_HOOKS_TARGETS.has(this.toolTarget)) {
+		if (!PER_HOOK_ENABLED_TARGETS.has(this.toolTarget)) {
 			const skippedEvents = new Set(unsupportedEventNames({
 				factory,
 				sharedHooks,
 				effectiveHooks
 			}));
 			const eventsWithDisabledHooks = Object.entries(sharedHooks).filter(([event, defs]) => !skippedEvents.has(event) && defs.some((def) => def.enabled === false)).map(([event]) => event);
-			if (eventsWithDisabledHooks.length > 0) this.logger.warn(`Emitting "enabled: false" hook(s) as active for ${this.toolTarget} (only the kiro-cli / kiro-ide standalone hooks format supports the flag): ${eventsWithDisabledHooks.join(", ")}`);
+			if (eventsWithDisabledHooks.length > 0) this.logger.warn(`Emitting "enabled: false" hook(s) as active for ${this.toolTarget} (only the kiro-cli / kiro-ide / zcode hooks formats support the flag): ${eventsWithDisabledHooks.join(", ")}`);
 		}
 		const eventsWithUnsupportedMatcher = unsupportedMatcherEventNames({
 			factory,
@@ -25771,6 +26530,7 @@ var HooksProcessor = class extends FeatureProcessor {
 			rulesyncHooks,
 			validate: true,
 			global: this.global,
+			preserveUnowned: this.preserveUnownedHooks,
 			logger: withToolTargetPrefix({
 				logger: this.logger,
 				toolTarget: this.toolTarget
@@ -26206,6 +26966,7 @@ var ClineIgnore = class ClineIgnore extends ToolIgnore {
 //#region src/constants/crush-paths.ts
 const CRUSH_RULE_FILE_NAME = "CRUSH.md";
 const CRUSH_GLOBAL_DIR = (0, node_path.join)(".config", "crush");
+const CRUSH_LOCAL_RULE_FILE_NAME = "CRUSH.local.md";
 const CRUSH_IGNORE_FILE_NAME = ".crushignore";
 const CRUSH_SKILLS_PROJECT_DIR = (0, node_path.join)(".crush", "skills");
 const CRUSH_SKILLS_GLOBAL_DIR = (0, node_path.join)(CRUSH_GLOBAL_DIR, "skills");
@@ -32426,9 +33187,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
@@ -32436,28 +33204,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);
@@ -32472,7 +33237,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 : {
@@ -32913,10 +33678,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.`);
@@ -32925,7 +33690,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
@@ -39069,6 +39833,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 = /[*?[\]]/;
@@ -39138,7 +39930,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
@@ -39240,6 +40035,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,
@@ -39264,8 +40066,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() {
@@ -39352,57 +40161,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 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.
 *
-* 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.
+* `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
@@ -39417,12 +40361,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)) {
@@ -39432,9 +40377,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
@@ -54055,7 +54997,10 @@ var WarpSkill = class WarpSkill extends ToolSkill {
 //#region src/features/skills/zcode-skill.ts
 const ZcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
-	description: zod_mini.z.string()
+	description: zod_mini.z.string(),
+	when_to_use: zod_mini.z.optional(zod_mini.z.string()),
+	license: zod_mini.z.optional(zod_mini.z.string()),
+	metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
 * Represents a ZCode skill directory.
@@ -54118,10 +55063,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,
@@ -54136,9 +55087,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({
@@ -62239,10 +63202,21 @@ var ClineRule = class ClineRule extends ToolRule {
 */
 const CodebuddyRuleFrontmatterSchema = zod_mini.z.object({
 	description: zod_mini.z.optional(zod_mini.z.string()),
-	paths: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-	alwaysApply: zod_mini.z.optional(zod_mini.z.boolean())
+	paths: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	alwaysApply: zod_mini.z.optional(zod_mini.z.boolean()),
+	enabled: zod_mini.z.optional(zod_mini.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
@@ -62260,7 +63234,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
@@ -62302,9 +63276,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
 		});
@@ -62352,10 +63327,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();
@@ -62372,17 +63373,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,
@@ -62412,17 +63413,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
 			} }
 		};
@@ -65205,33 +66208,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((0, node_path.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 !== "") {
@@ -66154,7 +67173,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", {
@@ -66874,6 +67895,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
@@ -69002,6 +70051,7 @@ async function generateHooksCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			preserveUnownedHooks: config.getPreserveUnownedHooks(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -69573,6 +70623,12 @@ Object.defineProperty(exports, "CONFLICTING_TARGET_PAIRS", {
 		return CONFLICTING_TARGET_PAIRS;
 	}
 });
+Object.defineProperty(exports, "CRUSH_LOCAL_RULE_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return CRUSH_LOCAL_RULE_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "CURATED_RULES_FEATURE_SUBDIR", {
 	enumerable: true,
 	get: function() {