rulesync 16.24.1 → 16.26.0

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

@@ -713,7 +713,8 @@ const hooksProcessorToolTargetTuple = [
 	"vibe",
 	"qwencode",
 	"reasonix",
-	"grokcli"
+	"grokcli",
+	"zcode"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -2393,6 +2394,7 @@ const ConfigParamsSchema = z.object({
 	simulateCommands: optional(z.boolean()),
 	simulateSubagents: optional(z.boolean()),
 	simulateSkills: optional(z.boolean()),
+	preserveUnownedHooks: optional(z.boolean()),
 	deriveSubprojectPathFromGlobs: optional(z.boolean()),
 	flattenedCommandNaming: optional(FlattenedCommandNamingSchema),
 	/**
@@ -2541,6 +2543,7 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	preserveUnownedHooks;
 	deriveSubprojectPathFromGlobs;
 	flattenedCommandNaming;
 	language;
@@ -2567,7 +2570,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
@@ -2599,6 +2602,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;
@@ -2777,6 +2781,9 @@ var Config = class Config {
 	getSimulateCommands() {
 		return this.simulateCommands;
 	}
+	getPreserveUnownedHooks() {
+		return this.preserveUnownedHooks;
+	}
 	getFlattenedCommandNaming() {
 		return this.flattenedCommandNaming;
 	}
@@ -2856,6 +2863,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	preserveUnownedHooks: false,
 	deriveSubprojectPathFromGlobs: false,
 	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
@@ -2904,6 +2912,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,
@@ -3127,6 +3136,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,
@@ -4686,6 +4700,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
@@ -4837,6 +4893,7 @@ const HooksConfigSchema = z.looseObject({
 	reasonix: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	grokcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	"kimi-code": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	zcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -6827,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
@@ -7843,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({
@@ -9137,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({}))
 	}))
 });
 /**
@@ -12387,14 +12475,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: {
@@ -12402,6 +12491,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
@@ -12659,8 +12758,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: {
@@ -17708,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/`.
@@ -18324,6 +18437,8 @@ const ZCODE_SKILLS_DIR_PATH = join(ZCODE_DIR, "skills");
 const ZCODE_CONFIG_FILE_NAME = "config.json";
 const ZCODE_GLOBAL_CONFIG_DIR_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 = join(ZCODE_DIR, "agents");
 //#endregion
 //#region src/features/commands/zcode-command.ts
@@ -19196,19 +19311,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 = z.object({
+	event: z.string(),
+	matcher: z.optional(z.string()),
+	identity: z.string()
+});
+const HooksOwnershipLockSchema = z.object({
+	lockfileVersion: z.number(),
+	owned: 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.");
 	}
@@ -20645,6 +20865,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,
@@ -20713,7 +21219,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		commandOnly: true
 	}]
 };
-var ClaudecodeHooks = class extends ToolHooks {
+var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -20748,7 +21254,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 = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
@@ -20759,11 +21271,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(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({
@@ -20771,6 +21292,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserving ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -20828,6 +21350,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,
@@ -21258,21 +21788,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(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(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
 		});
 	}
@@ -21308,8 +21847,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
@@ -21914,7 +22456,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 = {};
@@ -21941,21 +22483,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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "",
+			generatedHooks: mappedHooks,
+			shape: "flat",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull(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);
@@ -22323,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",
@@ -22331,6 +22888,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"sandbox",
 	"mcpPolicy",
 	"mcpAutonomyOverrides",
+	"mcpAutonomyUrlOverrides",
+	"builtInToolAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
@@ -22338,7 +22897,10 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"interactionMode",
 	"extraKnownMarketplaces",
 	"enabledPlugins",
+	"strictEnabledPlugins",
+	"strictKnownMarketplaces",
 	"hooksDisabled",
+	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
 	"missionPolicy"
@@ -25195,6 +25757,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 ?? "{}", 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(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 = 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 = z.enum(hooksProcessorToolTargetTuple);
 /**
@@ -25266,8 +26008,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,
@@ -25616,6 +26362,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);
@@ -25625,7 +26382,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,
@@ -25636,6 +26394,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);
@@ -25727,14 +26486,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,
@@ -25746,6 +26505,7 @@ var HooksProcessor = class extends FeatureProcessor {
 			rulesyncHooks,
 			validate: true,
 			global: this.global,
+			preserveUnowned: this.preserveUnownedHooks,
 			logger: withToolTargetPrefix({
 				logger: this.logger,
 				toolTarget: this.toolTarget
@@ -26181,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");
@@ -32401,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
@@ -32411,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);
@@ -32447,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 : {
@@ -32888,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.`);
@@ -32900,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
@@ -39044,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 = /[*?[\]]/;
@@ -39113,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
@@ -39215,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,
@@ -39239,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() {
@@ -39327,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
@@ -39392,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)) {
@@ -39407,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
@@ -54030,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.
@@ -54093,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,
@@ -54111,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({
@@ -62214,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
@@ -62235,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
@@ -62277,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
 		});
@@ -62327,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();
@@ -62347,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,
@@ -62387,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
 			} }
 		};
@@ -65180,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 !== "") {
@@ -66129,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", {
@@ -66849,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
@@ -68977,6 +70026,7 @@ async function generateHooksCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			preserveUnownedHooks: config.getPreserveUnownedHooks(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -69446,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-DL8paEMP.js.map
+//# sourceMappingURL=import-BlHibyDS.js.map