rulesync 16.24.0 → 16.25.0

package/dist/{import-DyWRanf6.js → import-B6p6c3L0.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,43 @@ 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 (a
+* case-sensitive regular expression) is honored on all of them except
+* `UserPromptSubmit` and `Stop`, which expose no value to match against.
+* 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 +4888,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())
@@ -12387,14 +12439,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 +12455,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 +12722,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: {
@@ -18324,6 +18387,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 +19261,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 +20815,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 +21169,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		commandOnly: true
 	}]
 };
-var ClaudecodeHooks = class extends ToolHooks {
+var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -20748,7 +21204,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 +21221,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 +21242,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserving ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -20828,6 +21300,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 +21738,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 +21797,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 +22406,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 +22433,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);
@@ -22802,8 +23309,10 @@ function definitionsToHermesEntries({ event, sourceEvent = event, definitions, l
 	for (const definition of definitions) {
 		if ((definition.type ?? "command") !== "command" || typeof definition.command !== "string" || definition.command === "") continue;
 		const entry = { command: definition.command };
-		if (typeof definition.matcher === "string" && definition.matcher !== "") if (supportsMatcher) entry.matcher = definition.matcher;
-		else logger?.warn(`matcher "${definition.matcher}" on "${sourceEvent}" hook will be ignored — Hermes Agent only supports matchers on pre_tool_call/post_tool_call`);
+		if (typeof definition.matcher === "string" && definition.matcher !== "") {
+			if (supportsMatcher) entry.matcher = definition.matcher;
+			else logger?.warn(`matcher "${definition.matcher}" on "${sourceEvent}" hook will be ignored — Hermes Agent only supports matchers on pre_tool_call/post_tool_call`);
+		}
 		if (typeof definition.timeout === "number") entry.timeout = definition.timeout;
 		if (typeof definition.failClosed === "boolean") {
 			if (event === HERMESAGENT_FAIL_CLOSED_EVENT) entry.fail_closed = definition.failClosed;
@@ -24031,8 +24540,10 @@ function canonicalToKiroHooks({ config, logger }) {
 			key: eventName
 		}) ?? eventName;
 		const entries = buildKiroEntriesForEvent(definitions);
-		if (entries.length > 0) if (kiro[kiroEventName]) kiro[kiroEventName].push(...entries);
-		else kiro[kiroEventName] = entries;
+		if (entries.length > 0) {
+			if (kiro[kiroEventName]) kiro[kiroEventName].push(...entries);
+			else kiro[kiroEventName] = entries;
+		}
 	}
 	return kiro;
 }
@@ -24858,8 +25369,10 @@ function canonicalToReasonixHooks({ config, toolOverrideHooks, logger }) {
 			if ((def.type ?? "command") !== "command") continue;
 			if (typeof def.command !== "string") continue;
 			const entry = { command: def.command };
-			if (typeof def.matcher === "string" && def.matcher !== "") if (isMatcherEvent) entry.match = def.matcher;
-			else logger?.warn(`matcher "${def.matcher}" on "${event}" hook will be ignored — Reasonix's "${reasonixEvent}" event does not support matchers`);
+			if (typeof def.matcher === "string" && def.matcher !== "") {
+				if (isMatcherEvent) entry.match = def.matcher;
+				else logger?.warn(`matcher "${def.matcher}" on "${event}" hook will be ignored — Reasonix's "${reasonixEvent}" event does not support matchers`);
+			}
 			if (typeof def.description === "string" && def.description !== "") entry.description = def.description;
 			if (typeof def.timeout === "number") entry.timeout = Math.round(def.timeout * 1e3);
 			entries.push(entry);
@@ -25189,6 +25702,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);
 /**
@@ -25260,8 +25953,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,
@@ -25610,6 +26307,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);
@@ -25619,7 +26327,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,
@@ -25630,6 +26339,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);
@@ -25721,14 +26431,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,
@@ -25740,6 +26450,7 @@ var HooksProcessor = class extends FeatureProcessor {
 			rulesyncHooks,
 			validate: true,
 			global: this.global,
+			preserveUnowned: this.preserveUnownedHooks,
 			logger: withToolTargetPrefix({
 				logger: this.logger,
 				toolTarget: this.toolTarget
@@ -28427,12 +29138,16 @@ function convertFromCodexFormat(codexMcp) {
 			} else if (key === "oauth" && isRecord$1(value)) converted[key] = mapOauthFromCodex(value);
 			else if (Object.hasOwn(CODEX_TO_RULESYNC_FIELD_MAP, key)) {
 				const mappedKey = CODEX_TO_RULESYNC_FIELD_MAP[key];
-				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
-				else warnWithFallback(void 0, `Ignored malformed array for ${key} in MCP server ${name}`);
+				if (mappedKey) {
+					if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
+					else warnWithFallback(void 0, `Ignored malformed array for ${key} in MCP server ${name}`);
+				}
 			} else if (Object.hasOwn(CODEX_TO_RULESYNC_SCALAR_FIELD_MAP, key)) {
 				const mappedKey = CODEX_TO_RULESYNC_SCALAR_FIELD_MAP[key];
-				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
-				else warnWithFallback(void 0, `Ignored malformed value for ${key} in MCP server ${name}: expected a string`);
+				if (mappedKey) {
+					if (typeof value === "string") converted[mappedKey] = value;
+					else warnWithFallback(void 0, `Ignored malformed value for ${key} in MCP server ${name}: expected a string`);
+				}
 			} else converted[key] = value;
 		}
 		restateCanonicalTransport(converted);
@@ -28464,12 +29179,16 @@ function convertToCodexFormat(mcpServers) {
 			} else if (key === "oauth" && isRecord$1(value)) converted[key] = mapOauthToCodex(value);
 			else if (Object.hasOwn(RULESYNC_TO_CODEX_FIELD_MAP, key)) {
 				const mappedKey = RULESYNC_TO_CODEX_FIELD_MAP[key];
-				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
-				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string array, got ${typeof value}`);
+				if (mappedKey) {
+					if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
+					else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string array, got ${typeof value}`);
+				}
 			} else if (Object.hasOwn(RULESYNC_TO_CODEX_SCALAR_FIELD_MAP, key)) {
 				const mappedKey = RULESYNC_TO_CODEX_SCALAR_FIELD_MAP[key];
-				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
-				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string, got ${typeof value}`);
+				if (mappedKey) {
+					if (typeof value === "string") converted[mappedKey] = value;
+					else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string, got ${typeof value}`);
+				}
 			} else converted[key] = value;
 		}
 		const previousName = originalNames.get(codexName);
@@ -28713,8 +29432,10 @@ function resolveRemoteMcpUrl(serverConfig) {
 /** The `command` array a `local` server is spawned with, `args` merged in. */
 function resolveLocalMcpCommand(serverConfig) {
 	const commandArray = [];
-	if (serverConfig.command) if (Array.isArray(serverConfig.command)) commandArray.push(...serverConfig.command);
-	else commandArray.push(serverConfig.command);
+	if (serverConfig.command) {
+		if (Array.isArray(serverConfig.command)) commandArray.push(...serverConfig.command);
+		else commandArray.push(serverConfig.command);
+	}
 	if (serverConfig.args) commandArray.push(...serverConfig.args);
 	return commandArray;
 }
@@ -29251,8 +29972,10 @@ function toDeepagentsServer({ name, server, logger }) {
 	const { enabledTools, disabledTools, type: _type, transport, ...rest } = server;
 	const converted = { ...rest };
 	const normalized = normalizeDeepagentsTransport(rawTransport);
-	if (normalized !== void 0) if (transport !== void 0) converted.transport = normalized;
-	else converted.type = normalized;
+	if (normalized !== void 0) {
+		if (transport !== void 0) converted.transport = normalized;
+		else converted.type = normalized;
+	}
 	if (enabledTools !== void 0 && disabledTools !== void 0) return warnAndSkipMcpServer({
 		toolName: TOOL_NAME,
 		serverName: name,
@@ -29267,8 +29990,10 @@ function toDeepagentsServer({ name, server, logger }) {
 			logger
 		});
 		converted.allowedTools = enabledTools;
-	} else if (disabledTools !== void 0) if (disabledTools.length === 0) logger?.warn(`${TOOL_NAME} MCP: dropping the empty disabledTools list on "${name}"; it denies nothing, and deepagents rejects the empty form.`);
-	else converted.disabledTools = disabledTools;
+	} else if (disabledTools !== void 0) {
+		if (disabledTools.length === 0) logger?.warn(`${TOOL_NAME} MCP: dropping the empty disabledTools list on "${name}"; it denies nothing, and deepagents rejects the empty form.`);
+		else converted.disabledTools = disabledTools;
+	}
 	return converted;
 }
 /** Lift dcode's spellings back into the canonical model. */
@@ -32205,14 +32930,16 @@ function rulesyncMcpServerToReasonix(name, server, logger) {
 		name,
 		...type !== void 0 && { type }
 	};
-	if (server.command !== void 0) if (Array.isArray(server.command)) {
-		const [command, ...commandArgs] = server.command;
-		if (command !== void 0) plugin.command = command;
-		const args = [...commandArgs, ...server.args ?? []];
-		if (args.length > 0) plugin.args = args;
-	} else {
-		plugin.command = server.command;
-		if (server.args !== void 0) plugin.args = server.args;
+	if (server.command !== void 0) {
+		if (Array.isArray(server.command)) {
+			const [command, ...commandArgs] = server.command;
+			if (command !== void 0) plugin.command = command;
+			const args = [...commandArgs, ...server.args ?? []];
+			if (args.length > 0) plugin.args = args;
+		} else {
+			plugin.command = server.command;
+			if (server.args !== void 0) plugin.args = server.args;
+		}
 	}
 	for (const field of REASONIX_PLUGIN_FIELDS) {
 		if (field === "type" || field === "command" || field === "args") continue;
@@ -33280,14 +34007,16 @@ function rulesyncMcpServerToVibe(name, server, existing) {
 		name,
 		...transport !== void 0 && { transport }
 	};
-	if (server.command !== void 0) if (Array.isArray(server.command)) {
-		const [command, ...commandArgs] = server.command;
-		if (command !== void 0) vibeServer.command = command;
-		const args = [...commandArgs, ...server.args ?? []];
-		if (args.length > 0) vibeServer.args = args;
-	} else {
-		vibeServer.command = server.command;
-		if (server.args !== void 0) vibeServer.args = server.args;
+	if (server.command !== void 0) {
+		if (Array.isArray(server.command)) {
+			const [command, ...commandArgs] = server.command;
+			if (command !== void 0) vibeServer.command = command;
+			const args = [...commandArgs, ...server.args ?? []];
+			if (args.length > 0) vibeServer.args = args;
+		} else {
+			vibeServer.command = server.command;
+			if (server.args !== void 0) vibeServer.args = server.args;
+		}
 	}
 	const hasStructuredAuth = serverRecord.auth !== void 0;
 	for (const field of VIBE_MCP_SERVER_FIELDS) {
@@ -65185,8 +65914,10 @@ var RooRule = class RooRule extends ToolRule {
 			nonRootPath: this.getSettablePaths().nonRoot
 		});
 		const mode = rulesyncRule.getFrontmatter().roo?.mode;
-		if (!params.root && mode !== void 0 && mode !== "") if (!ROO_MODE_SLUG_PATTERN.test(mode)) warnWithFallback(void 0, `Ignoring roo.mode "${mode}" on ${rulesyncRule.getRelativeFilePath()}: a mode slug may contain only letters, digits and hyphens. Writing the rule to ${params.relativeDirPath} instead.`);
-		else params.relativeDirPath = join(dirname(params.relativeDirPath), rooModeRulesDirName(mode));
+		if (!params.root && mode !== void 0 && mode !== "") {
+			if (!ROO_MODE_SLUG_PATTERN.test(mode)) warnWithFallback(void 0, `Ignoring roo.mode "${mode}" on ${rulesyncRule.getRelativeFilePath()}: a mode slug may contain only letters, digits and hyphens. Writing the rule to ${params.relativeDirPath} instead.`);
+			else params.relativeDirPath = join(dirname(params.relativeDirPath), rooModeRulesDirName(mode));
+		}
 		return new RooRule(params);
 	}
 	/**
@@ -68951,6 +69682,7 @@ async function generateHooksCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			preserveUnownedHooks: config.getPreserveUnownedHooks(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -69422,4 +70154,4 @@ async function importChecksCore(params) {
 //#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 };
 
-//# sourceMappingURL=import-DyWRanf6.js.map
+//# sourceMappingURL=import-B6p6c3L0.js.map