rulesync 43.2.0 → 43.4.0

package/dist/{import-DAT3ge4z.cjs → import-BU6Goa-J.cjs}

@@ -5635,11 +5635,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.
 *
@@ -5904,9 +5921,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
@@ -7088,10 +7106,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.
@@ -7635,14 +7681,18 @@ const toolScopedMcpSchema = zod_mini.z.looseObject({ mcpServers: zod_mini.z.opti
 * 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 = zod_mini.z.extend(toolScopedMcpSchema, {
 	startupTimeoutMs: zod_mini.z.optional(zod_mini.z.number()),
 	toolTimeoutMs: zod_mini.z.optional(zod_mini.z.number()),
-	defaultDeferred: zod_mini.z.optional(zod_mini.z.boolean())
+	defaultDeferred: zod_mini.z.optional(zod_mini.z.boolean()),
+	reconnectInitialDelayMs: zod_mini.z.optional(zod_mini.z.int().check(zod_mini.z.nonnegative())),
+	reconnectMaxDelayMs: zod_mini.z.optional(zod_mini.z.int().check(zod_mini.z.nonnegative()))
 });
 /**
 * Qwen Code's tool-scoped block also carries the server-level allow/deny lists
@@ -11468,6 +11518,7 @@ const piSkillSectionSchema = zod_mini.z.looseObject({
 });
 const antigravitySkillSectionSchema = zod_mini.z.looseObject({
 	"disable-slash-command": zod_mini.z.optional(zod_mini.z.boolean()),
+	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
@@ -11668,7 +11719,8 @@ const RulesyncSkillFrontmatterSchema = 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({})])),
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
-		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
 	})),
 	hermesagent: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -16226,8 +16278,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.
 */
@@ -16300,6 +16353,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
@@ -16309,6 +16364,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({
@@ -19622,7 +19678,8 @@ const AgentsSkillsSkillFrontmatterSchema = 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({})])),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
 });
 const COMPATIBILITY_MAX_LENGTH = 500;
 const AGENT_SKILLS_SPEC = "the Agent Skills spec";
@@ -19763,6 +19820,38 @@ function toSpecConformantAgentSkillFields(section, { coerceMetadata = true } = {
 		...allowedTools !== void 0 && allowedTools.length > 0 && { "allowed-tools": allowedTools }
 	};
 }
+/**
+* The opt-in `disable-model-invocation` flag of the `agentsskills` block.
+*
+* The key is not part of the Agent Skills specification, so `skills-ref
+* validate` rejects a `SKILL.md` that carries it, but several clients reading
+* `.agents/skills/` (e.g. pi) honor it. To keep the default output
+* spec-conformant, only an explicit `agentsskills.disable-model-invocation`
+* value is written; the root-level rulesync flag is deliberately not inherited.
+*
+* Kept apart from {@link toSpecConformantAgentSkillFields} because that helper
+* is shared with writers of other tools' own locations, which have their own
+* sections for tool-specific keys. Only writers of the shared `.agents/skills/`
+* root (see {@link isSharedAgentSkillsRoot}) — the native target, GitLab Duo's
+* project scope and the simulated `agentsmd` — spread this, so they all emit
+* the same frontmatter for that file.
+*/
+function toAgentsSkillsInvocationField(section) {
+	const value = section?.["disable-model-invocation"];
+	return value === void 0 ? {} : { "disable-model-invocation": value };
+}
+/**
+* Whether a skill directory lives in the cross-client `.agents/skills/` root
+* (project, or `~/.agents/skills/` in global scope). The
+* `agentsskills.disable-model-invocation` opt-in exists for the clients that
+* read that root, so it is written and imported only there — not by the
+* subclasses that reuse this class for a tool's own location (Trae, Qoder, Xum,
+* …), where the key would otherwise leak into the `agentsskills` section on
+* import and from there into every `.agents/skills/` output.
+*/
+function isSharedAgentSkillsRoot(relativeDirPath) {
+	return toPosixPath(relativeDirPath) === toPosixPath(AGENTSMD_SKILLS_DIR_PATH);
+}
 /** The `SKILL.md` a diagnostic should point at, in the scope it is written to. */
 function agentSkillFilePath({ outputRoot, relativeDirPath, dirName }) {
 	return (0, node_path.join)(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME);
@@ -19844,7 +19933,8 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 			...frontmatter.license !== void 0 && { license: frontmatter.license },
 			...frontmatter.compatibility !== void 0 && { compatibility: frontmatter.compatibility },
 			...frontmatter.metadata !== void 0 && { metadata: frontmatter.metadata },
-			...allowedTools !== void 0 && allowedTools.length > 0 && { "allowed-tools": allowedTools }
+			...allowedTools !== void 0 && allowedTools.length > 0 && { "allowed-tools": allowedTools },
+			...isSharedAgentSkillsRoot(this.getRelativeDirPath()) && frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -19870,7 +19960,8 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 		const agentsSkillsFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(rulesyncFrontmatter))
+			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(rulesyncFrontmatter)),
+			...isSharedAgentSkillsRoot(settablePaths.relativeDirPath) && toAgentsSkillsInvocationField(rulesyncFrontmatter.agentsskills)
 		};
 		AgentsSkillsSkill.reportSpecViolations({
 			outputRoot,
@@ -24944,7 +25035,8 @@ var AgentsmdSkill = class AgentsmdSkill extends SimulatedSkill {
 		const relativeDirPath = this.getSettablePaths().relativeDirPath;
 		const frontmatter = {
 			...defaults.frontmatter,
-			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(params.rulesyncSkill.getFrontmatter()))
+			...toSpecConformantAgentSkillFields(resolveAgentsSkillsSection(params.rulesyncSkill.getFrontmatter())),
+			...toAgentsSkillsInvocationField(params.rulesyncSkill.getFrontmatter().agentsskills)
 		};
 		AgentsSkillsSkill.reportSpecViolations({
 			outputRoot: params.outputRoot ?? process.cwd(),
@@ -31701,16 +31793,17 @@ const VibeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.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"]);
 /**
@@ -31753,11 +31846,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 }) {
@@ -42725,20 +42819,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,
@@ -42748,7 +42857,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,
@@ -42884,8 +42993,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
@@ -55913,12 +56022,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) : "";
@@ -56428,7 +56548,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,
@@ -56478,7 +56598,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;
@@ -56557,16 +56679,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";
 }
@@ -56794,7 +56919,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 },
@@ -58292,15 +58417,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
 	}
 };
@@ -58312,7 +58431,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.
@@ -60254,6 +60373,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",
@@ -60263,7 +60408,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",
@@ -60278,7 +60423,11 @@ const CORTEXCODE_SPEC = {
 			canonical: "source",
 			tool: "source",
 			commandOnly: true
-		}]
+		}],
+		matcherTranslation: {
+			toTool: canonicalToCortexcodeMatcher,
+			toCanonical: cortexcodeToCanonicalMatcher
+		}
 	}
 };
 /**
@@ -60459,35 +60608,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);
@@ -60497,7 +60691,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.`);
@@ -60505,7 +60699,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;
 }
@@ -60552,12 +60749,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;
@@ -63403,8 +63601,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
@@ -63507,13 +63708,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}") {`);
@@ -65647,7 +65853,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() {
@@ -65731,6 +65942,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
 };
 /**
@@ -73871,9 +74090,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,
@@ -75119,24 +75350,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
@@ -75174,7 +75428,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
 		});
@@ -75223,7 +75479,10 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 			fileContent,
 			validate,
 			global,
-			configDefaults: global ? await readKimiCodeMcpDefaults({ outputRoot }) : {},
+			configDefaults: global ? await readKimiCodeMcpDefaults({
+				outputRoot,
+				logger
+			}) : {},
 			logger
 		});
 	}
@@ -75273,7 +75532,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();
@@ -75285,7 +75554,9 @@ var KimiCodeMcp = class KimiCodeMcp extends ToolMcp {
 			defaults: {
 				startupTimeoutMs,
 				toolTimeoutMs,
-				defaultDeferred
+				defaultDeferred,
+				reconnectInitialDelayMs,
+				reconnectMaxDelayMs
 			},
 			existing
 		})];
@@ -85636,6 +85907,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",
@@ -104881,32 +105153,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 = (0, node_path.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 = (0, node_path.basename)((0, node_path.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 = (0, node_path.basename)((0, node_path.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);
@@ -104919,10 +105218,18 @@ async function ensureAntigravityPluginManifests({ outputRoots, dryRun, logger })
 		sourceLoadFailed: false
 	};
 }
-async function hasAntigravityPluginManifest(outputRoot) {
+async function findAntigravityPluginManifest(outputRoot) {
 	const candidates = [(0, node_path.join)(outputRoot, ANTIGRAVITY_PLUGIN_MANIFEST_FILE_NAME), ...ANTIGRAVITY_PLUGIN_MANIFEST_FOLDERS.map((folder) => (0, node_path.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 }) {