rulesync 43.5.0 → 43.6.0

package/dist/{import-CAePeHTT.cjs → import-C-oT_Hdp.cjs}

@@ -382,36 +382,36 @@ function formatError(error) {
 	return boundErrorMessage(String(error));
 }
 // src/constants/rulesync-paths.ts
-const { join: join$384 } = node_path.posix;
+const { join: join$385 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
 const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$384(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$385(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$384(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$384(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$385(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$385(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$384(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$385(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -895,6 +895,7 @@ const hooksProcessorToolTargetTuple = [
 	"qwencode",
 	"reasonix",
 	"tabnine",
+	"trae",
 	"grokcli",
 	"gitlabduo",
 	"lettacode",
@@ -3945,6 +3946,7 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".poolside/settings.yaml",
 	".config/poolside/settings.yaml",
 	".tabnine/agent/settings.json",
+	".trae/hooks.json",
 	".vibe/config.toml",
 	".zcode/config.json",
 	".zcode/cli/config.json",
@@ -6027,6 +6029,34 @@ const CANONICAL_TO_CORTEXCODE_EVENT_NAMES = {
 };
 const CORTEXCODE_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_CORTEXCODE_EVENT_NAMES);
 /**
+* Hook events supported by TRAE.
+*
+* TRAE reads `.trae/hooks.json` (project) and `~/.trae/hooks.json` (user):
+* `{ "version"?: 1, "hooks": { "<Event>": [{ "matcher"?, "hooks": [{ "type":
+* "command", "command", "timeout"? }] }] } }` with Claude-Code-style
+* PascalCase event names. `$TRAE_PROJECT_DIR` resolves to the workspace root
+* inside commands.
+*
+* @see https://docs.trae.ai/ide/hook-configuration-reference?_lang=en
+*/
+const TRAE_HOOK_EVENTS = [
+	"sessionStart",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"stop",
+	"notification"
+];
+const CANONICAL_TO_TRAE_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	stop: "Stop",
+	notification: "Notification"
+};
+const TRAE_TO_CANONICAL_EVENT_NAMES = invertEventNames(CANONICAL_TO_TRAE_EVENT_NAMES);
+/**
 * Hook events supported by CodeBuddy Code.
 *
 * CodeBuddy Code reads hooks from the `hooks` key of `.codebuddy/settings.json`
@@ -6499,6 +6529,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	bob: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	codebuddy: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	trae: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	commandcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	lettacode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	continue: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
@@ -14181,6 +14212,14 @@ const SHARED_CONFIG_OWNERSHIP = {
 			}
 		}
 	},
+	".trae/hooks.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
 	".trae/permission/global.json": {
 		format: "json",
 		invalidRootPolicy: "error",
@@ -23306,10 +23345,13 @@ var TaktCommand = class TaktCommand extends ToolCommand {
 * @see https://docs.trae.ai/ide/slash-commands?_lang=en
 * @see https://docs.trae.ai/ide/ignore-files?_lang=en
 * @see https://docs.trae.ai/ide/permission-and-approval?_lang=en
+* @see https://docs.trae.ai/ide/hook-configuration-reference?_lang=en
 */
 const TRAE_DIR = ".trae";
 /** Project MCP servers (`mcpServers` object), project scope only. */
 const TRAE_MCP_FILE_NAME = "mcp.json";
+/** Hooks: `.trae/hooks.json` (project) and `~/.trae/hooks.json` (global). */
+const TRAE_HOOKS_FILE_NAME = "hooks.json";
 /** Skills: `.trae/skills/<name>/SKILL.md` (project) and `~/.trae/skills/` (global). */
 const TRAE_SKILLS_DIR_PATH = (0, node_path.join)(TRAE_DIR, "skills");
 /**
@@ -25234,12 +25276,80 @@ var AiassistantSkill = class AiassistantSkill extends ToolSkill {
 		});
 	}
 };
+// src/features/shared/amp-settings.ts
+/**
+* Parse an Amp `settings.json` / `settings.jsonc` document.
+*
+* Shared by the MCP and permissions adapters because both read the very same
+* file. Two separately maintained copies drifted once already: the permissions
+* side was hardened while the MCP side kept calling `jsonc-parser` directly,
+* which left it importing MCP servers reachable only through an injected
+* `__proto__`.
+*
+* {@link parseJsonc} is the strict, sanitizing parser: it throws on any syntax
+* error instead of returning `jsonc-parser`'s best-effort value, and it
+* rebuilds every object from its own enumerable entries, so a root `__proto__`
+* cannot swap the returned object's prototype and `constructor` / `prototype`
+* never survive as own keys, at any depth.
+*
+* Removal is silent, matching every other tool-side adapter (opencode, kilo,
+* copilot). Reporting the removed keys through `droppedPollutionKeysError` is
+* reserved for the three files a user authors under `.rulesync/`, whose whole
+* purpose is to be turned into tool config — a key that vanishes there needs
+* explaining, whereas here the surrounding settings are the user's own file
+* and are left alone.
+*
+* Note the consequence for a root `__proto__`: sanitizing runs before the
+* plain-object check, so such a document parses successfully with the key
+* stripped rather than failing that check. That is deliberate — dropping the
+* one poisoned key keeps the user's unrelated settings — and matches the
+* sanitize-before-the-root-check design the shared config gateway documents.
+*/
+function parseAmpSettings({ fileContent }) {
+	let parsed;
+	try {
+		parsed = parseJsonc$6(fileContent || "{}");
+	} catch (error) {
+		throw new Error(`Failed to parse Amp settings: ${formatError(error)}`, { cause: error });
+	}
+	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
+	return parsed;
+}
+/**
+* Probe `<jsonDir>/settings.jsonc` first, falling back to `settings.json`, so
+* an existing user file is read-modified-written in place instead of a fresh
+* `.json` sibling being created next to a hand-authored `.jsonc`. Defaults to
+* `settings.json` when neither file exists: Amp's canonically documented
+* settings file (`.amp/settings.json`), shared by the MCP and permissions
+* adapters, so generating both on a clean repo writes a single settings file.
+*/
+async function resolveAmpSettingsFile(jsonDir) {
+	const jsoncContent = await readFileContentOrNull((0, node_path.join)(jsonDir, AMP_SETTINGS_JSONC_FILE_NAME));
+	if (jsoncContent !== null) return {
+		fileContent: jsoncContent,
+		relativeFilePath: AMP_SETTINGS_JSONC_FILE_NAME
+	};
+	const jsonContent = await readFileContentOrNull((0, node_path.join)(jsonDir, AMP_SETTINGS_FILE_NAME));
+	if (jsonContent !== null) return {
+		fileContent: jsonContent,
+		relativeFilePath: AMP_SETTINGS_FILE_NAME
+	};
+	return {
+		fileContent: null,
+		relativeFilePath: AMP_SETTINGS_FILE_NAME
+	};
+}
 // src/features/skills/amp-skill.ts
 const AmpSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string()
 });
 /**
+* Amp setting that makes it skip `~/.config/agents/skills/` and
+* `~/.agents/skills/`. https://ampcode.com/docs/cli/settings
+*/
+const AMP_DISABLE_GLOBAL_AGENTS_SKILLS_KEY = "amp.skills.disableGlobalAgentsSkills";
+/**
 * Represents an Amp Agent Skill directory.
 *
 * Amp natively reads Agent Skills following the open standard: a directory with a
@@ -25274,6 +25384,27 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 			...global && { importOnlySkillRoots: [AGENTSMD_SKILLS_DIR_PATH, AMP_SKILLS_NATIVE_GLOBAL_DIR] }
 		};
 	}
+	/**
+	* Warn when the user's Amp settings disable the global agent-agnostic skill
+	* roots, because the global skills rulesync writes to
+	* `~/.config/agents/skills/` would then never load. Only the user settings
+	* file is checked: a workspace `.amp/settings.json(c)` depends on where Amp
+	* is started, which global generation cannot know.
+	*/
+	static async getGenerationWarnings({ outputRoot, global, logger }) {
+		if (!global) return [];
+		const { fileContent, relativeFilePath } = await resolveAmpSettingsFile((0, node_path.join)(outputRoot, AMP_GLOBAL_DIR));
+		if (fileContent === null) return [];
+		let settings;
+		try {
+			settings = parseAmpSettings({ fileContent });
+		} catch (error) {
+			logger.debug(`Skipping the Amp skills settings check for ${(0, node_path.join)(AMP_GLOBAL_DIR, relativeFilePath)}: ${formatError(error)}`);
+			return [];
+		}
+		if (settings[AMP_DISABLE_GLOBAL_AGENTS_SKILLS_KEY] !== true) return [];
+		return [`Amp will not load the global skills rulesync writes to ~/${AMP_SKILLS_GLOBAL_DIR}/: '${AMP_DISABLE_GLOBAL_AGENTS_SKILLS_KEY}' is true in ~/${(0, node_path.join)(AMP_GLOBAL_DIR, relativeFilePath)}.`];
+	}
 	getFrontmatter() {
 		return AmpSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
@@ -33250,7 +33381,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 	async convertRulesyncDirsToToolDirs(rulesyncDirs) {
 		const rulesyncSkills = rulesyncDirs.filter((dir) => dir instanceof RulesyncSkill);
 		const factory = this.getFactory(this.toolTarget);
-		return (await Promise.all(rulesyncSkills.map(async (rulesyncSkill) => {
+		const toolSkills = (await Promise.all(rulesyncSkills.map(async (rulesyncSkill) => {
 			const isClaudecodeScheduledTask = rulesyncSkill.getFrontmatter().claudecode?.["scheduled-task"] === true;
 			if (isClaudecodeScheduledTask && this.toolTarget !== "claudecode" && this.toolTarget !== "claudecode-legacy") return null;
 			if (!factory.class.isTargetedByRulesyncSkill(rulesyncSkill)) return null;
@@ -33277,6 +33408,15 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				logger: this.logger
 			});
 		}))).filter((skill) => skill !== null);
+		if (toolSkills.length > 0 && factory.class.getGenerationWarnings) {
+			const warnings = await factory.class.getGenerationWarnings({
+				outputRoot: this.outputRoot,
+				global: this.global,
+				logger: this.logger
+			});
+			for (const warning of warnings) this.logger.warn(warning);
+		}
+		return toolSkills;
 	}
 	async convertToolDirsToRulesyncDirs(toolDirs) {
 		const toolSkills = toolDirs.filter((dir) => dir instanceof ToolSkill);
@@ -47482,6 +47622,45 @@ var DshRule = class DshRule extends NestedAgentsmdRule {
 		};
 	}
 };
+// src/features/rules/output-style-paths.ts
+/**
+* Shared helpers for tool rule adapters that write opted-in rules as custom
+* output styles (`<tool dir>/output-styles/<name>.md`), e.g. Qoder and
+* Factory Droid. Both tools read only the direct `.md` children of their
+* output-styles directory, with optional `name` / `description` frontmatter.
+*/
+/**
+* Whether the given path is a direct `.md` child of `outputStylesDirPath`.
+*/
+function isDirectMarkdownChild({ outputStylesDirPath, relativeDirPath, relativeFilePath }) {
+	return relativeDirPath === outputStylesDirPath && (0, node_path.extname)(relativeFilePath) === ".md" && (0, node_path.basename)(relativeFilePath) === relativeFilePath;
+}
+/**
+* Whether a rule opts into the `output-style` channel: only a non-root rule
+* can, since an output style is a file of its own.
+*/
+function isOutputStyleChannel({ root, channel }) {
+	return !root && channel === "output-style";
+}
+/**
+* Return the file stem of an output-style source rule, throwing `message`
+* when the rule is nested in a subdirectory of the rules directory: the
+* output file is named after the rule, and the tools read only the top level
+* of their output-styles directory.
+*/
+function resolveTopLevelOutputStyleStem({ sourcePath, message }) {
+	if ((0, node_path.basename)(sourcePath) !== sourcePath) throw new Error(message);
+	return (0, node_path.basename)(sourcePath, (0, node_path.extname)(sourcePath));
+}
+/**
+* The output style's frontmatter: only the `name` and `description` that are set.
+*/
+function buildOutputStyleFrontmatter({ name, description }) {
+	return {
+		...name !== void 0 && { name },
+		...description !== void 0 && { description }
+	};
+}
 // src/features/rules/factorydroid-rule.ts
 /**
 * The file-name glob `getExtraFixedFiles` returns for the output-styles
@@ -47586,7 +47765,11 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	* child of the output-styles directory, at either scope.
 	*/
 	static isOutputStylePath({ relativeDirPath, relativeFilePath }) {
-		return relativeDirPath === this.getOutputStylesDirPath() && (0, node_path.extname)(relativeFilePath) === ".md" && (0, node_path.basename)(relativeFilePath) === relativeFilePath;
+		return isDirectMarkdownChild({
+			outputStylesDirPath: this.getOutputStylesDirPath(),
+			relativeDirPath,
+			relativeFilePath
+		});
 	}
 	/**
 	* Which fixed-file channel, if any, owns the given output path. Matching on
@@ -47626,7 +47809,10 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	/** Whether a rule opts into the `output-style` channel (non-root only). */
 	static isOutputStyleRule(rulesyncRule) {
 		const frontmatter = rulesyncRule.getFrontmatter();
-		return !frontmatter.root && frontmatter.factorydroid?.channel === "output-style";
+		return isOutputStyleChannel({
+			root: frontmatter.root,
+			channel: frontmatter.factorydroid?.channel
+		});
 	}
 	/**
 	* Factory Droid loads the channel files itself, so listing one in the root
@@ -47758,15 +47944,17 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	static buildOutputStyle({ outputRoot, rulesyncRule, validate }) {
 		const frontmatter = rulesyncRule.getFrontmatter();
 		const sourcePath = rulesyncRule.getRelativeFilePath();
-		if ((0, node_path.basename)(sourcePath) !== sourcePath) throw new Error(`Rule '${sourcePath}' sets factorydroid.channel: output-style but is nested in a subdirectory: Factory Droid loads only direct .md children of .factory/output-styles/, so move it to the top of ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`);
-		const stem = (0, node_path.basename)(sourcePath, (0, node_path.extname)(sourcePath));
+		const stem = resolveTopLevelOutputStyleStem({
+			sourcePath,
+			message: `Rule '${sourcePath}' sets factorydroid.channel: output-style but is nested in a subdirectory: Factory Droid loads only direct .md children of .factory/output-styles/, so move it to the top of ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`
+		});
 		const name = frontmatter.factorydroid?.name;
 		const styleName = name ?? stem;
 		if (FACTORYDROID_RESERVED_OUTPUT_STYLE_NAMES.includes(styleName.trim().toLowerCase())) throw new Error(`Rule '${sourcePath}' sets factorydroid.channel: output-style with the style name '${styleName}', which is reserved: Factory Droid's built-in Default and Concise styles cannot be replaced. Rename the rule file or set factorydroid.name.`);
-		const styleFrontmatter = {
-			...name !== void 0 && { name },
-			...frontmatter.description !== void 0 && { description: frontmatter.description }
-		};
+		const styleFrontmatter = buildOutputStyleFrontmatter({
+			name,
+			description: frontmatter.description
+		});
 		const body = rulesyncRule.getBody();
 		return new FactorydroidRule({
 			outputRoot,
@@ -49402,12 +49590,19 @@ var QoderRule = class QoderRule extends ToolRule {
 	* `.qoder/output-styles/`, at either scope.
 	*/
 	static isOutputStylePath({ relativeDirPath, relativeFilePath }) {
-		return relativeDirPath === QODER_OUTPUT_STYLES_DIR_PATH && (0, node_path.extname)(relativeFilePath) === ".md" && (0, node_path.basename)(relativeFilePath) === relativeFilePath;
+		return isDirectMarkdownChild({
+			outputStylesDirPath: QODER_OUTPUT_STYLES_DIR_PATH,
+			relativeDirPath,
+			relativeFilePath
+		});
 	}
 	/** Whether a rule opts into the `output-style` channel (non-root only). */
 	static isOutputStyleRule(rulesyncRule) {
 		const frontmatter = rulesyncRule.getFrontmatter();
-		return !frontmatter.root && frontmatter.qoder?.channel === "output-style";
+		return isOutputStyleChannel({
+			root: frontmatter.root,
+			channel: frontmatter.qoder?.channel
+		});
 	}
 	/**
 	* The output-styles directory, enumerated for import only: it also holds
@@ -49518,16 +49713,18 @@ var QoderRule = class QoderRule extends ToolRule {
 	static buildOutputStyle({ outputRoot, rulesyncRule, validate }) {
 		const { description, qoder } = rulesyncRule.getFrontmatter();
 		const sourcePath = rulesyncRule.getRelativeFilePath();
-		if ((0, node_path.basename)(sourcePath) !== sourcePath) throw new Error(`Rule '${sourcePath}' sets qoder.channel: output-style but is nested in a subdirectory: Qoder reads only the files directly in .qoder/output-styles/, so move it to the top of ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`);
-		const name = qoder?.name;
+		const stem = resolveTopLevelOutputStyleStem({
+			sourcePath,
+			message: `Rule '${sourcePath}' sets qoder.channel: output-style but is nested in a subdirectory: Qoder reads only the files directly in .qoder/output-styles/, so move it to the top of ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`
+		});
 		return new QoderRule({
 			outputRoot,
 			relativeDirPath: QODER_OUTPUT_STYLES_DIR_PATH,
-			relativeFilePath: `${(0, node_path.basename)(sourcePath, (0, node_path.extname)(sourcePath))}.md`,
-			frontmatter: {
-				...name !== void 0 && { name },
-				...description !== void 0 && { description }
-			},
+			relativeFilePath: `${stem}.md`,
+			frontmatter: buildOutputStyleFrontmatter({
+				name: qoder?.name,
+				description
+			}),
 			body: rulesyncRule.getBody(),
 			validate,
 			root: false,
@@ -56205,9 +56402,9 @@ function groupDefinitionsByMatcher({ definitions, eventName, converterConfig, wa
 			});
 			translatedMatchers.set(normalizedMatcher, matcher);
 		}
-		const key = [matcher, ...subdividingFields.map(({ canonical, valueType }) => {
+		const key = [matcher, ...subdividingFields.map(({ canonical, valueType, events }) => {
 			const value = def[canonical];
-			return isGroupPassthroughValue(value, valueType) ? stableJson(value) : "";
+			return isGroupFieldOnEvent(events, eventName) && isGroupPassthroughValue(value, valueType) ? stableJson(value) : "";
 		})].join("\0");
 		const group = byMatcher.get(key);
 		if (group) group.defs.push(def);
@@ -56248,6 +56445,7 @@ function runsInPosixShell({ shell, converterConfig }) {
 * Apply the optional project directory variable prefix to a command string.
 */
 function applyCommandPrefix({ def, converterConfig }) {
+	if (converterConfig.stripsProjectDirVarOnImportOnly) return def.command;
 	const commandText = def.command;
 	const trimmedCommand = typeof commandText === "string" ? commandText.trimStart() : void 0;
 	const unquotedCommand = trimmedCommand?.replace(/^["']/, "");
@@ -56456,12 +56654,16 @@ const describeInvalidObject = ({ tool, canonical, value }) => isPlainObject(valu
 	value
 })} Importing it would fail validation on the next run.` : `Dropping "${tool}" while importing a hook: it must be an object.`;
 const describeInvalidRecord = ({ tool }) => `Dropping "${tool}" while importing a hook: it must be a map of strings whose keys are non-empty and free of "=", and whose keys and values carry no newline, carriage return or NUL characters.`;
+function isGroupFieldOnEvent(events, eventName) {
+	return events === void 0 || events.has(eventName);
+}
 /**
 * Check a value against the shape its field documents. A string field also
 * rejects control characters, matching the canonical `safeString` so an
 * imported value cannot fail validation on the next generate.
 */
 function isGroupPassthroughValue(value, valueType = "object") {
+	if (valueType === "number") return typeof value === "number" && Number.isFinite(value);
 	if (valueType === "string") return typeof value === "string" && !CONTROL_CHARS.some((char) => value.includes(char));
 	return isPlainObject(value);
 }
@@ -56471,10 +56673,14 @@ function isGroupPassthroughValue(value, valueType = "object") {
 */
 function emitGroupPassthroughFields({ defs, eventName, converterConfig, logger }) {
 	const emitted = {};
-	for (const { canonical, tool, valueType } of converterConfig.groupPassthroughFields ?? []) {
+	for (const { canonical, tool, valueType, events } of converterConfig.groupPassthroughFields ?? []) {
 		const carried = defs.map((def) => def[canonical]);
 		const first = carried.find((value) => isGroupPassthroughValue(value, valueType));
 		if (first === void 0) continue;
+		if (!isGroupFieldOnEvent(events, eventName)) {
+			logger?.warn(`"${canonical}" on "${eventName}" hooks is ignored — the tool supports "${tool}" only on ${[...events ?? []].map((event) => `"${event}"`).join(", ")} hooks.`);
+			continue;
+		}
 		const firstStable = stableJson(first);
 		const agrees = (value) => isGroupPassthroughValue(value, valueType) && stableJson(value) === firstStable;
 		if (!carried.every(agrees)) logger?.warn(`"${tool}" belongs to the whole matcher group on "${eventName}" hooks, so every hook in this group gets ${quoteValueForWarning(first)} — including any that asked for something else, or for nothing.`);
@@ -56486,9 +56692,9 @@ function emitGroupPassthroughFields({ defs, eventName, converterConfig, logger }
 * Import the configured group-level passthrough fields onto a definition,
 * reversing {@link emitGroupPassthroughFields}.
 */
-function importGroupPassthroughFields({ rawEntry, converterConfig }) {
+function importGroupPassthroughFields({ rawEntry, eventName, converterConfig }) {
 	const entry = rawEntry;
-	return Object.fromEntries((converterConfig.groupPassthroughFields ?? []).filter(({ tool, valueType }) => isGroupPassthroughValue(entry[tool], valueType)).map(({ canonical, tool }) => [canonical, entry[tool]]));
+	return Object.fromEntries((converterConfig.groupPassthroughFields ?? []).filter(({ tool, valueType, events }) => isGroupFieldOnEvent(events, eventName) && isGroupPassthroughValue(entry[tool], valueType)).map(({ canonical, tool }) => [canonical, entry[tool]]));
 }
 /**
 * Emit the payload fields specific to a hook type — `url`/`headers`/
@@ -56814,19 +57020,23 @@ function stripCommandPrefix({ command, args, shell, converterConfig, warn }) {
 	const cmd = typeof command === "string" ? command : void 0;
 	const { projectDirVar } = converterConfig;
 	if (projectDirVar === "" || typeof cmd !== "string") return cmd;
-	const { command: stripped, unrestored, retained } = importProjectDirVariable({
-		command: cmd,
-		projectDirVar,
-		firstWordOnly: isExecFormHook({
-			args,
-			converterConfig
-		}) || !runsInPosixShell({
-			shell,
-			converterConfig
-		})
-	});
-	if (warn && unrestored) warn(`Hook command ${quoteValueForWarning(cmd)} was imported as ${quoteValueForWarning(stripped)}: a ${projectDirVar} path that is not a script the command runs becomes relative to the hook's working directory and is not restored on generate. Put the exact command in a tool-specific hooks override (such as "claudecode.hooks") to keep the variable.`);
-	if (warn && retained) warn(`Hook command ${quoteValueForWarning(cmd)} keeps ${projectDirVar} in an assignment or option value, or in a later word of a command whose later words are not normalized, so the imported command still refers to it and other tools that do not define it receive it verbatim. Put the exact command in a tool-specific hooks override (such as "claudecode.hooks") if other tools should not see it.`);
+	let stripped = cmd;
+	for (const variable of [projectDirVar, ...converterConfig.importedProjectDirVarAliases ?? []]) {
+		const result = importProjectDirVariable({
+			command: stripped,
+			projectDirVar: variable,
+			firstWordOnly: isExecFormHook({
+				args,
+				converterConfig
+			}) || !runsInPosixShell({
+				shell,
+				converterConfig
+			})
+		});
+		stripped = result.command;
+		if (warn && result.unrestored && !converterConfig.stripsProjectDirVarOnImportOnly) warn(`Hook command ${quoteValueForWarning(cmd)} was imported as ${quoteValueForWarning(stripped)}: a ${variable} path that is not a script the command runs becomes relative to the hook's working directory and is not restored on generate. Put the exact command in a tool-specific hooks override (such as "claudecode.hooks") to keep the variable.`);
+		if (warn && result.retained) warn(`Hook command ${quoteValueForWarning(cmd)} keeps ${variable} in an assignment or option value, or in a later word of a command whose later words are not normalized, so the imported command still refers to it and other tools that do not define it receive it verbatim. Put the exact command in a tool-specific hooks override (such as "claudecode.hooks") if other tools should not see it.`);
+	}
 	return stripped;
 }
 /**
@@ -56867,7 +57077,7 @@ function isStringRecord(value) {
 }
 /** Compare object values without letting key order decide the answer. */
 function stableJson(value) {
-	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value !== "object") return JSON.stringify(value);
 	return JSON.stringify(Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b))));
 }
 /**
@@ -57107,6 +57317,7 @@ function toolHookToCanonical({ h, rawEntry, eventName, converterConfig, warn })
 		}),
 		...importGroupPassthroughFields({
 			rawEntry,
+			eventName,
 			converterConfig
 		}),
 		...matcher !== void 0 && matcher !== null && matcher !== "" && { matcher }
@@ -57159,15 +57370,26 @@ function definingFields({ h, rawEntry, hookType, converterConfig }) {
 * is the group-level twin of `matcher`: importing the group without it would
 * widen every hook in it, so the group is skipped instead.
 */
-function describeGroupSkipReason({ rawEntry, converterConfig }) {
+function describeGroupSkipReason({ rawEntry, eventName, converterConfig }) {
 	const entry = rawEntry;
-	for (const { tool, valueType, subdividesGroup } of converterConfig.groupPassthroughFields ?? []) {
+	for (const { tool, valueType, subdividesGroup, events, onInvalidImport } of converterConfig.groupPassthroughFields ?? []) {
 		const value = entry[tool];
-		if (subdividesGroup !== true || value === void 0) continue;
+		if (subdividesGroup !== true || onInvalidImport === "drop-field" || value === void 0 || !isGroupFieldOnEvent(events, eventName)) continue;
 		if (!isGroupPassthroughValue(value, valueType)) return `Skipping the hooks of a matcher group while importing: its "${tool}" (${quoteValueForWarning(value)}) is unusable, and these hooks run only where it matches. Importing them without it would widen when they fire, so they are skipped.`;
 	}
 }
 /**
+* Warn about each `"drop-field"` group value that is present but unusable;
+* {@link importGroupPassthroughFields} leaves it off the imported hooks.
+*/
+function warnDroppedGroupFields({ rawEntry, eventName, converterConfig, warn }) {
+	const entry = rawEntry;
+	for (const { tool, valueType, events, onInvalidImport } of converterConfig.groupPassthroughFields ?? []) {
+		const value = entry[tool];
+		if (onInvalidImport === "drop-field" && value !== void 0 && isGroupFieldOnEvent(events, eventName) && !isGroupPassthroughValue(value, valueType)) warn?.(`Dropping the unusable "${tool}" (${quoteValueForWarning(value)}) of a "${eventName}" matcher group while importing; its hooks are imported without it.`);
+	}
+}
+/**
 * Why this hook cannot be imported, or `undefined` when it can.
 */
 function describeHookSkipReason({ h, rawEntry, hookType, converterConfig }) {
@@ -57194,12 +57416,19 @@ function toolMatcherEntryToCanonical({ rawEntry, eventName, converterConfig, war
 	const hookDefs = rawEntry.hooks ?? [];
 	const groupSkipReason = describeGroupSkipReason({
 		rawEntry,
+		eventName,
 		converterConfig
 	});
 	if (groupSkipReason !== void 0) {
 		warn?.(groupSkipReason);
 		return [];
 	}
+	warnDroppedGroupFields({
+		rawEntry,
+		eventName,
+		converterConfig,
+		warn
+	});
 	const definitions = [];
 	for (const h of hookDefs) {
 		const skipReason = describeHookSkipReason({
@@ -60538,6 +60767,23 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 		});
 	}
 };
+// src/features/hooks/hook-matcher-tool-names.ts
+const MATCHER_TOKEN_PATTERN = /\\.|\[(?:\\.|[^\]\\])*\]|(?<=^|[^\w\\]|\\\w)[A-Za-z_]\w*(?!\w)/gs;
+function isMatcherName(token) {
+	return !token.startsWith("\\") && !token.startsWith("[");
+}
+/**
+* Rewrites the whole tool names inside a hook `matcher` regex through `names`,
+* leaving escapes, character classes and unknown names as written. Used by
+* adapters whose runtime tool names differ from the canonical (Claude Code)
+* spelling.
+*/
+function replaceMatcherNames(matcher, names) {
+	return matcher.replace(MATCHER_TOKEN_PATTERN, (token) => isMatcherName(token) && Object.hasOwn(names, token) ? names[token] ?? token : token);
+}
+function invertToolNames(names) {
+	return Object.fromEntries(Object.entries(names).map(([canonical, tool]) => [tool, canonical]));
+}
 // src/features/hooks/cortexcode-hooks.ts
 const CORTEXCODE_NO_MATCHER_EVENTS = /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]);
 const CANONICAL_TO_CORTEXCODE_TOOL_NAMES = {
@@ -60548,14 +60794,7 @@ const CANONICAL_TO_CORTEXCODE_TOOL_NAMES = {
 	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);
-}
+const CORTEXCODE_TO_CANONICAL_TOOL_NAMES = invertToolNames(CANONICAL_TO_CORTEXCODE_TOOL_NAMES);
 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));
@@ -65716,6 +65955,61 @@ var TabnineHooks = class TabnineHooks extends ToolHooks {
 		});
 	}
 };
+// src/features/hooks/trae-hooks.ts
+const TRAE_NO_MATCHER_EVENTS = /* @__PURE__ */ new Set([
+	"sessionStart",
+	"beforeSubmitPrompt",
+	"stop"
+]);
+const CANONICAL_TO_TRAE_TOOL_NAMES = { Bash: "RunCommand" };
+const TRAE_TO_CANONICAL_TOOL_NAMES = invertToolNames(CANONICAL_TO_TRAE_TOOL_NAMES);
+const TRAE_SPEC = {
+	displayName: "TRAE",
+	overrideKey: "trae",
+	converterConfig: {
+		supportedEvents: TRAE_HOOK_EVENTS,
+		canonicalToToolEventNames: CANONICAL_TO_TRAE_EVENT_NAMES,
+		toolToCanonicalEventNames: TRAE_TO_CANONICAL_EVENT_NAMES,
+		projectDirVar: "$TRAE_PROJECT_DIR",
+		stripsProjectDirVarOnImportOnly: true,
+		importedProjectDirVarAliases: ["$CLAUDE_PROJECT_DIR"],
+		noMatcherEvents: TRAE_NO_MATCHER_EVENTS,
+		supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+		groupPassthroughFields: [{
+			canonical: "loop_limit",
+			tool: "loop_limit",
+			valueType: "number",
+			events: /* @__PURE__ */ new Set(["stop"]),
+			subdividesGroup: true,
+			onInvalidImport: "drop-field"
+		}],
+		matcherTranslation: {
+			toTool: ({ matcher }) => replaceMatcherNames(matcher, CANONICAL_TO_TRAE_TOOL_NAMES),
+			toCanonical: (matcher) => replaceMatcherNames(matcher, TRAE_TO_CANONICAL_TOOL_NAMES)
+		}
+	}
+};
+/**
+* TRAE hooks.
+*
+* Hooks live under the top-level `hooks` key of the dedicated `.trae/hooks.json`
+* (project) and `~/.trae/hooks.json` (user scope). The IDE also writes a
+* `version` key there, so generation merges the `hooks` key into the file (see
+* `SHARED_CONFIG_OWNERSHIP`) instead of overwriting it.
+*
+* @see https://docs.trae.ai/ide/hook-configuration-reference?_lang=en
+*/
+var TraeHooks = class extends SettingsJsonHooks {
+	static getSpec() {
+		return TRAE_SPEC;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: TRAE_DIR,
+			relativeFilePath: TRAE_HOOKS_FILE_NAME
+		};
+	}
+};
 // src/features/hooks/vibe-hooks.ts
 const VIBE_DIR = ".vibe";
 const VIBE_HOOKS_FILE_NAME = "hooks.toml";
@@ -66900,6 +67194,21 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["trae", {
+		class: TraeHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		...converterCapabilities(TraeHooks.getConverterConfig()),
+		supportsMatcher: true,
+		matcherEvents: [
+			"preToolUse",
+			"postToolUse",
+			"notification"
+		]
+	}],
 	["vibe", {
 		class: VibeHooks,
 		meta: {
@@ -69008,69 +69317,6 @@ var AiassistantMcp = class extends ToolMcp {
 		});
 	}
 };
-// src/features/shared/amp-settings.ts
-/**
-* Parse an Amp `settings.json` / `settings.jsonc` document.
-*
-* Shared by the MCP and permissions adapters because both read the very same
-* file. Two separately maintained copies drifted once already: the permissions
-* side was hardened while the MCP side kept calling `jsonc-parser` directly,
-* which left it importing MCP servers reachable only through an injected
-* `__proto__`.
-*
-* {@link parseJsonc} is the strict, sanitizing parser: it throws on any syntax
-* error instead of returning `jsonc-parser`'s best-effort value, and it
-* rebuilds every object from its own enumerable entries, so a root `__proto__`
-* cannot swap the returned object's prototype and `constructor` / `prototype`
-* never survive as own keys, at any depth.
-*
-* Removal is silent, matching every other tool-side adapter (opencode, kilo,
-* copilot). Reporting the removed keys through `droppedPollutionKeysError` is
-* reserved for the three files a user authors under `.rulesync/`, whose whole
-* purpose is to be turned into tool config — a key that vanishes there needs
-* explaining, whereas here the surrounding settings are the user's own file
-* and are left alone.
-*
-* Note the consequence for a root `__proto__`: sanitizing runs before the
-* plain-object check, so such a document parses successfully with the key
-* stripped rather than failing that check. That is deliberate — dropping the
-* one poisoned key keeps the user's unrelated settings — and matches the
-* sanitize-before-the-root-check design the shared config gateway documents.
-*/
-function parseAmpSettings({ fileContent }) {
-	let parsed;
-	try {
-		parsed = parseJsonc$6(fileContent || "{}");
-	} catch (error) {
-		throw new Error(`Failed to parse Amp settings: ${formatError(error)}`, { cause: error });
-	}
-	if (!isPlainObject(parsed)) throw new Error("Amp settings must be a JSON object");
-	return parsed;
-}
-/**
-* Probe `<jsonDir>/settings.jsonc` first, falling back to `settings.json`, so
-* an existing user file is read-modified-written in place instead of a fresh
-* `.json` sibling being created next to a hand-authored `.jsonc`. Defaults to
-* `settings.json` when neither file exists: Amp's canonically documented
-* settings file (`.amp/settings.json`), shared by the MCP and permissions
-* adapters, so generating both on a clean repo writes a single settings file.
-*/
-async function resolveAmpSettingsFile(jsonDir) {
-	const jsoncContent = await readFileContentOrNull((0, node_path.join)(jsonDir, AMP_SETTINGS_JSONC_FILE_NAME));
-	if (jsoncContent !== null) return {
-		fileContent: jsoncContent,
-		relativeFilePath: AMP_SETTINGS_JSONC_FILE_NAME
-	};
-	const jsonContent = await readFileContentOrNull((0, node_path.join)(jsonDir, AMP_SETTINGS_FILE_NAME));
-	if (jsonContent !== null) return {
-		fileContent: jsonContent,
-		relativeFilePath: AMP_SETTINGS_FILE_NAME
-	};
-	return {
-		fileContent: null,
-		relativeFilePath: AMP_SETTINGS_FILE_NAME
-	};
-}
 // src/features/mcp/amp-mcp.ts
 const AMP_MCP_SERVERS_KEY = "amp.mcpServers";
 function filterMcpServers(mcpServers) {
@@ -72056,7 +72302,7 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "mcp",
 				existingContent,
-				patch: { servers: convertToCopilotFormat(mcpServers) },
+				patch: { servers: undefinedWhenEmpty(convertToCopilotFormat(mcpServers)) },
 				filePath,
 				logger
 			}),
@@ -74377,14 +74623,20 @@ function resolveGooseUrl(config) {
 }
 /**
 * Determines the Goose `type` for a server based on its command/url/transport.
+*
+* Goose no longer has an SSE extension type (it skips a `type: sse` entry as
+* unsupported), so every remote server is written as `streamable_http`.
 */
 function resolveGooseType(config, url) {
 	if (config.command !== void 0) return "stdio";
-	if (url !== void 0) return canonicalTransport(config) === "sse" ? "sse" : "streamable_http";
+	if (url !== void 0) return "streamable_http";
 	return canonicalTransport(config) === "builtin" ? "builtin" : "stdio";
 }
 /**
-* The Goose extension types that carry an MCP server. Goose also documents
+* The Goose extension types that carry an MCP server. `sse` is no longer one
+* Goose reads, but it stays here so a stale `type: sse` entry is still
+* recognized: imported as canonical `sse` and replaced by the regenerated
+* same-name `streamable_http` entry. Goose also documents
 * `builtin`, `platform`, `frontend` and `inline_python` extensions, which have
 * no canonical MCP counterpart: they name capabilities Goose provides itself
 * rather than a server rulesync could describe.
@@ -74444,7 +74696,8 @@ function convertServerToGooseExtension(name, config, logger) {
 			warnWithFallback(logger, `Goose extension "${name}" has no command to run; skipping it rather than writing a stdio extension Goose cannot start to ~/.config/goose/config.yaml.`);
 			return;
 		}
-	} else if (gooseType === "sse" || gooseType === "streamable_http") {
+	} else if (gooseType === "streamable_http") {
+		if (canonicalTransport(config) === "sse") warnWithFallback(logger, `Goose extension "${name}" uses SSE, which Goose no longer supports; writing it as streamable_http, which only works if the server also speaks Streamable HTTP.`);
 		if (url !== void 0) ext.uri = url;
 		if (isPlainObject(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
 	}
@@ -74457,8 +74710,9 @@ function convertServerToGooseExtension(name, config, logger) {
 * Converts rulesync canonical MCP servers into Goose `extensions:` entries.
 *
 * Goose uses a non-standard schema: `name`, `type` (`stdio` | `streamable_http`
-* | `sse` | `builtin`), `cmd`/`args`/`envs` for stdio, `uri`/`headers` for
-* remote, plus `enabled` and `timeout`.
+* | `builtin`), `cmd`/`args`/`envs` for stdio, `uri`/`headers` for remote, plus
+* `enabled` and `timeout`. A canonical `sse` server is written as
+* `streamable_http` with a warning, since Goose dropped SSE support.
 *
 * `extensions:` is co-owned: alongside the MCP servers rulesync manages it also
 * holds Goose's own `builtin`/`platform`/`frontend`/`inline_python` extensions
@@ -74589,7 +74843,8 @@ function convertToGoosePluginMcpServers(mcpServers, logger) {
 *   `~/.config/goose/config.yaml`. That file also holds other Goose settings
 *   (model, provider, ...), so generation merges the `extensions:` block into the
 *   existing config instead of overwriting it, and the file is never deleted.
-*   This location supports both stdio and remote (http/sse) servers.
+*   This location supports both stdio and remote servers (SSE is written as
+*   `streamable_http`, since Goose no longer reads `type: sse`).
 * - **Project**: a stdio-only open-plugin manifest at
 *   `.agents/plugins/rulesync/.mcp.json` (Goose v1.39.0+), reusing the same
 *   `.agents/plugins/rulesync/` tree as Goose hooks. The manifest uses the
@@ -79307,6 +79562,7 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 		const managedNames = new Set(Object.keys(rulesyncServers));
 		const mcpServers = Object.entries(rulesyncServers).map(([name, server]) => rulesyncMcpServerToVibe(name, server, existingByName.get(name)));
 		const unmanagedServers = existingServers.filter((server) => !managedNames.has(server.name));
+		const servers = [...mcpServers, ...unmanagedServers];
 		return new VibeMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -79315,7 +79571,7 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "mcp",
 				existingContent,
-				patch: { mcp_servers: [...mcpServers, ...unmanagedServers] },
+				patch: { mcp_servers: servers.length > 0 ? servers : void 0 },
 				filePath
 			}),
 			validate,
@@ -82739,6 +82995,20 @@ function isUnicodeClass(rest) {
 	}));
 }
 /**
+* Return a function that, for a `[:` at `index`, gives the position of the
+* next `:]` (Go reads everything between as the class name), or -1. The
+* position is cached and `index` only grows, so a long run of `[:` with no
+* `:]` costs linear time rather than a scan to the end at each one.
+*/
+function posixEndFinder(source) {
+	let next = -2;
+	return (index) => {
+		if (!source.startsWith("[:", index)) return -1;
+		if (next !== -1 && next < index + 2) next = source.indexOf(":]", index + 2);
+		return next;
+	};
+}
+/**
 * Replace each POSIX class (`[:alpha:]`) inside a bracket class with a plain
 * character, so JavaScript can compile the rest, or return `undefined` for an
 * unknown one. Only inside a bracket is `[:name:]` a POSIX class; a bare
@@ -82748,6 +83018,7 @@ function replacePosixClasses(source) {
 	let result = "";
 	let inClass = false;
 	let index = 0;
+	const findPosixEnd = posixEndFinder(source);
 	while (index < source.length) {
 		const character = source[index] ?? "";
 		if (character === "\\") {
@@ -82772,11 +83043,11 @@ function replacePosixClasses(source) {
 			}
 			continue;
 		}
-		const posix = /^\[:\^?([\s\S]*?):\]/.exec(source.slice(index));
-		if (posix !== null) {
-			if (!POSIX_CLASSES.has(posix[1] ?? "")) return;
+		const posixEnd = findPosixEnd(index);
+		if (posixEnd !== -1) {
+			if (!POSIX_CLASSES.has(source.slice(index + 2, posixEnd).replace(/^\^/, ""))) return;
 			result += "a";
-			index += posix[0].length;
+			index = posixEnd + 2;
 			continue;
 		}
 		if (character === "]") inClass = false;
@@ -82855,6 +83126,7 @@ function hasClassEscapeRangeEnd(source) {
 	let inClass = false;
 	let afterCharacter = false;
 	let index = 0;
+	const findPosixEnd = posixEndFinder(source);
 	while (index < source.length) {
 		const character = source[index] ?? "";
 		if (character === "\\") {
@@ -82870,7 +83142,7 @@ function hasClassEscapeRangeEnd(source) {
 			});
 			continue;
 		}
-		const posixEnd = source.startsWith("[:", index) ? source.indexOf(":]", index + 2) : -1;
+		const posixEnd = findPosixEnd(index);
 		if (character === "]" || posixEnd !== -1) {
 			inClass = character !== "]";
 			afterCharacter = false;
@@ -83432,6 +83704,8 @@ function buildToolPatternEntry({ toolName, pattern }) {
 * - `execute_url` takes a domain, like `read_url`.
 * - `command` and `unsandboxed` take literal words or a per-word `regex:`,
 *   matched word by word (see `antigravity-command-patterns.ts`).
+* - `mcp` takes `server/tool` or `server/*`, matched exactly. A canonical
+*   `mcp__<server>__<tool>` category is written as that target.
 *
 * A glob copied verbatim (`read_file(**\/*.env)`) is a literal path that
 * matches nothing, so a deny written that way blocks nothing. A pattern with
@@ -83455,7 +83729,8 @@ const DENY_HINTS = {
 	read_file: "deny a directory or file path instead",
 	write_file: "deny a directory or file path instead",
 	command: "deny the first words of the command instead",
-	unsandboxed: "deny the first words of the command instead"
+	unsandboxed: "deny the first words of the command instead",
+	mcp: "deny the whole MCP server or tool instead"
 };
 function hasGlob(pattern) {
 	return BRACE_ALTERNATIVES.test(pattern) || parseGlobPattern(pattern).steps.some((step) => step.kind !== "literal");
@@ -83511,6 +83786,40 @@ function toTarget(action, pattern) {
 	if (URL_ACTIONS.has(action)) return toUrlTarget(pattern);
 	return { target: pattern };
 }
+const MCP_CATEGORY_PREFIX = "mcp__";
+const MCP_TARGET_SEPARATORS = /[/()]/;
+/**
+* The `mcp` target of a canonical `mcp__<server>__<tool>` category:
+* `<server>/<tool>`, `<server>/*` for a whole server (`mcp__<server>`,
+* `mcp__<server>__*`), or `*` for every MCP tool (`mcp__*`, `mcp__*__*`). The
+* server ends at the first `__`, as elsewhere in rulesync. Antigravity matches
+* names exactly, so a glob, an empty name, or a `/` or parenthesis in a name
+* has no target; when only the tool part is at fault, its server is the `lead`
+* a deny widens to.
+*/
+function toMcpTarget(category) {
+	const remainder = category.slice(5);
+	const separator = remainder.indexOf("__");
+	const server = separator === -1 ? remainder : remainder.slice(0, separator);
+	const tool = separator === -1 ? "*" : remainder.slice(separator + 2);
+	if (server === "*" && tool === "*") return { target: "*" };
+	const skipReason = "Antigravity MCP targets name one server or one tool exactly. Only `mcp__<server>`, `mcp__<server>__*`, `mcp__<server>__<tool>` or `mcp__*` can be expressed";
+	if (server.length === 0 || MCP_TARGET_SEPARATORS.test(server) || hasGlob(server)) return { skipReason };
+	if (tool === "*") return { target: `${server}/*` };
+	return tool.length === 0 || MCP_TARGET_SEPARATORS.test(tool) || hasGlob(tool) ? {
+		skipReason,
+		lead: `${server}/*`
+	} : { target: `${server}/${tool}` };
+}
+/** The target of a canonical `mcp__...` rule, with the `lead` a deny widens to. */
+function toMcpRuleTarget(category, pattern) {
+	const target = toMcpTarget(category);
+	if (pattern === "*" || !("target" in target)) return target;
+	return {
+		skipReason: "Antigravity MCP targets name a server or a tool, not the tool's arguments",
+		lead: target.target
+	};
+}
 /**
 * The leading directories of a path glob (`src` for `src/*.ts`), or
 * `undefined` when it has none. A directory target covers everything inside
@@ -83533,6 +83842,20 @@ function toWidenedDenyTarget(action, pattern) {
 	if (ANTIGRAVITY_COMMAND_ACTIONS.has(action)) return toAntigravityCommandLiteralPrefix(pattern);
 	if (PATH_ACTIONS.has(action)) return toPathLiteralPrefix(pattern);
 }
+/** The entry a deny is widened to, and what it now blocks. */
+function describeWidenedDeny({ action, prefix, isMcp }) {
+	if (isMcp) return prefix === "*" ? {
+		entry: action,
+		scope: "every MCP tool"
+	} : {
+		entry: `${action}(${prefix})`,
+		scope: `every call of \`${action}(${prefix})\``
+	};
+	return {
+		entry: `${action}(${prefix})`,
+		scope: PATH_ACTIONS.has(action) ? `every path under \`${prefix}\`` : `every command that starts with \`${prefix}\``
+	};
+}
 /**
 * Warn about a path target that is a home or variable reference. Antigravity
 * documents absolute and workspace-relative paths only, so such a reference
@@ -83554,14 +83877,20 @@ function warnHomeOrVariablePath({ action, target, rule, decision, logger, toolLa
 * nothing enforces it, and a widened one is warned about too, because it
 * blocks more than it says.
 */
-function buildAntigravityPermissionEntry({ action, category, pattern, decision, logger, toolLabel }) {
-	const result = pattern === "*" ? { target: "*" } : toTarget(action, pattern);
+function buildAntigravityPermissionEntry({ action: toolAction, category, pattern, decision, logger, toolLabel }) {
+	const isMcp = category.startsWith(MCP_CATEGORY_PREFIX);
+	const action = isMcp ? "mcp" : toolAction;
+	const result = isMcp ? toMcpRuleTarget(category, pattern) : pattern === "*" ? { target: "*" } : toTarget(action, pattern);
 	const rule = `${category}: { "${pattern}": "${decision}" }`;
 	if ("skipReason" in result) {
-		const prefix = decision === "deny" ? toWidenedDenyTarget(action, pattern) : void 0;
+		const prefix = decision !== "deny" ? void 0 : isMcp ? result.lead : toWidenedDenyTarget(action, pattern);
 		if (prefix !== void 0) {
-			const scope = PATH_ACTIONS.has(action) ? `every path under \`${prefix}\`` : `every command that starts with \`${prefix}\``;
-			logger.warn(`${toolLabel} permissions: widening ${rule} to ${action}(${prefix}). ${result.skipReason}. The deny now blocks ${scope}, overriding any allow or ask for them.`);
+			const { entry, scope } = describeWidenedDeny({
+				action,
+				prefix,
+				isMcp
+			});
+			logger.warn(`${toolLabel} permissions: widening ${rule} to ${entry}. ${result.skipReason}. The deny now blocks ${scope}, overriding any allow or ask for them.`);
 			warnHomeOrVariablePath({
 				action,
 				target: prefix,
@@ -83570,7 +83899,7 @@ function buildAntigravityPermissionEntry({ action, category, pattern, decision,
 				logger,
 				toolLabel
 			});
-			return `${action}(${prefix})`;
+			return entry;
 		}
 		const consequence = decision === "deny" ? `This deny is NOT enforced in ${toolLabel}; ${DENY_HINTS[action] ?? "write it in a form Antigravity can match"}` : decision === "ask" ? `${toolLabel} falls back to its default for it, so it runs without a prompt when ${toolLabel} is set to always proceed` : `${toolLabel} falls back to its default for it`;
 		logger.warn(`${toolLabel} permissions: skipping ${rule}. ${result.skipReason}. ${consequence}.`);
@@ -83714,6 +84043,7 @@ const ANTIGRAVITY_CLI_TO_CANONICAL_TOOL_NAMES = {
 	mcp: "mcp"
 };
 function toAntigravityCliToolName(canonical) {
+	if (canonical.startsWith("mcp__")) return "mcp";
 	return CANONICAL_TO_ANTIGRAVITY_CLI_TOOL_NAMES[canonical] ?? canonical;
 }
 function toCanonicalToolName$9(cliName) {
@@ -83776,10 +84106,11 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 			logger
 		});
 		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toAntigravityCliToolName(category)));
+		const isManagedToolName = (toolName) => managedToolNames.has(toolName) || managedToolNames.has("mcp") && toolName.startsWith("mcp__");
 		const existingPermissions = settings.permissions ?? {};
-		const preservedAllow = (existingPermissions.allow ?? []).filter((entry) => !managedToolNames.has(parseToolPatternEntry(entry).toolName));
-		const preservedAsk = (existingPermissions.ask ?? []).filter((entry) => !managedToolNames.has(parseToolPatternEntry(entry).toolName));
-		const preservedDeny = (existingPermissions.deny ?? []).filter((entry) => !managedToolNames.has(parseToolPatternEntry(entry).toolName));
+		const preservedAllow = (existingPermissions.allow ?? []).filter((entry) => !isManagedToolName(parseToolPatternEntry(entry).toolName));
+		const preservedAsk = (existingPermissions.ask ?? []).filter((entry) => !isManagedToolName(parseToolPatternEntry(entry).toolName));
+		const preservedDeny = (existingPermissions.deny ?? []).filter((entry) => !isManagedToolName(parseToolPatternEntry(entry).toolName));
 		const mergedPermissions = { ...existingPermissions };
 		const mergedAllow = (0, es_toolkit.uniq)([...preservedAllow, ...allow].toSorted());
 		const mergedAsk = (0, es_toolkit.uniq)([...preservedAsk, ...ask].toSorted());
@@ -83888,6 +84219,7 @@ const IDE_ACTION_TO_CANONICAL = {
 	mcp: "mcp"
 };
 function toIdeAction(canonical) {
+	if (canonical.startsWith("mcp__")) return "mcp";
 	return CANONICAL_TO_IDE_ACTION[canonical] ?? canonical;
 }
 function toCanonicalCategory$2(ideAction) {
@@ -83944,8 +84276,9 @@ var AntigravityIdePermissions = class AntigravityIdePermissions extends ToolPerm
 			logger
 		});
 		const managedActions = new Set(Object.keys(config.permission).map((category) => toIdeAction(category)));
+		const isManagedAction = (action) => managedActions.has(action) || managedActions.has("mcp") && action.startsWith("mcp__");
 		const existingPermissions = settings.permissions ?? {};
-		const preserve = (entries) => (entries ?? []).filter((entry) => !managedActions.has(parseToolPatternEntry(entry).toolName));
+		const preserve = (entries) => (entries ?? []).filter((entry) => !isManagedAction(parseToolPatternEntry(entry).toolName));
 		const mergedPermissions = { ...existingPermissions };
 		const mergedAllow = (0, es_toolkit.uniq)([...preserve(existingPermissions.allow), ...allow].toSorted());
 		const mergedAsk = (0, es_toolkit.uniq)([...preserve(existingPermissions.ask), ...ask].toSorted());