rulesync 14.2.0 → 15.0.0

package/dist/{import-Ds8vYv6h.cjs → import-DRN7goJ_.cjs}

@@ -20,8 +20,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let zod_mini = require("zod/mini");
 let zod = require("zod");
+let zod_mini = require("zod/mini");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
@@ -39,10 +39,39 @@ let node_util = require("node:util");
 let smol_toml = require("smol-toml");
 smol_toml = __toESM(smol_toml, 1);
 let _toon_format_toon = require("@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 zod.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",
@@ -51,9 +80,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 = zod_mini.z.enum(ALL_FEATURES);
+const ACTIVE_FEATURES = [...ACTIVE_FEATURES_BEFORE_IGNORE, ...ACTIVE_FEATURES_AFTER_IGNORE];
+const DeprecatedIgnoreFeatureSchema = zod_mini.z.literal("ignore").check((0, zod_mini.meta)({
+	deprecated: true,
+	description: "Deprecated: use the permissions feature. Ignore remains supported for compatibility throughout Rulesync 14.x."
+}));
+const FeatureSchema = zod_mini.z.union([zod_mini.z.enum(ACTIVE_FEATURES), DeprecatedIgnoreFeatureSchema]);
 zod_mini.z.array(FeatureSchema);
+const FeatureWithWildcardSchema = zod_mini.z.union([zod_mini.z.enum([...ACTIVE_FEATURES, "*"]), DeprecatedIgnoreFeatureSchema]);
 const GitignoreDestinationSchema = zod_mini.z.enum(["gitignore", "gitattributes"]);
 const FlattenedCommandNamingSchema = zod_mini.z.enum(["basename", "path"]);
 const FeatureOptionsSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown());
@@ -63,8 +103,8 @@ const FeatureValueSchema = zod_mini.z.union([
 	GitignoreDestinationSchema
 ]);
 const PerFeatureConfigSchema = zod_mini.z.record(zod_mini.z.string(), FeatureValueSchema);
-const PerTargetFeaturesValueSchema = zod_mini.z.union([zod_mini.z.array(zod_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)), PerFeatureConfigSchema]);
-const RulesyncFeaturesSchema = zod_mini.z.array(zod_mini.z.enum(ALL_FEATURES_WITH_WILDCARD));
+const PerTargetFeaturesValueSchema = zod_mini.z.union([zod_mini.z.array(FeatureWithWildcardSchema), PerFeatureConfigSchema]);
+const RulesyncFeaturesSchema = zod_mini.z.array(FeatureWithWildcardSchema);
 /**
 * Returns true if a per-feature value enables the feature.
 *
@@ -86,66 +126,36 @@ 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 zod.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$264 } = node_path.posix;
+const { join: join$272 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$264(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$272(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$272(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$264(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$264(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$272(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";
@@ -158,6 +168,7 @@ const rulesProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"augmentcode-legacy",
 	"claudecode",
@@ -174,6 +185,7 @@ const rulesProcessorToolTargetTuple = [
 	"hermesagent",
 	"junie",
 	"kilo",
+	"kimi-code",
 	"kiro",
 	"kiro-cli",
 	"kiro-ide",
@@ -217,8 +229,10 @@ const mcpProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -230,6 +244,7 @@ const mcpProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"kilo",
 	"kiro",
 	"kiro-cli",
@@ -252,6 +267,7 @@ const commandsProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -279,6 +295,7 @@ const subagentsProcessorToolTargetTuple = [
 	"agentsmd",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -291,6 +308,7 @@ const subagentsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kiro",
 	"kiro-cli",
@@ -310,8 +328,10 @@ const skillsProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
+	"claudecode-plugin",
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
@@ -323,6 +343,7 @@ const skillsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kilo",
 	"kiro",
@@ -345,9 +366,11 @@ const hooksProcessorToolTargetTuple = [
 	"amp",
 	"antigravity-cli",
 	"antigravity-ide",
+	"antigravity-plugin",
 	"kilo",
 	"cursor",
 	"claudecode",
+	"claudecode-plugin",
 	"codexcli",
 	"copilot",
 	"copilotcli",
@@ -356,6 +379,7 @@ const hooksProcessorToolTargetTuple = [
 	"factorydroid",
 	"goose",
 	"hermesagent",
+	"kimi-code",
 	"deepagents",
 	"kiro",
 	"kiro-cli",
@@ -383,6 +407,7 @@ const permissionsProcessorToolTargetTuple = [
 	"goose",
 	"grokcli",
 	"hermesagent",
+	"kimi-code",
 	"junie",
 	"kilo",
 	"kiro",
@@ -413,6 +438,7 @@ const ALL_TOOL_TARGETS = [...new Set([
 ].flat())];
 const ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
 const ToolTargetSchema = zod_mini.z.enum(ALL_TOOL_TARGETS);
+const PACKAGING_TOOL_TARGETS = ["antigravity-plugin", "claudecode-plugin"];
 zod_mini.z.array(ToolTargetSchema);
 const RulesyncTargetsSchema = zod_mini.z.array(zod_mini.z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
 const RulesyncConfigTargetsObjectSchema = zod_mini.z.record(zod_mini.z.string(), PerTargetFeaturesValueSchema);
@@ -568,12 +594,12 @@ async function readFileBuffer(filepath) {
 	return (0, node_fs_promises.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((0, node_path.dirname)(filepath));
@@ -609,7 +635,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
@@ -622,7 +648,7 @@ async function findFilesByGlobs(globs, options = {}) {
 	};
 	const results = (0, globby.globbySync)(Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/"), {
 		absolute: true,
-		followSymbolicLinks: true,
+		followSymbolicLinks,
 		...globbyOptions
 	});
 	const seenRealPaths = /* @__PURE__ */ new Set();
@@ -1035,12 +1061,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
@@ -1190,7 +1217,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() {
@@ -1572,7 +1599,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
@@ -1968,7 +1995,7 @@ const hasControlChars = (val) => CONTROL_CHARS.some((char) => val.includes(char)
 const safeString = zod_mini.z.pipe(zod_mini.z.string(), zod_mini.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 = zod_mini.z.looseObject({
 	command: zod_mini.z.optional(safeString),
@@ -1982,6 +2009,7 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	])),
 	url: zod_mini.z.optional(safeString),
 	timeout: zod_mini.z.optional(zod_mini.z.number()),
+	cacheTtl: zod_mini.z.optional(zod_mini.z.number().check((0, zod_mini.nonnegative)())),
 	matcher: zod_mini.z.optional(safeString),
 	prompt: zod_mini.z.optional(safeString),
 	loop_limit: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.number())),
@@ -2521,6 +2549,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:
@@ -2611,6 +2684,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	reasonix: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	"kimi-code": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -3137,6 +3211,28 @@ function parseJsonc$8(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 = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+		if (await fileExists(targetPath)) {
+			await assertWritablePathInsideRoot({
+				rootPath: outputRoot,
+				targetPath
+			});
+			return candidate;
+		}
+	}
+	await assertWritablePathInsideRoot({
+		rootPath: outputRoot,
+		targetPath: (0, node_path.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;
@@ -3150,12 +3246,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() {
@@ -3171,11 +3269,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 = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
 			if (!await fileExists(filePath)) continue;
 			const fileContent = await readFileContent(filePath);
@@ -3187,7 +3281,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;
@@ -3305,8 +3399,8 @@ const RulesyncMcpConfigSchema = zod_mini.z.object({ mcpServers: zod_mini.z.recor
 * 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 = zod_mini.z.looseObject({ mcpServers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.nullable(RulesyncMcpServerSchema))) });
 const RulesyncMcpFileSchema = zod_mini.z.looseObject({
@@ -3331,6 +3425,7 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	hermesagent: zod_mini.z.optional(toolScopedMcpSchema),
 	junie: zod_mini.z.optional(toolScopedMcpSchema),
 	kilo: zod_mini.z.optional(toolScopedMcpSchema),
+	"kimi-code": zod_mini.z.optional(toolScopedMcpSchema),
 	kiro: zod_mini.z.optional(toolScopedMcpSchema),
 	opencode: zod_mini.z.optional(toolScopedMcpSchema),
 	qwencode: zod_mini.z.optional(toolScopedMcpSchema),
@@ -3358,14 +3453,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() {
@@ -3381,41 +3475,23 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, logger }) {
 		const paths = this.getSettablePaths();
-		const recommendedPath = (0, node_path.join)(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath);
-		const jsoncPath = (0, node_path.join)(outputRoot, paths.jsonc.relativeDirPath, paths.jsonc.relativeFilePath);
-		const legacyPath = (0, node_path.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 = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
+			if (!await fileExists(filePath)) continue;
+			if (candidate.relativeFilePath === ".mcp.json") {
+				const recommendedPath = (0, node_path.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((0, node_path.join)(outputRoot, paths.recommended.relativeDirPath, paths.recommended.relativeFilePath));
 		return new RulesyncMcp({
 			outputRoot,
 			relativeDirPath: paths.recommended.relativeDirPath,
@@ -3616,7 +3692,7 @@ const PermissionRulesSchema = zod_mini.z.record(zod_mini.z.string(), PermissionA
 * 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" } } } }
@@ -3629,6 +3705,25 @@ const ToolScopedPermissionSchema = zod_mini.z.record(zod_mini.z.string(), Permis
 * added without a schema break.
 */
 const CanonicalPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(ToolScopedPermissionSchema) });
+const KimiCodePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	defaultPermissionMode: zod_mini.z.optional(zod_mini.z.enum([
+		"manual",
+		"yolo",
+		"auto"
+	])),
+	rules: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.looseObject({
+		decision: PermissionActionSchema,
+		pattern: zod_mini.z.string(),
+		scope: zod_mini.z.optional(zod_mini.z.enum([
+			"turn-override",
+			"session-runtime",
+			"project",
+			"user"
+		])),
+		reason: zod_mini.z.optional(zod_mini.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
@@ -4220,6 +4315,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	devin: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	"kimi-code": zod_mini.z.optional(KimiCodePermissionsOverrideSchema),
 	rovodev: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	zed: zod_mini.z.optional(CanonicalPermissionsOverrideSchema)
 });
@@ -4244,12 +4340,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() {
@@ -4265,11 +4363,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 = (0, node_path.join)(outputRoot, candidate.relativeDirPath, candidate.relativeFilePath);
 			if (!await fileExists(filePath)) continue;
 			const fileContent = await readFileContent(filePath);
@@ -4281,7 +4375,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;
@@ -4291,7 +4385,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.
 	*
@@ -4656,6 +4750,16 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean())
 	})),
+	"kimi-code": zod_mini.z.optional(zod_mini.z.looseObject({
+		type: zod_mini.z.optional(zod_mini.z.enum([
+			"prompt",
+			"inline",
+			"flow"
+		])),
+		whenToUse: zod_mini.z.optional(zod_mini.z.string()),
+		disableModelInvocation: zod_mini.z.optional(zod_mini.z.boolean()),
+		arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	})),
 	agentsskills: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
 		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
@@ -6357,6 +6461,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";
@@ -7372,6 +7498,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";
 /**
@@ -7716,6 +7843,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: {
@@ -7850,6 +7991,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.
 *
@@ -7932,6 +8077,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.
@@ -8683,6 +8835,7 @@ const KIRO_IDE_HOOKS_DIR_PATH = (0, node_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 {
@@ -9963,6 +10116,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: {
@@ -10500,7 +10663,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
 		});
 	}
@@ -10597,7 +10760,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;
@@ -10727,7 +10890,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
@@ -10864,7 +11027,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
@@ -11067,6 +11230,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)
@@ -11292,7 +11465,7 @@ const CLAUDE_CONVERTER_CONFIG = {
 		tool: "if"
 	}]
 };
-var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
+var ClaudecodeHooks = class extends ToolHooks {
 	constructor(params) {
 		super({
 			...params,
@@ -11309,9 +11482,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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
@@ -11320,7 +11493,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 = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readOrInitializeFileContent(filePath, JSON.stringify({}, null, 2));
 		const config = rulesyncHooks.getJson();
@@ -11336,7 +11509,7 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 			}) },
 			filePath
 		});
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
@@ -11367,7 +11540,7 @@ var ClaudecodeHooks = class ClaudecodeHooks extends ToolHooks {
 		};
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new ClaudecodeHooks({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
@@ -11377,6 +11550,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,
@@ -12743,7 +12929,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;
@@ -12765,7 +12951,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];
@@ -13205,6 +13391,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 = (0, node_path.join)(KIMI_CODE_DIR, KIMI_CODE_SKILLS_DIR_NAME);
+(0, node_path.join)(KIMI_CODE_DIR, KIMI_CODE_AGENTS_DIR_NAME);
+const KIMI_CODE_SHARED_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
+const KIMI_CODE_SHARED_AGENTS_DIR_PATH = (0, node_path.join)(".agents", "agents");
+//#endregion
+//#region src/utils/kimi-code.ts
+function getKimiCodeHome() {
+	const configuredHome = process.env.KIMI_CODE_HOME?.trim();
+	return configuredHome ? (0, node_path.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 : (0, node_path.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: (0, node_path.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((0, node_path.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: (0, node_path.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.
@@ -13220,6 +13597,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 }
 		});
@@ -13252,9 +13630,14 @@ const KiroHookEntrySchema = zod_mini.z.looseObject({
 	command: zod_mini.z.optional(safeString),
 	matcher: zod_mini.z.optional(zod_mini.z.string()),
 	timeout_ms: zod_mini.z.optional(zod_mini.z.number()),
+	cache_ttl_seconds: zod_mini.z.optional(zod_mini.z.number().check((0, zod_mini.nonnegative)())),
 	name: zod_mini.z.optional(zod_mini.z.string()),
 	description: zod_mini.z.optional(zod_mini.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.
 */
@@ -13275,6 +13658,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 }
 			});
@@ -14514,6 +14898,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: {
@@ -14542,6 +14937,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: {
@@ -14645,6 +15057,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: {
@@ -15820,40 +16244,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((0, node_path.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((0, node_path.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
 		});
 	}
 };
@@ -16160,6 +16589,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}`);
@@ -16169,7 +16603,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,
@@ -16181,6 +16616,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);
@@ -16205,12 +16641,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 [];
@@ -16230,7 +16670,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
 		})];
 	}
 	/**
@@ -16244,7 +16685,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,
@@ -16266,7 +16708,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;
 	}
 };
@@ -16706,6 +17148,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 = (0, node_path.join)(relativeDirPath, relativeFilePath);
@@ -17125,7 +17577,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;
@@ -18934,6 +19386,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 ${(0, node_path.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((0, node_path.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 = (0, node_path.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;
@@ -19742,7 +20358,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
@@ -20262,6 +20878,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: {
@@ -20280,6 +20905,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: {
@@ -20379,6 +21013,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: {
@@ -20394,7 +21037,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["kiro-cli", {
@@ -20403,7 +21046,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["kiro-ide", {
@@ -20412,7 +21055,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["junie", {
@@ -22979,7 +23622,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);
@@ -24439,8 +25082,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)
 		});
 	}
@@ -24862,7 +25506,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,
@@ -24922,6 +25566,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: (0, node_path.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((0, node_path.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 = zod_mini.z.looseObject({
 	allowedTools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
@@ -27137,6 +28002,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodePermissions,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["junie", {
 		class: JuniePermissions,
 		meta: {
@@ -28230,6 +29103,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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -28424,7 +29308,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,
@@ -28519,9 +29403,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(),
@@ -28541,14 +29425,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 = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new ClaudecodeSkill({
+		return new this({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -28560,7 +29444,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,
@@ -28576,6 +29460,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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -30365,6 +31260,197 @@ var KiloSkill = class KiloSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/kimi-code-skill.ts
+const KimiCodeSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string(),
+	type: zod_mini.z.optional(zod_mini.z.enum([
+		"prompt",
+		"inline",
+		"flow"
+	])),
+	whenToUse: zod_mini.z.optional(zod_mini.z.string()),
+	disableModelInvocation: zod_mini.z.optional(zod_mini.z.boolean()),
+	arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+});
+const KimiCodeFlatSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	type: zod_mini.z.optional(zod_mini.z.enum([
+		"prompt",
+		"inline",
+		"flow"
+	])),
+	whenToUse: zod_mini.z.optional(zod_mini.z.string()),
+	disableModelInvocation: zod_mini.z.optional(zod_mini.z.boolean()),
+	arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.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 ${(0, node_path.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 = (0, node_path.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 = (0, node_path.basename)(relativeFilePath, (0, node_path.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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -32091,6 +33177,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: false
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeSkill,
 		meta: {
@@ -32107,6 +33201,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: false
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeSkill,
 		meta: {
@@ -32211,6 +33313,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["kiro", {
 		class: KiroSkill,
 		meta: {
@@ -32432,36 +33542,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 = (0, node_path.join)(this.outputRoot, root);
+			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
+			const relativeDirPath = typeof root === "string" ? root : root.relativeDirPath;
+			const skillsDirPath = (0, node_path.join)(rootOutputRoot, relativeDirPath);
 			if (!await directoryExists(skillsDirPath)) continue;
 			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
+			const ownedDirNames = [];
 			for (const dirPath of dirPaths) {
 				const dirName = (0, node_path.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((0, node_path.join)(skillsDirPath, "*.md"), { type: "file" })).filter((filePath) => !directoryStems.has((0, node_path.basename)(filePath, ".md")));
+			const flatSkills = await Promise.all(flatFilePaths.map((filePath) => fromFlatFile({
+				outputRoot: rootOutputRoot,
+				relativeDirPath,
+				relativeFilePath: (0, node_path.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() {
@@ -32471,8 +33601,19 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 		for (const root of roots) {
 			const skillsDirPath = (0, node_path.join)(this.outputRoot, root);
 			if (!await directoryExists(skillsDirPath)) continue;
-			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
+			await assertWritablePathInsideRoot({
+				rootPath: this.outputRoot,
+				targetPath: skillsDirPath
+			});
+			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), {
+				type: "dir",
+				followSymbolicLinks: false
+			});
 			for (const dirPath of dirPaths) {
+				await assertWritablePathInsideRoot({
+					rootPath: skillsDirPath,
+					targetPath: dirPath
+				});
 				const dirName = (0, node_path.basename)(dirPath);
 				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
 					outputRoot: this.outputRoot,
@@ -32562,6 +33703,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.");
 	}
@@ -33223,6 +34368,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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -35210,9 +36366,153 @@ var KiloSubagent = class KiloSubagent extends OpenCodeStyleSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/kimi-code-subagent.ts
+const KimiCodeAgentNameSchema = zod_mini.z.pipe(zod_mini.z.string(), zod_mini.z.custom((value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value), "must be a kebab-case name"));
+const KimiCodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(KimiCodeAgentNameSchema),
+	description: zod_mini.z.string(),
+	whenToUse: zod_mini.z.optional(zod_mini.z.string()),
+	override: zod_mini.z.optional(zod_mini.z.boolean()),
+	tools: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	disallowedTools: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	subagents: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.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 ${(0, node_path.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 = (0, node_path.basename)(this.getRelativeFilePath(), (0, node_path.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 ${(0, node_path.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 = (0, node_path.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 = zod_mini.z.looseObject({
-	name: zod_mini.z.string(),
+	name: zod_mini.z.optional(zod_mini.z.string()),
 	description: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.string())),
 	prompt: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.string())),
 	tools: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.array(zod_mini.z.string()))),
@@ -35227,7 +36527,7 @@ const KiroCliSubagentJsonSchema = zod_mini.z.looseObject({
 	allowedTools: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.array(zod_mini.z.string()))),
 	includeMcpJson: zod_mini.z.optional(zod_mini.z.nullable(zod_mini.z.boolean()))
 });
-var KiroSubagent = class KiroSubagent extends ToolSubagent {
+var KiroSubagent = class extends ToolSubagent {
 	body;
 	constructor({ body, ...rest }) {
 		if (rest.validate !== false) try {
@@ -35245,6 +36545,9 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 	getBody() {
 		return this.body;
 	}
+	static getToolTarget() {
+		return "kiro";
+	}
 	toRulesyncSubagent() {
 		let parsed;
 		try {
@@ -35253,12 +36556,13 @@ var KiroSubagent = class KiroSubagent extends ToolSubagent {
 			throw new Error(`Failed to parse JSON in ${(0, node_path.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 ?? (0, node_path.basename)(this.getRelativeFilePath(), ".json"),
 				description: description ?? void 0,
 				...Object.keys(kiroSection).length > 0 && { kiro: kiroSection }
 			},
@@ -35285,7 +36589,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,
@@ -35313,14 +36617,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 = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
 		const fileContent = await readFileContent(filePath);
-		const subagent = new KiroSubagent({
+		const subagent = new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath,
@@ -35336,7 +36640,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,
@@ -35358,11 +36662,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
@@ -36349,6 +37650,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["claudecode-plugin", {
+		class: ClaudecodePluginSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: false,
+			filePattern: "*.md"
+		}
+	}],
 	["claudecode-legacy", {
 		class: ClaudecodeSubagent,
 		meta: {
@@ -36485,6 +37794,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["kimi-code", {
+		class: KimiCodeSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: (0, node_path.join)("**", "*.md")
+		}
+	}],
 	["opencode", {
 		class: OpenCodeSubagent,
 		meta: {
@@ -36606,7 +37923,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 = (0, node_path.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
@@ -36654,25 +37982,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 = (0, node_path.join)(this.outputRoot, dirPath);
-			const subagentFilePaths = await findFilesByGlobs((0, node_path.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 = (0, node_path.join)(rootOutputRoot, dirPath);
+			if (forDeletion && await directoryExists(baseDir)) await assertWritablePathInsideRoot({
+				rootPath: rootOutputRoot,
+				targetPath: baseDir
+			});
+			const subagentFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern), { followSymbolicLinks: !forDeletion });
 			const toRelativeFilePath = (path) => (0, node_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
@@ -36680,14 +38018,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;
@@ -36703,7 +38041,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;
@@ -36712,7 +38050,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;
 	}
 	/**
@@ -37376,17 +38714,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((0, node_path.join)(outputRoot, rootPath.relativeDirPath, rootPath.relativeFilePath));
-			return new AntigravityIdeRule({
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37396,10 +38735,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((0, node_path.join)(outputRoot, rootPath.relativeDirPath, rootPath.relativeFilePath));
-			return new AntigravityIdeRule({
+			return new this({
 				outputRoot,
 				relativeDirPath: rootPath.relativeDirPath,
 				relativeFilePath: rootPath.relativeFilePath,
@@ -37409,7 +38748,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 = (0, node_path.join)(outputRoot, nonRootDirPath, relativeFilePath);
 		const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
 		let parsedFrontmatter;
@@ -37418,7 +38758,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,
@@ -37429,9 +38769,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,
@@ -37442,8 +38783,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,
@@ -37460,10 +38801,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(),
@@ -37532,6 +38874,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() {
@@ -39481,13 +40840,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({
@@ -39608,6 +40971,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((0, node_path.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([
 	"**/*",
@@ -41058,6 +42512,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: false,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeRule,
 		meta: {
@@ -41197,6 +42659,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: {
@@ -41670,7 +43141,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)}`);
@@ -41873,12 +43344,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)),
@@ -41957,7 +43441,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,
@@ -41971,18 +43459,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")
@@ -42002,7 +43492,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,
@@ -42051,7 +43545,11 @@ function buildSubagentsStrategy(ctx) {
 			includeSimulated: false
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new SubagentsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42072,7 +43570,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,
@@ -42097,7 +43599,11 @@ function buildHooksStrategy(ctx) {
 			importOnly: true
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new HooksProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42122,7 +43628,11 @@ function buildPermissionsStrategy(ctx) {
 			importOnly: true
 		}),
 		createProcessor: ({ toolTarget, dryRun }) => new PermissionsProcessor({
-			outputRoot,
+			outputRoot: resolveToolOutputRoot({
+				outputRoot,
+				toolTarget,
+				global
+			}),
 			toolTarget,
 			global,
 			dryRun,
@@ -42623,6 +44133,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
@@ -42742,7 +44256,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(),
@@ -42777,18 +44295,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;
@@ -42799,6 +44313,7 @@ async function generateIgnoreCore(params) {
 				outputRoot,
 				inputRoot: config.getInputRoot(),
 				toolTarget,
+				global,
 				dryRun: config.isPreviewMode(),
 				logger,
 				featureOptions: config.getFeatureOptions(toolTarget, "ignore")
@@ -42838,7 +44353,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(),
@@ -42923,7 +44442,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(),
@@ -42966,7 +44489,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(),
@@ -43007,7 +44534,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(),
@@ -43045,7 +44576,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(),
@@ -43111,21 +44646,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((0, node_path.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,
@@ -43180,7 +44735,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
@@ -43198,14 +44756,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")
 	});
@@ -43226,7 +44785,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
@@ -43236,14 +44798,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;
 }
@@ -43256,7 +44817,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
@@ -43280,7 +44844,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
@@ -43301,7 +44868,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
@@ -43311,8 +44881,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;
 }
@@ -43331,7 +44914,10 @@ async function importHooksCore(params) {
 		return 0;
 	}
 	const hooksProcessor = new HooksProcessor({
-		outputRoot: config.getOutputRoots()[0] ?? ".",
+		outputRoot: getToolOutputRoot({
+			config,
+			tool
+		}),
 		toolTarget: tool,
 		global,
 		logger
@@ -43341,14 +44927,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;
 }
@@ -43366,7 +44951,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
@@ -43376,14 +44964,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;
 }
@@ -43547,6 +45133,12 @@ Object.defineProperty(exports, "McpProcessor", {
 		return McpProcessor;
 	}
 });
+Object.defineProperty(exports, "PACKAGING_TOOL_TARGETS", {
+	enumerable: true,
+	get: function() {
+		return PACKAGING_TOOL_TARGETS;
+	}
+});
 Object.defineProperty(exports, "RULESYNC_AIIGNORE_FILE_NAME", {
 	enumerable: true,
 	get: function() {
@@ -43601,10 +45193,10 @@ Object.defineProperty(exports, "RULESYNC_HOOKS_FILE_NAME", {
 		return RULESYNC_HOOKS_FILE_NAME;
 	}
 });
-Object.defineProperty(exports, "RULESYNC_HOOKS_JSONC_FILE_NAME", {
+Object.defineProperty(exports, "RULESYNC_HOOKS_LEGACY_FILE_NAME", {
 	enumerable: true,
 	get: function() {
-		return RULESYNC_HOOKS_JSONC_FILE_NAME;
+		return RULESYNC_HOOKS_LEGACY_FILE_NAME;
 	}
 });
 Object.defineProperty(exports, "RULESYNC_HOOKS_RELATIVE_FILE_PATH", {
@@ -43631,10 +45223,10 @@ Object.defineProperty(exports, "RULESYNC_MCP_FILE_NAME", {
 		return RULESYNC_MCP_FILE_NAME;
 	}
 });
-Object.defineProperty(exports, "RULESYNC_MCP_JSONC_FILE_NAME", {
+Object.defineProperty(exports, "RULESYNC_MCP_LEGACY_FILE_NAME", {
 	enumerable: true,
 	get: function() {
-		return RULESYNC_MCP_JSONC_FILE_NAME;
+		return RULESYNC_MCP_LEGACY_FILE_NAME;
 	}
 });
 Object.defineProperty(exports, "RULESYNC_MCP_RELATIVE_FILE_PATH", {
@@ -43661,10 +45253,10 @@ Object.defineProperty(exports, "RULESYNC_PERMISSIONS_FILE_NAME", {
 		return RULESYNC_PERMISSIONS_FILE_NAME;
 	}
 });
-Object.defineProperty(exports, "RULESYNC_PERMISSIONS_JSONC_FILE_NAME", {
+Object.defineProperty(exports, "RULESYNC_PERMISSIONS_LEGACY_FILE_NAME", {
 	enumerable: true,
 	get: function() {
-		return RULESYNC_PERMISSIONS_JSONC_FILE_NAME;
+		return RULESYNC_PERMISSIONS_LEGACY_FILE_NAME;
 	}
 });
 Object.defineProperty(exports, "RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH", {
@@ -43949,12 +45541,24 @@ Object.defineProperty(exports, "getProcessorRegistryEntry", {
 		return getProcessorRegistryEntry;
 	}
 });
+Object.defineProperty(exports, "getRulesyncSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return getRulesyncSourceCandidates;
+	}
+});
 Object.defineProperty(exports, "importFromTool", {
 	enumerable: true,
 	get: function() {
 		return importFromTool;
 	}
 });
+Object.defineProperty(exports, "isPackagingToolTarget", {
+	enumerable: true,
+	get: function() {
+		return isPackagingToolTarget;
+	}
+});
 Object.defineProperty(exports, "isSymlink", {
 	enumerable: true,
 	get: function() {
@@ -43973,6 +45577,12 @@ Object.defineProperty(exports, "loadYaml", {
 		return loadYaml;
 	}
 });
+Object.defineProperty(exports, "parseJsonc", {
+	enumerable: true,
+	get: function() {
+		return parseJsonc$8;
+	}
+});
 Object.defineProperty(exports, "readFileContent", {
 	enumerable: true,
 	get: function() {
@@ -44021,6 +45631,12 @@ Object.defineProperty(exports, "resolvePath", {
 		return resolvePath;
 	}
 });
+Object.defineProperty(exports, "resolveRulesyncSourceWritePath", {
+	enumerable: true,
+	get: function() {
+		return resolveRulesyncSourceWritePath;
+	}
+});
 Object.defineProperty(exports, "runWithDirectoryRollback", {
 	enumerable: true,
 	get: function() {