rulesync 43.3.0 → 43.4.0

package/dist/{import-BQNLyW5s.js → import-D2mUPFM0.js}

@@ -5613,11 +5613,28 @@ const POOL_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_POOL_EVENT_N
 /**
 * Hook events supported by Crush.
 *
-* Crush's `hooks` config block currently fires a single event, `PreToolUse`
-* (Claude Code-compatible payload; `matcher` is a regex on the tool name).
-* @see https://github.com/charmbracelet/crush/blob/main/docs/hooks/README.md
+* Crush v0.99.0 fires 13 events under its `hooks` config block (Claude
+* Code-compatible payload; `matcher` is a regex on the tool name and is only
+* accepted on tool events). Twelve of them have a canonical counterpart;
+* `PermissionResult` has none and is authored under the `crush.hooks`
+* override.
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/docs/hooks/README.md
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/internal/hooks/events.go
 */
-const CRUSH_HOOK_EVENTS = ["preToolUse"];
+const CRUSH_HOOK_EVENTS = [
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionRequest",
+	"sessionStart",
+	"sessionEnd",
+	"beforeSubmitPrompt",
+	"stop",
+	"stopFailure",
+	"stopCancelled",
+	"preCompact",
+	"postCompact"
+];
 /**
 * Hook events supported by JetBrains Junie CLI.
 *
@@ -5882,9 +5899,10 @@ const ZCODE_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_ZCODE_EVENT
 * Bob reads `hooks` from `.bob/settings.json` (project) and
 * `~/.bob/settings/settings.json` (user) in the Claude-Code shape and fires
 * seven events: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse,
-* PreCompact, PostCompact (both added by Bob Shell 2.0.3) and Stop. Handlers
-* are `command` or `https` hooks, and `matcher` (a regex over the tool name)
-* applies to the two tool events.
+* PreCompact, PostCompact and Stop (Bob IDE and Bob Shell list the same
+* seven). Handlers are `command` or `http` hooks. `matcher` is a regex matched
+* against the tool name on PreToolUse / PostToolUse, `source` on SessionStart
+* and `trigger` on PreCompact / PostCompact; the other events ignore it.
 *
 * @see https://bob.ibm.com/docs/shell/configuration/lifecycle-hooks
 * @see https://bob.ibm.com/docs/ide/configuration/lifecycle-hooks
@@ -7066,10 +7084,38 @@ const CANONICAL_TO_CODEWHALE_EVENT_NAMES = {
 const CODEWHALE_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_CODEWHALE_EVENT_NAMES);
 /**
 * Canonical -> Crush event names. Crush spells its events the Claude Code
-* way (`PreToolUse`).
-* @see https://github.com/charmbracelet/crush/blob/main/docs/hooks/README.md
+* way (`PreToolUse`), but names the turn events `TurnStart` (Claude Code's
+* `UserPromptSubmit`) and `TurnEnd` (Claude Code's `Stop`), and the
+* user-cancelled turn `Interrupt`.
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/docs/hooks/README.md
+*/
+const CANONICAL_TO_CRUSH_EVENT_NAMES = {
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionRequest: "PermissionRequest",
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	beforeSubmitPrompt: "TurnStart",
+	stop: "TurnEnd",
+	stopFailure: "StopFailure",
+	stopCancelled: "Interrupt",
+	preCompact: "PreCompact",
+	postCompact: "PostCompact"
+};
+/**
+* Crush events that carry a tool call, the only ones whose hooks may set a
+* `matcher` (Crush's `EventHasTool`). A matcher on any other event makes
+* Crush reject the whole config at load time.
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/internal/config/hooks.go
 */
-const CANONICAL_TO_CRUSH_EVENT_NAMES = { preToolUse: "PreToolUse" };
+const CRUSH_TOOL_EVENTS = [
+	"PreToolUse",
+	"PostToolUse",
+	"PostToolUseFailure",
+	"PermissionRequest",
+	"PermissionResult"
+];
 const CRUSH_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_CRUSH_EVENT_NAMES);
 /**
 * Map canonical camelCase event names to Qwen Code PascalCase.
@@ -7613,14 +7659,18 @@ const toolScopedMcpSchema = z.looseObject({ mcpServers: z.optional(z.record(z.st
 * server opts out. Per-server `startupTimeoutMs` / `toolTimeoutMs` / `deferred`
 * in `mcpServers` still win. `defaultDeferred` only takes effect when Kimi's
 * experimental `tool-select` flag is on, and is captured when a server connects
-* (MoonshotAI/kimi-code#4210).
+* (MoonshotAI/kimi-code#4210). `reconnectInitialDelayMs` / `reconnectMaxDelayMs`
+* (Kimi Code 2.4.0) set the first delay and the cap of the automatic reconnect
+* backoff for workspace-level servers (MoonshotAI/kimi-code#4283).
 *
 * @see https://moonshotai.github.io/kimi-code/en/configuration/config-files.html#mcp
 */
 const kimiCodeScopedMcpSchema = z.extend(toolScopedMcpSchema, {
 	startupTimeoutMs: z.optional(z.number()),
 	toolTimeoutMs: z.optional(z.number()),
-	defaultDeferred: z.optional(z.boolean())
+	defaultDeferred: z.optional(z.boolean()),
+	reconnectInitialDelayMs: z.optional(z.int().check(z.nonnegative())),
+	reconnectMaxDelayMs: z.optional(z.int().check(z.nonnegative()))
 });
 /**
 * Qwen Code's tool-scoped block also carries the server-level allow/deny lists
@@ -11446,6 +11496,7 @@ const piSkillSectionSchema = z.looseObject({
 });
 const antigravitySkillSectionSchema = z.looseObject({
 	"disable-slash-command": z.optional(z.boolean()),
+	"disable-model-invocation": z.optional(z.boolean()),
 	metadata: z.optional(z.looseObject({}))
 });
 const RulesyncSkillFrontmatterSchema = z.looseObject({
@@ -16205,8 +16256,9 @@ var ToolSkill = class extends AiDir {
 * {@link AntigravitySharedSkill.getToolTarget}.
 *
 * Frontmatter beyond `name`/`description` (e.g. `disable-slash-command`,
-* `metadata`) comes from the rulesync section named after that target, with the
-* root-level `user-invocable` / `metadata` as defaults. On the shared project
+* `disable-model-invocation`, `metadata`) comes from the rulesync section named
+* after that target, with the root-level `user-invocable` /
+* `disable-model-invocation` / `metadata` as defaults. On the shared project
 * `.agents/skills/` tree both targets merge the `antigravity-ide` and
 * `antigravity-cli` sections so their output never diverges.
 */
@@ -16279,6 +16331,8 @@ var AntigravitySharedSkill = class extends ToolSkill {
 		const { name: _name, description: _description, ...sectionFields } = section;
 		const sectionDisableSlashCommand = sectionFields["disable-slash-command"];
 		const disableSlashCommand = typeof sectionDisableSlashCommand === "boolean" ? sectionDisableSlashCommand : rulesyncFrontmatter["user-invocable"] === false ? true : void 0;
+		const sectionDisableModelInvocation = sectionFields["disable-model-invocation"];
+		const disableModelInvocation = typeof sectionDisableModelInvocation === "boolean" ? sectionDisableModelInvocation : rulesyncFrontmatter["disable-model-invocation"];
 		const metadata = resolveMetadata({
 			rootFrontmatter: rulesyncFrontmatter,
 			section: sectionFields
@@ -16288,6 +16342,7 @@ var AntigravitySharedSkill = class extends ToolSkill {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...disableSlashCommand !== void 0 && { "disable-slash-command": disableSlashCommand },
+			...disableModelInvocation !== void 0 && { "disable-model-invocation": disableModelInvocation },
 			...metadata !== void 0 && { metadata }
 		};
 		return new this({
@@ -31716,16 +31771,17 @@ const VibeSkillFrontmatterSchema = z.looseObject({
 	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
 });
 /**
-* Skill names Vibe's built-in skills occupy. `SkillManager` treats them as
-* reserved: a project or user skill whose frontmatter `name` matches one is
-* skipped at load time with only a debug log ("Skipping skill '<name>' ...
-* because builtin skill names are reserved"), so a generated skill by that
-* name is silently never offered. That is the legacy backend, still the
-* default; the unified harness constructs the manager with
-* `include_builtins=False` because its built-ins arrive as skills of the
-* shipped `vibe` plugin under namespaced names, so it reserves nothing.
-* @see https://github.com/mistralai/mistral-vibe/blob/v2.25.3/vibe/core/skills/builtins/__init__.py
-* @see https://github.com/mistralai/mistral-vibe/blob/v2.25.3/vibe/core/skills/manager.py
+* Skill names Vibe's built-in skills occupy. Before v3.0.4, `SkillManager`
+* treats them as reserved: a project or user skill whose frontmatter `name`
+* matches one is skipped at load time with only a debug log ("Skipping skill
+* '<name>' ... because builtin skill names are reserved"), so a generated
+* skill by that name is silently never offered. v3.0.4 removed
+* `_reserved_builtins` and that skip ("A user skill named vibe or
+* skill-creator is no longer silently skipped"), so the warning below is
+* scoped to older Vibe releases.
+* @see https://github.com/mistralai/mistral-vibe/blob/v3.0.3/vibe/core/skills/manager.py
+* @see https://github.com/mistralai/mistral-vibe/blob/v3.0.4/vibe/core/skills/manager.py
+* @see https://github.com/mistralai/mistral-vibe/blob/v3.0.4/CHANGELOG.md
 */
 const VIBE_RESERVED_SKILL_NAMES = /* @__PURE__ */ new Set(["vibe", "skill-creator"]);
 /**
@@ -31768,11 +31824,12 @@ function buildVibeFrontmatter(rulesyncFrontmatter) {
 /**
 * The skill is still generated under the reserved name — the name is the
 * user's to change, and a rename here would make it diverge from the other
-* targets — but Vibe would drop it without a visible word, so say so now.
+* targets — but Vibe before v3.0.4 would drop it without a visible word, so
+* say so now.
 */
 function warnAboutReservedSkillName({ name, logger }) {
 	if (!VIBE_RESERVED_SKILL_NAMES.has(name)) return;
-	logger?.warn(`Vibe skills: the skill name ${quoteValueForWarning(name)} is reserved for a Vibe built-in skill, so Vibe skips a project or user skill by that name when it loads skills. Rename the skill for it to be available in Vibe.`);
+	logger?.warn(`Vibe skills: the skill name ${quoteValueForWarning(name)} matches a Vibe built-in skill. Vibe before v3.0.4 skips a project or user skill by that name when it loads skills; upgrade Vibe to v3.0.4 or later, or rename the skill, for it to be available.`);
 }
 var VibeSkill = class VibeSkill extends ToolSkill {
 	constructor({ outputRoot = process.cwd(), relativeDirPath = VibeSkill.getSettablePaths().relativeDirPath, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
@@ -42740,20 +42797,35 @@ const OPENCODE_KNOWN_SERVER_KEYS = /* @__PURE__ */ new Set([
 	"disabledTools"
 ]);
 function convertFromOpencodeFormat(opencodeMcp, tools, remoteType) {
+	const serverNames = Object.keys(opencodeMcp);
 	return {
-		...orphanMcpToolFiltersToRulesync(opencodeMcp, tools),
+		...orphanMcpToolFiltersToRulesync(opencodeMcp, Object.fromEntries(Object.entries(tools ?? {}).filter(([key]) => !findOpencodeToolOwner({
+			key,
+			serverNames
+		})))),
 		...convertOpencodeServers(opencodeMcp, tools, remoteType)
 	};
 }
+/** Recognize both OpenCode's sanitized names and keys older rulesync versions wrote. */
+function findOpencodeToolOwner({ key, serverNames }) {
+	return findOpencodeMcpToolKeyOwner({
+		key,
+		serverNames,
+		builtinKeys: /* @__PURE__ */ new Set(),
+		acceptRawPrefix: true
+	});
+}
 /** Split the shared top-level `tools` map into this server's own two lists. */
-function splitOpencodeServerTools(serverName, tools) {
+function splitOpencodeServerTools(serverName, serverNames, tools) {
 	const enabledTools = [];
 	const disabledTools = [];
-	const prefix = `${serverName}_`;
 	for (const [toolName, enabled] of Object.entries(tools ?? {})) {
-		if (!toolName.startsWith(prefix)) continue;
-		const toolSuffix = toolName.slice(prefix.length);
-		(enabled ? enabledTools : disabledTools).push(toolSuffix);
+		const owner = findOpencodeToolOwner({
+			key: toolName,
+			serverNames
+		});
+		if (owner?.serverName !== serverName) continue;
+		(enabled ? enabledTools : disabledTools).push(owner.toolName);
 	}
 	return {
 		enabledTools,
@@ -42763,7 +42835,7 @@ function splitOpencodeServerTools(serverName, tools) {
 function convertOpencodeServers(opencodeMcp, tools, remoteType) {
 	return Object.fromEntries(Object.entries(opencodeMcp).map(([serverName, serverConfig]) => {
 		const extraFields = Object.fromEntries(Object.entries(serverConfig).filter(([key]) => !OPENCODE_KNOWN_SERVER_KEYS.has(key)));
-		const { enabledTools, disabledTools } = splitOpencodeServerTools(serverName, tools);
+		const { enabledTools, disabledTools } = splitOpencodeServerTools(serverName, Object.keys(opencodeMcp), tools);
 		if (!isOpencodeTransportServer(serverConfig)) return [serverName, {
 			...extraFields,
 			disabled: serverConfig.enabled === false,
@@ -42899,8 +42971,8 @@ function convertToOpencodeFormat(mcpServers, existingMcp, configShape, logger) {
 	return {
 		mcp: Object.fromEntries(Object.entries(mcpServers).map(([serverName, serverConfig]) => {
 			const converted = convertServerToOpencodeFormat(serverName, serverConfig, existingMcp[serverName], configShape, logger);
-			if (serverConfig.enabledTools) for (const tool of serverConfig.enabledTools) tools[`${serverName}_${tool}`] = true;
-			if (serverConfig.disabledTools) for (const tool of serverConfig.disabledTools) tools[`${serverName}_${tool}`] = false;
+			if (serverConfig.enabledTools) for (const tool of serverConfig.enabledTools) tools[opencodeMcpToolPermissionKey(serverName, tool)] = true;
+			if (serverConfig.disabledTools) for (const tool of serverConfig.disabledTools) tools[opencodeMcpToolPermissionKey(serverName, tool)] = false;
 			return converted === null ? null : [serverName, converted];
 		}).filter((entry) => entry !== null)),
 		tools
@@ -55928,12 +56000,23 @@ function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
 * into separate groups, so a restricting field is never inherited by a hook
 * that did not ask for it.
 */
-function groupDefinitionsByMatcher({ definitions, converterConfig }) {
+function groupDefinitionsByMatcher({ definitions, eventName, converterConfig, warn }) {
 	const subdividingFields = (converterConfig.groupPassthroughFields ?? []).filter(({ subdividesGroup }) => subdividesGroup);
 	const byMatcher = /* @__PURE__ */ new Map();
+	const translatedMatchers = /* @__PURE__ */ new Map();
 	for (const def of definitions) {
 		const rawMatcher = def.matcher ?? "";
-		const matcher = converterConfig.wildcardMatcherMeansAll && rawMatcher === "*" ? "" : rawMatcher;
+		const normalizedMatcher = converterConfig.wildcardMatcherMeansAll && rawMatcher === "*" ? "" : rawMatcher;
+		const translation = converterConfig.matcherTranslation;
+		let matcher = normalizedMatcher;
+		if (translation && normalizedMatcher && !converterConfig.noMatcherEvents?.has(eventName)) {
+			matcher = translatedMatchers.get(normalizedMatcher) ?? translation.toTool({
+				matcher: normalizedMatcher,
+				eventName,
+				warn
+			});
+			translatedMatchers.set(normalizedMatcher, matcher);
+		}
 		const key = [matcher, ...subdividingFields.map(({ canonical, valueType }) => {
 			const value = def[canonical];
 			return isGroupPassthroughValue(value, valueType) ? stableJson(value) : "";
@@ -56443,7 +56526,7 @@ function buildToolHooks({ defs, eventName, converterConfig, warn }) {
 				converterConfig,
 				warn
 			}),
-			type: converterConfig.hookTypeNames?.[hookType] ?? hookType,
+			type: hookType,
 			...command !== void 0 && command !== null && { command },
 			...def.timeout !== void 0 && def.timeout !== null && { timeout: emitTimeout({
 				timeout: def.timeout,
@@ -56493,7 +56576,9 @@ function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logg
 		}) ?? eventName;
 		const byMatcher = groupDefinitionsByMatcher({
 			definitions,
-			converterConfig
+			eventName,
+			converterConfig,
+			warn
 		});
 		const entries = [];
 		const isNoMatcherEvent = converterConfig.noMatcherEvents?.has(eventName) ?? false;
@@ -56572,16 +56657,19 @@ function isImportedHookType(value) {
 	return typeof value === "string" && IMPORTED_HOOK_TYPES.has(value);
 }
 /**
-* The canonical hook type a tool-side `type` value denotes: the tool's own
-* spelling from {@link ToolHooksConverterConfig.hookTypeNames} when it has
-* one, otherwise the value itself when it is a canonical type, and `command`
-* for anything else (the same coercion as before the renames existed).
+* The canonical hook type a tool-side `type` value denotes: the canonical type
+* an {@link ToolHooksConverterConfig.importedHookTypeAliases} entry maps it to
+* when it has one, otherwise the value itself when it is a canonical type, and
+* `command` for anything else.
 */
 function resolveImportedHookType({ value, converterConfig }) {
-	const names = converterConfig.hookTypeNames;
-	if (names !== void 0 && typeof value === "string") {
-		for (const [canonical, tool] of Object.entries(names)) if (tool === value) return canonical;
-		if (Object.hasOwn(names, value)) return "command";
+	const aliases = converterConfig.importedHookTypeAliases;
+	if (aliases !== void 0 && typeof value === "string") {
+		const aliased = lookupOwn({
+			record: aliases,
+			key: value
+		});
+		if (aliased !== void 0) return aliased;
 	}
 	return isImportedHookType(value) ? value : "command";
 }
@@ -56809,7 +56897,7 @@ function toolHookToCanonical({ h, rawEntry, eventName, converterConfig, warn })
 		canonical: "description",
 		warn
 	});
-	const matcher = rawEntry.matcher;
+	const matcher = typeof rawEntry.matcher === "string" && converterConfig.matcherTranslation ? converterConfig.matcherTranslation.toCanonical(rawEntry.matcher) : rawEntry.matcher;
 	return {
 		type: hookType,
 		...command !== void 0 && command !== null && { command },
@@ -58307,15 +58395,9 @@ const BOB_SPEC = {
 		canonicalToToolEventNames: CANONICAL_TO_BOB_EVENT_NAMES,
 		toolToCanonicalEventNames: BOB_TO_CANONICAL_EVENT_NAMES,
 		projectDirVar: "",
-		noMatcherEvents: /* @__PURE__ */ new Set([
-			"sessionStart",
-			"beforeSubmitPrompt",
-			"preCompact",
-			"postCompact",
-			"stop"
-		]),
+		noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
 		supportedHookTypes: /* @__PURE__ */ new Set(["command", "http"]),
-		hookTypeNames: { http: "https" },
+		importedHookTypeAliases: { https: "http" },
 		wildcardMatcherMeansAll: true
 	}
 };
@@ -58327,7 +58409,7 @@ const BOB_SPEC = {
 * `~/.bob/settings/settings.json` (user scope) — in the Claude-Code shape:
 * `{ "<Event>": [{ "matcher"?: "<regex>", "hooks": [{ "type": "command",
 * "command": "...", "timeout"?: <seconds> }] }] }`, where a handler may
-* instead be `{ "type": "https", "url": "...", "timeout"?: <seconds> }`. The
+* instead be `{ "type": "http", "url": "https://...", "timeout"?: <seconds> }`. The
 * file also holds settings rulesync does not own, so generation merges the
 * `hooks` key into it (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting
 * the file.
@@ -60269,6 +60351,32 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 	}
 };
 // src/features/hooks/cortexcode-hooks.ts
+const CORTEXCODE_NO_MATCHER_EVENTS = /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]);
+const CANONICAL_TO_CORTEXCODE_TOOL_NAMES = {
+	Bash: "bash",
+	Read: "read",
+	Write: "write",
+	Edit: "edit",
+	Grep: "grep",
+	Glob: "glob"
+};
+const CORTEXCODE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CORTEXCODE_TOOL_NAMES).map(([canonical, tool]) => [tool, canonical]));
+const MATCHER_TOKEN_PATTERN = /\\.|\[(?:\\.|[^\]\\])*\]|(?<=^|[^\w\\]|\\\w)[A-Za-z_]\w*(?!\w)/gs;
+function isMatcherName(token) {
+	return !token.startsWith("\\") && !token.startsWith("[");
+}
+function replaceMatcherNames(matcher, names) {
+	return matcher.replace(MATCHER_TOKEN_PATTERN, (token) => isMatcherName(token) && Object.hasOwn(names, token) ? names[token] ?? token : token);
+}
+function canonicalToCortexcodeMatcher({ matcher, eventName, warn }) {
+	const translated = replaceMatcherNames(matcher, CANONICAL_TO_CORTEXCODE_TOOL_NAMES);
+	const unmatched = [...translated.matchAll(MATCHER_TOKEN_PATTERN)].map(([token]) => token).filter((token) => isMatcherName(token) && /^[A-Z]/.test(token));
+	if (unmatched.length > 0) warn(`Cortex Code matches hook matchers case-sensitively against lowercase runtime tool names, and ${[...new Set(unmatched)].map((name) => quoteValueForWarning(name)).join(", ")} in the "${eventName}" matcher ${quoteValueForWarning(matcher)} is not a tool Cortex Code documents a runtime ID for, so it is written as-is and will likely never match. Replace it with the lowercase name Cortex Code uses for that tool, if it has one.`);
+	return translated;
+}
+function cortexcodeToCanonicalMatcher(matcher) {
+	return replaceMatcherNames(matcher, CORTEXCODE_TO_CANONICAL_TOOL_NAMES);
+}
 const CORTEXCODE_SPEC = {
 	displayName: "Cortex Code",
 	overrideKey: "cortexcode",
@@ -60278,7 +60386,7 @@ const CORTEXCODE_SPEC = {
 		toolToCanonicalEventNames: CORTEXCODE_TO_CANONICAL_EVENT_NAMES,
 		projectDirVar: "$CORTEX_PROJECT_DIR",
 		prefixDotRelativeCommandsOnly: true,
-		noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+		noMatcherEvents: CORTEXCODE_NO_MATCHER_EVENTS,
 		supportedHookTypes: /* @__PURE__ */ new Set(["command", "prompt"]),
 		booleanPassthroughFields: [{
 			canonical: "enabled",
@@ -60293,7 +60401,11 @@ const CORTEXCODE_SPEC = {
 			canonical: "source",
 			tool: "source",
 			commandOnly: true
-		}]
+		}],
+		matcherTranslation: {
+			toTool: canonicalToCortexcodeMatcher,
+			toCanonical: cortexcodeToCanonicalMatcher
+		}
 	}
 };
 /**
@@ -60474,35 +60586,80 @@ const NORMALIZED_CRUSH_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entr
 function normalizeCrushEventName(event) {
 	return event.replaceAll("_", "").toLowerCase();
 }
+/** Crush tool events, by normalized spelling, on which a `matcher` is valid. */
+const NORMALIZED_CRUSH_TOOL_EVENTS = new Set(CRUSH_TOOL_EVENTS.map((event) => normalizeCrushEventName(event)));
+/**
+* Resolve a `crush.hooks` override key to the canonical event it names, or
+* null when it names no canonical event. The key may be spelled the canonical
+* way (`stop`) or in any spelling Crush accepts for the event (`TurnEnd`,
+* `turn_end`), so an override an earlier import filed under a Crush name still
+* lands on the same event as the shared hooks.
+*/
+function resolveOverrideCanonicalEvent(key) {
+	if (lookupOwn({
+		record: CANONICAL_TO_CRUSH_EVENT_NAMES,
+		key
+	}) !== void 0) return key;
+	return lookupOwn({
+		record: NORMALIZED_CRUSH_TO_CANONICAL_EVENT_NAMES,
+		key: normalizeCrushEventName(key)
+	}) ?? null;
+}
 /**
 * Build the `hooks` block of `crush.json` from a canonical hooks config.
 * Crush keys a flat array of `{name, matcher, command, timeout}` entries by
 * event name; `matcher` is a regex tested against the (lower-case) Crush tool
 * name and `timeout` is in seconds. Only `type: "command"` canonical hooks are
 * emitted, since a Crush hook is a shell command. A shared canonical event
-* Crush does not fire is skipped (the HooksProcessor reports it), while an
-* event under the `crush.hooks` override — such as one an import filed there
-* — is written verbatim so it round-trips.
+* Crush does not fire is skipped (the HooksProcessor reports it).
+*
+* Every `crush.hooks` override key is resolved to its event first, whatever
+* spelling it uses: the override replaces the shared entries of that event
+* (as for every other tool's override), and override keys that name the same
+* event are concatenated in order, the way Crush itself merges them. A key
+* that names no canonical event — such as `PermissionResult`, or one an
+* import filed there — is written verbatim so it round-trips; keys of that
+* kind that Crush reads as the same event are concatenated under the first
+* spelling. A `matcher` is only written on a tool event: Crush rejects the
+* whole config when one appears anywhere else.
 */
 function canonicalToCrushHooks({ config, toolOverride, logger }) {
-	const sharedHooks = {};
-	for (const [event, defs] of Object.entries(config.hooks)) if (SUPPORTED_CRUSH_EVENTS.has(event)) sharedHooks[event] = defs;
-	const effective = {
-		...sharedHooks,
-		...toolOverride
-	};
-	const hooks = {};
-	for (const [event, defs] of Object.entries(effective)) {
-		if (isPrototypePollutionKey(event)) continue;
-		const crushEvent = lookupOwn({
+	const shared = /* @__PURE__ */ new Map();
+	for (const [event, defs] of Object.entries(config.hooks)) {
+		const crushEvent = SUPPORTED_CRUSH_EVENTS.has(event) ? lookupOwn({
 			record: CANONICAL_TO_CRUSH_EVENT_NAMES,
 			key: event
-		}) ?? event;
+		}) : void 0;
+		if (crushEvent !== void 0) shared.set(crushEvent, defs);
+	}
+	const override = /* @__PURE__ */ new Map();
+	const verbatimSpellings = /* @__PURE__ */ new Map();
+	for (const [key, defs] of Object.entries(toolOverride ?? {})) {
+		if (isPrototypePollutionKey(key) || !Array.isArray(defs)) continue;
+		const canonical = resolveOverrideCanonicalEvent(key);
+		let crushEvent;
+		if (canonical !== null) crushEvent = lookupOwn({
+			record: CANONICAL_TO_CRUSH_EVENT_NAMES,
+			key: canonical
+		}) ?? key;
+		else {
+			const normalized = normalizeCrushEventName(key);
+			crushEvent = verbatimSpellings.get(normalized) ?? key;
+			verbatimSpellings.set(normalized, crushEvent);
+		}
+		override.set(crushEvent, [...override.get(crushEvent) ?? [], ...defs]);
+	}
+	const effective = new Map(shared);
+	for (const [crushEvent, defs] of override) effective.set(crushEvent, defs);
+	const hooks = {};
+	for (const [crushEvent, defs] of effective) {
+		const allowsMatcher = NORMALIZED_CRUSH_TOOL_EVENTS.has(normalizeCrushEventName(crushEvent));
 		const entries = [];
 		for (const def of defs) {
 			const entry = canonicalDefToCrushEntry({
 				def,
-				event,
+				event: crushEvent,
+				allowsMatcher,
 				logger
 			});
 			if (entry !== null) entries.push(entry);
@@ -60512,7 +60669,7 @@ function canonicalToCrushHooks({ config, toolOverride, logger }) {
 	return hooks;
 }
 /** Convert one canonical hook definition to a Crush entry, or null to skip. */
-function canonicalDefToCrushEntry({ def, event, logger }) {
+function canonicalDefToCrushEntry({ def, event, allowsMatcher, logger }) {
 	if ((def.type ?? "command") !== "command") return null;
 	if (typeof def.command !== "string" || def.command === "") {
 		logger?.warn(`Crush hook ${quoteValueForWarning(def.name ?? "")} under "${event}" has no "command", which Crush would discard, so it was skipped.`);
@@ -60520,7 +60677,10 @@ function canonicalDefToCrushEntry({ def, event, logger }) {
 	}
 	const entry = { command: def.command };
 	if (typeof def.name === "string" && def.name !== "") entry.name = def.name;
-	if (typeof def.matcher === "string" && def.matcher !== "" && def.matcher !== "*") entry.matcher = def.matcher;
+	if (typeof def.matcher === "string" && def.matcher !== "" && def.matcher !== "*") {
+		if (allowsMatcher) entry.matcher = def.matcher;
+		else logger?.warn(`matcher ${quoteValueForWarning(def.matcher)} on "${event}" hook will be ignored — Crush only accepts a matcher on tool events.`);
+	}
 	if (typeof def.timeout === "number") entry.timeout = Math.ceil(def.timeout);
 	return entry;
 }
@@ -60567,12 +60727,13 @@ function crushHooksToCanonical(hooksBlock) {
 * `<project>/crush.json` (or an existing `.crush.json`; Crush merges the pair,
 * lists concatenated) at project scope and `~/.config/crush/crush.json` at
 * user scope — as
-* `hooks.<Event>: [{name?, matcher?, command, timeout?}]`. Only `PreToolUse`
-* fires today. The `hooks` key is owned outright; every other top-level key
+* `hooks.<Event>: [{name?, matcher?, command, timeout?}]`. `matcher` is only
+* valid on tool events (`PreToolUse`, `PostToolUse`, `PostToolUseFailure`,
+* `PermissionRequest`, `PermissionResult`). The `hooks` key is owned outright; every other top-level key
 * of the file is preserved and the file is never deleted.
 *
-* @see https://github.com/charmbracelet/crush/blob/main/docs/hooks/README.md
-* @see https://github.com/charmbracelet/crush/blob/main/internal/config/config.go
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/docs/hooks/README.md
+* @see https://github.com/charmbracelet/crush/blob/v0.99.0/internal/config/hooks.go
 */
 var CrushHooks = class CrushHooks extends ToolHooks {
 	json;
@@ -63418,8 +63579,11 @@ var LettacodeHooks = class LettacodeHooks extends ToolHooks {
 * OpenCode 2.x no longer runs V1 plugin modules: a plugin must default-export
 * `{ id, setup(ctx) }`. Inside `setup` hooks are registered per domain
 * (`await ctx.tool.hook("execute.before", handler)`), and lifecycle events
-* are read from `ctx.event.subscribe({ signal })`, an async iterable of the
-* public event stream whose payload lives under `event.data`.
+* are read from `ctx.event.subscribe({ types, signal })`, an async iterable of
+* the public event stream whose payload lives under `event.data`. `types`
+* narrows the stream to the event types the plugin handles (a newer 2.x
+* option; the per-type checks inside the loop stay, so an older 2.x that
+* ignores it still runs each command only for its own event).
 *
 * Commands run through a private Bun Shell instance (`new Bun.$.Shell()`, the
 * plugin runs inside the Bun-built OpenCode binary) whose working directory is
@@ -63522,13 +63686,18 @@ function buildHookRegistrationLines(hookPoint, handlers) {
 }
 /**
 * Emit the event-stream loop. Each command is isolated in its own try/catch so
-* a failing hook neither skips its siblings nor ends the subscription.
+* a failing hook neither skips its siblings nor ends the subscription. The
+* subscription passes `types` so the server delivers only the handled events.
 */
 function buildEventLoopLines(eventHandlers) {
 	const lines = [];
+	const types = [...eventHandlers.keys()].map((eventType) => JSON.stringify(eventType)).join(", ");
 	lines.push("const __rulesyncEvents = new AbortController();");
 	lines.push("void (async () => {");
-	lines.push("  for await (const event of ctx.event.subscribe({ signal: __rulesyncEvents.signal })) {");
+	lines.push("  for await (const event of ctx.event.subscribe({");
+	lines.push(`    types: [${types}],`);
+	lines.push("    signal: __rulesyncEvents.signal,");
+	lines.push("  })) {");
 	let isFirst = true;
 	for (const [eventType, handlers] of eventHandlers) {
 		lines.push(`    ${isFirst ? "if" : "} else if"} (event.type === "${eventType}") {`);
@@ -65662,7 +65831,12 @@ var VibeHooks = class extends ToolHooks {
 * resolves inside the bundle and is written as is. The file is loaded only
 * when `plugin.json` declares the `ai.mistral.vibe` extension.
 *
+* Plugin hooks run on Vibe v2.x and on v3.0.4+. v3.0.0 through v3.0.3 do not
+* run them (v3.0.4 Fixed: "Hooks shipped in a native Vibe plugin's
+* `ai.mistral.vibe/hooks.toml` now run"). The output is the same either way.
+*
 * @see https://github.com/mistralai/mistral-vibe/blob/v2.25.8/vibe/core/plugins/_native.py
+* @see https://github.com/mistralai/mistral-vibe/blob/v3.0.4/CHANGELOG.md
 */
 var VibePluginHooks = class extends VibeHooks {
 	static getSettablePaths() {
@@ -65746,6 +65920,14 @@ const ZCODE_CONVERTER_CONFIG = {
 		tool: "shell",
 		commandOnly: true
 	}],
+	keywordPassthroughFields: [{
+		canonical: "failClosed",
+		tool: "onError",
+		trueValue: "deny",
+		falseValue: "allow",
+		events: /* @__PURE__ */ new Set(["preToolUse"]),
+		ignoredWhenFlags: ["async"]
+	}],
 	wildcardMatcherMeansAll: true
 };
 /**
@@ -73886,9 +74068,21 @@ function toGitlabduoServer({ serverName, serverConfig, logger }) {
 		...rest
 	};
 }
+/**
+* GitLab Duo CLI reserves the MCP server name `duo` for its first-party server
+* (gitlab-lsp v9.33.0+): a workspace, user or plugin entry named exactly `duo`
+* (case-sensitive) is dropped with only a log line, so it would never load.
+*
+* @see https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/commit/0572967c915465c1ac94ca38ef57676eb44e16d6
+*/
+const GITLABDUO_RESERVED_MCP_SERVER_NAME = "duo";
 function toGitlabduoServers(servers, logger) {
 	const result = {};
 	for (const [serverName, serverConfig] of Object.entries(servers)) {
+		if (serverName === GITLABDUO_RESERVED_MCP_SERVER_NAME) {
+			logger?.warn(`GitLab Duo CLI MCP: skipping "${serverName}" because GitLab Duo CLI 9.33.0+ reserves that name for its first-party server and never loads a config entry with it. Rename the server to use it with GitLab Duo CLI.`);
+			continue;
+		}
 		const converted = toGitlabduoServer({
 			serverName,
 			serverConfig,
@@ -75134,24 +75328,47 @@ async function readKimiCodeConfig({ outputRoot }) {
 	}
 }
 /**
+* Kimi's reconnect delays are millisecond counts, so only a non-negative safe
+* integer is passed through. Anything else (a negative, a fraction, a string)
+* is dropped with a warning rather than written into, or lifted out of, the
+* shared global `config.toml`.
+*/
+function toKimiCodeReconnectDelay({ value, key, logger }) {
+	if (value === void 0) return;
+	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value;
+	warnWithFallback(logger, `Kimi Code MCP: dropping ${key} because it is not a non-negative integer number of milliseconds.`);
+}
+/**
 * Read the `[mcp]` defaults back out of the shared user `config.toml` so a
 * generate → import round trip keeps them. Absent or unparseable content yields
 * no defaults rather than failing the import: this file belongs to three
 * features plus the user.
 */
-async function readKimiCodeMcpDefaults({ outputRoot }) {
+async function readKimiCodeMcpDefaults({ outputRoot, logger }) {
 	const config = await readKimiCodeConfig({ outputRoot });
 	if (!config.parsed) return {};
+	const reconnectInitialDelayMs = toKimiCodeReconnectDelay({
+		value: config.mcp.reconnect_initial_delay_ms,
+		key: "[mcp] reconnect_initial_delay_ms",
+		logger
+	});
+	const reconnectMaxDelayMs = toKimiCodeReconnectDelay({
+		value: config.mcp.reconnect_max_delay_ms,
+		key: "[mcp] reconnect_max_delay_ms",
+		logger
+	});
 	return {
 		...typeof config.mcp.startup_timeout_ms === "number" && { startupTimeoutMs: config.mcp.startup_timeout_ms },
 		...typeof config.mcp.tool_timeout_ms === "number" && { toolTimeoutMs: config.mcp.tool_timeout_ms },
-		...typeof config.mcp.default_deferred === "boolean" && { defaultDeferred: config.mcp.default_deferred }
+		...typeof config.mcp.default_deferred === "boolean" && { defaultDeferred: config.mcp.default_deferred },
+		...reconnectInitialDelayMs !== void 0 && { reconnectInitialDelayMs },
+		...reconnectMaxDelayMs !== void 0 && { reconnectMaxDelayMs }
 	};
 }
 /**
 * Kimi's `[mcp]` section in the shared user config sets the default connect and
-* per-tool-call timeouts, and whether tools load on demand, for *every* MCP
-* server, including ones rulesync did not write. Per-server values in
+* per-tool-call timeouts, whether tools load on demand, and the automatic
+* reconnect backoff for *every* MCP server, including ones rulesync did not write. Per-server values in
 * `mcp.json` still take precedence; this only moves the default.
 *
 * Written as an auxiliary file so it goes through the normal write phase and
@@ -75189,7 +75406,9 @@ var KimiCodeMcpConfigToml = class KimiCodeMcpConfigToml extends ToolFile {
 				...existingSection,
 				...defaults.startupTimeoutMs !== void 0 && { startup_timeout_ms: defaults.startupTimeoutMs },
 				...defaults.toolTimeoutMs !== void 0 && { tool_timeout_ms: defaults.toolTimeoutMs },
-				...defaults.defaultDeferred !== void 0 && { default_deferred: defaults.defaultDeferred }
+				...defaults.defaultDeferred !== void 0 && { default_deferred: defaults.defaultDeferred },
+				...defaults.reconnectInitialDelayMs !== void 0 && { reconnect_initial_delay_ms: defaults.reconnectInitialDelayMs },
+				...defaults.reconnectMaxDelayMs !== void 0 && { reconnect_max_delay_ms: defaults.reconnectMaxDelayMs }
 			} },
 			filePath: relativeConfigPath
 		});
@@ -75238,7 +75457,10 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 			fileContent,
 			validate,
 			global,
-			configDefaults: global ? await readKimiCodeMcpDefaults({ outputRoot }) : {},
+			configDefaults: global ? await readKimiCodeMcpDefaults({
+				outputRoot,
+				logger
+			}) : {},
 			logger
 		});
 	}
@@ -75288,7 +75510,17 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 		const startupTimeoutMs = typeof block.startupTimeoutMs === "number" ? block.startupTimeoutMs : void 0;
 		const toolTimeoutMs = typeof block.toolTimeoutMs === "number" ? block.toolTimeoutMs : void 0;
 		const defaultDeferred = typeof block.defaultDeferred === "boolean" ? block.defaultDeferred : void 0;
-		if (startupTimeoutMs === void 0 && toolTimeoutMs === void 0 && defaultDeferred === void 0) return [];
+		const reconnectInitialDelayMs = toKimiCodeReconnectDelay({
+			value: block.reconnectInitialDelayMs,
+			key: "kimi-code.reconnectInitialDelayMs",
+			logger
+		});
+		const reconnectMaxDelayMs = toKimiCodeReconnectDelay({
+			value: block.reconnectMaxDelayMs,
+			key: "kimi-code.reconnectMaxDelayMs",
+			logger
+		});
+		if (startupTimeoutMs === void 0 && toolTimeoutMs === void 0 && defaultDeferred === void 0 && reconnectInitialDelayMs === void 0 && reconnectMaxDelayMs === void 0) return [];
 		const existing = await readKimiCodeConfig({ outputRoot });
 		if (!existing.parsed) {
 			const paths = kimiCodeConfigRelativePath();
@@ -75300,7 +75532,9 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 			defaults: {
 				startupTimeoutMs,
 				toolTimeoutMs,
-				defaultDeferred
+				defaultDeferred,
+				reconnectInitialDelayMs,
+				reconnectMaxDelayMs
 			},
 			existing
 		})];
@@ -85651,6 +85885,7 @@ const CLAUDECODE_ENV_IGNORED_IN_EVERY_FILE = /* @__PURE__ */ new Set([
 	"CLAUDE_CODE_DISABLE_MOUNTED_DRIVE_RM_PROMPT",
 	"CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY",
 	"CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT",
+	"CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS",
 	"CLAUDE_CODE_MESSAGING_SOCKET",
 	"CLAUDE_CODE_MESSAGING_TOKEN",
 	"CLAUDE_CODE_PROJECT_DIR_NAME",
@@ -104896,32 +105131,59 @@ function buildChecksStrategy(ctx) {
 }
 // src/features/shared/antigravity-plugin-manifest.ts
 const ANTIGRAVITY_PLUGIN_NAME_PATTERN = /^[a-zA-Z0-9-_]+$/;
+const ANTIGRAVITY_PLUGIN_STRICT_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/**
+* Lower-case a directory name and turn `_` into `-` (collapsing repeated and
+* trimming edge hyphens), so `My_Plugin` becomes `my-plugin`.
+*/
+function toStrictAntigravityPluginName(name) {
+	return name.toLowerCase().replace(/[-_]+/g, "-").replace(/^-+|-+$/g, "");
+}
 /**
 * Create the `plugin.json` manifest Antigravity requires before it treats a
 * directory as a plugin, so a tree generated from scratch actually loads.
 *
-* The manifest declares only `name` and `description`, and rejects anything
-* else, so the one required field is derived from the plugin directory's name.
-* An existing manifest is never read or rewritten: it may carry a
-* hand-authored `name` or `description` that rulesync has no source for. A
+* Only the required `name` is written, derived from the plugin directory's
+* name and normalized to the lowercase kebab-case form `agy plugin validate
+* --strict` and the Marketplace require; the other manifest fields (such as
+* `description`, `version` or `author`) have no rulesync source. An existing
+* manifest is never rewritten: it may carry hand-authored fields. Its `name` is
+* read only to report a collision with another output root's name. A
 * manifest kept in one of the manifest folders counts as present too, so no
 * root stub is written next to it.
 */
 async function ensureAntigravityPluginManifests({ outputRoots, dryRun, logger }) {
 	const paths = [];
+	const seenNames = /* @__PURE__ */ new Map();
+	const noteName = (name, manifestPath) => {
+		const previousPath = seenNames.get(name);
+		if (previousPath === void 0) {
+			seenNames.set(name, manifestPath);
+			return;
+		}
+		warnOnceWithFallback(logger, `The Antigravity plugin manifests ${quoteForLog(manifestPath)} and ${quoteForLog(previousPath)} both name the plugin ${quoteForLog(name)}, so the plugins collide in Antigravity. Rename one of the directories or set a distinct "name" by hand.`);
+	};
 	for (const outputRoot of outputRoots) {
 		const filePath = join(outputRoot, ANTIGRAVITY_PLUGIN_MANIFEST_FILE_NAME);
-		if (await hasAntigravityPluginManifest(outputRoot)) continue;
+		const existingManifestPath = await findAntigravityPluginManifest(outputRoot);
+		if (existingManifestPath !== void 0) {
+			const existingName = await readManifestName(existingManifestPath);
+			if (existingName !== void 0) noteName(existingName, existingManifestPath);
+			continue;
+		}
 		if (await refusesWriteOutsideRoot({
 			logger,
 			rootPath: outputRoot,
 			targetPath: filePath
 		})) continue;
-		const name = basename(resolve(outputRoot));
-		if (!ANTIGRAVITY_PLUGIN_NAME_PATTERN.test(name)) {
-			warnOnceWithFallback(logger, `Cannot derive an Antigravity plugin name from the directory ${quoteForLog(name)}: it must match ${ANTIGRAVITY_PLUGIN_NAME_PATTERN.source}. Create ${quoteForLog(filePath)} by hand with a valid "name".`);
+		const dirName = basename(resolve(outputRoot));
+		const name = toStrictAntigravityPluginName(dirName);
+		if (!ANTIGRAVITY_PLUGIN_NAME_PATTERN.test(dirName) || !ANTIGRAVITY_PLUGIN_STRICT_NAME_PATTERN.test(name)) {
+			warnOnceWithFallback(logger, `Cannot derive an Antigravity plugin name from the directory ${quoteForLog(dirName)}: it must contain only letters, digits, "-" and "_", and at least one letter or digit, so that it normalizes to ${ANTIGRAVITY_PLUGIN_STRICT_NAME_PATTERN.source}. Create ${quoteForLog(filePath)} by hand with a valid "name".`);
 			continue;
 		}
+		if (name !== dirName) warnOnceWithFallback(logger, `The Antigravity plugin directory ${quoteForLog(dirName)} is not lowercase kebab-case, which \`agy plugin validate --strict\` and the Marketplace reject, so ${quoteForLog(filePath)} names the plugin ${quoteForLog(name)}.`);
+		noteName(name, filePath);
 		const content = addTrailingNewline(JSON.stringify({ name }, null, 2));
 		if (dryRun) logger.info(`[DRY RUN] Would write: ${stripControlCharacters(filePath)}`);
 		else await writeFileContent(filePath, content);
@@ -104934,10 +105196,18 @@ async function ensureAntigravityPluginManifests({ outputRoots, dryRun, logger })
 		sourceLoadFailed: false
 	};
 }
-async function hasAntigravityPluginManifest(outputRoot) {
+async function findAntigravityPluginManifest(outputRoot) {
 	const candidates = [join(outputRoot, ANTIGRAVITY_PLUGIN_MANIFEST_FILE_NAME), ...ANTIGRAVITY_PLUGIN_MANIFEST_FOLDERS.map((folder) => join(outputRoot, folder, ANTIGRAVITY_PLUGIN_MANIFEST_FILE_NAME))];
-	for (const candidate of candidates) if (await fileExists(candidate)) return true;
-	return false;
+	for (const candidate of candidates) if (await fileExists(candidate)) return candidate;
+}
+/** The manifest's string `name`, or `undefined` when it is unreadable or absent. */
+async function readManifestName(manifestPath) {
+	try {
+		const parsed = JSON.parse(await readFileContent(manifestPath));
+		return isRecord(parsed) && typeof parsed.name === "string" ? parsed.name : void 0;
+	} catch {
+		return;
+	}
 }
 // src/features/shared/hermes-project-plugin-activation.ts
 function mergeEnabledPlugins({ existingContent, filePath, pluginNames }) {
@@ -107040,4 +107310,4 @@ async function importChecksCore(params) {
 }
 export { RulesyncPermissions as $, formatError as $n, isSymlink as $t, CODEBUDDY_DIR as A, MAX_FILE_SIZE as An, withFallbackLoggerTarget as At, CLAUDECODE_LOCAL_RULE_FILE_NAME as B, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Bn, assertTreeContainsNoSymlinks as Bt, QWENCODE_LOCAL_RULE_FILE_NAME as C, PACKAGING_TOOL_TARGETS as Cn, getSourceTransport as Ct, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as D, DEPRECATED_FEATURE_REPLACEMENTS as Dn, WarningCollectingLogger as Dt, FACTORYDROID_DIR as E, ALL_FEATURES_WITH_WILDCARD as En, JsonLogger as Et, groupSpellingsByCaseFoldedIdentity as F, RULESYNC_CONFIG_SCHEMA_URL as Fn, PathOutsideRootError as Ft, toInstructionBudgetFile as G, RULESYNC_PERMISSIONS_SCHEMA_URL as Gn, ensureDir as Gt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as H, RULESYNC_MCP_SCHEMA_URL as Hn, checkPathTraversal as Ht, CODEXCLI_BASH_RULES_FILE_NAME as I, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as In, applyFileMode as It, RulesyncSubagentFrontmatterSchema as J, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Jn, findFilesByGlobs as Jt, getLocalSkillDirNames as K, RULESYNC_RELATIVE_DIR_PATH as Kn, fileExists as Kt, CODEXCLI_DIR as L, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as Ln, assertDirectoryIfExists as Lt, AUGMENTCODE_DIR as M, RULESYNC_CHECKS_RELATIVE_DIR_PATH as Mn, withWarnOnceScope as Mt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as N, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as Nn, CLIError as Nt, COMMANDCODE_DIR as O, CURATED_RULES_FEATURE_SUBDIR as On, fallbackLogger as Ot, caseFoldIdentity as P, RULESYNC_CONFIG_RELATIVE_FILE_PATH as Pn, ErrorCodes as Pt, RulesyncRuleFrontmatterSchema as Q, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as Qn, isFileSystemError as Qt, CLAUDECODE_AGENT_MEMORY_LOCAL_DIR_NAME as R, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Rn, assertNoSymlinkBelowRoot as Rt, QWENCODE_DIR as S, ALL_TOOL_TARGETS_WITH_WILDCARD as Sn, assertTargetsFeaturesExclusive as St, LETTACODE_SETTINGS_LOCAL_FILE_NAME as T, ALL_FEATURES as Tn, ConsoleLogger as Tt, CLAUDECODE_SKILLS_DIR_PATH as U, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Un, createTempDirectory as Ut, CLAUDECODE_MEMORIES_DIR_NAME as V, RULESYNC_MCP_RELATIVE_FILE_PATH as Vn, assertWritablePathInsideRoot as Vt, findProjectInstructionBudgetFindings as W, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Wn, directoryExists as Wt, RulesyncSkillFrontmatterSchema as X, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Xn, getHomeDirectory as Xt, RulesyncSkill as Y, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Yn, getFileSizeAndExecutableBit as Yt, RulesyncRule as Z, RULESYNC_USER_CONFIG_DIR_NAME as Zn, isFileNotFoundError as Zt, SubagentsProcessor as _, toPosixPath as _n, resolveEffectiveInputRoots as _t, convertFromTool as a, readFileContent as an, stripControlCharactersKeepingLineFeeds as ar, parseJsonc as at, CommandsProcessor as b, mapWithConcurrency as bn, GITIGNORE_DESTINATION_KEY as bt, parseCommaSeparatedList as c, removeDirectoryStrict as cn, RulesyncCheck as ct, shortenToWidth as d, removeFileWithoutFollowingSymlinks as dn, loadYaml as dt, listDirectoryEntryNames as en, truncateText as er, RulesyncMcp as et, McpProcessor as f, removeTempDirectory as fn, isRecord as ft, RulesProcessor as g, splitPathSegments as gn, mergeInputRootConfigs as gt, ChecksProcessor as h, runWithDirectoryRollback as hn, ConfigResolver as ht, inspectInputRoots as i, posixRelativePathEscapesRoot as in, stripControlCharacters as ir, resolveRulesyncSourceWritePath as it, CODEBUDDY_LOCAL_RULE_FILE_NAME as j, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as jn, resetRunWarningState as jt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as k, FEATURE_SOURCE_TREE_ENTRIES as kn, warnOnConflictingFlags as kt, ELLIPSIS_WIDTH as l, removeFile as ln, RulesyncCheckFrontmatterSchema as lt, HooksProcessor as m, resolvedRelativePath as mn, SKILL_FILE_NAME as mt, formatSourceLoadFailure as n, listSubdirectoryNames as nn, hasEnclosingMarkOutsideKeycap as nr, RulesyncHooks as nt, isPackagingToolTarget as o, readFileContentOrNull as on, stripControlCharactersKeepingLineFeedsAndTabs as or, RulesyncCommand as ot, IgnoreProcessor as p, resolvePath as pn, SHARED_USER_MANAGED_CONFIG_PATHS as pt, RulesyncSubagent as q, RULESYNC_RULES_RELATIVE_DIR_PATH as qn, fileExistsStrict as qt, generate as r, pathEscapesRoot as rn, quoteForLog as rr, getRulesyncSourceCandidates as rt, getProcessorRegistryEntry as s, removeDirectory as sn, stripHiddenCharacters as sr, RulesyncCommandFrontmatterSchema as st, importFromTool as t, listFilePathsRecursively as tn, hasDeceptiveHiddenCharacters as tr, RulesyncIgnore as tt, displayWidthOf as u, removeFileStrict as un, stringifyFrontmatter as ut, SkillsProcessor as v, writeFileBuffer as vn, CONFLICTING_TARGET_PAIRS as vt, LETTACODE_DIR as w, ToolTargetSchema as wn, findControlCharacter as wt, REASONIX_LOCAL_RULE_FILE_NAME as x, ALL_TOOL_TARGETS as xn, SourceEntrySchema as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, writeFileContent as yn, ConfigFileSchema as yt, CLAUDECODE_DIR as z, RULESYNC_IGNORE_RELATIVE_FILE_PATH as zn, assertPathResolvesInsideRoot as zt };
 
-//# sourceMappingURL=import-BQNLyW5s.js.map
+//# sourceMappingURL=import-D2mUPFM0.js.map