rulesync 16.24.1 → 16.25.0

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

@@ -444,34 +444,34 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$304 } = node_path.posix;
+const { join: join$305 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$304(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$305(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$304(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$304(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$305(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$305(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$304(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$305(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -738,7 +738,8 @@ const hooksProcessorToolTargetTuple = [
 	"vibe",
 	"qwencode",
 	"reasonix",
-	"grokcli"
+	"grokcli",
+	"zcode"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -2418,6 +2419,7 @@ const ConfigParamsSchema = zod_mini.z.object({
 	simulateCommands: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSubagents: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSkills: (0, zod_mini.optional)(zod_mini.z.boolean()),
+	preserveUnownedHooks: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	deriveSubprojectPathFromGlobs: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	flattenedCommandNaming: (0, zod_mini.optional)(FlattenedCommandNamingSchema),
 	/**
@@ -2566,6 +2568,7 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	preserveUnownedHooks;
 	deriveSubprojectPathFromGlobs;
 	flattenedCommandNaming;
 	language;
@@ -2592,7 +2595,7 @@ var Config = class Config {
 	inputRoots;
 	configFilePath;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, preserveUnownedHooks, deriveSubprojectPathFromGlobs, flattenedCommandNaming, language, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, inputRoots, configFilePath, sources, configFileTargets }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -2624,6 +2627,7 @@ var Config = class Config {
 		this.simulateCommands = simulateCommands ?? false;
 		this.simulateSubagents = simulateSubagents ?? false;
 		this.simulateSkills = simulateSkills ?? false;
+		this.preserveUnownedHooks = preserveUnownedHooks ?? false;
 		this.deriveSubprojectPathFromGlobs = deriveSubprojectPathFromGlobs ?? false;
 		this.flattenedCommandNaming = flattenedCommandNaming ?? "basename";
 		this.language = language;
@@ -2802,6 +2806,9 @@ var Config = class Config {
 	getSimulateCommands() {
 		return this.simulateCommands;
 	}
+	getPreserveUnownedHooks() {
+		return this.preserveUnownedHooks;
+	}
 	getFlattenedCommandNaming() {
 		return this.flattenedCommandNaming;
 	}
@@ -2881,6 +2888,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	preserveUnownedHooks: false,
 	deriveSubprojectPathFromGlobs: false,
 	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
@@ -2929,6 +2937,7 @@ const mergeConfigs = (baseConfig, localConfig) => {
 		simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
 		simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
 		simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+		preserveUnownedHooks: localConfig.preserveUnownedHooks ?? baseConfig.preserveUnownedHooks,
 		deriveSubprojectPathFromGlobs: localConfig.deriveSubprojectPathFromGlobs ?? baseConfig.deriveSubprojectPathFromGlobs,
 		flattenedCommandNaming: localConfig.flattenedCommandNaming ?? baseConfig.flattenedCommandNaming,
 		language: localConfig.language ?? baseConfig.language,
@@ -3152,6 +3161,11 @@ var ConfigResolver = class {
 				file: configByFile.simulateSkills,
 				fallback: getDefaults().simulateSkills
 			}),
+			preserveUnownedHooks: pick({
+				cli: void 0,
+				file: configByFile.preserveUnownedHooks,
+				fallback: getDefaults().preserveUnownedHooks
+			}),
 			deriveSubprojectPathFromGlobs: pick({
 				cli: deriveSubprojectPathFromGlobs,
 				file: configByFile.deriveSubprojectPathFromGlobs,
@@ -4711,6 +4725,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
@@ -4862,6 +4913,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"kimi-code": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	zcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -12412,14 +12464,15 @@ const KIMI_CODE_CONFIG_DECLARATION = {
 };
 /**
 * ZCode's settings file, which also carries model/theme/permission keys
-* rulesync does not own. The workspace copy (`<project>/.zcode/config.json`)
-* and the user copy (`~/.zcode/cli/config.json`) are the same file with the
-* same owners, so the declaration is written once and shared — a policy edit
-* cannot land on one scope only. `mcp` is owned as a whole key because the
-* writer recomputes it from the existing file (non-`servers` siblings carried
-* over) before applying the patch.
-*/
-const ZCODE_CONFIG_DECLARATION = {
+* rulesync does not own. Both copies are the user's primary ZCode config, so
+* every writer refuses to read-modify-write a file it could not parse rather
+* than replacing it with generated output. `mcp` and `hooks` are owned as
+* whole keys because their writers recompute each from the existing file
+* (non-owned siblings carried over) before applying the patch. ZCode never
+* executes workspace config hooks, so the workspace copy is declared with
+* `mcp` alone and the user copy adds `hooks`.
+*/
+const ZCODE_WORKSPACE_CONFIG_DECLARATION = {
 	format: "json",
 	invalidRootPolicy: "error",
 	features: { mcp: {
@@ -12427,6 +12480,16 @@ const ZCODE_CONFIG_DECLARATION = {
 		ownedKeys: ["mcp"]
 	} }
 };
+const ZCODE_USER_CONFIG_DECLARATION = {
+	...ZCODE_WORKSPACE_CONFIG_DECLARATION,
+	features: {
+		...ZCODE_WORKSPACE_CONFIG_DECLARATION.features,
+		hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		}
+	}
+};
 /**
 * What the two Claude Code settings files have in common: both are plain JSON,
 * and both validate against the one published schema, which the gateway
@@ -12684,8 +12747,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: {
@@ -18349,6 +18412,8 @@ const ZCODE_SKILLS_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "skills");
 const ZCODE_CONFIG_FILE_NAME = "config.json";
 const ZCODE_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "cli");
 const ZCODE_MCP_SERVERS_KEY = "servers";
+const ZCODE_HOOKS_CONFIG_KEY = "hooks";
+const ZCODE_HOOKS_EVENTS_KEY = "events";
 const ZCODE_AGENTS_DIR_PATH = (0, node_path.join)(ZCODE_DIR, "agents");
 //#endregion
 //#region src/features/commands/zcode-command.ts
@@ -19221,19 +19286,124 @@ function generateAmpPluginCode({ config, supportedEvents, eventMap }) {
 	lines.push("}", "");
 	return lines.join("\n");
 }
+/**
+* Name of the ownership record written next to the hooks destination it
+* describes (e.g. `.claude/.rulesync-hooks-lock.json`). Only written when hook
+* preservation is enabled, so a project that never opts in never sees it.
+*/
+const HOOKS_OWNERSHIP_LOCK_FILE_NAME = ".rulesync-hooks-lock.json";
+const OwnedHookRefSchema = zod_mini.z.object({
+	event: zod_mini.z.string(),
+	matcher: zod_mini.z.optional(zod_mini.z.string()),
+	identity: zod_mini.z.string()
+});
+const HooksOwnershipLockSchema = zod_mini.z.object({
+	lockfileVersion: zod_mini.z.number(),
+	owned: zod_mini.z.array(OwnedHookRefSchema)
+});
+/**
+* The comparable form of a hook entry: identical keys mean "the same hook, in
+* the same place". Encoded as JSON so no separator can collide with a matcher
+* or an identity that happens to contain one.
+*/
+function ownedHookKey({ event, matcher, identity }) {
+	return JSON.stringify([
+		event,
+		matcher ?? null,
+		identity
+	]);
+}
+/**
+* Read the previous run's owned set. Anything unreadable — missing, empty,
+* malformed, or written by a different lock version — yields an empty set,
+* which makes every existing handler look third-party and therefore preserved.
+*/
+function parseHooksOwnershipLock(content) {
+	if (content === null || content.trim() === "") return /* @__PURE__ */ new Set();
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+	const result = HooksOwnershipLockSchema.safeParse(parsed);
+	if (!result.success || result.data.lockfileVersion !== 1) return /* @__PURE__ */ new Set();
+	return new Set(result.data.owned.map((ref) => ownedHookKey(ref)));
+}
+function compareOwnedHookRefs(a, b) {
+	const left = ownedHookKey(a);
+	const right = ownedHookKey(b);
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+/** Serialize the owned set in a stable order so regenerating produces no diff. */
+function serializeHooksOwnershipLock(owned) {
+	return `${JSON.stringify({
+		lockfileVersion: 1,
+		owned: [...owned].toSorted(compareOwnedHookRefs)
+	}, null, 2)}\n`;
+}
+/**
+* The ownership record itself. It is a rulesync by-product rather than tool
+* configuration, so it is deletable: dropping the target should take it along.
+*/
+var HooksOwnershipLockFile = class extends ToolFile {
+	isDeletable() {
+		return true;
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+};
+/** Build the lock file that records what this run generated. */
+function buildHooksOwnershipLockFile({ outputRoot, relativeDirPath, owned }) {
+	return new HooksOwnershipLockFile({
+		outputRoot,
+		relativeDirPath,
+		relativeFilePath: HOOKS_OWNERSHIP_LOCK_FILE_NAME,
+		fileContent: serializeHooksOwnershipLock(owned),
+		validate: false
+	});
+}
 //#endregion
 //#region src/features/hooks/tool-hooks.ts
 var ToolHooks = class extends ToolFile {
+	ownedHookRefs;
 	constructor(params) {
 		super({
 			...params,
 			validate: true
 		});
+		this.ownedHookRefs = params.ownedHookRefs;
 		if (params.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
 		}
 	}
+	/**
+	* The ownership record for this destination, or nothing when preservation is
+	* off — in which case rulesync owns the whole list and needs no record.
+	*/
+	getOwnershipLockFiles() {
+		if (this.ownedHookRefs === void 0) return [];
+		return [buildHooksOwnershipLockFile({
+			outputRoot: this.getOutputRoot(),
+			relativeDirPath: this.getRelativeDirPath(),
+			owned: this.ownedHookRefs
+		})];
+	}
+	/**
+	* Whether the adapter can keep handlers it did not generate. Destinations
+	* rulesync owns outright (plugin bundles) must answer `false`: there is no
+	* third party writing into them, and preserving there would only make
+	* removals impossible.
+	*/
+	static supportsPreserveUnowned() {
+		return false;
+	}
 	static getSettablePaths(_options) {
 		throw new Error("Please implement this method in the subclass.");
 	}
@@ -20670,6 +20840,292 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/preserve-unowned-hook-commands.ts
+/**
+* Read the `hooks` value from a destination JSON file.
+*
+* `malformed` separates "the file has no hooks" from "the file could not be
+* read", so a caller that is about to preserve content can say out loud that
+* it is replacing a file it failed to parse.
+*/
+function parseExistingHooksValue(existingContent) {
+	if (existingContent.trim() === "") return {
+		hooks: void 0,
+		malformed: false
+	};
+	try {
+		const parsed = JSON.parse(existingContent);
+		return {
+			hooks: isPlainObject$1(parsed) ? parsed.hooks : void 0,
+			malformed: false
+		};
+	} catch {
+		return {
+			hooks: void 0,
+			malformed: true
+		};
+	}
+}
+/**
+* Produce the destination hooks list, optionally keeping handlers rulesync does
+* not own.
+*
+* Ownership is decided by `previouslyOwned` — the identities recorded in the
+* destination's ownership lock on the previous run — and never by guessing from
+* the command text. That is what makes removal work: a handler rulesync wrote
+* before and no longer generates is retracted, while a handler rulesync has
+* never written is left alone. Without a lock (the first run after opting in)
+* nothing is retracted, which is the non-destructive direction.
+*
+* Callers must pass the destination's shape. Plugin destinations are fully
+* owned by rulesync and must not call this.
+*/
+function mergeGeneratedHookLists({ existingContent, generatedHooks, shape, preserveUnowned, previouslyOwned, logger }) {
+	const owned = collectOwnedRefs({
+		generatedHooks,
+		shape
+	});
+	if (!preserveUnowned) return {
+		hooks: generatedHooks,
+		owned
+	};
+	const { hooks: existingHooks, malformed } = parseExistingHooksValue(existingContent);
+	if (malformed) logger?.warn("Replacing hooks wholesale: the existing file is not valid JSON, so no third-party hook in it can be preserved.");
+	return {
+		hooks: preserveUnownedHookCommands({
+			existingHooks,
+			generatedHooks,
+			shape,
+			owned,
+			previouslyOwned: previouslyOwned ?? /* @__PURE__ */ new Set(),
+			logger
+		}),
+		owned
+	};
+}
+/**
+* Merge the destination's existing handlers into the generated set.
+*
+* Each existing handler falls into exactly one of three cases:
+* - this run generates it → the generated copy stands, the existing one is dropped;
+* - a previous run generated it and this one does not → it is retracted, with a warning;
+* - neither → it is unowned, and kept.
+*/
+function preserveUnownedHookCommands({ existingHooks, generatedHooks, shape, owned, previouslyOwned, logger }) {
+	const result = cloneGeneratedHooks({
+		generatedHooks,
+		shape
+	});
+	if (!isPlainObject$1(existingHooks)) return result;
+	const seen = new Set(owned.map((ref) => ownedHookKey(ref)));
+	for (const [event, existingValue] of Object.entries(existingHooks)) {
+		if (isPrototypePollutionKey(event)) continue;
+		if (!Array.isArray(existingValue)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "an array of hook entries"
+			});
+			continue;
+		}
+		const merged = shape === "matcher-groups" ? mergeMatcherGroups({
+			existing: existingValue,
+			generated: result[event] ?? [],
+			event,
+			seen,
+			previouslyOwned,
+			logger
+		}) : mergeFlatHandlers({
+			existing: existingValue,
+			generated: result[event] ?? [],
+			event,
+			seen,
+			previouslyOwned,
+			logger
+		});
+		if (merged.length === 0) delete result[event];
+		else result[event] = merged;
+	}
+	return result;
+}
+function cloneGeneratedHooks({ generatedHooks, shape }) {
+	const result = Object.create(null);
+	for (const [event, value] of Object.entries(generatedHooks)) {
+		if (isPrototypePollutionKey(event) || !Array.isArray(value)) continue;
+		result[event] = shape === "matcher-groups" ? value.map((group) => cloneMatcherGroup(group)) : value.map((handler) => cloneHandler(handler));
+	}
+	return result;
+}
+/** The identities of every handler in the generated set, in destination order. */
+function collectOwnedRefs({ generatedHooks, shape }) {
+	const owned = [];
+	for (const [event, value] of Object.entries(generatedHooks)) {
+		if (isPrototypePollutionKey(event) || !Array.isArray(value)) continue;
+		if (shape === "flat") {
+			for (const handler of value) if (isPlainObject$1(handler)) owned.push({
+				event,
+				identity: handlerIdentity(handler)
+			});
+			continue;
+		}
+		for (const group of value) {
+			if (!isMatcherGroup(group)) continue;
+			const matcher = matcherKey(group.matcher);
+			for (const handler of group.hooks) if (isPlainObject$1(handler)) owned.push({
+				event,
+				matcher,
+				identity: handlerIdentity(handler)
+			});
+		}
+	}
+	return owned;
+}
+function mergeMatcherGroups({ existing, generated, event, seen, previouslyOwned, logger }) {
+	const merged = [...generated];
+	for (const group of existing) {
+		if (!isMatcherGroup(group)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "a matcher group"
+			});
+			continue;
+		}
+		const matcher = matcherKey(group.matcher);
+		const preserved = group.hooks.filter((handler) => shouldPreserve({
+			handler,
+			event,
+			matcher,
+			seen,
+			previouslyOwned,
+			logger
+		})).map((handler) => cloneHandler(handler));
+		if (preserved.length === 0) continue;
+		const target = merged.find((candidate) => isMatcherGroup(candidate) && matcherKey(candidate.matcher) === matcher);
+		if (target !== void 0 && isMatcherGroup(target)) target.hooks.push(...preserved);
+		else merged.push({
+			...omitPrototypePollutionKeys(group),
+			hooks: preserved
+		});
+	}
+	return merged;
+}
+function mergeFlatHandlers({ existing, generated, event, seen, previouslyOwned, logger }) {
+	const preserved = [];
+	for (const handler of existing) {
+		if (isMatcherGroup(handler)) {
+			warnSkip({
+				logger,
+				event,
+				expected: "a flat handler"
+			});
+			continue;
+		}
+		if (!shouldPreserve({
+			handler,
+			event,
+			matcher: void 0,
+			seen,
+			previouslyOwned,
+			logger
+		})) continue;
+		preserved.push(cloneHandler(handler));
+	}
+	return [...generated, ...preserved];
+}
+function isMatcherGroup(value) {
+	return isPlainObject$1(value) && Array.isArray(value.hooks);
+}
+function cloneMatcherGroup(group) {
+	if (!isMatcherGroup(group)) return cloneHandler(group);
+	return {
+		...group,
+		hooks: group.hooks.map((handler) => cloneHandler(handler))
+	};
+}
+function cloneHandler(handler) {
+	return isPlainObject$1(handler) ? omitPrototypePollutionKeys(handler) : handler;
+}
+/**
+* Decide one existing handler, and remember it so an exact duplicate later in
+* the same event is not appended twice.
+*/
+function shouldPreserve({ handler, event, matcher, seen, previouslyOwned, logger }) {
+	if (!isPlainObject$1(handler)) {
+		warnSkip({
+			logger,
+			event,
+			expected: "a hook object"
+		});
+		return false;
+	}
+	const identity = handlerIdentity(handler);
+	const key = ownedHookKey({
+		event,
+		matcher,
+		identity
+	});
+	if (seen.has(key)) return false;
+	if (previouslyOwned.has(key)) {
+		logger?.warn(`Removing hook rulesync no longer generates on ${event}: ${identity}`);
+		return false;
+	}
+	seen.add(key);
+	logger?.warn(`Preserving unowned hook on ${event}: ${identity}`);
+	return true;
+}
+/**
+* A handler's identity is its action, not its whole shape: two entries running
+* the same command are the same hook even if their timeouts differ, so the
+* generated one replaces the existing one instead of doubling it. Shapes with
+* no recognizable action fall back to their full structure, which keeps them
+* comparable across runs — the alternative, no identity at all, made them
+* accumulate on every generate.
+*/
+function handlerIdentity(handler) {
+	const type = typeof handler.type === "string" ? handler.type : inferredType(handler);
+	switch (type) {
+		case "http": return taggedIdentity("http", handler.url) ?? structuralIdentity(handler);
+		case "mcp_tool": return mcpToolIdentity(handler) ?? structuralIdentity(handler);
+		case "prompt":
+		case "agent": return taggedIdentity(type, handler.prompt) ?? structuralIdentity(handler);
+		case "function": return taggedIdentity("function", handler.name) ?? structuralIdentity(handler);
+		default: return taggedIdentity("command", handler.command) ?? taggedIdentity("prompt", handler.prompt) ?? structuralIdentity(handler);
+	}
+}
+function inferredType(handler) {
+	return typeof handler.url === "string" ? "http" : "command";
+}
+function taggedIdentity(kind, value) {
+	return typeof value === "string" && value !== "" ? `${kind}:${value}` : void 0;
+}
+function mcpToolIdentity(handler) {
+	const server = typeof handler.server === "string" ? handler.server : "";
+	const tool = typeof handler.tool === "string" ? handler.tool : "";
+	if (server === "" && tool === "") return;
+	return `mcp_tool:${server}:${tool}:${stableStringify$1(handler.input)}`;
+}
+function structuralIdentity(handler) {
+	return `json:${stableStringify$1(handler)}`;
+}
+/** Key-order-independent JSON, so an identity survives a rewritten file. */
+function stableStringify$1(value) {
+	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify$1(entry)).join(",")}]`;
+	if (isPlainObject$1(value)) return `{${Object.entries(value).filter(([key]) => !isPrototypePollutionKey(key)).toSorted(([left], [right]) => left === right ? 0 : left < right ? -1 : 1).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify$1(entry)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/**
+* Matcher groups are matched by the whole matcher value, not just strings: a
+* non-string matcher is a shape rulesync does not emit, and collapsing every
+* such group onto one key would merge unrelated third-party groups together.
+*/
+function matcherKey(matcher) {
+	return matcher === void 0 ? "" : stableStringify$1(matcher);
+}
+function warnSkip({ logger, event, expected }) {
+	logger?.warn(`Skipping existing hook entry on ${event}: expected ${expected}`);
+}
+//#endregion
 //#region src/features/hooks/claudecode-hooks.ts
 const CLAUDE_CONVERTER_CONFIG = {
 	supportedEvents: CLAUDE_HOOK_EVENTS,
@@ -20738,7 +21194,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		commandOnly: true
 	}]
 };
-var ClaudecodeHooks = class extends ToolHooks {
+var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -20773,7 +21229,13 @@ var ClaudecodeHooks = class extends ToolHooks {
 			validate
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ toolHooks } = {}) {
+		return toolHooks instanceof ClaudecodeHooks ? toolHooks.getOwnershipLockFiles() : [];
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const paths = this.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
@@ -20784,11 +21246,20 @@ var ClaudecodeHooks = class extends ToolHooks {
 			converterConfig: this.getConverterConfig(),
 			logger
 		});
+		const preserving = preserveUnowned && this.supportsPreserveUnowned();
+		const merged = mergeGeneratedHookLists({
+			existingContent,
+			generatedHooks: claudeHooks,
+			shape: "matcher-groups",
+			preserveUnowned: preserving,
+			previouslyOwned: preserving ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
+			logger
+		});
 		const fileContent = applySharedConfigPatch({
 			fileKey: CLAUDE_SETTINGS_SHARED_FILE_KEY,
 			feature: "hooks",
 			existingContent,
-			patch: { hooks: claudeHooks },
+			patch: { hooks: merged.hooks },
 			filePath
 		});
 		return new this({
@@ -20796,6 +21267,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserving ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -20853,6 +21325,14 @@ var ClaudecodePluginHooks = class extends ClaudecodeHooks {
 			projectDirVar: "$CLAUDE_PLUGIN_ROOT"
 		};
 	}
+	/**
+	* The plugin bundle is generated in full by rulesync — nothing else writes
+	* into it — so preserving there would buy nothing and cost the ability to
+	* remove a hook.
+	*/
+	static supportsPreserveUnowned() {
+		return false;
+	}
 	static getSettablePaths() {
 		return {
 			relativeDirPath: CLAUDECODE_PLUGIN_HOOKS_DIR,
@@ -21283,21 +21763,30 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			validate
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const paths = CodexcliHooks.getSettablePaths({ global });
+		const existingContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		const config = rulesyncHooks.getJson();
-		const codexHooks = canonicalToToolHooks({
-			config,
-			toolOverrideHooks: config.codexcli?.hooks,
-			converterConfig: CODEXCLI_CONVERTER_CONFIG,
+		const merged = mergeGeneratedHookLists({
+			existingContent,
+			generatedHooks: canonicalToToolHooks({
+				config,
+				toolOverrideHooks: config.codexcli?.hooks,
+				converterConfig: CODEXCLI_CONVERTER_CONFIG,
+				logger
+			}),
+			shape: "matcher-groups",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
 			logger
 		});
-		const fileContent = JSON.stringify({ hooks: codexHooks }, null, 2);
+		const fileContent = JSON.stringify({ hooks: merged.hooks }, null, 2);
 		return new CodexcliHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserveUnowned ? merged.owned : void 0,
 			validate
 		});
 	}
@@ -21333,8 +21822,11 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 			validate: false
 		});
 	}
-	static async getAuxiliaryFiles({ outputRoot = process.cwd() } = {}) {
-		return [await CodexcliConfigToml.fromOutputRoot({ outputRoot })];
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ outputRoot = process.cwd(), toolHooks } = {}) {
+		return [await CodexcliConfigToml.fromOutputRoot({ outputRoot }), ...toolHooks instanceof CodexcliHooks ? toolHooks.getOwnershipLockFiles() : []];
 	}
 };
 //#endregion
@@ -21939,7 +22431,7 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			validate
 		});
 	}
-	static fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, preserveUnowned = false, logger }) {
 		const config = rulesyncHooks.getJson();
 		const cursorSupported = new Set(CURSOR_HOOK_EVENTS);
 		const sharedHooks = {};
@@ -21966,21 +22458,36 @@ var CursorHooks = class CursorHooks extends ToolHooks {
 			}));
 			if (mappedDefs.length > 0) mappedHooks[cursorEventName] = mappedDefs;
 		}
+		const paths = CursorHooks.getSettablePaths({ global });
+		const merged = mergeGeneratedHookLists({
+			existingContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "",
+			generatedHooks: mappedHooks,
+			shape: "flat",
+			preserveUnowned,
+			previouslyOwned: preserveUnowned ? parseHooksOwnershipLock(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, HOOKS_OWNERSHIP_LOCK_FILE_NAME))) : void 0,
+			logger
+		});
 		const cursorConfig = {
 			version: config.version ?? 1,
-			hooks: mappedHooks
+			hooks: merged.hooks
 		};
 		const fileContent = JSON.stringify(cursorConfig, null, 2);
-		const paths = CursorHooks.getSettablePaths({ global });
 		return new CursorHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
+			ownedHookRefs: preserveUnowned ? merged.owned : void 0,
 			validate,
 			rulesyncHooks
 		});
 	}
+	static supportsPreserveUnowned() {
+		return true;
+	}
+	static async getAuxiliaryFiles({ toolHooks } = {}) {
+		return toolHooks instanceof CursorHooks ? toolHooks.getOwnershipLockFiles() : [];
+	}
 	toRulesyncHooks() {
 		const content = this.getFileContent();
 		const parsed = JSON.parse(content);
@@ -25220,6 +25727,186 @@ var VibeHooks = class VibeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/zcode-hooks.ts
+/**
+* Single spelling of the config.json codec/policy, matching the one in
+* ZcodeMcp: fail closed on an unparseable root rather than replacing the
+* user's primary ZCode config with generated output.
+*/
+function parseZcodeConfig$1(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Drop ZCode's native `process` hooks from an `events` map before the shared
+* import converter runs. The converter would coerce the unknown type to
+* `command` and import the executable alone — losing the `args` vector that
+* *is* the process hook's command line — so the imported hook would run
+* something else than the file states. Matcher groups left without hooks are
+* dropped with them.
+*/
+function stripProcessHooks({ events, logger }) {
+	if (!isRecord$1(events)) return events;
+	const result = Object.create(null);
+	for (const [eventName, entries] of Object.entries(events)) {
+		if (!Array.isArray(entries)) {
+			result[eventName] = entries;
+			continue;
+		}
+		const kept = [];
+		for (const entry of entries) {
+			if (!isRecord$1(entry) || !Array.isArray(entry.hooks)) {
+				kept.push(entry);
+				continue;
+			}
+			const hooks = entry.hooks.filter((hook) => {
+				if (isRecord$1(hook) && hook.type === "process") {
+					logger?.warn(`Skipping a ZCode "process" hook on "${eventName}" while importing: it has no canonical equivalent, and importing its executable alone would change what it runs.`);
+					return false;
+				}
+				return true;
+			});
+			if (hooks.length > 0) kept.push({
+				...entry,
+				hooks
+			});
+		}
+		result[eventName] = kept;
+	}
+	return result;
+}
+const ZCODE_CONVERTER_CONFIG = {
+	supportedEvents: ZCODE_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_ZCODE_EVENT_NAMES,
+	toolToCanonicalEventNames: ZCODE_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	booleanPassthroughFields: [{
+		canonical: "async",
+		tool: "async"
+	}, {
+		canonical: "enabled",
+		tool: "enabled"
+	}],
+	stringPassthroughFields: [{
+		canonical: "statusMessage",
+		tool: "statusMessage"
+	}, {
+		canonical: "shell",
+		tool: "shell",
+		commandOnly: true
+	}],
+	wildcardMatcherMeansAll: true
+};
+/**
+* ZCode hooks.
+*
+* ZCode reads configuration-file hooks from the `hooks` block of its user
+* config file, `~/.zcode/cli/config.json`. Workspace config hooks are never
+* executed — the workspace file is ignored regardless of `hooks.enabled` — so
+* rulesync treats ZCode hooks as global-only. The event map is nested under
+* `hooks.events` beside the user-tunable `enabled` and `timeoutMs` siblings,
+* which are carried over while `events` is replaced.
+*
+* @see https://zcode.z.ai/en/docs
+*/
+var ZcodeHooks = class ZcodeHooks extends ToolHooks {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = parseZcodeConfig$1(this.fileContent ?? "{}", (0, node_path.join)(this.relativeDirPath, this.relativeFilePath));
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: ZCODE_GLOBAL_CONFIG_DIR_PATH,
+			relativeFilePath: ZCODE_CONFIG_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const existing = parseZcodeConfig$1(existingContent, filePath);
+		const config = rulesyncHooks.getJson();
+		const events = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.zcode?.hooks,
+			converterConfig: ZCODE_CONVERTER_CONFIG,
+			logger
+		});
+		const existingHooks = isRecord$1(existing["hooks"]) ? existing[ZCODE_HOOKS_CONFIG_KEY] : {};
+		const shouldStateEnabled = Object.keys(events).length > 0 && existingHooks.enabled === void 0;
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "hooks",
+				existingContent,
+				patch: { [ZCODE_HOOKS_CONFIG_KEY]: {
+					...existingHooks,
+					...shouldStateEnabled ? { enabled: true } : {},
+					[ZCODE_HOOKS_EVENTS_KEY]: events
+				} },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncHooks({ logger } = {}) {
+		const hooks = toolHooksToCanonical({
+			hooks: stripProcessHooks({
+				events: (isRecord$1(this.json["hooks"]) ? this.json[ZCODE_HOOKS_CONFIG_KEY] : {})[ZCODE_HOOKS_EVENTS_KEY],
+				logger
+			}),
+			converterConfig: ZCODE_CONVERTER_CONFIG,
+			logger
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "zcode"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new ZcodeHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ [ZCODE_HOOKS_CONFIG_KEY]: { [ZCODE_HOOKS_EVENTS_KEY]: {} } }, null, 2),
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/hooks-processor.ts
 const HooksProcessorToolTargetSchema = zod_mini.z.enum(hooksProcessorToolTargetTuple);
 /**
@@ -25291,8 +25978,12 @@ const HOOKS_OVERRIDE_KEY_ALIASES = {
 	"kiro-cli": KIRO_HOOKS_OVERRIDE_KEY,
 	"kiro-ide": KIRO_HOOKS_OVERRIDE_KEY
 };
-/** The targets writing the standalone `.kiro/hooks/*.json` v1 format. */
-const KIRO_STANDALONE_HOOKS_TARGETS = /* @__PURE__ */ new Set(["kiro-cli", "kiro-ide"]);
+/** The targets whose hooks format carries a per-hook on-disk enable flag. */
+const PER_HOOK_ENABLED_TARGETS = /* @__PURE__ */ new Set([
+	"kiro-cli",
+	"kiro-ide",
+	"zcode"
+]);
 const toolHooksFactories = /* @__PURE__ */ new Map([
 	["amp", {
 		class: AmpHooks,
@@ -25641,6 +26332,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedEvents: GROKCLI_HOOK_EVENTS,
 		supportedHookTypes: ["command", "http"],
 		supportsMatcher: true
+	}],
+	["zcode", {
+		class: ZcodeHooks,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: ZCODE_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
 	}]
 ]);
 const hooksProcessorToolTargets = [...toolHooksFactories.entries()].filter(([, f]) => f.meta.supportsProject).map(([t]) => t);
@@ -25650,7 +26352,8 @@ const hooksProcessorToolTargetsGlobalImportable = [...toolHooksFactories.entries
 var HooksProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
-	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, dryRun = false, logger }) {
+	preserveUnownedHooks;
+	constructor({ outputRoot = process.cwd(), inputRoots, toolTarget, global = false, dryRun = false, preserveUnownedHooks = false, logger }) {
 		super({
 			outputRoot,
 			inputRoots,
@@ -25661,6 +26364,7 @@ var HooksProcessor = class extends FeatureProcessor {
 		if (!result.success) throw new Error(`Invalid tool target for HooksProcessor: ${toolTarget}. ${formatError(result.error)}`);
 		this.toolTarget = result.data;
 		this.global = global;
+		this.preserveUnownedHooks = preserveUnownedHooks;
 	}
 	async loadRulesyncFiles() {
 		const relativePaths = getRulesyncSourceCandidates({ paths: RulesyncHooks.getSettablePaths() }).map((candidate) => candidate.relativeFilePath);
@@ -25752,14 +26456,14 @@ var HooksProcessor = class extends FeatureProcessor {
 			}
 			for (const [hookType, events] of unsupportedTypeToEvents) this.logger.warn(`Skipped ${hookType}-type hook(s) for ${this.toolTarget} (not supported): ${Array.from(events).join(", ")}`);
 		}
-		if (!KIRO_STANDALONE_HOOKS_TARGETS.has(this.toolTarget)) {
+		if (!PER_HOOK_ENABLED_TARGETS.has(this.toolTarget)) {
 			const skippedEvents = new Set(unsupportedEventNames({
 				factory,
 				sharedHooks,
 				effectiveHooks
 			}));
 			const eventsWithDisabledHooks = Object.entries(sharedHooks).filter(([event, defs]) => !skippedEvents.has(event) && defs.some((def) => def.enabled === false)).map(([event]) => event);
-			if (eventsWithDisabledHooks.length > 0) this.logger.warn(`Emitting "enabled: false" hook(s) as active for ${this.toolTarget} (only the kiro-cli / kiro-ide standalone hooks format supports the flag): ${eventsWithDisabledHooks.join(", ")}`);
+			if (eventsWithDisabledHooks.length > 0) this.logger.warn(`Emitting "enabled: false" hook(s) as active for ${this.toolTarget} (only the kiro-cli / kiro-ide / zcode hooks formats support the flag): ${eventsWithDisabledHooks.join(", ")}`);
 		}
 		const eventsWithUnsupportedMatcher = unsupportedMatcherEventNames({
 			factory,
@@ -25771,6 +26475,7 @@ var HooksProcessor = class extends FeatureProcessor {
 			rulesyncHooks,
 			validate: true,
 			global: this.global,
+			preserveUnowned: this.preserveUnownedHooks,
 			logger: withToolTargetPrefix({
 				logger: this.logger,
 				toolTarget: this.toolTarget
@@ -69002,6 +69707,7 @@ async function generateHooksCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			preserveUnownedHooks: config.getPreserveUnownedHooks(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({