rulesync 14.2.0 → 15.0.1

package/dist/{import-CMCy95RI.js → import-BuxzyDyH.js}

@@ -1,5 +1,5 @@
-import { minLength, optional, refine, z } from "zod/mini";
 import { ZodError } from "zod";
+import { meta, minLength, nonnegative, optional, refine, z } from "zod/mini";
 import { cp, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import path, { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -14,10 +14,39 @@ import { isDeepStrictEqual } from "node:util";
 import * as smolToml from "smol-toml";
 import { parse as parse$1, stringify } from "smol-toml";
 import { encode } from "@toon-format/toon";
+//#region src/utils/error.ts
+/**
+* Convert various error types to a readable error message
+* @param error Error instance (ZodError, Error, or unknown)
+* @returns Human-readable error message
+*
+* @example
+* // ZodError
+* const result = schema.safeParse(data);
+* if (!result.success) {
+*   throw new Error(`Validation failed: ${formatError(result.error)}`);
+* }
+*
+* @example
+* // Standard Error
+* try {
+*   // some operation
+* } catch (error) {
+*   console.error(formatError(error));
+* }
+*/
+function isZodErrorLike(error) {
+	return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every((issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string");
+}
+function formatError(error) {
+	if (error instanceof ZodError || isZodErrorLike(error)) return `Zod raw error: ${JSON.stringify(error.issues)}`;
+	if (error instanceof Error) return `${error.name}: ${error.message}`;
+	return String(error);
+}
+//#endregion
 //#region src/types/features.ts
-const ALL_FEATURES = [
-	"rules",
-	"ignore",
+const ACTIVE_FEATURES_BEFORE_IGNORE = ["rules"];
+const ACTIVE_FEATURES_AFTER_IGNORE = [
 	"mcp",
 	"subagents",
 	"commands",
@@ -26,9 +55,20 @@ const ALL_FEATURES = [
 	"permissions",
 	"checks"
 ];
+const ALL_FEATURES = [
+	...ACTIVE_FEATURES_BEFORE_IGNORE,
+	"ignore",
+	...ACTIVE_FEATURES_AFTER_IGNORE
+];
 const ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
-const FeatureSchema = z.enum(ALL_FEATURES);
+const ACTIVE_FEATURES = [...ACTIVE_FEATURES_BEFORE_IGNORE, ...ACTIVE_FEATURES_AFTER_IGNORE];
+const DeprecatedIgnoreFeatureSchema = z.literal("ignore").check(meta({
+	deprecated: true,
+	description: "Deprecated: use the permissions feature. Ignore remains supported for compatibility throughout Rulesync 14.x."
+}));
+const FeatureSchema = z.union([z.enum(ACTIVE_FEATURES), DeprecatedIgnoreFeatureSchema]);
 z.array(FeatureSchema);
+const FeatureWithWildcardSchema = z.union([z.enum([...ACTIVE_FEATURES, "*"]), DeprecatedIgnoreFeatureSchema]);
 const GitignoreDestinationSchema = z.enum(["gitignore", "gitattributes"]);
 const FlattenedCommandNamingSchema = z.enum(["basename", "path"]);
 const FeatureOptionsSchema = z.record(z.string(), z.unknown());
@@ -38,8 +78,8 @@ const FeatureValueSchema = z.union([
 	GitignoreDestinationSchema
 ]);
 const PerFeatureConfigSchema = z.record(z.string(), FeatureValueSchema);
-const PerTargetFeaturesValueSchema = z.union([z.array(z.enum(ALL_FEATURES_WITH_WILDCARD)), PerFeatureConfigSchema]);
-const RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
+const PerTargetFeaturesValueSchema = z.union([z.array(FeatureWithWildcardSchema), PerFeatureConfigSchema]);
+const RulesyncFeaturesSchema = z.array(FeatureWithWildcardSchema);
 /**
 * Returns true if a per-feature value enables the feature.
 *
@@ -61,36 +101,6 @@ const isFeatureValueEnabled = (value) => {
 	return false;
 };
 //#endregion
-//#region src/utils/error.ts
-/**
-* Convert various error types to a readable error message
-* @param error Error instance (ZodError, Error, or unknown)
-* @returns Human-readable error message
-*
-* @example
-* // ZodError
-* const result = schema.safeParse(data);
-* if (!result.success) {
-*   throw new Error(`Validation failed: ${formatError(result.error)}`);
-* }
-*
-* @example
-* // Standard Error
-* try {
-*   // some operation
-* } catch (error) {
-*   console.error(formatError(error));
-* }
-*/
-function isZodErrorLike(error) {
-	return error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues) && error.issues.every((issue) => issue !== null && typeof issue === "object" && "path" in issue && Array.isArray(issue.path) && "message" in issue && typeof issue.message === "string");
-}
-function formatError(error) {
-	if (error instanceof ZodError || isZodErrorLike(error)) return `Zod raw error: ${JSON.stringify(error.issues)}`;
-	if (error instanceof Error) return `${error.name}: ${error.message}`;
-	return String(error);
-}
-//#endregion
 //#region src/constants/rulesync-paths.ts
 const { join: join$1 } = posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
@@ -101,12 +111,12 @@ const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$1(RULESYNC_RULES_RELATIVE_
 const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "commands");
 const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "subagents");
 const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$1(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
 const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
@@ -115,12 +125,12 @@ const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$1(RULESYNC_RELATIVE_DIR_PATH, "sk
 const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$1(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 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.json";
-const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
-const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.json";
-const RULESYNC_MCP_JSONC_FILE_NAME = "mcp.jsonc";
-const RULESYNC_HOOKS_JSONC_FILE_NAME = "hooks.jsonc";
-const RULESYNC_PERMISSIONS_JSONC_FILE_NAME = "permissions.jsonc";
+const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
+const RULESYNC_HOOKS_FILE_NAME = "hooks.jsonc";
+const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.jsonc";
+const RULESYNC_MCP_LEGACY_FILE_NAME = "mcp.json";
+const RULESYNC_HOOKS_LEGACY_FILE_NAME = "hooks.json";
+const RULESYNC_PERMISSIONS_LEGACY_FILE_NAME = "permissions.json";
 const RULESYNC_CONFIG_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/config-schema.json";
 const RULESYNC_MCP_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/mcp-schema.json";
 const RULESYNC_PERMISSIONS_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/permissions-schema.json";
@@ -133,6 +143,7 @@ const rulesProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"augmentcode-legacy",
 	"claudecode",
@@ -149,6 +160,7 @@ const rulesProcessorToolTargetTuple = [
 	"hermesagent",
 	"junie",
 	"kilo",
+	"kimi-code",
 	"kiro",
 	"kiro-cli",
 	"kiro-ide",
@@ -192,8 +204,10 @@ const mcpProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -205,6 +219,7 @@ const mcpProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"kilo",
 	"kiro",
 	"kiro-cli",
@@ -227,6 +242,7 @@ const commandsProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -254,6 +270,7 @@ const subagentsProcessorToolTargetTuple = [
 	"agentsmd",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -266,6 +283,7 @@ const subagentsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kiro",
 	"kiro-cli",
@@ -285,8 +303,10 @@ const skillsProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -298,6 +318,7 @@ const skillsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kilo",
 	"kiro",
@@ -320,9 +341,11 @@ const hooksProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"kilo",
 	"cursor",
 	"claudecode",
+	"claudecode-plugin",
 	"codexcli",
 	"copilot",
 	"copilotcli",
@@ -331,6 +354,7 @@ const hooksProcessorToolTargetTuple = [
 	"factorydroid",
 	"goose",
 	"hermesagent",
+	"kimi-code",
 	"deepagents",
 	"kiro",
 	"kiro-cli",
@@ -358,6 +382,7 @@ const permissionsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kilo",
 	"kiro",
@@ -388,6 +413,7 @@ const ALL_TOOL_TARGETS = [...new Set([
 ].flat())];
 const ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
 const ToolTargetSchema = z.enum(ALL_TOOL_TARGETS);
+const PACKAGING_TOOL_TARGETS = ["antigravity-plugin", "claudecode-plugin"];
 z.array(ToolTargetSchema);
 const RulesyncTargetsSchema = z.array(z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
 const RulesyncConfigTargetsObjectSchema = z.record(z.string(), PerTargetFeaturesValueSchema);
@@ -543,12 +569,12 @@ async function readFileBuffer(filepath) {
 	return readFile(filepath);
 }
 /**
-* Adds exactly one trailing newline to content.
+* Normalizes text to LF line endings and adds exactly one trailing newline.
 * Removes any existing trailing whitespace and appends a single newline.
 */
 function addTrailingNewline(content) {
 	if (!content) return "\n";
-	return content.trimEnd() + "\n";
+	return content.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trimEnd() + "\n";
 }
 async function writeFileContent(filepath, content) {
 	await ensureDir(dirname(filepath));
@@ -584,7 +610,7 @@ async function listDirectoryFiles(dir) {
 	}
 }
 async function findFilesByGlobs(globs, options = {}) {
-	const { type = "all" } = options;
+	const { type = "all", followSymbolicLinks = true } = options;
 	const globbyOptions = type === "file" ? {
 		onlyFiles: true,
 		onlyDirectories: false
@@ -597,7 +623,7 @@ async function findFilesByGlobs(globs, options = {}) {
 	};
 	const results = globbySync(Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/"), {
 		absolute: true,
-		followSymbolicLinks: true,
+		followSymbolicLinks,
 		...globbyOptions
 	});
 	const seenRealPaths = /* @__PURE__ */ new Set();
@@ -1010,12 +1036,13 @@ const CONFLICTING_TARGET_PAIRS = [["augmentcode", "augmentcode-legacy"], ["claud
 */
 const LEGACY_TARGETS = ["augmentcode-legacy", "claudecode-legacy"];
 /**
-* Expand the wildcard target (`*`) to every non-legacy tool target. Legacy
-* targets are excluded because they must be requested explicitly. Shared by
-* `Config.getTargets()` and `extractConfigFileTargets()` so the two never drift.
+* Expand the wildcard target (`*`) to every ordinary non-legacy tool target.
+* Legacy aliases and package-root targets are excluded because they must be
+* requested explicitly. Shared by `Config.getTargets()` and
+* `extractConfigFileTargets()` so the two never drift.
 */
 function expandWildcardTargets() {
-	return ALL_TOOL_TARGETS.filter((target) => !LEGACY_TARGETS.includes(target));
+	return ALL_TOOL_TARGETS.filter((target) => !LEGACY_TARGETS.includes(target) && !PACKAGING_TOOL_TARGETS.includes(target));
 }
 /**
 * Validates that the user-authored config does not double-define the
@@ -1165,7 +1192,7 @@ var Config = class Config {
 	getTargets() {
 		if (this.objectFormTargetKeys !== void 0) return this.objectFormTargetKeys;
 		const arrayTargets = Array.isArray(this.targets) ? this.targets : [];
-		if (arrayTargets.includes("*")) return expandWildcardTargets();
+		if (arrayTargets.includes("*")) return [.../* @__PURE__ */ new Set([...expandWildcardTargets(), ...arrayTargets.filter((target) => target !== "*")])];
 		return arrayTargets.filter((target) => target !== "*");
 	}
 	getConfigFileTargets() {
@@ -1547,7 +1574,7 @@ function extractConfigFileTargets(targets) {
 	if (targets === void 0) return void 0;
 	const validTargets = new Set(ALL_TOOL_TARGETS);
 	if (isRulesyncConfigTargetsObject(targets)) return Object.keys(targets).filter((key) => validTargets.has(key));
-	if (targets.includes("*")) return expandWildcardTargets();
+	if (targets.includes("*")) return [.../* @__PURE__ */ new Set([...expandWildcardTargets(), ...targets.filter((key) => key !== "*" && validTargets.has(key))])];
 	return targets.filter((key) => key !== "*" && validTargets.has(key));
 }
 //#endregion
@@ -1943,7 +1970,7 @@ const hasControlChars = (val) => CONTROL_CHARS.some((char) => val.includes(char)
 const safeString = z.pipe(z.string(), z.custom((val) => typeof val === "string" && !hasControlChars(val), "must not contain newline, carriage return, or NUL characters"));
 /**
 * Canonical hook definition.
-* Used in .rulesync/hooks.json and mapped to tool-specific formats.
+* Used in .rulesync/hooks.jsonc and mapped to tool-specific formats.
 */
 const HookDefinitionSchema = z.looseObject({
 	command: z.optional(safeString),
@@ -1957,6 +1984,7 @@ const HookDefinitionSchema = z.looseObject({
 	])),
 	url: z.optional(safeString),
 	timeout: z.optional(z.number()),
+	cacheTtl: z.optional(z.number().check(nonnegative())),
 	matcher: z.optional(safeString),
 	prompt: z.optional(safeString),
 	loop_limit: z.optional(z.nullable(z.number())),
@@ -2496,6 +2524,51 @@ const GROKCLI_HOOK_EVENTS = [
 	"postCompact"
 ];
 /**
+* Hook events supported by Kimi Code.
+*
+* Kimi Code also exposes `Interrupt`, which has no canonical rulesync event.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/hooks.html
+*/
+const KIMI_CODE_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionRequest",
+	"stop",
+	"stopFailure",
+	"notification",
+	"subagentStart",
+	"subagentStop",
+	"preCompact",
+	"postCompact"
+];
+const CANONICAL_TO_KIMI_CODE_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionRequest: "PermissionRequest",
+	stop: "Stop",
+	stopFailure: "StopFailure",
+	notification: "Notification",
+	subagentStart: "SubagentStart",
+	subagentStop: "SubagentStop",
+	preCompact: "PreCompact",
+	postCompact: "PostCompact"
+};
+const KIMI_CODE_NATIVE_HOOK_EVENTS = [
+	...Object.values(CANONICAL_TO_KIMI_CODE_EVENT_NAMES),
+	"PermissionResult",
+	"Interrupt"
+];
+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 Hermes Agent's native Shell Hooks system.
 *
 * Hermes validates hook events against a fixed `VALID_HOOKS` set:
@@ -2586,6 +2659,7 @@ const HooksConfigSchema = z.looseObject({
 	vibe: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	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) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -3112,6 +3186,28 @@ function parseJsonc(content) {
 	return deepSanitize(result);
 }
 //#endregion
+//#region src/utils/rulesync-source-path.ts
+function getRulesyncSourceCandidates({ paths }) {
+	return [paths.recommended, ...paths.legacy];
+}
+async function resolveRulesyncSourceWritePath({ outputRoot, paths }) {
+	for (const candidate of getRulesyncSourceCandidates({ paths })) {
+		const targetPath = join(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+		if (await fileExists(targetPath)) {
+			await assertWritablePathInsideRoot({
+				rootPath: outputRoot,
+				targetPath
+			});
+			return candidate;
+		}
+	}
+	await assertWritablePathInsideRoot({
+		rootPath: outputRoot,
+		targetPath: join(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath)
+	});
+	return paths.recommended;
+}
+//#endregion
 //#region src/features/hooks/rulesync-hooks.ts
 var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	json;
@@ -3125,12 +3221,14 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	}
 	static getSettablePaths() {
 		return {
-			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: RULESYNC_HOOKS_FILE_NAME,
-			jsonc: {
+			recommended: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: RULESYNC_HOOKS_JSONC_FILE_NAME
-			}
+				relativeFilePath: RULESYNC_HOOKS_FILE_NAME
+			},
+			legacy: [{
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_HOOKS_LEGACY_FILE_NAME
+			}]
 		};
 	}
 	validate() {
@@ -3146,11 +3244,7 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncHooks.getSettablePaths();
-		const candidates = [paths.jsonc, {
-			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath
-		}];
-		for (const candidate of candidates) {
+		for (const candidate of getRulesyncSourceCandidates({ paths })) {
 			const filePath = join(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
 			if (!await fileExists(filePath)) continue;
 			const fileContent = await readFileContent(filePath);
@@ -3162,7 +3256,7 @@ var RulesyncHooks = class RulesyncHooks extends RulesyncFile {
 				validate
 			});
 		}
-		throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} or ${RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH} found.`);
+		throw new Error(`No ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} or ${RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
@@ -3280,8 +3374,8 @@ const RulesyncMcpConfigSchema = z.object({ mcpServers: z.record(z.string(), Rule
 * Tool-scoped MCP block: servers that apply only to one tool. A named entry
 * replaces/adds the same-named shared server wholesale for that tool; `null`
 * removes the shared server for that tool. Mirrors `{toolname}.hooks` in
-* `.rulesync/hooks.json` and `{toolname}.permission` in
-* `.rulesync/permissions.json`.
+* `.rulesync/hooks.jsonc` and `{toolname}.permission` in
+* `.rulesync/permissions.jsonc`.
 */
 const toolScopedMcpSchema = z.looseObject({ mcpServers: z.optional(z.record(z.string(), z.nullable(RulesyncMcpServerSchema))) });
 const RulesyncMcpFileSchema = z.looseObject({
@@ -3306,6 +3400,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	hermesagent: z.optional(toolScopedMcpSchema),
 	junie: z.optional(toolScopedMcpSchema),
 	kilo: z.optional(toolScopedMcpSchema),
+	"kimi-code": z.optional(toolScopedMcpSchema),
 	kiro: z.optional(toolScopedMcpSchema),
 	opencode: z.optional(toolScopedMcpSchema),
 	qwencode: z.optional(toolScopedMcpSchema),
@@ -3333,14 +3428,13 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
 				relativeFilePath: RULESYNC_MCP_FILE_NAME
 			},
-			jsonc: {
+			legacy: [{
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: RULESYNC_MCP_JSONC_FILE_NAME
-			},
-			legacy: {
+				relativeFilePath: RULESYNC_MCP_LEGACY_FILE_NAME
+			}, {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
 				relativeFilePath: ".mcp.json"
-			}
+			}]
 		};
 	}
 	validate() {
@@ -3356,41 +3450,23 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, logger }) {
 		const paths = this.getSettablePaths();
-		const recommendedPath = join(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
-		const jsoncPath = join(outputRoot, paths.jsonc.relativeDirPath, paths.jsonc.relativeFilePath);
-		const legacyPath = join(outputRoot, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
-		if (await fileExists(jsoncPath)) {
-			const fileContent = await readFileContent(jsoncPath);
-			return new RulesyncMcp({
-				outputRoot,
-				relativeDirPath: paths.jsonc.relativeDirPath,
-				relativeFilePath: paths.jsonc.relativeFilePath,
-				fileContent,
-				validate
-			});
-		}
-		if (await fileExists(recommendedPath)) {
-			const fileContent = await readFileContent(recommendedPath);
-			return new RulesyncMcp({
-				outputRoot,
-				relativeDirPath: paths.recommended.relativeDirPath,
-				relativeFilePath: paths.recommended.relativeFilePath,
-				fileContent,
-				validate
-			});
-		}
-		if (await fileExists(legacyPath)) {
-			logger?.warn(`⚠️  Using deprecated path "${legacyPath}". Please migrate to "${recommendedPath}"`);
-			const fileContent = await readFileContent(legacyPath);
+		for (const candidate of getRulesyncSourceCandidates({ paths })) {
+			const filePath = join(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			if (candidate.relativeFilePath === ".mcp.json") {
+				const recommendedPath = join(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
+				logger?.warn(`⚠️  Using deprecated path "${filePath}". Please migrate to "${recommendedPath}"`);
+			}
+			const fileContent = await readFileContent(filePath);
 			return new RulesyncMcp({
 				outputRoot,
-				relativeDirPath: paths.legacy.relativeDirPath,
-				relativeFilePath: paths.legacy.relativeFilePath,
+				relativeDirPath: candidate.relativeDirPath,
+				relativeFilePath: candidate.relativeFilePath,
 				fileContent,
 				validate
 			});
 		}
-		const fileContent = await readFileContent(recommendedPath);
+		const fileContent = await readFileContent(join(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath));
 		return new RulesyncMcp({
 			outputRoot,
 			relativeDirPath: paths.recommended.relativeDirPath,
@@ -3591,7 +3667,7 @@ const PermissionRulesSchema = z.record(z.string(), PermissionActionSchema);
 * key it appears under. During generation the categories placed here are
 * merged over the shared `permission` block per category (the tool-scoped
 * category replaces the shared one wholesale), mirroring how
-* `.rulesync/hooks.json` merges `{toolname}.hooks` per event.
+* `.rulesync/hooks.jsonc` merges `{toolname}.hooks` per event.
 *
 * @example
 * { "claudecode": { "permission": { "bash": { "git push *": "deny" } } } }
@@ -3604,6 +3680,25 @@ const ToolScopedPermissionSchema = z.record(z.string(), PermissionRulesSchema);
 * added without a schema break.
 */
 const CanonicalPermissionsOverrideSchema = z.looseObject({ permission: z.optional(ToolScopedPermissionSchema) });
+const KimiCodePermissionsOverrideSchema = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	defaultPermissionMode: z.optional(z.enum([
+		"manual",
+		"yolo",
+		"auto"
+	])),
+	rules: z.optional(z.array(z.looseObject({
+		decision: PermissionActionSchema,
+		pattern: z.string(),
+		scope: z.optional(z.enum([
+			"turn-override",
+			"session-runtime",
+			"project",
+			"user"
+		])),
+		reason: z.optional(z.string())
+	})))
+});
 /**
 * OpenCode-specific permission value. Unlike the shared canonical block, which
 * only accepts a pattern-to-action map, OpenCode also allows a bare action
@@ -4195,6 +4290,7 @@ const PermissionsConfigSchema = z.looseObject({
 	devin: z.optional(CanonicalPermissionsOverrideSchema),
 	goose: z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: z.optional(CanonicalPermissionsOverrideSchema),
+	"kimi-code": z.optional(KimiCodePermissionsOverrideSchema),
 	rovodev: z.optional(CanonicalPermissionsOverrideSchema),
 	zed: z.optional(CanonicalPermissionsOverrideSchema)
 });
@@ -4219,12 +4315,14 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	}
 	static getSettablePaths() {
 		return {
-			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
-			jsonc: {
+			recommended: {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: RULESYNC_PERMISSIONS_JSONC_FILE_NAME
-			}
+				relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME
+			},
+			legacy: [{
+				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_PERMISSIONS_LEGACY_FILE_NAME
+			}]
 		};
 	}
 	validate() {
@@ -4240,11 +4338,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
 		const paths = RulesyncPermissions.getSettablePaths();
-		const candidates = [paths.jsonc, {
-			relativeDirPath: paths.relativeDirPath,
-			relativeFilePath: paths.relativeFilePath
-		}];
-		for (const candidate of candidates) {
+		for (const candidate of getRulesyncSourceCandidates({ paths })) {
 			const filePath = join(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
 			if (!await fileExists(filePath)) continue;
 			const fileContent = await readFileContent(filePath);
@@ -4256,7 +4350,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 				validate
 			});
 		}
-		throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} or ${RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH} found.`);
+		throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} or ${RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH} found.`);
 	}
 	getJson() {
 		return this.json;
@@ -4266,7 +4360,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	* tool-scoped `{toolname}.permission` block over the shared `permission`
 	* block, per category (the tool-scoped category replaces the shared one
 	* wholesale — mirroring how `{toolname}.hooks` merges per event in
-	* `.rulesync/hooks.json`). The consumed `permission` key is stripped from
+	* `.rulesync/hooks.jsonc`). The consumed `permission` key is stripped from
 	* the override block so verbatim-passthrough translators (e.g. the Hermes
 	* deep merge or the Codex CLI top-level key whitelist) never see it.
 	*
@@ -4631,6 +4725,16 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		"disable-model-invocation": z.optional(z.boolean()),
 		"user-invocable": z.optional(z.boolean())
 	})),
+	"kimi-code": z.optional(z.looseObject({
+		type: z.optional(z.enum([
+			"prompt",
+			"inline",
+			"flow"
+		])),
+		whenToUse: z.optional(z.string()),
+		disableModelInvocation: z.optional(z.boolean()),
+		arguments: z.optional(z.union([z.string(), z.array(z.string())]))
+	})),
 	agentsskills: z.optional(z.looseObject({
 		license: z.optional(z.string()),
 		compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
@@ -6332,6 +6436,28 @@ var ClaudecodeCommand = class ClaudecodeCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/plugin-paths.ts
+const CLAUDECODE_PLUGIN_COMMANDS_DIR = "commands";
+const CLAUDECODE_PLUGIN_AGENTS_DIR = "agents";
+const CLAUDECODE_PLUGIN_SKILLS_DIR = "skills";
+const CLAUDECODE_PLUGIN_HOOKS_DIR = "hooks";
+const CLAUDECODE_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
+const ANTIGRAVITY_PLUGIN_RULES_DIR = "rules";
+const ANTIGRAVITY_PLUGIN_SKILLS_DIR = "skills";
+const ANTIGRAVITY_PLUGIN_MCP_FILE_NAME = "mcp_config.json";
+const ANTIGRAVITY_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
+//#endregion
+//#region src/features/commands/claudecode-plugin-command.ts
+var ClaudecodePluginCommand = class extends ClaudecodeCommand {
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		const targets = rulesyncCommand.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("claudecode-plugin");
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: CLAUDECODE_PLUGIN_COMMANDS_DIR };
+	}
+};
+//#endregion
 //#region src/constants/cline-paths.ts
 const CLINE_DIR = ".cline";
 const CLINERULES_DIR = ".clinerules";
@@ -7347,6 +7473,7 @@ const TAKT_CONFIG_SHARED_FILE_KEY = ".takt/config.yaml";
 const CODEXCLI_CONFIG_SHARED_FILE_KEY = ".codex/config.toml";
 const GROKCLI_CONFIG_SHARED_FILE_KEY = ".grok/config.toml";
 const VIBE_CONFIG_SHARED_FILE_KEY = ".vibe/config.toml";
+const KIMI_CODE_CONFIG_SHARED_FILE_KEY = ".kimi-code/config.toml";
 const REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY = "reasonix.toml";
 const REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY = ".reasonix/config.toml";
 /**
@@ -7691,6 +7818,20 @@ const SHARED_CONFIG_OWNERSHIP = {
 			}
 		}
 	},
+	[KIMI_CODE_CONFIG_SHARED_FILE_KEY]: {
+		format: "toml",
+		invalidRootPolicy: "error",
+		features: {
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permission", "default_permission_mode"]
+			}
+		}
+	},
 	[REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY]: {
 		format: "toml",
 		features: {
@@ -7825,6 +7966,10 @@ const applyPermissions = (params) => {
 function toolSkillSearchRoots(paths) {
 	return [paths.relativeDirPath, ...paths.alternativeSkillRoots ?? []];
 }
+/** Ordered import roots: managed roots first, followed by read-only discovery roots. */
+function toolSkillImportRoots(paths) {
+	return [...toolSkillSearchRoots(paths), ...paths.importOnlySkillRoots ?? []];
+}
 /**
 * Abstract base class for AI development tool-specific skill formats.
 *
@@ -7907,6 +8052,13 @@ var ToolSkill = class extends AiDir {
 		throw new Error("Please implement this method in the subclass.");
 	}
 	/**
+	* Identity used to resolve duplicates across discovery roots during import.
+	* Most tools identify a skill by its directory name.
+	*/
+	getImportIdentity() {
+		return this.getDirName();
+	}
+	/**
 	* Load and parse skill directory content.
 	* This is a helper method that handles the common logic of reading SKILL.md,
 	* parsing frontmatter, and collecting other files.
@@ -8658,6 +8810,7 @@ const KIRO_IDE_HOOKS_DIR_PATH = join(KIRO_DIR, "hooks");
 const KIRO_IDE_HOOKS_FILE_NAME = "rulesync.json";
 const KIRO_MCP_FILE_NAME = "mcp.json";
 const KIRO_IGNORE_FILE_NAME = ".kiroignore";
+const KIRO_GLOBAL_IGNORE_FILE_NAME = "kiroignore";
 //#endregion
 //#region src/features/commands/kiro-command.ts
 var KiroCommand = class KiroCommand extends ToolCommand {
@@ -9938,6 +10091,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: true
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: false,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeCommand,
 		meta: {
@@ -10475,7 +10638,7 @@ var ToolHooks = class extends ToolFile {
 		return new RulesyncHooks({
 			outputRoot: this.outputRoot,
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-			relativeFilePath: "hooks.json",
+			relativeFilePath: RULESYNC_HOOKS_FILE_NAME,
 			fileContent: fileContent ?? this.fileContent
 		});
 	}
@@ -10572,7 +10735,7 @@ function isToolMatcherEntry(x) {
 /**
 * Filter the shared canonical hooks to the supported events and merge tool overrides on top.
 */
-function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
+function buildEffectiveHooks$2({ config, toolOverrideHooks, supportedEvents }) {
 	const supported = new Set(supportedEvents);
 	const sharedHooks = {};
 	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) sharedHooks[event] = defs;
@@ -10702,7 +10865,7 @@ function buildToolHooks({ defs, converterConfig }) {
 * (e.g. beforeSubmitPrompt → UserPromptSubmit).
 */
 function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logger }) {
-	const effectiveHooks = buildEffectiveHooks$1({
+	const effectiveHooks = buildEffectiveHooks$2({
 		config,
 		toolOverrideHooks,
 		supportedEvents: converterConfig.supportedEvents
@@ -10839,7 +11002,7 @@ function toolMatcherEntryToCanonical({ rawEntry, converterConfig }) {
 }
 /**
 * Assemble the canonical hooks config a tool importer writes to
-* `.rulesync/hooks.json`.
+* `.rulesync/hooks.jsonc`.
 *
 * The top-level `hooks` record only accepts canonical event names, so any
 * imported native event key without a canonical mapping is moved under the
@@ -11042,6 +11205,16 @@ var AntigravityCliHooks = class extends AntigravityHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/antigravity-plugin-hooks.ts
+var AntigravityPluginHooks = class extends AntigravityIdeHooks {
+	static getSettablePaths() {
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: ANTIGRAVITY_PLUGIN_HOOKS_FILE_NAME
+		};
+	}
+};
+//#endregion
 //#region src/utils/augmentcode-settings.ts
 /**
 * Top-level keys AugmentCode *replaces* (higher-precedence wins wholesale)
@@ -11267,7 +11440,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		tool: "if"
 	}]
 };
-var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
+var ClaudecodeHooks = class extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -11284,9 +11457,9 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		const paths = ClaudecodeHooks.getSettablePaths({ global });
+		const paths = this.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
@@ -11295,7 +11468,7 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 		});
 	}
 	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
-		const paths = ClaudecodeHooks.getSettablePaths({ global });
+		const paths = this.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
 		const config = rulesyncHooks.getJson();
@@ -11311,7 +11484,7 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 			}) },
 			filePath
 		});
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
@@ -11342,7 +11515,7 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
@@ -11352,6 +11525,19 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/claudecode-plugin-hooks.ts
+var ClaudecodePluginHooks = class extends ClaudecodeHooks {
+	isDeletable() {
+		return true;
+	}
+	static getSettablePaths() {
+		return {
+			relativeDirPath: CLAUDECODE_PLUGIN_HOOKS_DIR,
+			relativeFilePath: CLAUDECODE_PLUGIN_HOOKS_FILE_NAME
+		};
+	}
+};
+//#endregion
 //#region src/features/hooks/codexcli-hooks.ts
 const CODEXCLI_CONVERTER_CONFIG = {
 	supportedEvents: CODEXCLI_HOOK_EVENTS,
@@ -12718,7 +12904,7 @@ const HERMESAGENT_MATCHER_EVENTS = /* @__PURE__ */ new Set(["preToolUse", "postT
 * Filter the shared canonical hooks to the events Hermes understands and merge
 * the `hermesagent`-specific override block on top.
 */
-function buildEffectiveHooks(config, toolOverrideHooks) {
+function buildEffectiveHooks$1(config, toolOverrideHooks) {
 	const supported = new Set(HERMESAGENT_HOOK_EVENTS);
 	const shared = {};
 	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) shared[event] = defs;
@@ -12740,7 +12926,7 @@ function buildEffectiveHooks(config, toolOverrideHooks) {
 * matcher-less lifecycle events.
 */
 function canonicalToHermesHooks({ config, toolOverrideHooks, logger }) {
-	const effectiveHooks = buildEffectiveHooks(config, toolOverrideHooks);
+	const effectiveHooks = buildEffectiveHooks$1(config, toolOverrideHooks);
 	const result = {};
 	for (const [canonicalEvent, defs] of Object.entries(effectiveHooks)) {
 		const nativeEvent = CANONICAL_TO_HERMESAGENT_EVENT_NAMES[canonicalEvent];
@@ -13180,6 +13366,197 @@ var KiloHooks = class KiloHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/constants/kimi-code-paths.ts
+const KIMI_CODE_DIR = ".kimi-code";
+const KIMI_CODE_RULE_FILE_NAME = "AGENTS.md";
+const KIMI_CODE_MCP_FILE_NAME = "mcp.json";
+const KIMI_CODE_CONFIG_FILE_NAME = "config.toml";
+const KIMI_CODE_SKILLS_DIR_NAME = "skills";
+const KIMI_CODE_AGENTS_DIR_NAME = "agents";
+const KIMI_CODE_SKILLS_DIR_PATH = join(KIMI_CODE_DIR, KIMI_CODE_SKILLS_DIR_NAME);
+join(KIMI_CODE_DIR, KIMI_CODE_AGENTS_DIR_NAME);
+const KIMI_CODE_SHARED_SKILLS_DIR_PATH = join(".agents", "skills");
+const KIMI_CODE_SHARED_AGENTS_DIR_PATH = join(".agents", "agents");
+//#endregion
+//#region src/utils/kimi-code.ts
+function getKimiCodeHome() {
+	const configuredHome = process.env.KIMI_CODE_HOME?.trim();
+	return configuredHome ? resolve(configuredHome) : void 0;
+}
+function resolveToolOutputRoot({ outputRoot, toolTarget, global }) {
+	return toolTarget === "kimi-code" && global ? getKimiCodeHome() ?? outputRoot : outputRoot;
+}
+function getKimiCodeRelativeDirPath({ global, relativeDirPath = "." }) {
+	return global && getKimiCodeHome() ? relativeDirPath : join(KIMI_CODE_DIR, relativeDirPath);
+}
+function getKimiCodeRulesyncOutputRoot({ nativeOutputRoot, global }) {
+	return global && getKimiCodeHome() ? getHomeDirectory() : nativeOutputRoot;
+}
+//#endregion
+//#region src/features/hooks/kimi-code-hooks.ts
+function runFromTrustedDirectory({ command, trustedDirectory }) {
+	if (process.platform === "win32") return `set "RULESYNC_KIMI_HOOK_CWD=1" && cd /d "${trustedDirectory.replaceAll("%", "%%").replaceAll("\"", "\"\"")}" && ${command}`;
+	return `export RULESYNC_KIMI_HOOK_CWD=1 && cd -- '${trustedDirectory.replaceAll("'", `'"'"'`)}' && ${command}`;
+}
+function stripTrustedDirectoryWrapper(command) {
+	const posix = command.match(/^export RULESYNC_KIMI_HOOK_CWD=1 && cd -- '(?:[^']|'"'"')*' && ([\s\S]*)$/);
+	if (posix?.[1]) return posix[1];
+	return command.match(/^set "RULESYNC_KIMI_HOOK_CWD=1" && cd \/d "(?:""|[^"])*" && ([\s\S]*)$/)?.[1] ?? command;
+}
+function buildEffectiveHooks(config, toolOverrideHooks) {
+	const supported = new Set(KIMI_CODE_HOOK_EVENTS);
+	const shared = {};
+	for (const [event, definitions] of Object.entries(config.hooks)) if (supported.has(event)) shared[event] = definitions;
+	return {
+		...shared,
+		...toolOverrideHooks
+	};
+}
+function canonicalToKimiCodeHooks({ config, toolOverrideHooks, trustedDirectory, logger }) {
+	const result = [];
+	const nativeEvents = new Set(KIMI_CODE_NATIVE_HOOK_EVENTS);
+	for (const [event, definitions] of Object.entries(buildEffectiveHooks(config, toolOverrideHooks))) {
+		const nativeEvent = CANONICAL_TO_KIMI_CODE_EVENT_NAMES[event] ?? event;
+		if (!nativeEvents.has(nativeEvent)) {
+			logger?.warn(`Kimi Code hooks: skipping unsupported event "${event}".`);
+			continue;
+		}
+		for (const definition of definitions) {
+			if ((definition.type ?? "command") !== "command" || !definition.command) continue;
+			const timeout = definition.timeout;
+			const validTimeout = timeout === void 0 || Number.isInteger(timeout) && timeout >= 1 && timeout <= 600;
+			if (!validTimeout) logger?.warn(`Kimi Code hooks: omitting invalid timeout for "${event}"; expected an integer from 1 to 600 seconds.`);
+			result.push({
+				event: nativeEvent,
+				command: runFromTrustedDirectory({
+					command: definition.command,
+					trustedDirectory
+				}),
+				...definition.matcher && { matcher: definition.matcher },
+				...validTimeout && timeout !== void 0 && { timeout }
+			});
+		}
+	}
+	return result;
+}
+function kimiCodeHooksToCanonical(hooks) {
+	const result = {};
+	if (!Array.isArray(hooks)) return result;
+	for (const raw of hooks) {
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) continue;
+		const entry = raw;
+		if (typeof entry.event !== "string" || typeof entry.command !== "string") continue;
+		const event = KIMI_CODE_TO_CANONICAL_EVENT_NAMES[entry.event] ?? entry.event;
+		const definition = {
+			type: "command",
+			command: stripTrustedDirectoryWrapper(entry.command),
+			...typeof entry.matcher === "string" && { matcher: entry.matcher },
+			...typeof entry.timeout === "number" && { timeout: entry.timeout }
+		};
+		(result[event] ??= []).push(definition);
+	}
+	return result;
+}
+/**
+* Kimi Code lifecycle hooks in the shared user `config.toml`.
+*
+* Kimi Code documents hooks only at user scope. The config file also contains
+* models, providers, permissions, and other settings, so the hooks patch is
+* merged in place and the file is never deleted.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/hooks.html
+*/
+var KimiCodeHooks = class KimiCodeHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			...KimiCodeHooks.getSettablePaths({ global: params.global ?? true })
+		});
+	}
+	static getSettablePaths({ global = true } = {}) {
+		return {
+			relativeDirPath: getKimiCodeRelativeDirPath({ global }),
+			relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
+		};
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	isDeletable() {
+		return false;
+	}
+	shouldMergeExistingFileContent() {
+		return true;
+	}
+	setFileContent(fileContent) {
+		const paths = KimiCodeHooks.getSettablePaths({ global: this.global });
+		this.fileContent = applySharedConfigPatch({
+			fileKey: KIMI_CODE_CONFIG_SHARED_FILE_KEY,
+			feature: "hooks",
+			existingContent: fileContent,
+			patch: parseSharedConfig({
+				format: "toml",
+				fileContent: this.fileContent
+			}),
+			filePath: join(paths.relativeDirPath, paths.relativeFilePath)
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = true }) {
+		const paths = this.getSettablePaths({ global });
+		return new KimiCodeHooks({
+			outputRoot,
+			fileContent: await readFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)),
+			validate,
+			global
+		});
+	}
+	static fromRulesyncHooks({ outputRoot, rulesyncHooks, logger }) {
+		const config = rulesyncHooks.getJson();
+		return new KimiCodeHooks({
+			outputRoot,
+			fileContent: stringifySharedConfig({
+				format: "toml",
+				document: { hooks: canonicalToKimiCodeHooks({
+					config,
+					toolOverrideHooks: config["kimi-code"]?.hooks,
+					trustedDirectory: resolve(rulesyncHooks.getOutputRoot()),
+					logger
+				}) }
+			}),
+			global: true
+		});
+	}
+	toRulesyncHooks() {
+		const config = parseSharedConfig({
+			format: "toml",
+			fileContent: this.getFileContent()
+		});
+		return new RulesyncHooks({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+			relativeFilePath: RULESYNC_HOOKS_FILE_NAME,
+			fileContent: JSON.stringify(buildImportedHooksConfig({
+				hooks: kimiCodeHooksToCanonical(config.hooks),
+				overrideKey: "kimi-code"
+			}), null, 2)
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd() }) {
+		return new KimiCodeHooks({
+			outputRoot,
+			fileContent: "",
+			validate: false,
+			global: true
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/kiro-hooks.ts
 /**
 * Convert canonical hooks config to Kiro CLI format.
@@ -13195,6 +13572,7 @@ function buildKiroEntriesForEvent(definitions) {
 			command: def.command,
 			...def.matcher !== void 0 && def.matcher !== null && def.matcher !== "" && { matcher: def.matcher },
 			...def.timeout !== void 0 && def.timeout !== null && def.timeout > 0 && { timeout_ms: def.timeout },
+			...def.cacheTtl !== void 0 && { cache_ttl_seconds: def.cacheTtl },
 			...def.name !== void 0 && def.name !== null && { name: def.name },
 			...def.description !== void 0 && def.description !== null && { description: def.description }
 		});
@@ -13227,9 +13605,14 @@ const KiroHookEntrySchema = z.looseObject({
 	command: z.optional(safeString),
 	matcher: z.optional(z.string()),
 	timeout_ms: z.optional(z.number()),
+	cache_ttl_seconds: z.optional(z.number().check(nonnegative())),
 	name: z.optional(z.string()),
 	description: z.optional(z.string())
 });
+function importCacheTtl(entry) {
+	if (entry.cache_ttl_seconds === void 0) return {};
+	return { cacheTtl: entry.cache_ttl_seconds };
+}
 /**
 * Extract hooks from Kiro CLI agent config into canonical format.
 */
@@ -13250,6 +13633,7 @@ function kiroHooksToCanonical(kiroHooks) {
 				command: entry.command,
 				...entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" && { matcher: entry.matcher },
 				...entry.timeout_ms !== void 0 && entry.timeout_ms !== null && { timeout: entry.timeout_ms },
+				...importCacheTtl(entry),
 				...entry.name !== void 0 && entry.name !== null && { name: entry.name },
 				...entry.description !== void 0 && entry.description !== null && { description: entry.description }
 			});
@@ -14489,6 +14873,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsImport: true
+		},
+		supportedEvents: ANTIGRAVITY_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
+	}],
 	["cursor", {
 		class: CursorHooks,
 		meta: {
@@ -14517,6 +14912,23 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		],
 		supportsMatcher: true
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsImport: true
+		},
+		supportedEvents: CLAUDE_HOOK_EVENTS,
+		supportedHookTypes: [
+			"command",
+			"prompt",
+			"http",
+			"mcp_tool",
+			"agent"
+		],
+		supportsMatcher: true
+	}],
 	["codexcli", {
 		class: CodexcliHooks,
 		meta: {
@@ -14620,6 +15032,18 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["kimi-code", {
+		class: KimiCodeHooks,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: KIMI_CODE_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true,
+		passthroughOverrideEvents: true
+	}],
 	["deepagents", {
 		class: DeepagentsHooks,
 		meta: {
@@ -15795,40 +16219,45 @@ var KiloIgnore = class KiloIgnore extends ToolIgnore {
 //#endregion
 //#region src/features/ignore/kiro-ignore.ts
 var KiroIgnore = class KiroIgnore extends ToolIgnore {
-	static getSettablePaths() {
+	static getSettablePaths({ global = false } = {}) {
 		return {
-			relativeDirPath: ".",
-			relativeFilePath: KIRO_IGNORE_FILE_NAME
+			relativeDirPath: global ? KIRO_SETTINGS_DIR_PATH : ".",
+			relativeFilePath: global ? KIRO_GLOBAL_IGNORE_FILE_NAME : KIRO_IGNORE_FILE_NAME
 		};
 	}
 	toRulesyncIgnore() {
 		return this.toRulesyncIgnoreDefault();
 	}
-	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore }) {
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore, global = false }) {
+		const paths = this.getSettablePaths({ global });
 		return new KiroIgnore({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
-			fileContent: rulesyncIgnore.getFileContent()
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent(),
+			global
 		});
 	}
-	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
-		const fileContent = await readFileContent(join(outputRoot, this.getSettablePaths().relativeDirPath, this.getSettablePaths().relativeFilePath));
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
 		return new KiroIgnore({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		return new KiroIgnore({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
-			validate: false
+			validate: false,
+			global
 		});
 	}
 };
@@ -16135,6 +16564,11 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["zed", { class: ZedIgnore }]
 ]);
 const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
+const ignoreProcessorGlobalToolTargets = [
+	"kiro",
+	"kiro-cli",
+	"kiro-ide"
+];
 const defaultGetFactory$4 = (target) => {
 	const factory = toolIgnoreFactories.get(target);
 	if (!factory) throw new Error(`Unsupported tool target: ${target}`);
@@ -16144,7 +16578,8 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	toolTarget;
 	getFactory;
 	featureOptions;
-	constructor({ outputRoot = process.cwd(), inputRoot = process.cwd(), toolTarget, getFactory = defaultGetFactory$4, dryRun = false, logger, featureOptions }) {
+	global;
+	constructor({ outputRoot = process.cwd(), inputRoot = process.cwd(), toolTarget, getFactory = defaultGetFactory$4, global = false, dryRun = false, logger, featureOptions }) {
 		super({
 			outputRoot,
 			inputRoot,
@@ -16156,6 +16591,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 		this.toolTarget = result.data;
 		this.getFactory = getFactory;
 		this.featureOptions = featureOptions;
+		this.global = global;
 	}
 	async writeToolIgnoresFromRulesyncIgnores(rulesyncIgnores) {
 		const toolIgnores = await this.convertRulesyncFilesToToolFiles(rulesyncIgnores);
@@ -16180,12 +16616,16 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	async loadToolFiles({ forDeletion = false } = {}) {
 		try {
 			const factory = this.getFactory(this.toolTarget);
-			const paths = factory.class.getSettablePaths({ options: this.featureOptions });
+			const paths = factory.class.getSettablePaths({
+				options: this.featureOptions,
+				global: this.global
+			});
 			if (forDeletion) {
 				const toolIgnore = factory.class.forDeletion({
 					outputRoot: this.outputRoot,
 					relativeDirPath: paths.relativeDirPath,
-					relativeFilePath: paths.relativeFilePath
+					relativeFilePath: paths.relativeFilePath,
+					global: this.global
 				});
 				const hasOwnershipGuard = factory.class.canDeleteAuxiliaryFiles !== void 0;
 				if (!(!hasOwnershipGuard || await factory.class.canDeleteAuxiliaryFiles?.({ outputRoot: this.outputRoot }) === true)) return [];
@@ -16205,7 +16645,8 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	async loadToolIgnores() {
 		return [await this.getFactory(this.toolTarget).class.fromFile({
 			outputRoot: this.outputRoot,
-			options: this.featureOptions
+			options: this.featureOptions,
+			global: this.global
 		})];
 	}
 	/**
@@ -16219,7 +16660,8 @@ var IgnoreProcessor = class extends FeatureProcessor {
 		const toolIgnore = await factory.class.fromRulesyncIgnore({
 			outputRoot: this.outputRoot,
 			rulesyncIgnore,
-			options: this.featureOptions
+			options: this.featureOptions,
+			global: this.global
 		});
 		const auxiliaryFiles = await factory.class.getAuxiliaryFiles?.({
 			toolIgnore,
@@ -16241,7 +16683,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 	* Return the tool targets that this processor supports
 	*/
 	static getToolTargets({ global = false } = {}) {
-		if (global) throw new Error("IgnoreProcessor does not support global mode");
+		if (global) return ignoreProcessorGlobalToolTargets;
 		return ignoreProcessorToolTargets;
 	}
 };
@@ -16681,6 +17123,16 @@ var AntigravityIdeMcp = class extends AntigravityMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/antigravity-plugin-mcp.ts
+var AntigravityPluginMcp = class extends AntigravityIdeMcp {
+	static getSettablePaths() {
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: ANTIGRAVITY_PLUGIN_MCP_FILE_NAME
+		};
+	}
+};
+//#endregion
 //#region src/features/mcp/augmentcode-mcp.ts
 function parseAugmentcodeSettings(fileContent, relativeDirPath, relativeFilePath) {
 	const configPath = join(relativeDirPath, relativeFilePath);
@@ -17100,7 +17552,7 @@ function convertToCodexFormat(mcpServers) {
 	for (const [name, config] of Object.entries(mcpServers)) {
 		if (!isRecord(config)) continue;
 		const { codexName, usedFallback } = normalizeCodexMcpServerName(name);
-		if (usedFallback) warnWithFallback(void 0, `MCP server "${name}" cannot be represented as a Codex MCP server name (ASCII [a-zA-Z0-9_-] only), so the stable fallback name "${codexName}" was used. Rename the server in .rulesync/mcp.json to choose a readable Codex name.`);
+		if (usedFallback) warnWithFallback(void 0, `MCP server "${name}" cannot be represented as a Codex MCP server name (ASCII [a-zA-Z0-9_-] only), so the stable fallback name "${codexName}" was used. Rename the server in .rulesync/mcp.jsonc to choose a readable Codex name.`);
 		const converted = {};
 		for (const [key, value] of Object.entries(config)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
@@ -18909,6 +19361,170 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/kimi-code-mcp.ts
+function normalizeKimiCodeTransport({ transport, hasCommand }) {
+	if (transport === "local" || transport === "stdio") return "stdio";
+	if (transport === "sse") return "sse";
+	if (transport === "http" || transport === "streamable-http") return "http";
+	return hasCommand ? "stdio" : "http";
+}
+function toKimiCodeServer({ name, server, logger }) {
+	const transport = server.transport ?? server.type;
+	if (transport === "ws") {
+		logger?.warn(`Kimi Code MCP: skipping "${name}" because WebSocket transport is unsupported.`);
+		return null;
+	}
+	const command = server.command;
+	const normalizedCommand = Array.isArray(command) ? command[0] : command;
+	const args = [...Array.isArray(command) ? command.slice(1) : [], ...server.args ?? []];
+	const url = server.httpUrl ?? server.url;
+	const normalizedTransport = normalizeKimiCodeTransport({
+		transport,
+		hasCommand: normalizedCommand !== void 0
+	});
+	if (normalizedTransport === "stdio" && !normalizedCommand || normalizedTransport !== "stdio" && !url) {
+		logger?.warn(`Kimi Code MCP: skipping "${name}" because its ${normalizedTransport} configuration is incomplete.`);
+		return null;
+	}
+	const converted = {
+		transport: normalizedTransport,
+		...normalizedCommand && { command: normalizedCommand },
+		...args.length > 0 && { args },
+		...url && { url }
+	};
+	for (const field of [
+		"env",
+		"cwd",
+		"headers",
+		"bearerTokenEnvVar",
+		"enabled",
+		"startupTimeoutMs",
+		"toolTimeoutMs",
+		"enabledTools",
+		"disabledTools"
+	]) if (server[field] !== void 0) converted[field] = server[field];
+	if (server.disabled === true) converted.enabled = false;
+	return converted;
+}
+function toKimiCodeServers({ servers, logger }) {
+	const result = {};
+	for (const [name, server] of Object.entries(servers)) {
+		const converted = toKimiCodeServer({
+			name,
+			server,
+			logger
+		});
+		if (converted) result[name] = converted;
+	}
+	return result;
+}
+function fromKimiCodeServers(servers) {
+	return Object.fromEntries(Object.entries(servers).map(([name, server]) => {
+		const { transport, enabled, ...rest } = server;
+		const type = transport === "stdio" || transport === "sse" || transport === "http" ? transport : void 0;
+		return [name, {
+			...rest,
+			...type && { type },
+			...enabled === false && { disabled: true }
+		}];
+	}));
+}
+/**
+* Kimi Code MCP configuration.
+*
+* Both project and user scope use `.kimi-code/mcp.json`, resolved against the
+* project root or home directory respectively.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/mcp.html
+*/
+var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		try {
+			this.json = this.fileContent ? JSON.parse(this.fileContent) : {};
+		} catch (error) {
+			throw new Error(`Failed to parse Kimi Code MCP config at ${join(this.relativeDirPath, this.relativeFilePath)}: ${formatError(error)}`, { cause: error });
+		}
+	}
+	isDeletable() {
+		return !this.global;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: getKimiCodeRelativeDirPath({ global }),
+			relativeFilePath: KIMI_CODE_MCP_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)) ?? "{\"mcpServers\":{}}";
+		return new KimiCodeMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		let existing;
+		try {
+			existing = JSON.parse(existingContent);
+		} catch (error) {
+			throw new Error(`Failed to parse Kimi Code MCP config at ${filePath}: ${formatError(error)}`, { cause: error });
+		}
+		return new KimiCodeMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify({
+				...existing,
+				mcpServers: toKimiCodeServers({
+					servers: rulesyncMcp.getMcpServers(),
+					logger
+				})
+			}, null, 2),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		return new RulesyncMcp({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+			relativeFilePath: RULESYNC_MCP_FILE_NAME,
+			fileContent: JSON.stringify({
+				...this.json,
+				mcpServers: fromKimiCodeServers(isMcpServers(this.json.mcpServers) ? this.json.mcpServers : {})
+			}, null, 2)
+		});
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new KimiCodeMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/kiro-mcp.ts
 var KiroMcp = class KiroMcp extends ToolMcp {
 	json;
@@ -19717,7 +20333,7 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 * `workflow_mcp_servers: { stdio, sse, http }`. Without it, workflow-defined MCP
 * servers are refused regardless of how they are declared. So this adapter emits
 * the transport allowlist derived from the transports present in
-* `.rulesync/mcp.json`, enabling exactly the transports the user's servers need.
+* `.rulesync/mcp.jsonc`, enabling exactly the transports the user's servers need.
 *
 * Lossiness (documented, intentional): the per-server names, commands, env, URLs
 * and headers are NOT representable in `config.yaml` and are intentionally not
@@ -20237,6 +20853,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsEnabledTools: false,
+			supportsDisabledTools: true
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeMcp,
 		meta: {
@@ -20255,6 +20880,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodeMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeMcp,
 		meta: {
@@ -20354,6 +20988,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
+		}
+	}],
 	["kilo", {
 		class: KiloMcp,
 		meta: {
@@ -20369,7 +21012,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["kiro-cli", {
@@ -20378,7 +21021,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["kiro-ide", {
@@ -20387,7 +21030,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["junie", {
@@ -22954,7 +23597,7 @@ function mergeFilesystemCategoryRules({ categoryRules, logger }) {
 function buildCodexBashRulesContent(config) {
 	const bashRules = config.permission.bash ?? {};
 	const entries = Object.entries(bashRules);
-	const header = ["# Generated by Rulesync from .rulesync/permissions.json (permission.bash)", "# https://developers.openai.com/codex/rules"];
+	const header = ["# Generated by Rulesync from .rulesync/permissions.jsonc (permission.bash)", "# https://developers.openai.com/codex/rules"];
 	if (entries.length === 0) return [...header, "# No bash permission rules were configured."].join("\n");
 	const ruleBlocks = entries.map(([pattern, action]) => {
 		const tokens = toCommandPatternTokens(pattern);
@@ -24414,8 +25057,9 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 		});
 		const permissions = config.permissions && typeof config.permissions === "object" ? config.permissions.rulesync : {};
 		return new RulesyncPermissions({
-			relativeDirPath: "",
-			relativeFilePath: ".rulesync/permissions.json",
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
 			fileContent: JSON.stringify(permissions ?? {}, null, 2)
 		});
 	}
@@ -24837,7 +25481,7 @@ var KiloPermissions = class KiloPermissions extends ToolPermissions {
 		}
 		if (Object.keys(droppedDenyByKey).length > 0) {
 			const summary = Object.entries(droppedDenyByKey).map(([key, patterns]) => `${key}: [${patterns.join(", ")}]`).join("; ");
-			logger?.warn(`WARNING: Kilo permissions regeneration drops existing 'deny' rule(s) because rulesync output owns these tool keys. Dropped — ${summary}. To preserve these denies, add them to '.rulesync/permissions.json'.`);
+			logger?.warn(`WARNING: Kilo permissions regeneration drops existing 'deny' rule(s) because rulesync output owns these tool keys. Dropped — ${summary}. To preserve these denies, add them to '.rulesync/permissions.jsonc'.`);
 		}
 		const mergedPermission = {
 			...existingPermission,
@@ -24897,6 +25541,227 @@ var KiloPermissions = class KiloPermissions extends ToolPermissions {
 	}
 };
 //#endregion
+//#region src/features/permissions/kimi-code-permissions.ts
+const CATEGORY_TO_KIMI_CODE_TOOL = {
+	bash: "Bash",
+	read: "Read",
+	write: "Write",
+	edit: "Edit",
+	grep: "Grep",
+	glob: "Glob",
+	websearch: "WebSearch",
+	webfetch: "FetchURL",
+	agent: "Agent"
+};
+function buildKimiCodePattern(category, pattern) {
+	if (category.startsWith("mcp__")) return pattern === "*" || pattern === "" ? category : null;
+	if (category === "mcp") return pattern === "*" || pattern === "" ? "mcp__*" : `mcp__${pattern}`;
+	const tool = CATEGORY_TO_KIMI_CODE_TOOL[category];
+	if (!tool) return null;
+	return pattern === "*" || pattern === "" ? tool : `${tool}(${pattern})`;
+}
+function canonicalToKimiCodeRules({ config, logger }) {
+	const canonicalRules = [];
+	const overrideRules = config["kimi-code"]?.rules ?? [];
+	for (const [category, rules] of Object.entries(config.permission)) {
+		if (!(category === "mcp" || category.startsWith("mcp__") || CATEGORY_TO_KIMI_CODE_TOOL[category] !== void 0)) {
+			if (Object.keys(rules).length > 0) logger?.warn(`Kimi Code permissions: skipping unsupported category "${category}".`);
+			continue;
+		}
+		for (const [pattern, decision] of Object.entries(rules)) {
+			if (category.startsWith("mcp__") && pattern !== "*" && pattern !== "") {
+				if (decision === "deny") {
+					logger?.warn(`Kimi Code permissions: broadening argument-specific deny for "${category}" to the whole MCP tool because Kimi does not match MCP tool arguments.`);
+					canonicalRules.push({
+						decision,
+						pattern: category,
+						scope: "user"
+					});
+				} else logger?.warn(`Kimi Code permissions: skipping argument-specific ${decision} for "${category}" because Kimi does not match MCP tool arguments.`);
+				continue;
+			}
+			const kimiCodePattern = buildKimiCodePattern(category, pattern);
+			if (!kimiCodePattern) continue;
+			canonicalRules.push({
+				decision,
+				pattern: kimiCodePattern,
+				scope: "user"
+			});
+		}
+	}
+	return [...overrideRules, ...sortKimiCodeRulesFailClosed(canonicalRules)];
+}
+function getKimiCodePatternSpecificity(pattern) {
+	const opening = pattern.indexOf("(");
+	const hasArguments = opening >= 0 && pattern.endsWith(")");
+	const tool = hasArguments ? pattern.slice(0, opening) : pattern;
+	const argument = hasArguments ? pattern.slice(opening + 1, -1) : "";
+	return {
+		tool,
+		toolLiteralLength: tool.replaceAll("*", "").replaceAll("?", "").length,
+		toolWildcardCount: [...tool].filter((character) => "*?".includes(character)).length,
+		literalLength: argument.replaceAll("*", "").replaceAll("?", "").replaceAll("[", "").replaceAll("]", "").length,
+		wildcardCount: [...argument].filter((character) => "*?[]".includes(character)).length,
+		hasArguments
+	};
+}
+function sortKimiCodeRulesFailClosed(rules) {
+	const actionPriority = {
+		deny: 0,
+		ask: 1,
+		allow: 2
+	};
+	return rules.map((rule, index) => ({
+		rule,
+		index,
+		specificity: getKimiCodePatternSpecificity(rule.pattern)
+	})).toSorted((left, right) => {
+		const actionOrder = actionPriority[left.rule.decision] - actionPriority[right.rule.decision];
+		if (actionOrder !== 0) return actionOrder;
+		if (left.specificity.tool.startsWith("mcp__") && right.specificity.tool.startsWith("mcp__")) {
+			const toolLiteralOrder = right.specificity.toolLiteralLength - left.specificity.toolLiteralLength;
+			if (toolLiteralOrder !== 0) return toolLiteralOrder;
+			const toolWildcardOrder = left.specificity.toolWildcardCount - right.specificity.toolWildcardCount;
+			if (toolWildcardOrder !== 0) return toolWildcardOrder;
+		}
+		const toolOrder = left.specificity.tool.localeCompare(right.specificity.tool);
+		if (toolOrder !== 0) return toolOrder;
+		if (left.specificity.hasArguments !== right.specificity.hasArguments) return left.specificity.hasArguments ? -1 : 1;
+		const literalOrder = right.specificity.literalLength - left.specificity.literalLength;
+		if (literalOrder !== 0) return literalOrder;
+		const wildcardOrder = left.specificity.wildcardCount - right.specificity.wildcardCount;
+		if (wildcardOrder !== 0) return wildcardOrder;
+		return left.index - right.index;
+	}).map(({ rule }) => rule);
+}
+function preserveKimiCodeRules(rules) {
+	const permission = {};
+	const nativeRules = [];
+	if (!Array.isArray(rules)) return {
+		permission,
+		nativeRules
+	};
+	for (const raw of rules) {
+		if (!isRecord(raw)) continue;
+		const decision = raw.decision;
+		const pattern = raw.pattern;
+		if (decision !== "allow" && decision !== "ask" && decision !== "deny" || typeof pattern !== "string") continue;
+		nativeRules.push({
+			decision,
+			pattern,
+			...typeof raw.scope === "string" && { scope: raw.scope },
+			...typeof raw.reason === "string" && { reason: raw.reason }
+		});
+	}
+	return {
+		permission,
+		nativeRules
+	};
+}
+/**
+* Kimi Code permission rules in the shared user `config.toml`.
+*
+* @see https://moonshotai.github.io/kimi-code/en/configuration/config-files.html
+*/
+var KimiCodePermissions = class KimiCodePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			...KimiCodePermissions.getSettablePaths({ global: params.global ?? true })
+		});
+	}
+	static getSettablePaths({ global = true } = {}) {
+		return {
+			relativeDirPath: getKimiCodeRelativeDirPath({ global }),
+			relativeFilePath: KIMI_CODE_CONFIG_FILE_NAME
+		};
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	isDeletable() {
+		return false;
+	}
+	shouldMergeExistingFileContent() {
+		return true;
+	}
+	setFileContent(fileContent) {
+		const paths = KimiCodePermissions.getSettablePaths({ global: this.global });
+		this.fileContent = applySharedConfigPatch({
+			fileKey: KIMI_CODE_CONFIG_SHARED_FILE_KEY,
+			feature: "permissions",
+			existingContent: fileContent,
+			patch: parseSharedConfig({
+				format: "toml",
+				fileContent: this.fileContent
+			}),
+			filePath: join(paths.relativeDirPath, paths.relativeFilePath)
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = true }) {
+		const paths = this.getSettablePaths({ global });
+		return new KimiCodePermissions({
+			outputRoot,
+			fileContent: await readFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)),
+			validate,
+			global
+		});
+	}
+	static fromRulesyncPermissions({ outputRoot, rulesyncPermissions, logger }) {
+		const config = rulesyncPermissions.getJson();
+		const defaultPermissionMode = config["kimi-code"]?.defaultPermissionMode;
+		return new KimiCodePermissions({
+			outputRoot,
+			fileContent: stringifySharedConfig({
+				format: "toml",
+				document: {
+					...defaultPermissionMode && { default_permission_mode: defaultPermissionMode },
+					permission: { rules: canonicalToKimiCodeRules({
+						config,
+						logger
+					}) }
+				}
+			}),
+			global: true
+		});
+	}
+	toRulesyncPermissions() {
+		const config = parseSharedConfig({
+			format: "toml",
+			fileContent: this.getFileContent()
+		});
+		const { permission, nativeRules } = preserveKimiCodeRules((isRecord(config.permission) ? config.permission : {}).rules);
+		const defaultPermissionMode = config.default_permission_mode;
+		const toolOverride = {
+			...defaultPermissionMode === "manual" || defaultPermissionMode === "yolo" || defaultPermissionMode === "auto" ? { defaultPermissionMode } : {},
+			...nativeRules.length > 0 && { rules: nativeRules }
+		};
+		return new RulesyncPermissions({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
+			fileContent: JSON.stringify({
+				permission,
+				...Object.keys(toolOverride).length > 0 && { "kimi-code": toolOverride }
+			}, null, 2)
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd() }) {
+		return new KimiCodePermissions({
+			outputRoot,
+			fileContent: "",
+			validate: false,
+			global: true
+		});
+	}
+};
+//#endregion
 //#region src/features/permissions/kiro-permissions.ts
 const KiroAgentSchema = z.looseObject({
 	allowedTools: z.optional(z.array(z.string())),
@@ -27112,6 +27977,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodePermissions,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["junie", {
 		class: JuniePermissions,
 		meta: {
@@ -28205,6 +29078,17 @@ var AntigravityIdeSkill = class extends AntigravitySharedSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/antigravity-plugin-skill.ts
+var AntigravityPluginSkill = class extends AntigravityIdeSkill {
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("antigravity-plugin");
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: ANTIGRAVITY_PLUGIN_SKILLS_DIR };
+	}
+};
+//#endregion
 //#region src/features/skills/augmentcode-skill.ts
 const AugmentcodeSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -28399,7 +29283,7 @@ function buildClaudecodeSkillFrontmatter({ rulesyncFrontmatter, resolvedDisableM
 * Unlike subagents and commands, skills are directories containing SKILL.md and other files.
 * Extends ToolSkill to inherit directory management and security features from AiDir.
 */
-var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
+var ClaudecodeSkill = class extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = CLAUDECODE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
 		super({
 			outputRoot,
@@ -28494,9 +29378,9 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 				section: rulesyncFrontmatter.claudecode
 			})
 		});
-		const settablePaths = ClaudecodeSkill.getSettablePaths({ global });
+		const settablePaths = this.getSettablePaths({ global });
 		const relativeDirPath = rulesyncFrontmatter.claudecode?.["scheduled-task"] ? CLAUDECODE_SCHEDULED_TASKS_DIR_PATH : settablePaths.relativeDirPath;
-		return new ClaudecodeSkill({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
@@ -28516,14 +29400,14 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
-			getSettablePaths: ClaudecodeSkill.getSettablePaths
+			getSettablePaths: (options) => this.getSettablePaths(options)
 		});
 		const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new ClaudecodeSkill({
+		return new this({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -28535,7 +29419,7 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
-		return new ClaudecodeSkill({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			dirName,
@@ -28551,6 +29435,17 @@ var ClaudecodeSkill = class ClaudecodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/claudecode-plugin-skill.ts
+var ClaudecodePluginSkill = class extends ClaudecodeSkill {
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("claudecode-plugin");
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: CLAUDECODE_PLUGIN_SKILLS_DIR };
+	}
+};
+//#endregion
 //#region src/features/skills/cline-skill.ts
 const ClineSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -30340,6 +31235,197 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/kimi-code-skill.ts
+const KimiCodeSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.string(),
+	type: z.optional(z.enum([
+		"prompt",
+		"inline",
+		"flow"
+	])),
+	whenToUse: z.optional(z.string()),
+	disableModelInvocation: z.optional(z.boolean()),
+	arguments: z.optional(z.union([z.string(), z.array(z.string())]))
+});
+const KimiCodeFlatSkillFrontmatterSchema = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	type: z.optional(z.enum([
+		"prompt",
+		"inline",
+		"flow"
+	])),
+	whenToUse: z.optional(z.string()),
+	disableModelInvocation: z.optional(z.boolean()),
+	arguments: z.optional(z.union([z.string(), z.array(z.string())]))
+});
+function logicalSkillDirName(name) {
+	const normalized = name.toLowerCase();
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(normalized) ? normalized : `kimi-${encodeURIComponent(normalized)}`;
+}
+/**
+* Kimi Code Agent Skill.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/skills.html
+*/
+var KimiCodeSkill = class KimiCodeSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = KIMI_CODE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global = false } = {}) {
+		const customHome = global ? getKimiCodeHome() : void 0;
+		return {
+			relativeDirPath: getKimiCodeRelativeDirPath({
+				global,
+				relativeDirPath: KIMI_CODE_SKILLS_DIR_NAME
+			}),
+			importOnlySkillRoots: [customHome ? {
+				outputRoot: getHomeDirectory(),
+				relativeDirPath: KIMI_CODE_SHARED_SKILLS_DIR_PATH
+			} : KIMI_CODE_SHARED_SKILLS_DIR_PATH]
+		};
+	}
+	getFrontmatter() {
+		return KimiCodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	getImportIdentity() {
+		return this.getFrontmatter().name.toLowerCase();
+	}
+	validate() {
+		if (!this.mainFile) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = KimiCodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		return result.success ? {
+			success: true,
+			error: null
+		} : {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+	}
+	toRulesyncSkill() {
+		const { name, description, disableModelInvocation, ...kimiCodeFrontmatter } = this.getFrontmatter();
+		const toolSection = {
+			...kimiCodeFrontmatter,
+			...disableModelInvocation !== void 0 && { disableModelInvocation }
+		};
+		const frontmatter = {
+			name,
+			description,
+			targets: ["*"],
+			...disableModelInvocation !== void 0 && { "disable-model-invocation": disableModelInvocation },
+			...Object.keys(toolSection).length > 0 && { "kimi-code": toolSection }
+		};
+		return new RulesyncSkill({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: logicalSkillDirName(name),
+			frontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const frontmatter = rulesyncSkill.getFrontmatter();
+		const kimiCodeSection = frontmatter["kimi-code"] ?? {};
+		const kimiCodeFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			...frontmatter["disable-model-invocation"] !== void 0 && { disableModelInvocation: frontmatter["disable-model-invocation"] },
+			...kimiCodeSection
+		};
+		return new KimiCodeSkill({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: kimiCodeFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("kimi-code");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: KimiCodeSkill.getSettablePaths
+		});
+		const result = KimiCodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		return new KimiCodeSkill({
+			...loaded,
+			frontmatter: result.data,
+			validate: true
+		});
+	}
+	static async fromFlatFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const filePath = join(outputRoot, relativeDirPath, relativeFilePath);
+		const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = KimiCodeFlatSkillFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		const fileName = basename(relativeFilePath, extname(relativeFilePath));
+		const firstBodyLine = body.split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "");
+		const normalizedFrontmatter = {
+			...result.data,
+			name: result.data.name ?? fileName,
+			description: result.data.description ?? firstBodyLine?.slice(0, 240) ?? "No description provided."
+		};
+		return new KimiCodeSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName: fileName,
+			frontmatter: normalizedFrontmatter,
+			body: body.trim(),
+			validate: true,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new KimiCodeSkill({
+			outputRoot,
+			relativeDirPath: relativeDirPath ?? this.getSettablePaths({ global }).relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/skills/kiro-skill.ts
 const KiroSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -32066,6 +33152,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: false
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeSkill,
 		meta: {
@@ -32082,6 +33176,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: false
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeSkill,
 		meta: {
@@ -32186,6 +33288,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["kiro", {
 		class: KiroSkill,
 		meta: {
@@ -32407,36 +33517,56 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 	*/
 	async loadToolDirs() {
 		const factory = this.getFactory(this.toolTarget);
-		const roots = toolSkillSearchRoots(factory.class.getSettablePaths({ global: this.global }));
-		const seenDirNames = /* @__PURE__ */ new Set();
-		const loadEntries = [];
+		const roots = toolSkillImportRoots(factory.class.getSettablePaths({ global: this.global }));
+		const seenSkillNames = /* @__PURE__ */ new Set();
+		const toolSkills = [];
 		for (const root of roots) {
-			const skillsDirPath = join(this.outputRoot, root);
+			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
+			const relativeDirPath = typeof root === "string" ? root : root.relativeDirPath;
+			const skillsDirPath = join(rootOutputRoot, relativeDirPath);
 			if (!await directoryExists(skillsDirPath)) continue;
 			const dirPaths = await findFilesByGlobs(join(skillsDirPath, "*"), { type: "dir" });
+			const ownedDirNames = [];
 			for (const dirPath of dirPaths) {
 				const dirName = basename(dirPath);
-				if (seenDirNames.has(dirName)) continue;
 				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
-					outputRoot: this.outputRoot,
-					relativeDirPath: root,
+					outputRoot: rootOutputRoot,
+					relativeDirPath,
 					dirName,
 					inputRoot: this.inputRoot
 				})) continue;
-				seenDirNames.add(dirName);
-				loadEntries.push({
-					root,
-					dirName
-				});
+				ownedDirNames.push(dirName);
+			}
+			const directorySkills = await Promise.all(ownedDirNames.map((dirName) => factory.class.fromDir({
+				outputRoot: rootOutputRoot,
+				relativeDirPath,
+				dirName,
+				global: this.global
+			})));
+			for (const skill of directorySkills) {
+				const skillName = skill.getImportIdentity();
+				if (seenSkillNames.has(skillName)) continue;
+				seenSkillNames.add(skillName);
+				toolSkills.push(skill);
+			}
+			if (!factory.class.fromFlatFile) continue;
+			const fromFlatFile = factory.class.fromFlatFile;
+			const directoryStems = new Set(ownedDirNames);
+			const flatFilePaths = (await findFilesByGlobs(join(skillsDirPath, "*.md"), { type: "file" })).filter((filePath) => !directoryStems.has(basename(filePath, ".md")));
+			const flatSkills = await Promise.all(flatFilePaths.map((filePath) => fromFlatFile({
+				outputRoot: rootOutputRoot,
+				relativeDirPath,
+				relativeFilePath: basename(filePath),
+				global: this.global
+			})));
+			for (const skill of flatSkills) {
+				const skillName = skill.getImportIdentity();
+				if (seenSkillNames.has(skillName)) continue;
+				seenSkillNames.add(skillName);
+				toolSkills.push(skill);
 			}
 		}
-		const toolSkills = await Promise.all(loadEntries.map(({ root, dirName }) => factory.class.fromDir({
-			outputRoot: this.outputRoot,
-			relativeDirPath: root,
-			dirName,
-			global: this.global
-		})));
-		this.logger.debug(`Successfully loaded ${toolSkills.length} skills from ${roots.length} root(s): ${roots.join(", ")}`);
+		this.logger.debug(`Successfully loaded ${toolSkills.length} skills from ${roots.length} root(s)`);
 		return toolSkills;
 	}
 	async loadToolDirsToDelete() {
@@ -32446,8 +33576,19 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 		for (const root of roots) {
 			const skillsDirPath = join(this.outputRoot, root);
 			if (!await directoryExists(skillsDirPath)) continue;
-			const dirPaths = await findFilesByGlobs(join(skillsDirPath, "*"), { type: "dir" });
+			await assertWritablePathInsideRoot({
+				rootPath: this.outputRoot,
+				targetPath: skillsDirPath
+			});
+			const dirPaths = await findFilesByGlobs(join(skillsDirPath, "*"), {
+				type: "dir",
+				followSymbolicLinks: false
+			});
 			for (const dirPath of dirPaths) {
+				await assertWritablePathInsideRoot({
+					rootPath: skillsDirPath,
+					targetPath: dirPath
+				});
 				const dirName = basename(dirPath);
 				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
 					outputRoot: this.outputRoot,
@@ -32537,6 +33678,10 @@ var ToolSubagent = class extends ToolFile {
 	static fromRulesyncSubagent(_params) {
 		throw new Error("Please implement this method in the subclass.");
 	}
+	/** Identity used to resolve duplicate imports across discovery roots. */
+	getImportIdentity() {
+		return this.getRelativeFilePath();
+	}
 	static isTargetedByRulesyncSubagent(_rulesyncSubagent) {
 		throw new Error("Please implement this method in the subclass.");
 	}
@@ -33198,6 +34343,17 @@ var ClaudecodeSubagent = class ClaudecodeSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/claudecode-plugin-subagent.ts
+var ClaudecodePluginSubagent = class extends ClaudecodeSubagent {
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		const targets = rulesyncSubagent.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("claudecode-plugin");
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: CLAUDECODE_PLUGIN_AGENTS_DIR };
+	}
+};
+//#endregion
 //#region src/features/subagents/cline-subagent.ts
 const ClineSubagentFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -35185,9 +36341,153 @@ var KiloSubagent = class KiloSubagent extends OpenCodeStyleSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/kimi-code-subagent.ts
+const KimiCodeAgentNameSchema = z.pipe(z.string(), z.custom((value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value), "must be a kebab-case name"));
+const KimiCodeSubagentFrontmatterSchema = z.looseObject({
+	name: z.optional(KimiCodeAgentNameSchema),
+	description: z.string(),
+	whenToUse: z.optional(z.string()),
+	override: z.optional(z.boolean()),
+	tools: z.optional(z.union([z.string(), z.array(z.string())])),
+	disallowedTools: z.optional(z.union([z.string(), z.array(z.string())])),
+	subagents: z.optional(z.union([z.string(), z.array(z.string())]))
+});
+/**
+* Kimi Code custom agent.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/agents.html
+*/
+var KimiCodeSubagent = class KimiCodeSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = KimiCodeSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${join(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		const customHome = global ? getKimiCodeHome() : void 0;
+		return {
+			relativeDirPath: getKimiCodeRelativeDirPath({
+				global,
+				relativeDirPath: KIMI_CODE_AGENTS_DIR_NAME
+			}),
+			importDirPaths: [customHome ? {
+				outputRoot: getHomeDirectory(),
+				relativeDirPath: KIMI_CODE_SHARED_AGENTS_DIR_PATH
+			} : KIMI_CODE_SHARED_AGENTS_DIR_PATH]
+		};
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	getImportIdentity() {
+		const fileName = basename(this.getRelativeFilePath(), extname(this.getRelativeFilePath()));
+		return KimiCodeAgentNameSchema.parse(this.frontmatter.name ?? fileName).toLowerCase();
+	}
+	toRulesyncSubagent() {
+		const { name: _name, description, ...rest } = this.frontmatter;
+		const resolvedName = this.getImportIdentity();
+		const frontmatter = {
+			targets: ["*"],
+			name: resolvedName,
+			description,
+			...Object.keys(rest).length > 0 && { "kimi-code": rest }
+		};
+		return new RulesyncSubagent({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: `${resolvedName}.md`,
+			frontmatter,
+			body: this.body,
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const frontmatter = rulesyncSubagent.getFrontmatter();
+		const toolSection = frontmatter["kimi-code"] ?? {};
+		const kimiCodeFrontmatter = KimiCodeSubagentFrontmatterSchema.parse({
+			name: frontmatter.name,
+			description: frontmatter.description,
+			...toolSection
+		});
+		const body = rulesyncSubagent.getBody();
+		return new KimiCodeSubagent({
+			outputRoot,
+			relativeDirPath: this.getSettablePaths({ global }).relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			frontmatter: kimiCodeFrontmatter,
+			body,
+			fileContent: stringifyFrontmatter(body, kimiCodeFrontmatter, { avoidBlockScalars: true }),
+			validate,
+			global
+		});
+	}
+	validate() {
+		const result = KimiCodeSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		return result.success ? {
+			success: true,
+			error: null
+		} : {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${join(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "kimi-code"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true, global = false }) {
+		const actualRelativeDirPath = relativeDirPath ?? this.getSettablePaths({ global }).relativeDirPath;
+		const filePath = join(outputRoot, actualRelativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body } = parseFrontmatter(fileContent, filePath);
+		const result = KimiCodeSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new KimiCodeSubagent({
+			outputRoot,
+			relativeDirPath: actualRelativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: body.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new KimiCodeSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/kiro-subagent.ts
 const KiroCliSubagentJsonSchema = z.looseObject({
-	name: z.string(),
+	name: z.optional(z.string()),
 	description: z.optional(z.nullable(z.string())),
 	prompt: z.optional(z.nullable(z.string())),
 	tools: z.optional(z.nullable(z.array(z.string()))),
@@ -35202,7 +36502,7 @@ const KiroCliSubagentJsonSchema = z.looseObject({
 	allowedTools: z.optional(z.nullable(z.array(z.string()))),
 	includeMcpJson: z.optional(z.nullable(z.boolean()))
 });
-var KiroSubagent = class KiroSubagent extends ToolSubagent {
+var KiroSubagent = class extends ToolSubagent {
 	body;
 	constructor({ body, ...rest }) {
 		if (rest.validate !== false) try {
@@ -35220,6 +36520,9 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 	getBody() {
 		return this.body;
 	}
+	static getToolTarget() {
+		return "kiro";
+	}
 	toRulesyncSubagent() {
 		let parsed;
 		try {
@@ -35228,12 +36531,13 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 			throw new Error(`Failed to parse JSON in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}
 		const { name, description, prompt, ...restFields } = parsed;
+		const toolTarget = this.constructor.getToolTarget();
 		const kiroSection = { ...restFields };
 		return new RulesyncSubagent({
 			outputRoot: ".",
 			frontmatter: {
-				targets: ["kiro"],
-				name,
+				targets: [toolTarget],
+				name: name ?? basename(this.getRelativeFilePath(), ".json"),
 				description: description ?? void 0,
 				...Object.keys(kiroSection).length > 0 && { kiro: kiroSection }
 			},
@@ -35260,7 +36564,7 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 		const body = JSON.stringify(json, null, 2);
 		const paths = this.getSettablePaths({ global });
 		const relativeFilePath = rulesyncSubagent.getRelativeFilePath().replace(/\.md$/, ".json");
-		return new KiroSubagent({
+		return new this({
 			outputRoot,
 			body,
 			relativeDirPath: paths.relativeDirPath,
@@ -35288,14 +36592,14 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
 		return this.isTargetedByRulesyncSubagentDefault({
 			rulesyncSubagent,
-			toolTarget: "kiro"
+			toolTarget: this.getToolTarget()
 		});
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
 		const fileContent = await readFileContent(filePath);
-		const subagent = new KiroSubagent({
+		const subagent = new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
@@ -35311,7 +36615,7 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 		return subagent;
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new KiroSubagent({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
@@ -35333,11 +36637,8 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 * {@link import("./kiro-ide-subagent.js").KiroIdeSubagent}.)
 */
 var KiroCliSubagent = class extends KiroSubagent {
-	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
-		return this.isTargetedByRulesyncSubagentDefault({
-			rulesyncSubagent,
-			toolTarget: "kiro-cli"
-		});
+	static getToolTarget() {
+		return "kiro-cli";
 	}
 };
 //#endregion
@@ -36324,6 +37625,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: false,
+			filePattern: "*.md"
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeSubagent,
 		meta: {
@@ -36460,6 +37769,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: join("**", "*.md")
+		}
+	}],
 	["opencode", {
 		class: OpenCodeSubagent,
 		meta: {
@@ -36581,7 +37898,18 @@ var SubagentsProcessor = class extends FeatureProcessor {
 			}
 			rulesyncSubagents.push(toolSubagent.toRulesyncSubagent());
 		}
-		return rulesyncSubagents;
+		const uniqueRulesyncSubagents = [];
+		const seenOutputPaths = /* @__PURE__ */ new Set();
+		for (const rulesyncSubagent of rulesyncSubagents) {
+			const outputPath = join(rulesyncSubagent.getRelativeDirPath(), rulesyncSubagent.getRelativeFilePath());
+			if (seenOutputPaths.has(outputPath)) {
+				this.logger.warn(`Multiple ${this.toolTarget} subagents resolve to "${outputPath}"; keeping the first and ignoring this copy.`);
+				continue;
+			}
+			seenOutputPaths.add(outputPath);
+			uniqueRulesyncSubagents.push(rulesyncSubagent);
+		}
+		return uniqueRulesyncSubagents;
 	}
 	/**
 	* Implementation of abstract method from Processor
@@ -36629,25 +37957,35 @@ var SubagentsProcessor = class extends FeatureProcessor {
 	async loadToolFiles({ forDeletion = false } = {}) {
 		const factory = this.getFactory(this.toolTarget);
 		const paths = factory.class.getSettablePaths({ global: this.global });
-		const dirPaths = forDeletion ? [paths.relativeDirPath] : [paths.relativeDirPath, ...paths.importDirPaths ?? []];
+		const roots = forDeletion ? [paths.relativeDirPath] : [paths.relativeDirPath, ...paths.importDirPaths ?? []];
 		const toolSubagents = [];
 		const seenRelativeFilePaths = /* @__PURE__ */ new Set();
-		for (const dirPath of dirPaths) {
-			const baseDir = join(this.outputRoot, dirPath);
-			const subagentFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern));
+		for (const root of roots) {
+			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
+			const dirPath = typeof root === "string" ? root : root.relativeDirPath;
+			const baseDir = join(rootOutputRoot, dirPath);
+			if (forDeletion && await directoryExists(baseDir)) await assertWritablePathInsideRoot({
+				rootPath: rootOutputRoot,
+				targetPath: baseDir
+			});
+			const subagentFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern), { followSymbolicLinks: !forDeletion });
 			const toRelativeFilePath = (path) => relative(baseDir, path);
 			let ownedFilePaths = subagentFilePaths;
 			if (factory.class.isFileOwned) {
 				const ownership = await Promise.all(subagentFilePaths.map((path) => factory.class.isFileOwned({
-					outputRoot: this.outputRoot,
+					outputRoot: rootOutputRoot,
 					relativeDirPath: dirPath,
 					relativeFilePath: toRelativeFilePath(path)
 				})));
 				ownedFilePaths = subagentFilePaths.filter((_, index) => ownership[index]);
 			}
 			if (forDeletion) {
+				await Promise.all(ownedFilePaths.map((path) => assertWritablePathInsideRoot({
+					rootPath: baseDir,
+					targetPath: path
+				})));
 				toolSubagents.push(...ownedFilePaths.map((path) => factory.class.forDeletion({
-					outputRoot: this.outputRoot,
+					outputRoot: rootOutputRoot,
 					relativeDirPath: dirPath,
 					relativeFilePath: toRelativeFilePath(path),
 					global: this.global
@@ -36655,14 +37993,14 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				continue;
 			}
 			const loaded = await Promise.all(ownedFilePaths.map((path) => factory.class.fromFile({
-				outputRoot: this.outputRoot,
+				outputRoot: rootOutputRoot,
 				relativeDirPath: dirPath,
 				relativeFilePath: toRelativeFilePath(path),
 				global: this.global
 			})));
 			const deduped = [];
 			for (const subagent of loaded) {
-				const key = subagent.getRelativeFilePath();
+				const key = subagent.getImportIdentity();
 				if (seenRelativeFilePaths.has(key)) {
 					this.logger.warn(`Duplicate ${this.toolTarget} subagent "${key}" found in ${dirPath}; keeping the one from a higher-precedence directory and ignoring this copy.`);
 					continue;
@@ -36678,7 +38016,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				global: this.global
 			});
 			for (const subagent of additionalSubagents) {
-				const key = subagent.getRelativeFilePath();
+				const key = subagent.getImportIdentity();
 				if (seenRelativeFilePaths.has(key)) {
 					this.logger.warn(`Duplicate ${this.toolTarget} subagent "${key}" defined inline; keeping the standalone file and ignoring the inline copy.`);
 					continue;
@@ -36687,7 +38025,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				toolSubagents.push(subagent);
 			}
 		}
-		this.logger.debug(`Successfully loaded ${toolSubagents.length} ${this.toolTarget} subagents from ${dirPaths.join(", ")}`);
+		this.logger.debug(`Successfully loaded ${toolSubagents.length} ${this.toolTarget} subagents from ${roots.length} root(s)`);
 		return toolSubagents;
 	}
 	/**
@@ -37351,17 +38689,18 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 		};
 	}
 	static getSettablePaths({ global = false, excludeToolDir } = {}) {
-		if (global) return { root: AntigravityIdeRule.getGlobalRootPath(excludeToolDir) };
+		if (global) return { root: this.getGlobalRootPath(excludeToolDir) };
 		return {
-			root: AntigravityIdeRule.getProjectRootPath(),
+			root: this.getProjectRootPath(),
 			nonRoot: { relativeDirPath: buildToolPath(ANTIGRAVITY_IDE_AGENTS_DIR, "rules", excludeToolDir) }
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
 		if (global) {
-			const rootPath = AntigravityIdeRule.getGlobalRootPath();
+			const rootPath = paths.root;
 			const fileContent = await readFileContent(join(outputRoot, rootPath.relativeDirPath, rootPath.relativeFilePath));
-			return new AntigravityIdeRule({
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37371,10 +38710,10 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 				root: true
 			});
 		}
-		if (relativeFilePath === "AGENTS.md") {
-			const rootPath = AntigravityIdeRule.getProjectRootPath();
+		if (relativeFilePath === paths.root.relativeFilePath) {
+			const rootPath = paths.root;
 			const rootContent = await readFileContent(join(outputRoot, rootPath.relativeDirPath, rootPath.relativeFilePath));
-			return new AntigravityIdeRule({
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37384,7 +38723,8 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 				root: true
 			});
 		}
-		const nonRootDirPath = buildToolPath(ANTIGRAVITY_IDE_AGENTS_DIR, "rules");
+		if (!("nonRoot" in paths) || !paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
+		const nonRootDirPath = paths.nonRoot.relativeDirPath;
 		const filePath = join(outputRoot, nonRootDirPath, relativeFilePath);
 		const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
 		let parsedFrontmatter;
@@ -37393,7 +38733,7 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 			if (result.success) parsedFrontmatter = result.data;
 			else throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
 		} else parsedFrontmatter = frontmatter;
-		return new AntigravityIdeRule({
+		return new this({
 			outputRoot,
 			relativeDirPath: nonRootDirPath,
 			relativeFilePath,
@@ -37404,9 +38744,10 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
 		if (global) {
-			const rootPath = AntigravityIdeRule.getGlobalRootPath();
-			return new AntigravityIdeRule({
+			const rootPath = paths.root;
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37417,8 +38758,8 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 			});
 		}
 		if (rulesyncRule.getFrontmatter().root) {
-			const rootPath = AntigravityIdeRule.getProjectRootPath();
-			return new AntigravityIdeRule({
+			const rootPath = paths.root;
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37435,10 +38776,11 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 		const strategy = STRATEGIES$1.find((s) => s.canHandle(storedTrigger));
 		if (!strategy) throw new Error(`No strategy found for trigger: ${storedTrigger}`);
 		const frontmatter = strategy.generateFrontmatter(normalized, rulesyncFrontmatter);
+		if (!("nonRoot" in paths) || !paths.nonRoot) throw new Error(`nonRoot path is not set for ${rulesyncRule.getRelativeFilePath()}`);
 		const kebabCaseFilename = toKebabCaseFilename(rulesyncRule.getRelativeFilePath());
-		return new AntigravityIdeRule({
+		return new this({
 			outputRoot,
-			relativeDirPath: buildToolPath(ANTIGRAVITY_IDE_AGENTS_DIR, "rules"),
+			relativeDirPath: paths.nonRoot.relativeDirPath,
 			relativeFilePath: kebabCaseFilename,
 			frontmatter,
 			body: rulesyncRule.getBody(),
@@ -37507,6 +38849,23 @@ var AntigravityIdeRule = class AntigravityIdeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/antigravity-plugin-rule.ts
+var AntigravityPluginRule = class extends AntigravityIdeRule {
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		const targets = rulesyncRule.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("antigravity-plugin");
+	}
+	static getSettablePaths() {
+		return {
+			root: {
+				relativeDirPath: ANTIGRAVITY_PLUGIN_RULES_DIR,
+				relativeFilePath: "AGENTS.md"
+			},
+			nonRoot: { relativeDirPath: ANTIGRAVITY_PLUGIN_RULES_DIR }
+		};
+	}
+};
+//#endregion
 //#region src/features/rules/augmentcode-legacy-rule.ts
 var AugmentcodeLegacyRule = class AugmentcodeLegacyRule extends ToolRule {
 	toRulesyncRule() {
@@ -39456,13 +40815,17 @@ var JunieRule = class JunieRule extends ToolRule {
 		if (global) {
 			const paths = this.getSettablePaths({ global: true });
 			if (!("root" in paths) || !paths.root) throw new Error("JunieRule global settable paths must include a root path");
-			if (!rulesyncRule.getFrontmatter().root) throw new Error(`JunieRule does not support non-root rules in global mode; expected a root rule but got '${rulesyncRule.getRelativeFilePath()}'`);
-			return new JunieRule(this.buildToolRuleParamsDefault({
+			const frontmatter = rulesyncRule.getFrontmatter();
+			return new JunieRule({
 				outputRoot,
-				rulesyncRule,
+				relativeDirPath: paths.root.relativeDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				fileContent: rulesyncRule.getBody(),
 				validate,
-				rootPath: paths.root
-			}));
+				root: frontmatter.root ?? false,
+				description: frontmatter.description,
+				globs: frontmatter.globs
+			});
 		}
 		const { root } = this.getSettablePaths();
 		return new JunieRule({
@@ -39583,6 +40946,97 @@ var KiloRule = class KiloRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/kimi-code-rule.ts
+/**
+* Kimi Code instruction file.
+*
+* Kimi Code discovers `.kimi-code/AGENTS.md` at project scope and
+* `~/.kimi-code/AGENTS.md` at user scope. Rulesync's topic rules have no
+* dedicated Kimi rule directory, so the processor folds them into this root
+* instruction file.
+*
+* @see https://moonshotai.github.io/kimi-code/en/customization/agents.html
+*/
+var KimiCodeRule = class KimiCodeRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { root: {
+			relativeDirPath: getKimiCodeRelativeDirPath({ global }),
+			relativeFilePath: KIMI_CODE_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent(join(outputRoot, root.relativeDirPath, root.relativeFilePath));
+		return new KimiCodeRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			global,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		return new KimiCodeRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			global,
+			root: rulesyncRule.getFrontmatter().root ?? false
+		});
+	}
+	toRulesyncRule() {
+		return new RulesyncRule({
+			outputRoot: getKimiCodeRulesyncOutputRoot({
+				nativeOutputRoot: this.outputRoot,
+				global: this.global
+			}),
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: RULESYNC_OVERVIEW_FILE_NAME,
+			frontmatter: {
+				root: true,
+				targets: ["*"],
+				globs: ["**/*"]
+			},
+			body: this.getFileContent()
+		});
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new KimiCodeRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global,
+			root: relativeDirPath === getKimiCodeRelativeDirPath({ global }) && relativeFilePath === "AGENTS.md"
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "kimi-code"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/kiro-rule.ts
 const WILDCARD_GLOBS = /* @__PURE__ */ new Set([
 	"**/*",
@@ -41033,6 +42487,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: false,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeRule,
 		meta: {
@@ -41172,6 +42634,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			mcpInstructionsRegistrar: KiloMcp
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			foldsNonRootIntoRoot: true
+		}
+	}],
 	["kiro", {
 		class: KiroRule,
 		meta: {
@@ -41645,7 +43116,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		if (targetedLocalRootRules.length > 0 && targetedRootRules.length === 0) throw new Error(`localRoot: true requires a root: true rule to exist for target '${this.toolTarget}' (found in ${formatRulePaths(targetedLocalRootRules)})`);
 		if (this.global) {
 			const globalPaths = factory.class.getSettablePaths({ global: true });
-			const supportsGlobalNonRoot = "nonRoot" in globalPaths && globalPaths.nonRoot !== null;
+			const supportsGlobalNonRoot = "nonRoot" in globalPaths && globalPaths.nonRoot !== null || factory.meta.supportsGlobal && factory.meta.foldsNonRootIntoRoot === true;
 			const nonRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().root && !rule.getFrontmatter().localRoot && factory.class.isTargetedByRulesyncRule(rule));
 			if (nonRootRules.length > 0 && !supportsGlobalNonRoot) this.logger.warn(`${nonRootRules.length} non-root rulesync rules found, but it's in global mode, so ignoring them: ${formatRulePaths(nonRootRules)}`);
 			if (targetedLocalRootRules.length > 0) this.logger.warn(`${targetedLocalRootRules.length} localRoot rules found, but localRoot is not supported in global mode, ignoring them: ${formatRulePaths(targetedLocalRootRules)}`);
@@ -41848,12 +43319,25 @@ As this project's AI coding tool, you must follow the additional conventions bel
 	}
 };
 //#endregion
+//#region src/utils/plugin-root.ts
+function isPackagingToolTarget(toolTarget) {
+	return PACKAGING_TOOL_TARGETS.includes(toolTarget);
+}
+async function assertPluginRootSafe(params) {
+	if (!isPackagingToolTarget(params.toolTarget)) return;
+	await assertDirectoryIfExists(params.outputRoot);
+	if (!await directoryExists(params.outputRoot)) throw new Error(`Plugin output root must be an existing directory: ${params.outputRoot}.`);
+	await assertTreeContainsNoSymlinks(params.outputRoot);
+}
+//#endregion
 //#region src/lib/convert.ts
 /**
 * Convert configuration files between AI tools without writing intermediate
 * `.rulesync/` files to disk. Rulesync file instances live in memory only.
 */
 async function convertFromTool(params) {
+	const packagingTarget = [params.fromTool, ...params.toTools].find(isPackagingToolTarget);
+	if (packagingTarget) throw new Error(`Plugin packaging target '${packagingTarget}' is not supported by convert. Use import and generate with explicit plugin directories.`);
 	const ctx = params;
 	const [rulesCount, ignoreCount, mcpCount, commandsCount, subagentsCount, skillsCount, hooksCount, permissionsCount, checksCount] = [
 		await runFeatureConvert(ctx, buildRulesStrategy(ctx)),
@@ -41932,7 +43416,11 @@ function buildRulesStrategy(ctx) {
 		itemLabel: "rule file(s)",
 		allTargets: RulesProcessor.getToolTargets({ global }),
 		createProcessor: ({ toolTarget, dryRun }) => new RulesProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -41946,18 +43434,20 @@ function buildRulesStrategy(ctx) {
 }
 function buildIgnoreStrategy(ctx) {
 	const { config, logger } = ctx;
-	if (config.getGlobal()) {
-		logger.debug("Skipping ignore conversion (not supported in global mode)");
-		return null;
-	}
+	const global = config.getGlobal();
 	const outputRoot = getOutputRoot(config);
 	return {
 		feature: "ignore",
 		itemLabel: "ignore file(s)",
-		allTargets: IgnoreProcessor.getToolTargets(),
+		allTargets: IgnoreProcessor.getToolTargets({ global }),
 		createProcessor: ({ toolTarget, dryRun }) => new IgnoreProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
+			global,
 			dryRun,
 			logger,
 			featureOptions: config.getFeatureOptions(toolTarget, "ignore")
@@ -41977,7 +43467,11 @@ function buildMcpStrategy(ctx) {
 		itemLabel: "MCP file(s)",
 		allTargets: McpProcessor.getToolTargets({ global }),
 		createProcessor: ({ toolTarget, dryRun }) => new McpProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42026,7 +43520,11 @@ function buildSubagentsStrategy(ctx) {
 			includeSimulated: false
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new SubagentsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42047,7 +43545,11 @@ function buildSkillsStrategy(ctx) {
 		itemLabel: "skill(s)",
 		allTargets: SkillsProcessor.getToolTargets({ global }),
 		createProcessor: ({ toolTarget, dryRun }) => new SkillsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42072,7 +43574,11 @@ function buildHooksStrategy(ctx) {
 			importOnly: true
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new HooksProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42097,7 +43603,11 @@ function buildPermissionsStrategy(ctx) {
 			importOnly: true
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new PermissionsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42598,6 +44108,10 @@ async function warnSkillSubagentNameCollisions(params) {
 */
 async function generate(params) {
 	const { config, logger } = params;
+	for (const toolTarget of config.getTargets()) for (const outputRoot of config.getOutputRoots(toolTarget)) await assertPluginRootSafe({
+		toolTarget,
+		outputRoot
+	});
 	await warnSkillSubagentNameCollisions({
 		config,
 		logger
@@ -42717,7 +44231,11 @@ async function generateRulesCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("rules")) continue;
 		const processor = new RulesProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -42752,18 +44270,14 @@ async function generateRulesCore(params) {
 }
 async function generateIgnoreCore(params) {
 	const { config, logger } = params;
-	const supportedIgnoreTargets = config.getGlobal() ? [] : IgnoreProcessor.getToolTargets();
+	const global = config.getGlobal();
+	const supportedIgnoreTargets = IgnoreProcessor.getToolTargets({ global });
 	warnUnsupportedTargets({
 		config,
 		supportedTargets: supportedIgnoreTargets,
 		featureName: "ignore",
 		logger
 	});
-	if (config.getGlobal()) return {
-		count: 0,
-		paths: [],
-		hasDiff: false
-	};
 	let totalCount = 0;
 	const allPaths = [];
 	let hasDiff = false;
@@ -42774,6 +44288,7 @@ async function generateIgnoreCore(params) {
 				outputRoot,
 				inputRoot: config.getInputRoot(),
 				toolTarget,
+				global,
 				dryRun: config.isPreviewMode(),
 				logger,
 				featureOptions: config.getFeatureOptions(toolTarget, "ignore")
@@ -42813,7 +44328,11 @@ async function generateMcpCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("mcp")) continue;
 		const processor = new McpProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -42898,7 +44417,11 @@ async function generateSubagentsCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("subagents")) continue;
 		const processor = new SubagentsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -42941,7 +44464,11 @@ async function generateSkillsCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("skills")) continue;
 		const processor = new SkillsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -42982,7 +44509,11 @@ async function generateHooksCore(params) {
 	for (const toolTarget of toolTargets) for (const outputRoot of config.getOutputRoots(toolTarget)) {
 		if (!config.getFeatures(toolTarget).includes("hooks")) continue;
 		const processor = new HooksProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global: config.getGlobal()
+			}),
 			inputRoot: config.getInputRoot(),
 			toolTarget,
 			global: config.getGlobal(),
@@ -43020,7 +44551,11 @@ async function generatePermissionsCore(params) {
 		if (!config.getFeatures(toolTarget).includes("permissions")) continue;
 		try {
 			const processor = new PermissionsProcessor({
-				outputRoot,
+				outputRoot: resolveToolOutputRoot({
+					outputRoot,
+					toolTarget,
+					global: config.getGlobal()
+				}),
 				inputRoot: config.getInputRoot(),
 				toolTarget,
 				global: config.getGlobal(),
@@ -43086,21 +44621,41 @@ async function generateChecksCore(params) {
 }
 //#endregion
 //#region src/lib/import.ts
-/**
-* Import always writes the `.json` variant of a fixed-path source file, but a
-* sibling `.jsonc` variant takes precedence at read time — so an import into a
-* project that authors the `.jsonc` variant would be silently shadowed. Warn
-* so the user merges (or removes) one of the two by hand.
-*/
-async function warnIfShadowedByJsonc(params) {
-	const { outputRoot, jsonRelativePath, jsoncRelativePath, logger } = params;
-	if (await fileExists(join(outputRoot, jsoncRelativePath))) logger.warn(`${jsoncRelativePath} exists and takes precedence over the imported ${jsonRelativePath}. Merge the imported content into ${jsoncRelativePath} (or remove it) so the import takes effect.`);
+async function applyRulesyncSourcePath({ files, paths, sourceClass, outputRoot }) {
+	const first = files[0];
+	if (!first) return files;
+	const destinationOutputRoot = outputRoot ?? first.getOutputRoot();
+	const destination = await resolveRulesyncSourceWritePath({
+		outputRoot: destinationOutputRoot,
+		paths
+	});
+	return files.map((file) => new sourceClass({
+		outputRoot: destinationOutputRoot,
+		relativeDirPath: destination.relativeDirPath,
+		relativeFilePath: destination.relativeFilePath,
+		fileContent: file.getFileContent(),
+		validate: true
+	}));
+}
+function getToolOutputRoot({ config, tool }) {
+	return resolveToolOutputRoot({
+		outputRoot: config.getOutputRoots(tool)[0] ?? ".",
+		toolTarget: tool,
+		global: config.getGlobal()
+	});
 }
 /**
 * Import configuration files from AI tools.
 */
 async function importFromTool(params) {
 	const { config, tool, logger } = params;
+	await assertPluginRootSafe({
+		toolTarget: tool,
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		})
+	});
 	return {
 		rulesCount: await importRulesCore({
 			config,
@@ -43155,7 +44710,10 @@ async function importRulesCore(params) {
 	const global = config.getGlobal();
 	if (!RulesProcessor.getToolTargets({ global }).includes(tool)) return 0;
 	const rulesProcessor = new RulesProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43173,14 +44731,15 @@ async function importRulesCore(params) {
 async function importIgnoreCore(params) {
 	const { config, tool, logger } = params;
 	if (!config.getFeatures(tool).includes("ignore")) return 0;
-	if (config.getGlobal()) {
-		logger.debug("Skipping ignore file import (not supported in global mode)");
-		return 0;
-	}
-	if (!IgnoreProcessor.getToolTargets().includes(tool)) return 0;
+	const global = config.getGlobal();
+	if (!IgnoreProcessor.getToolTargets({ global }).includes(tool)) return 0;
 	const ignoreProcessor = new IgnoreProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
+		global,
 		logger,
 		featureOptions: config.getFeatureOptions(tool, "ignore")
 	});
@@ -43201,7 +44760,10 @@ async function importMcpCore(params) {
 	const global = config.getGlobal();
 	if (!McpProcessor.getToolTargets({ global }).includes(tool)) return 0;
 	const mcpProcessor = new McpProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43211,14 +44773,13 @@ async function importMcpCore(params) {
 		logger.warn(`No MCP files found for ${tool}. Skipping import.`);
 		return 0;
 	}
-	const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-	const { count: writtenCount } = await mcpProcessor.writeAiFiles(rulesyncFiles);
-	if (writtenCount > 0) await warnIfShadowedByJsonc({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
-		jsonRelativePath: RULESYNC_MCP_RELATIVE_FILE_PATH,
-		jsoncRelativePath: RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH,
-		logger
+	const rulesyncFiles = await applyRulesyncSourcePath({
+		files: await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles),
+		paths: RulesyncMcp.getSettablePaths(),
+		sourceClass: RulesyncMcp,
+		outputRoot: isPackagingToolTarget(tool) ? process.cwd() : void 0
 	});
+	const { count: writtenCount } = await mcpProcessor.writeAiFiles(rulesyncFiles);
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} MCP files`);
 	return writtenCount;
 }
@@ -43231,7 +44792,10 @@ async function importCommandsCore(params) {
 		includeSimulated: false
 	}).includes(tool)) return 0;
 	const commandsProcessor = new CommandsProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43255,7 +44819,10 @@ async function importSubagentsCore(params) {
 		includeSimulated: false
 	}).includes(tool)) return 0;
 	const subagentsProcessor = new SubagentsProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global: config.getGlobal(),
 		logger
@@ -43276,7 +44843,10 @@ async function importSkillsCore(params) {
 	const global = config.getGlobal();
 	if (!SkillsProcessor.getToolTargets({ global }).includes(tool)) return 0;
 	const skillsProcessor = new SkillsProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43286,8 +44856,21 @@ async function importSkillsCore(params) {
 		logger.warn(`No skill directories found for ${tool}. Skipping import.`);
 		return 0;
 	}
-	const rulesyncDirs = await skillsProcessor.convertToolDirsToRulesyncDirs(toolDirs);
-	const { count: writtenCount } = await skillsProcessor.writeAiDirs(rulesyncDirs);
+	const rebasedRulesyncDirs = (await skillsProcessor.convertToolDirsToRulesyncDirs(toolDirs)).map((dir) => {
+		if (!isPackagingToolTarget(tool)) return dir;
+		if (!(dir instanceof RulesyncSkill)) return dir;
+		return new RulesyncSkill({
+			outputRoot: process.cwd(),
+			relativeDirPath: dir.getRelativeDirPath(),
+			dirName: dir.getDirName(),
+			frontmatter: dir.getFrontmatter(),
+			body: dir.getBody(),
+			otherFiles: dir.getOtherFiles(),
+			validate: true,
+			global: false
+		});
+	});
+	const { count: writtenCount } = await skillsProcessor.writeAiDirs(rebasedRulesyncDirs);
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} skill directories`);
 	return writtenCount;
 }
@@ -43306,7 +44889,10 @@ async function importHooksCore(params) {
 		return 0;
 	}
 	const hooksProcessor = new HooksProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43316,14 +44902,13 @@ async function importHooksCore(params) {
 		logger.warn(`No hooks files found for ${tool}. Skipping import.`);
 		return 0;
 	}
-	const rulesyncFiles = await hooksProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-	const { count: writtenCount } = await hooksProcessor.writeAiFiles(rulesyncFiles);
-	if (writtenCount > 0) await warnIfShadowedByJsonc({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
-		jsonRelativePath: RULESYNC_HOOKS_RELATIVE_FILE_PATH,
-		jsoncRelativePath: RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH,
-		logger
+	const rulesyncFiles = await applyRulesyncSourcePath({
+		files: await hooksProcessor.convertToolFilesToRulesyncFiles(toolFiles),
+		paths: RulesyncHooks.getSettablePaths(),
+		sourceClass: RulesyncHooks,
+		outputRoot: isPackagingToolTarget(tool) ? process.cwd() : void 0
 	});
+	const { count: writtenCount } = await hooksProcessor.writeAiFiles(rulesyncFiles);
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} hooks file(s)`);
 	return writtenCount;
 }
@@ -43341,7 +44926,10 @@ async function importPermissionsCore(params) {
 		return 0;
 	}
 	const permissionsProcessor = new PermissionsProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global: config.getGlobal(),
 		logger
@@ -43351,14 +44939,12 @@ async function importPermissionsCore(params) {
 		logger.warn(`No permissions files found for ${tool}. Skipping import.`);
 		return 0;
 	}
-	const rulesyncFiles = await permissionsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
-	const { count: writtenCount } = await permissionsProcessor.writeAiFiles(rulesyncFiles);
-	if (writtenCount > 0) await warnIfShadowedByJsonc({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
-		jsonRelativePath: RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH,
-		jsoncRelativePath: RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH,
-		logger
+	const rulesyncFiles = await applyRulesyncSourcePath({
+		files: await permissionsProcessor.convertToolFilesToRulesyncFiles(toolFiles),
+		paths: RulesyncPermissions.getSettablePaths(),
+		sourceClass: RulesyncPermissions
 	});
+	const { count: writtenCount } = await permissionsProcessor.writeAiFiles(rulesyncFiles);
 	if (config.getVerbose() && writtenCount > 0) logger.success(`Created ${writtenCount} permissions file(s)`);
 	return writtenCount;
 }
@@ -43384,6 +44970,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { createTempDirectory as $, RulesyncIgnore as A, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as At, ConfigFileSchema as B, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Bt, RulesyncSubagentFrontmatterSchema as C, RULESYNC_AIIGNORE_FILE_NAME as Ct, RulesyncRuleFrontmatterSchema as D, RULESYNC_CONFIG_RELATIVE_FILE_PATH as Dt, RulesyncRule as E, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as Et, RulesyncCheckFrontmatterSchema as F, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Ft, fallbackLogger as G, RULESYNC_RELATIVE_DIR_PATH as Gt, findControlCharacter as H, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as Ht, stringifyFrontmatter as I, RULESYNC_MCP_FILE_NAME as It, ErrorCodes as J, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Jt, warnOnConflictingFlags as K, RULESYNC_RULES_RELATIVE_DIR_PATH as Kt, loadYaml as L, RULESYNC_MCP_JSONC_FILE_NAME as Lt, RulesyncCommand as M, RULESYNC_HOOKS_JSONC_FILE_NAME as Mt, RulesyncCommandFrontmatterSchema as N, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Nt, RulesyncPermissions as O, RULESYNC_CONFIG_SCHEMA_URL as Ot, RulesyncCheck as P, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Pt, checkPathTraversal as Q, ALL_FEATURES_WITH_WILDCARD as Qt, SKILL_FILE_NAME as R, RULESYNC_MCP_RELATIVE_FILE_PATH as Rt, RulesyncSubagent as S, MAX_FILE_SIZE as St, RulesyncSkillFrontmatterSchema as T, RULESYNC_CHECKS_RELATIVE_DIR_PATH as Tt, ConsoleLogger as U, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Ut, SourceEntrySchema as V, RULESYNC_PERMISSIONS_FILE_NAME as Vt, JsonLogger as W, RULESYNC_PERMISSIONS_SCHEMA_URL as Wt, assertTreeContainsNoSymlinks as X, formatError as Xt, assertDirectoryIfExists as Y, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Yt, assertWritablePathInsideRoot as Z, ALL_FEATURES as Zt, CLAUDECODE_MEMORIES_DIR_NAME as _, toPosixPath as _t, convertFromTool as a, getHomeDirectory as at, ChecksProcessor as b, ALL_TOOL_TARGETS_WITH_WILDCARD as bt, SkillsProcessor as c, readFileContent as ct, HooksProcessor as d, removeDirectoryStrict as dt, directoryExists as et, CommandsProcessor as f, removeFile as ft, CLAUDECODE_LOCAL_RULE_FILE_NAME as g, runWithDirectoryRollback as gt, CLAUDECODE_DIR as h, resolvePath as ht, getProcessorRegistryEntry as i, getFileSize as it, RulesyncHooks as j, RULESYNC_HOOKS_FILE_NAME as jt, RulesyncMcp as k, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as kt, McpProcessor as l, readFileContentOrNull as lt, CODEXCLI_DIR as m, removeTempDirectory as mt, checkRulesyncDirExists as n, fileExists as nt, RulesProcessor as o, isSymlink as ot, CODEXCLI_BASH_RULES_FILE_NAME as p, removeFileStrict as pt, CLIError as q, RULESYNC_SKILLS_RELATIVE_DIR_PATH as qt, generate as r, findFilesByGlobs as rt, SubagentsProcessor as s, listDirectoryFiles as st, importFromTool as t, ensureDir as tt, IgnoreProcessor as u, removeDirectory as ut, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as v, writeFileContent as vt, RulesyncSkill as w, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as wt, getLocalSkillDirNames as x, ToolTargetSchema as xt, CLAUDECODE_SKILLS_DIR_PATH as y, ALL_TOOL_TARGETS as yt, ConfigResolver as z, RULESYNC_MCP_SCHEMA_URL as zt };
+export { assertDirectoryIfExists as $, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as $t, RulesyncMcp as A, RULESYNC_CHECKS_RELATIVE_DIR_PATH as At, stringifyFrontmatter as B, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Bt, RulesyncSubagent as C, ALL_TOOL_TARGETS as Ct, RulesyncRule as D, MAX_FILE_SIZE as Dt, RulesyncSkillFrontmatterSchema as E, ToolTargetSchema as Et, parseJsonc as F, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as Ft, SourceEntrySchema as G, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Gt, SKILL_FILE_NAME as H, RULESYNC_MCP_LEGACY_FILE_NAME as Ht, RulesyncCommand as I, RULESYNC_HOOKS_FILE_NAME as It, JsonLogger as J, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Jt, findControlCharacter as K, RULESYNC_PERMISSIONS_FILE_NAME as Kt, RulesyncCommandFrontmatterSchema as L, RULESYNC_HOOKS_LEGACY_FILE_NAME as Lt, RulesyncHooks as M, RULESYNC_CONFIG_RELATIVE_FILE_PATH as Mt, getRulesyncSourceCandidates as N, RULESYNC_CONFIG_SCHEMA_URL as Nt, RulesyncRuleFrontmatterSchema as O, RULESYNC_AIIGNORE_FILE_NAME as Ot, resolveRulesyncSourceWritePath as P, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as Pt, ErrorCodes as Q, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Qt, RulesyncCheck as R, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Rt, getLocalSkillDirNames as S, writeFileContent as St, RulesyncSkill as T, PACKAGING_TOOL_TARGETS as Tt, ConfigResolver as U, RULESYNC_MCP_RELATIVE_FILE_PATH as Ut, loadYaml as V, RULESYNC_MCP_FILE_NAME as Vt, ConfigFileSchema as W, RULESYNC_MCP_SCHEMA_URL as Wt, warnOnConflictingFlags as X, RULESYNC_RELATIVE_DIR_PATH as Xt, fallbackLogger as Y, RULESYNC_PERMISSIONS_SCHEMA_URL as Yt, CLIError as Z, RULESYNC_RULES_RELATIVE_DIR_PATH as Zt, CLAUDECODE_LOCAL_RULE_FILE_NAME as _, removeFileStrict as _t, convertFromTool as a, ensureDir as at, CLAUDECODE_SKILLS_DIR_PATH as b, runWithDirectoryRollback as bt, SubagentsProcessor as c, getFileSize as ct, IgnoreProcessor as d, listDirectoryFiles as dt, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as en, assertTreeContainsNoSymlinks as et, HooksProcessor as f, readFileContent as ft, CLAUDECODE_DIR as g, removeFile as gt, CODEXCLI_DIR as h, removeDirectoryStrict as ht, getProcessorRegistryEntry as i, directoryExists as it, RulesyncIgnore as j, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as jt, RulesyncPermissions as k, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as kt, SkillsProcessor as l, getHomeDirectory as lt, CODEXCLI_BASH_RULES_FILE_NAME as m, removeDirectory as mt, checkRulesyncDirExists as n, ALL_FEATURES_WITH_WILDCARD as nn, checkPathTraversal as nt, isPackagingToolTarget as o, fileExists as ot, CommandsProcessor as p, readFileContentOrNull as pt, ConsoleLogger as q, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as qt, generate as r, formatError as rn, createTempDirectory as rt, RulesProcessor as s, findFilesByGlobs as st, importFromTool as t, ALL_FEATURES as tn, assertWritablePathInsideRoot as tt, McpProcessor as u, isSymlink as ut, CLAUDECODE_MEMORIES_DIR_NAME as v, removeTempDirectory as vt, RulesyncSubagentFrontmatterSchema as w, ALL_TOOL_TARGETS_WITH_WILDCARD as wt, ChecksProcessor as x, toPosixPath as xt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as y, resolvePath as yt, RulesyncCheckFrontmatterSchema as z, RULESYNC_IGNORE_RELATIVE_FILE_PATH as zt };
 
-//# sourceMappingURL=import-CMCy95RI.js.map
+//# sourceMappingURL=import-BuxzyDyH.js.map