rulesync 16.0.0 → 16.1.0

package/dist/{import-Dyo6JaHg.cjs → import-eG7fZPXI.cjs}

@@ -127,27 +127,27 @@ const isFeatureValueEnabled = (value) => {
 };
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$275 } = node_path.posix;
+const { join: join$277 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$275(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$275(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$277(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$277(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$275(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$277(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$275(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$275(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$277(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$277(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -293,6 +293,9 @@ const commandsProcessorToolTargetTuple = [
 const subagentsProcessorToolTargetTuple = [
 	"kilo",
 	"agentsmd",
+	"antigravity-cli",
+	"antigravity-ide",
+	"antigravity-plugin",
 	"augmentcode",
 	"claudecode",
 	"claudecode-plugin",
@@ -424,6 +427,7 @@ const permissionsProcessorToolTargetTuple = [
 ];
 const checksProcessorToolTargetTuple = [
 	"amp",
+	"cursor",
 	"hermesagent",
 	"takt"
 ];
@@ -2134,7 +2138,10 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	model: zod_mini.z.optional(safeString),
 	args: zod_mini.z.optional(zod_mini.z.array(safeString)),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	if: zod_mini.z.optional(safeString)
+	if: zod_mini.z.optional(safeString),
+	commandWindows: zod_mini.z.optional(safeString),
+	asyncRewake: zod_mini.z.optional(zod_mini.z.boolean()),
+	continueOnBlock: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * All canonical hook event names.
@@ -2188,6 +2195,7 @@ const HOOK_EVENTS = [
 	"configChange",
 	"cwdChanged",
 	"fileChanged",
+	"directoryAdded",
 	"elicitation",
 	"elicitationResult"
 ];
@@ -2249,6 +2257,7 @@ const CLAUDE_HOOK_EVENTS = [
 	"configChange",
 	"cwdChanged",
 	"fileChanged",
+	"directoryAdded",
 	"postCompact",
 	"elicitation",
 	"elicitationResult"
@@ -2281,7 +2290,15 @@ const DEVIN_HOOK_EVENTS = [
 	"permissionRequest",
 	"postCompact"
 ];
-/** Hook events supported by OpenCode. */
+/**
+* Hook events supported by OpenCode.
+*
+* `preCompact` maps to `experimental.session.compacting`, which the plugin docs
+* document as a named `(input, output)` hook rather than an `event.type`
+* dispatch; the other entries are all generic events.
+*
+* @see https://opencode.ai/docs/plugins/
+*/
 const OPENCODE_HOOK_EVENTS = [
 	"sessionStart",
 	"preToolUse",
@@ -2289,9 +2306,19 @@ const OPENCODE_HOOK_EVENTS = [
 	"stop",
 	"afterFileEdit",
 	"afterShellExecution",
-	"permissionRequest"
+	"permissionRequest",
+	"preCompact",
+	"postCompact",
+	"afterError",
+	"fileChanged"
 ];
-/** Hook events supported by Kilo. (Currently identical to OpenCode) */
+/**
+* Hook events supported by Kilo. Identical to OpenCode: Kilo's plugin docs list
+* the same event surface, including `session.compacted`, `session.error`,
+* `file.watcher.updated` and the experimental compaction hook.
+*
+* @see https://kilo.ai/docs/automate/extending/plugins
+*/
 const KILO_HOOK_EVENTS = OPENCODE_HOOK_EVENTS;
 /**
 * Hook events supported by Pi Coding Agent, bridged through a generated
@@ -2358,7 +2385,8 @@ const COPILOT_HOOK_EVENTS = [
 * `sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`, `preMcpToolCall` ← `beforeMCPExecution`.
+* `notification`, `userPromptTransformed` ← `userPromptExpansion`,
+* `preMcpToolCall` ← `beforeMCPExecution`.
 *
 * `preMcpToolCall` (canonical `beforeMCPExecution`) was added in Copilot CLI
 * v1.0.51 (2026-05-20) for hook providers to control outgoing MCP request
@@ -2380,6 +2408,7 @@ const COPILOTCLI_HOOK_EVENTS = [
 	"preCompact",
 	"permissionRequest",
 	"notification",
+	"userPromptExpansion",
 	"beforeMCPExecution"
 ];
 /**
@@ -2424,6 +2453,7 @@ const DEEPAGENTS_HOOK_EVENTS = [
 /** Hook events supported by Codex CLI. */
 const CODEXCLI_HOOK_EVENTS = [
 	"sessionStart",
+	"sessionEnd",
 	"preToolUse",
 	"postToolUse",
 	"beforeSubmitPrompt",
@@ -2858,6 +2888,7 @@ const CANONICAL_TO_CLAUDE_EVENT_NAMES = {
 	configChange: "ConfigChange",
 	cwdChanged: "CwdChanged",
 	fileChanged: "FileChanged",
+	directoryAdded: "DirectoryAdded",
 	postCompact: "PostCompact",
 	elicitation: "Elicitation",
 	elicitationResult: "ElicitationResult"
@@ -2979,7 +3010,11 @@ const CANONICAL_TO_OPENCODE_EVENT_NAMES = {
 	stop: "session.idle",
 	afterFileEdit: "file.edited",
 	afterShellExecution: "command.executed",
-	permissionRequest: "permission.asked"
+	permissionRequest: "permission.asked",
+	preCompact: "experimental.session.compacting",
+	postCompact: "session.compacted",
+	afterError: "session.error",
+	fileChanged: "file.watcher.updated"
 };
 /**
 * Map canonical camelCase event names to Kilo dot-notation.
@@ -3055,6 +3090,7 @@ const CANONICAL_TO_COPILOTCLI_EVENT_NAMES = {
 	preCompact: "preCompact",
 	permissionRequest: "permissionRequest",
 	notification: "notification",
+	userPromptExpansion: "userPromptTransformed",
 	beforeMCPExecution: "preMcpToolCall"
 };
 /** Map GitHub Copilot CLI event names back to canonical camelCase. */
@@ -3064,6 +3100,7 @@ const COPILOTCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CA
 */
 const CANONICAL_TO_CODEXCLI_EVENT_NAMES = {
 	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
@@ -3486,6 +3523,25 @@ var RulesyncIgnore = class RulesyncIgnore extends RulesyncFile {
 //#endregion
 //#region src/types/mcp.ts
 const EnvVarNameSchema = zod_mini.z.string().check((0, zod_mini.refine)((value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), "envVars entries must be valid environment variable names"));
+/**
+* One `envVars` entry. A bare name reads the variable from Codex's own
+* environment; the object form names the environment to read it from, where
+* `source = "remote"` reads from the remote executor environment.
+* @see https://learn.chatgpt.com/docs/extend/mcp
+*/
+const EnvVarEntrySchema = zod_mini.z.union([EnvVarNameSchema, zod_mini.z.strictObject({
+	name: EnvVarNameSchema,
+	source: zod_mini.z.optional(zod_mini.z.enum(["local", "remote"]))
+})]);
+/**
+* Whether a value is usable as `envVars`. Applied in both directions by the
+* codex adapter, so an entry read out of somebody's `config.toml` can never be
+* imported into a `.rulesync/mcp.jsonc` that the next generate would refuse to
+* parse.
+*/
+function isEnvVarEntryArray(value) {
+	return Array.isArray(value) && value.every((entry) => EnvVarEntrySchema.safeParse(entry).success);
+}
 const McpServerSchema = zod_mini.z.looseObject({
 	type: zod_mini.z.optional(zod_mini.z.enum([
 		"local",
@@ -3500,7 +3556,8 @@ const McpServerSchema = zod_mini.z.looseObject({
 	url: zod_mini.z.optional(zod_mini.z.string()),
 	httpUrl: zod_mini.z.optional(zod_mini.z.string()),
 	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
-	envVars: zod_mini.z.optional(zod_mini.z.array(EnvVarNameSchema)),
+	envVars: zod_mini.z.optional(zod_mini.z.array(EnvVarEntrySchema)),
+	experimentalEnvironment: zod_mini.z.optional(zod_mini.z.string()),
 	disabled: zod_mini.z.optional(zod_mini.z.boolean()),
 	networkTimeout: zod_mini.z.optional(zod_mini.z.number()),
 	timeout: zod_mini.z.optional(zod_mini.z.number()),
@@ -3666,6 +3723,8 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				"description",
 				"exposed",
 				"envVars",
+				"experimentalEnvironment",
+				"experimental_environment",
 				"enabled"
 			])];
 		}));
@@ -3968,12 +4027,23 @@ const KiloPermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_m
 * authored without modeling each one; the managed `allow`/`ask`/`deny` arrays are
 * ignored here (rulesync owns them).
 *
+* `sandbox` is the sibling top-level settings subtree that governs the sandbox
+* Claude Code runs commands in (`sandbox.network.*`, `sandbox.filesystem.*`,
+* `sandbox.credentials`, `sandbox.allowAppleEvents`, ...). It has no canonical
+* permission category either — it constrains how a permitted command runs
+* rather than which commands are permitted — so it is a loose passthrough on
+* the same terms, merged into the top level of `.claude/settings.json`.
+*
 * @example
 * { "permissions": { "defaultMode": "acceptEdits", "additionalDirectories": ["../shared"] } }
+* @example
+* { "sandbox": { "network": { "allowedDomains": ["example.com"], "strictAllowlist": true } } }
+* @see https://code.claude.com/docs/en/sandboxing
 */
 const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	permissions: zod_mini.z.optional(zod_mini.z.looseObject({}))
+	permissions: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Mistral Vibe. Vibe's per-tool `BaseToolConfig`
@@ -4246,19 +4316,24 @@ const AmpPermissionsOverrideSchema = zod_mini.z.looseObject({
 });
 /**
 * Tool-scoped override block for the Google Antigravity CLI. Antigravity's CLI
-* `settings.json` carries two global autonomy/sandbox knobs outside the
+* `settings.json` carries four global autonomy/sandbox knobs outside the
 * `permissions.allow/ask/deny` arrays rulesync manages: `toolPermission` (the
 * global autonomy preset — `request-review` (default) / `proceed-in-sandbox` /
-* `always-proceed` / `strict`) and `enableTerminalSandbox` (a boolean confining
-* agent-run commands to OS containment). Antigravity applies the allow/deny
+* `always-proceed` / `strict`), `enableTerminalSandbox` (a boolean confining
+* agent-run commands to OS containment), `artifactReviewPolicy` (whether the
+* agent's artifact changes are gated on a review prompt — `asks-for-review`
+* (default) / `agent-decides` / `always-proceed`) and `allowNonWorkspaceAccess`
+* (a boolean, off by default, letting the agent read or write files outside the
+* active workspace roots). Antigravity applies the allow/deny
 * lists as per-rule exceptions to the preset at runtime, so rulesync only
 * authors these keys verbatim — no precedence modeling is needed on our side.
 * Fields placed here are merged onto the top level of
 * `~/.gemini/antigravity-cli/settings.json` (global-only) and emitted only for
 * the CLI. The Antigravity IDE exposes the same concepts through a GUI (no
 * documented JSON schema), so this override does NOT apply to `antigravity-ide`.
-* Verified against https://antigravity.google/docs/cli/reference and
-* https://antigravity.google/docs/cli/sandbox.
+* Verified against https://antigravity.google/docs/cli/reference,
+* https://antigravity.google/docs/cli/sandbox and
+* https://antigravity.google/docs/cli/settings.
 *
 * @example
 * { "toolPermission": "strict", "enableTerminalSandbox": true }
@@ -4271,7 +4346,13 @@ const AntigravityCliPermissionsOverrideSchema = zod_mini.z.looseObject({
 		"always-proceed",
 		"strict"
 	])),
-	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean())
+	enableTerminalSandbox: zod_mini.z.optional(zod_mini.z.boolean()),
+	artifactReviewPolicy: zod_mini.z.optional(zod_mini.z.enum([
+		"asks-for-review",
+		"agent-decides",
+		"always-proceed"
+	])),
+	allowNonWorkspaceAccess: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * Tool-scoped override block for AugmentCode. AugmentCode's `toolPermissions[]`
@@ -4675,11 +4756,14 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 		description: zod_mini.z.optional(zod_mini.z.string()),
 		globs: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 	})),
-	copilot: zod_mini.z.optional(zod_mini.z.looseObject({ excludeAgent: zod_mini.z.optional(zod_mini.z.union([
-		zod_mini.z.literal("code-review"),
-		zod_mini.z.literal("cloud-agent"),
-		zod_mini.z.literal("coding-agent")
-	])) })),
+	copilot: zod_mini.z.optional(zod_mini.z.looseObject({
+		excludeAgent: zod_mini.z.optional(zod_mini.z.union([
+			zod_mini.z.literal("code-review"),
+			zod_mini.z.literal("cloud-agent"),
+			zod_mini.z.literal("coding-agent")
+		])),
+		name: zod_mini.z.optional(zod_mini.z.string())
+	})),
 	antigravity: zod_mini.z.optional(zod_mini.z.looseObject({
 		trigger: zod_mini.z.optional(zod_mini.z.string()),
 		globs: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
@@ -4887,6 +4971,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 		context: zod_mini.z.optional(zod_mini.z.string()),
 		agent: zod_mini.z.optional(zod_mini.z.string()),
+		background: zod_mini.z.optional(zod_mini.z.boolean()),
 		hooks: zod_mini.z.optional(zod_mini.z.looseObject({})),
 		shell: zod_mini.z.optional(zod_mini.z.string()),
 		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
@@ -4938,7 +5023,9 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	copilotcli: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(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())])),
-		"argument-hint": zod_mini.z.optional(zod_mini.z.string())
+		"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
 	})),
 	pi: 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())])),
@@ -5224,6 +5311,18 @@ function resolveUserInvocable({ rootFrontmatter, section }) {
 	return section?.["user-invocable"] ?? rootFrontmatter["user-invocable"];
 }
 //#endregion
+//#region src/constants/cursor-paths.ts
+const CURSOR_DIR = ".cursor";
+const CURSOR_COMMANDS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "commands");
+const CURSOR_SKILLS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "skills");
+const CURSOR_AGENTS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "agents");
+const CURSOR_BUGBOT_FILE_NAME = "BUGBOT.md";
+const CURSOR_MCP_FILE_NAME = "mcp.json";
+const CURSOR_HOOKS_FILE_NAME = "hooks.json";
+const CURSOR_IGNORE_FILE_NAME = ".cursorignore";
+const CURSOR_PERMISSIONS_FILE_NAME = "cli.json";
+const CURSOR_PERMISSIONS_GLOBAL_FILE_NAME = "cli-config.json";
+//#endregion
 //#region src/constants/takt-paths.ts
 const TAKT_DIR = ".takt";
 const TAKT_FACETS_SUBDIR = "facets";
@@ -5674,6 +5773,235 @@ var AmpCheck = class AmpCheck extends ToolCheck {
 	}
 };
 //#endregion
+//#region src/features/checks/check-slug.ts
+/**
+* Turn a name that came out of a tool's own config file into one safe to use as
+* a `.rulesync/checks/<name>.md` file name. Shared by the adapters whose checks
+* collapse into a single file, since the name they read back is whatever the
+* user wrote there.
+*/
+function slugifyCheckName(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/, "");
+}
+//#endregion
+//#region src/features/checks/cursor-check.ts
+/**
+* Marks where one check starts inside the single instruction file. Bugbot reads
+* the file as prose, and an HTML comment is invisible in rendered Markdown, so
+* the marker carries the check identity without changing what Bugbot is told.
+*/
+const CHECK_MARKER_PATTERN = /^<!--\s*rulesync:check:(.+?)\s*-->[ \t]*$/gm;
+/**
+* A marker line a check body wrote itself — a rulesync doc fragment quoted in a
+* code block, say. Emitting it verbatim would split that check in two on the
+* next import, so `literal-` is inserted before `check:` on the way out and
+* taken off on the way back. `(?:literal-)*` makes it a ladder, so a body that
+* already contains an escaped marker survives the round trip too.
+*/
+const ESCAPABLE_MARKER_PATTERN = /^(<!--\s*rulesync:)((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
+const ESCAPED_MARKER_PATTERN = /^(<!--\s*rulesync:)literal-((?:literal-)*check:.+?\s*-->[ \t]*)$/gm;
+const FALLBACK_CHECK_NAME = "bugbot";
+function renderMarker(name) {
+	return `<!-- rulesync:check:${name} -->`;
+}
+function escapeMarkers(content) {
+	return content.replace(ESCAPABLE_MARKER_PATTERN, "$1literal-$2");
+}
+function unescapeMarkers(content) {
+	return content.replace(ESCAPED_MARKER_PATTERN, "$1$2");
+}
+function findMarkers(fileContent) {
+	CHECK_MARKER_PATTERN.lastIndex = 0;
+	const markers = [];
+	let match = CHECK_MARKER_PATTERN.exec(fileContent);
+	while (match !== null) {
+		markers.push({
+			name: match[1] ?? "",
+			start: match.index,
+			end: match.index + match[0].length
+		});
+		match = CHECK_MARKER_PATTERN.exec(fileContent);
+	}
+	return markers;
+}
+/**
+* The instruction text one check contributes. Bugbot has no field to put a
+* summary in, so `description` is used only when there is no body — the same
+* fallback the file-stem heading above it gets.
+*/
+function toInstruction(rulesyncCheck) {
+	const body = rulesyncCheck.getBody().trim();
+	if (body.length > 0) return body;
+	return rulesyncCheck.getFrontmatter().description?.trim() ?? "";
+}
+function renderSection(rulesyncCheck) {
+	const name = (0, node_path.basename)(rulesyncCheck.getRelativeFilePath(), ".md");
+	const heading = `## ${name}`;
+	const instruction = toInstruction(rulesyncCheck);
+	const lines = [renderMarker(name), heading];
+	if (instruction.length > 0) lines.push("", escapeMarkers(instruction));
+	return lines.join("\n");
+}
+/** Drop the heading generate writes, so a round trip does not stack headings. */
+function stripGeneratedHeading(section, name) {
+	const [firstLine, ...rest] = section.split("\n");
+	if (firstLine?.trim() === `## ${name}`) return rest.join("\n").trim();
+	return section.trim();
+}
+/**
+* Checks adapter for Cursor Bugbot (`.cursor/BUGBOT.md`).
+*
+* Bugbot takes one aggregated instruction file per directory rather than a file
+* per check, so every `.rulesync/checks/*.md` targeting Cursor collapses into
+* the repository-root `.cursor/BUGBOT.md` — hence {@link fromRulesyncChecks}
+* rather than the usual per-check conversion. Each check becomes one section:
+* an HTML-comment marker carrying the check name, an `## <name>` heading, and
+* the check body as the instruction text (the `description` is used when the
+* body is empty).
+*
+* Bugbot reads the file as free prose, so a check's `severity` and `tools` have
+* no equivalent there: they are not written and do not come back on import. So
+* is `description` whenever the check also has a body.
+*
+* Project scope only — Bugbot reads repository files, and there is no
+* user-level instruction file. Bugbot also merges nested `<dir>/.cursor/BUGBOT.md`
+* files found while traversing upward from changed files, but rulesync check
+* sources carry no directory-placement semantics, so only the root file is
+* generated.
+*
+* On import the markers split the file back into one check per section; content
+* before the first marker — and a hand-written file with no markers at all —
+* becomes a single `bugbot` check, so nothing in the file is dropped. A file
+* holding anything rulesync did not write is never deleted either (see
+* {@link canDeleteAuxiliaryFiles}), though generating checks for Cursor does
+* replace it — import first to keep what is there, which is warned about.
+*
+* @see https://cursor.com/docs/bugbot
+*/
+var CursorCheck = class CursorCheck extends ToolCheck {
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: CURSOR_DIR,
+			relativeFilePath: CURSOR_BUGBOT_FILE_NAME
+		};
+	}
+	static isTargetedByRulesyncCheck(rulesyncCheck) {
+		return this.isTargetedByRulesyncCheckDefault({
+			rulesyncCheck,
+			toolTarget: "cursor"
+		});
+	}
+	/**
+	* Ownership guard the processor consults before it deletes anything for this
+	* tool. `.cursor/BUGBOT.md` is a file Cursor's own documentation tells users
+	* to hand-write, so anything in it that rulesync did not write is not
+	* rulesync's to remove — dropping the last check targeting Cursor must not
+	* take somebody's hand-written review instructions with it. Deletion is
+	* therefore allowed only for a file that is nothing but generated sections:
+	* one that carries no marker at all, or that carries hand-written text ahead
+	* of the first marker, stays.
+	*/
+	static async canDeleteAuxiliaryFiles({ outputRoot }) {
+		const paths = CursorCheck.getSettablePaths();
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath ?? "BUGBOT.md"));
+		if (fileContent === null) return true;
+		const firstMarkerStart = findMarkers(fileContent)[0]?.start;
+		if (firstMarkerStart === void 0) return false;
+		return fileContent.slice(0, firstMarkerStart).trim().length === 0;
+	}
+	static fromRulesyncCheck(_params) {
+		throw new Error("Cursor checks are built from all checks at once; use fromRulesyncChecks.");
+	}
+	static async fromRulesyncChecks({ outputRoot = process.cwd(), rulesyncChecks, global = false, logger }) {
+		if (rulesyncChecks.length === 0) return [];
+		const paths = CursorCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? "BUGBOT.md";
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const firstMarkerStart = findMarkers(existingContent)[0]?.start ?? existingContent.length;
+		if (existingContent.slice(0, firstMarkerStart).trim().length > 0) logger?.warn(`Cursor checks: ${filePath} holds instructions rulesync did not write, and generating replaces the whole file. Run \`rulesync import --targets cursor --features checks\` first to keep them.`);
+		const fileContent = `${rulesyncChecks.map(renderSection).join("\n\n")}\n`;
+		return [new CursorCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			global
+		})];
+	}
+	static async fromFile({ outputRoot = process.cwd(), global = false }) {
+		const paths = CursorCheck.getSettablePaths({ global });
+		const relativeFilePath = paths.relativeFilePath ?? "BUGBOT.md";
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		return new CursorCheck({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent: await readFileContentOrNull(filePath) ?? "",
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new CursorCheck({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncCheck() {
+		const first = this.toRulesyncChecks()[0];
+		if (!first) throw new Error(`No check instructions found in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}.`);
+		return first;
+	}
+	toRulesyncChecks() {
+		const fileContent = this.getFileContent();
+		const sections = [];
+		const markers = findMarkers(fileContent);
+		const preambleEnd = markers[0]?.start ?? fileContent.length;
+		const preamble = fileContent.slice(0, preambleEnd).trim();
+		if (preamble.length > 0) sections.push({
+			name: FALLBACK_CHECK_NAME,
+			content: unescapeMarkers(preamble)
+		});
+		for (const [index, marker] of markers.entries()) {
+			const sectionEnd = markers[index + 1]?.start ?? fileContent.length;
+			const markerName = marker.name.trim();
+			const name = slugifyCheckName(markerName) || FALLBACK_CHECK_NAME;
+			const content = stripGeneratedHeading(fileContent.slice(marker.end, sectionEnd).trim(), markerName);
+			sections.push({
+				name,
+				content: unescapeMarkers(content)
+			});
+		}
+		const used = /* @__PURE__ */ new Set();
+		return sections.map(({ name, content }) => {
+			let uniqueName = name;
+			let suffix = 2;
+			while (used.has(uniqueName)) {
+				uniqueName = `${name}-${suffix}`;
+				suffix += 1;
+			}
+			used.add(uniqueName);
+			return new RulesyncCheck({
+				outputRoot: ".",
+				relativeDirPath: RULESYNC_CHECKS_RELATIVE_DIR_PATH,
+				relativeFilePath: `${uniqueName}.md`,
+				frontmatter: { targets: ["*"] },
+				body: content
+			});
+		});
+	}
+};
+//#endregion
 //#region src/constants/hermesagent-paths.ts
 /**
 * Hermes Agent configuration-layout conventions.
@@ -6172,7 +6500,20 @@ const SHARED_CONFIG_OWNERSHIP = {
 		jsoncParseErrors: "error",
 		features: { permissions: {
 			kind: "replace-owned-keys",
-			ownedKeys: ["chat.tools.terminal.autoApprove"]
+			ownedKeys: [
+				"chat.tools.terminal.autoApprove",
+				"chat.tools.edits.autoApprove",
+				"chat.tools.urls.autoApprove"
+			]
+		} }
+	},
+	".vscode/mcp.json": {
+		format: "jsonc",
+		invalidRootPolicy: "error",
+		jsoncParseErrors: "error",
+		features: { mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["servers"]
 		} }
 	},
 	".qwen/settings.json": {
@@ -6538,7 +6879,12 @@ const applyIgnoreReadDenies = (params) => {
 const applyPermissions = (params) => {
 	const { settings, managedToolNames, toolNameOf, allow, ask, deny, logger } = params;
 	const current = parsePermissionsBlock(settings);
-	const keepUnmanaged = (entries) => entries.filter((entry) => !managedToolNames.has(toolNameOf(entry)));
+	const emitted = /* @__PURE__ */ new Set([
+		...allow,
+		...ask,
+		...deny
+	]);
+	const keepUnmanaged = (entries) => entries.filter((entry) => !managedToolNames.has(toolNameOf(entry)) && !emitted.has(entry));
 	if (logger && managedToolNames.has(READ_TOOL_NAME)) {
 		const overwrittenReadDenies = current.deny.filter((entry) => toolNameOf(entry) === READ_TOOL_NAME);
 		if (overwrittenReadDenies.length > 0) logger.warn(`Permissions feature manages '${READ_TOOL_NAME}' tool and will overwrite ${overwrittenReadDenies.length} existing ${READ_TOOL_NAME} deny entries. Permissions take precedence.`);
@@ -6688,12 +7034,9 @@ function toRulesyncCheckFromGate({ gate, index, scope, editOnly }) {
 		body: ""
 	});
 }
-function slugify(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/, "");
-}
 function slugForGate({ gate, index, scope }) {
-	const slug = slugify(typeof gate === "string" ? gate : typeof gate.name === "string" ? gate.name : typeof gate.command === "string" ? gate.command : "");
-	return `${scope ? `${slugify(scope.name)}-` : ""}${slug.length > 0 ? slug : "quality-gate"}-${index + 1}`;
+	const slug = slugifyCheckName(typeof gate === "string" ? gate : typeof gate.name === "string" ? gate.name : typeof gate.command === "string" ? gate.command : "");
+	return `${scope ? `${slugifyCheckName(scope.name)}-` : ""}${slug.length > 0 ? slug : "quality-gate"}-${index + 1}`;
 }
 /**
 * Checks adapter for Takt (`.takt/config.yaml` project / `~/.takt/config.yaml`
@@ -6869,6 +7212,13 @@ const toolCheckFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["cursor", {
+		class: CursorCheck,
+		meta: {
+			supportsGlobal: false,
+			filePattern: CURSOR_BUGBOT_FILE_NAME
+		}
+	}],
 	["hermesagent", {
 		class: HermesagentCheck,
 		meta: {
@@ -7284,6 +7634,7 @@ var AgentsmdCommand = class AgentsmdCommand extends SimulatedCommand {
 const ANTIGRAVITY_DIR = ".agents";
 const ANTIGRAVITY_SKILLS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "skills");
 const ANTIGRAVITY_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "workflows");
+const ANTIGRAVITY_AGENTS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_DIR, "agents");
 const ANTIGRAVITY_MCP_FILE_NAME = "mcp_config.json";
 const ANTIGRAVITY_HOOKS_FILE_NAME = "hooks.json";
 const ANTIGRAVITY_IGNORE_FILE_NAME = ".geminiignore";
@@ -7294,6 +7645,7 @@ const ANTIGRAVITY_CLI_PERMISSIONS_FILE_NAME = "settings.json";
 const ANTIGRAVITY_CLI_GLOBAL_WORKFLOWS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR, "global_workflows");
 const ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR = "config";
 const ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GEMINI_DIR, ANTIGRAVITY_GLOBAL_CONFIG_SUBDIR);
+const ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(ANTIGRAVITY_GLOBAL_CONFIG_DIR_PATH, "agents");
 //#endregion
 //#region src/constants/antigravity-cli-paths.ts
 const ANTIGRAVITY_AGENTS_DIR = ANTIGRAVITY_DIR;
@@ -7852,6 +8204,7 @@ const CLAUDECODE_PLUGIN_HOOKS_DIR = "hooks";
 const CLAUDECODE_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
 const ANTIGRAVITY_PLUGIN_RULES_DIR = "rules";
 const ANTIGRAVITY_PLUGIN_SKILLS_DIR = "skills";
+const ANTIGRAVITY_PLUGIN_AGENTS_DIR = "agents";
 const ANTIGRAVITY_PLUGIN_MCP_FILE_NAME = "mcp_config.json";
 const ANTIGRAVITY_PLUGIN_HOOKS_FILE_NAME = "hooks.json";
 //#endregion
@@ -8076,6 +8429,7 @@ const COPILOT_SKILLS_DIR_PATH = (0, node_path.join)(GITHUB_DIR, "skills");
 const COPILOT_AGENTS_DIR_PATH = (0, node_path.join)(GITHUB_DIR, "agents");
 const COPILOT_HOOKS_DIR_PATH = (0, node_path.join)(GITHUB_DIR, "hooks");
 const COPILOT_HOOKS_FILE_NAME = "copilot-hooks.json";
+const COPILOT_GLOBAL_HOOKS_FILE_NAME = "copilot-ide-hooks.json";
 const COPILOT_MCP_DIR = ".vscode";
 const COPILOT_MCP_FILE_NAME = "mcp.json";
 const COPILOT_VSCODE_SETTINGS_FILE_NAME = "settings.json";
@@ -8083,6 +8437,7 @@ const COPILOTCLI_MCP_FILE_NAME = "mcp-config.json";
 const COPILOTCLI_PROJECT_MCP_FILE_NAME = "mcp.json";
 const COPILOTCLI_AGENTS_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "agents");
 const COPILOTCLI_HOOKS_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "hooks");
+const COPILOT_GLOBAL_HOOKS_DIR_PATH = COPILOTCLI_HOOKS_DIR_PATH;
 const COPILOTCLI_HOOKS_FILE_NAME = "copilotcli-hooks.json";
 const COPILOT_SKILLS_GLOBAL_DIR_PATH = (0, node_path.join)(COPILOT_DIR, "skills");
 //#endregion
@@ -8206,17 +8561,6 @@ var CopilotCommand = class CopilotCommand extends ToolCommand {
 	}
 };
 //#endregion
-//#region src/constants/cursor-paths.ts
-const CURSOR_DIR = ".cursor";
-const CURSOR_COMMANDS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "commands");
-const CURSOR_SKILLS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "skills");
-const CURSOR_AGENTS_DIR_PATH = (0, node_path.join)(CURSOR_DIR, "agents");
-const CURSOR_MCP_FILE_NAME = "mcp.json";
-const CURSOR_HOOKS_FILE_NAME = "hooks.json";
-const CURSOR_IGNORE_FILE_NAME = ".cursorignore";
-const CURSOR_PERMISSIONS_FILE_NAME = "cli.json";
-const CURSOR_PERMISSIONS_GLOBAL_FILE_NAME = "cli-config.json";
-//#endregion
 //#region src/features/commands/cursor-command.ts
 const CursorCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
@@ -11985,6 +12329,13 @@ function groupDefinitionsByMatcher(definitions) {
 	}
 	return byMatcher;
 }
+/** `$CLAUDE_PROJECT_DIR` -> `${CLAUDE_PROJECT_DIR}`, the form the tool substitutes. */
+function bracePlaceholder(projectDirVar) {
+	return `\${${projectDirVar.replace(/^\$/, "")}}`;
+}
+function stripSurroundingQuotes(value) {
+	return value.replace(/^(["'])(.*)\1$/, "$2").replace(/^["']/, "");
+}
 /**
 * Apply the optional project directory variable prefix to a command string.
 */
@@ -11994,8 +12345,10 @@ function applyCommandPrefix({ def, converterConfig }) {
 	const unquotedCommand = trimmedCommand?.replace(/^["']/, "");
 	const isDotRelativeCommand = unquotedCommand?.startsWith(".") ?? false;
 	const isAbsoluteCommand = typeof unquotedCommand === "string" && (node_path.posix.isAbsolute(unquotedCommand) || node_path.win32.isAbsolute(unquotedCommand) || unquotedCommand.startsWith("~/"));
+	const isExecForm = (converterConfig.arrayPassthroughFields?.some(({ canonical }) => canonical === "args") ?? false) && Array.isArray(def.args);
 	if (!(converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && !isAbsoluteCommand && (!converterConfig.prefixDotRelativeCommandsOnly || isDotRelativeCommand)) || typeof trimmedCommand !== "string") return def.command;
 	const relativeCommand = trimmedCommand.replace(/^(["'])\.\//, "$1").replace(/^\.\//, "");
+	if (isExecForm) return `${bracePlaceholder(converterConfig.projectDirVar)}/${stripSurroundingQuotes(relativeCommand)}`;
 	return `"${converterConfig.projectDirVar}"/${relativeCommand}`;
 }
 /**
@@ -12003,8 +12356,11 @@ function applyCommandPrefix({ def, converterConfig }) {
 * canonical field name to its (possibly renamed) tool field name. Only boolean
 * values are carried through.
 */
-function emitBooleanPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "boolean").map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitBooleanPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return typeof def[canonical] === "boolean";
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured boolean passthrough fields back into canonical fields,
@@ -12018,8 +12374,11 @@ function importBooleanPassthroughFields({ h, converterConfig }) {
 * canonical field name to its (possibly renamed) tool field name. Only non-empty
 * string values are carried through.
 */
-function emitStringPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ canonical }) => typeof def[canonical] === "string" && def[canonical] !== "").map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitStringPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.stringPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return typeof def[canonical] === "string" && def[canonical] !== "";
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured string passthrough fields back into canonical fields,
@@ -12032,8 +12391,11 @@ function importStringPassthroughFields({ h, converterConfig }) {
 /**
 * Emit the configured string-array passthrough fields on the tool side.
 */
-function emitArrayPassthroughFields({ def, converterConfig }) {
-	return Object.fromEntries((converterConfig.arrayPassthroughFields ?? []).filter(({ canonical }) => isStringArray(def[canonical])).map(({ canonical, tool }) => [tool, def[canonical]]));
+function emitArrayPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.arrayPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return isStringArray(def[canonical]);
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
 }
 /**
 * Import the configured string-array passthrough fields, reversing
@@ -12110,14 +12472,17 @@ function buildToolHooks({ defs, converterConfig }) {
 		hooks.push({
 			...emitBooleanPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			...emitStringPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			...emitArrayPassthroughFields({
 				def,
+				hookType,
 				converterConfig
 			}),
 			type: hookType,
@@ -12201,6 +12566,8 @@ function stripCommandPrefix({ command, converterConfig }) {
 	if (converterConfig.projectDirVar === "" || typeof cmd !== "string") return cmd;
 	const quotedPrefix = `"${converterConfig.projectDirVar}"/`;
 	if (cmd.startsWith(quotedPrefix)) return `./${cmd.slice(quotedPrefix.length)}`;
+	const bracedPrefix = `${bracePlaceholder(converterConfig.projectDirVar)}/`;
+	if (cmd.startsWith(bracedPrefix)) return `./${cmd.slice(bracedPrefix.length)}`;
 	if (cmd.includes(`${converterConfig.projectDirVar}/`)) {
 		const escapedVar = converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 		return cmd.replace(new RegExp(`^${escapedVar}\\/?`), "./");
@@ -12748,7 +13115,10 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"taskCreated",
 		"taskCompleted",
 		"teammateIdle",
-		"cwdChanged"
+		"cwdChanged",
+		"beforeSubmitPrompt",
+		"stop",
+		"directoryAdded"
 	]),
 	supportedHookTypes: /* @__PURE__ */ new Set([
 		"command",
@@ -12758,9 +13128,45 @@ const CLAUDE_CONVERTER_CONFIG = {
 		"agent"
 	]),
 	emitsPromptModel: true,
-	stringPassthroughFields: [{
-		canonical: "if",
-		tool: "if"
+	stringPassthroughFields: [
+		{
+			canonical: "if",
+			tool: "if"
+		},
+		{
+			canonical: "statusMessage",
+			tool: "statusMessage"
+		},
+		{
+			canonical: "shell",
+			tool: "shell",
+			commandOnly: true
+		}
+	],
+	booleanPassthroughFields: [
+		{
+			canonical: "once",
+			tool: "once"
+		},
+		{
+			canonical: "async",
+			tool: "async",
+			commandOnly: true
+		},
+		{
+			canonical: "asyncRewake",
+			tool: "asyncRewake",
+			commandOnly: true
+		},
+		{
+			canonical: "continueOnBlock",
+			tool: "continueOnBlock"
+		}
+	],
+	arrayPassthroughFields: [{
+		canonical: "args",
+		tool: "args",
+		commandOnly: true
 	}]
 };
 var ClaudecodeHooks = class extends ToolHooks {
@@ -12868,7 +13274,14 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: CODEXCLI_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
-	passthroughFields: ["name", "description"]
+	passthroughFields: ["name", "description"],
+	stringPassthroughFields: [{
+		canonical: "commandWindows",
+		tool: "commandWindows"
+	}, {
+		canonical: "statusMessage",
+		tool: "statusMessage"
+	}]
 };
 /**
 * Build the content for `.codex/config.toml`, cleaning up the deprecated `codex_hooks` key.
@@ -13116,7 +13529,11 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			fileContent: params.fileContent ?? "{}"
 		});
 	}
-	static getSettablePaths(_options = {}) {
+	static getSettablePaths({ global = false } = {}) {
+		if (global) return {
+			relativeDirPath: COPILOT_GLOBAL_HOOKS_DIR_PATH,
+			relativeFilePath: COPILOT_GLOBAL_HOOKS_FILE_NAME
+		};
 		return {
 			relativeDirPath: COPILOT_HOOKS_DIR_PATH,
 			relativeFilePath: COPILOT_HOOKS_FILE_NAME
@@ -13130,11 +13547,12 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
-	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true }) {
-		const paths = CopilotHooks.getSettablePaths();
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+		const paths = CopilotHooks.getSettablePaths({ global });
 		const copilotHooks = canonicalToCopilotHooks(rulesyncHooks.getJson());
 		const fileContent = JSON.stringify({
 			version: 1,
@@ -13145,7 +13563,8 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
-			validate
+			validate,
+			global
 		});
 	}
 	toRulesyncHooks(options) {
@@ -13189,10 +13608,16 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 * (`sessionStart`, `sessionEnd`, `userPromptSubmitted`, `preToolUse`,
 * `postToolUse`, `postToolUseFailure`, `agentStop`, `subagentStart`,
 * `subagentStop`, `errorOccurred`, `preCompact`, `permissionRequest`,
-* `notification`, `preMcpToolCall`). Each entry supports three hook types:
+* `notification`, `userPromptTransformed`, `preMcpToolCall`). Each entry
+* supports three hook types:
 *
 * - `command` — the `bash` / `powershell` command-field shape with optional
-*   `timeoutSec`, plus optional `cwd` / `env`.
+*   `timeoutSec`, plus optional `cwd` / `env`. Upstream also accepts the
+*   portable `command` field (copied to both shells when neither is present)
+*   and `timeout` as an alias for `timeoutSec`; rulesync reads both on import.
+*   On generate the canonical `shell` selector picks `bash` or `powershell`,
+*   and without it the portable `command` field is written — so the generated
+*   file does not depend on the machine rulesync ran on.
 * - `prompt` — a `prompt` string (Copilot CLI only honors prompt hooks on
 *   `sessionStart`, so prompt hooks on other events are skipped).
 * - `http` — `url` / `headers` / `allowedEnvVars` with optional `timeoutSec`.
@@ -13218,11 +13643,11 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 *   all rulesync-managed Copilot CLI files under the single `~/.copilot/`
 *   root and will revisit if the spec later mandates an alternate layout.
 *
-* Hook entries on `preToolUse` / `postToolUse` may carry an optional `matcher`
-* field (a regex compiled as `^(?:PATTERN)$`, tested against `toolName`); it is
-* emitted on those events and dropped (with a warning) on any other event,
-* which never honors matchers. See changelog v1.0.36 (2026-04-24) and v1.0.63
-* (2026-06-15). Reference: https://docs.github.com/en/copilot/reference/hooks-reference
+* Hook entries on the six matcher-aware events (see
+* {@link COPILOTCLI_MATCHER_EVENTS}) may carry an optional `matcher` regex; it
+* is emitted on those events and dropped (with a warning) on any other event,
+* which never honors matchers.
+* Reference: https://docs.github.com/en/copilot/reference/hooks-reference
 *
 * The output JSON schema and platform-specific `bash` / `powershell` command
 * field selection match `copilot-hooks.ts`, but the event surface diverges (the
@@ -13237,19 +13662,30 @@ var CopilotHooks = class CopilotHooks extends ToolHooks {
 * `Edit|Write`) are now honored instead of silently dropped").
 * @see https://docs.github.com/en/copilot/reference/hooks-reference
 */
-const COPILOTCLI_MATCHER_EVENTS = /* @__PURE__ */ new Set(["preToolUse", "postToolUse"]);
+const COPILOTCLI_MATCHER_EVENTS = /* @__PURE__ */ new Set([
+	"preToolUse",
+	"postToolUse",
+	"notification",
+	"permissionRequest",
+	"preCompact",
+	"subagentStart"
+]);
+/** Human-readable list of the matcher-aware events, for the drop warning. */
+const COPILOTCLI_MATCHER_EVENTS_LABEL = [...COPILOTCLI_MATCHER_EVENTS].join("/");
 const CopilotCliHookEntrySchema = zod_mini.z.looseObject({
 	type: zod_mini.z._default(zod_mini.z.string(), "command"),
 	matcher: zod_mini.z.optional(zod_mini.z.string()),
 	bash: zod_mini.z.optional(zod_mini.z.string()),
 	powershell: zod_mini.z.optional(zod_mini.z.string()),
+	command: zod_mini.z.optional(zod_mini.z.string()),
 	prompt: zod_mini.z.optional(zod_mini.z.string()),
 	url: zod_mini.z.optional(zod_mini.z.string()),
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	allowedEnvVars: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
 	cwd: zod_mini.z.optional(zod_mini.z.string()),
 	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
-	timeoutSec: zod_mini.z.optional(zod_mini.z.number())
+	timeoutSec: zod_mini.z.optional(zod_mini.z.number()),
+	timeout: zod_mini.z.optional(zod_mini.z.number())
 });
 /** Filter the shared config hooks down to events the Copilot CLI supports. */
 function filterSupportedCopilotCliHooks(hooks) {
@@ -13260,21 +13696,21 @@ function filterSupportedCopilotCliHooks(hooks) {
 }
 /**
 * Resolve the `matcher` part for an exported entry. Copilot CLI honors `matcher`
-* only on preToolUse/postToolUse entries; on any other event a matcher would be
-* silently dropped by the CLI, so we drop it here with a warning rather than
-* emitting a dead field.
+* only on the events listed in {@link COPILOTCLI_MATCHER_EVENTS}; on any other
+* event a matcher would be silently dropped by the CLI, so we drop it here with
+* a warning rather than emitting a dead field.
 */
 function resolveExportMatcherPart({ matcher, matcherSupported, eventName, logger }) {
 	if (matcher === void 0 || matcher === null || matcher === "") return {};
 	if (matcherSupported) return { matcher };
-	logger?.warn(`Copilot CLI hook matchers are only honored on preToolUse/postToolUse; dropping matcher "${matcher}" on '${eventName}'.`);
+	logger?.warn(`Copilot CLI hook matchers are only honored on ${COPILOTCLI_MATCHER_EVENTS_LABEL}; dropping matcher "${matcher}" on '${eventName}'.`);
 	return {};
 }
 /**
 * Build the exported entries for a single canonical event. Returns an empty
 * array when no entries are emitted (e.g. all prompt hooks were skipped).
 */
-function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchemaKeys, commandField, logger }) {
+function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchemaKeys, logger }) {
 	const matcherSupported = COPILOTCLI_MATCHER_EVENTS.has(eventName);
 	const entries = [];
 	for (const def of definitions) {
@@ -13310,22 +13746,24 @@ function buildCopilotCliEntriesForEvent({ eventName, definitions, canonicalSchem
 			...timeoutPart,
 			...rest
 		});
-		else if (hookType === "command") entries.push({
-			type: "command",
-			...matcherPart,
-			...compact({
-				[commandField]: def.command,
-				env: def.env
-			}),
-			...timeoutPart,
-			...rest
-		});
+		else if (hookType === "command") {
+			const commandField = def.shell ?? "command";
+			entries.push({
+				type: "command",
+				...matcherPart,
+				...compact({
+					[commandField]: def.command,
+					env: def.env
+				}),
+				...timeoutPart,
+				...rest
+			});
+		}
 	}
 	return entries;
 }
 function canonicalToCopilotCliHooks(config, logger) {
 	const canonicalSchemaKeys = Object.keys(HookDefinitionSchema.shape);
-	const commandField = process.platform === "win32" ? "powershell" : "bash";
 	const effectiveHooks = {
 		...filterSupportedCopilotCliHooks(config.hooks),
 		...config.copilot?.hooks,
@@ -13338,7 +13776,6 @@ function canonicalToCopilotCliHooks(config, logger) {
 			eventName,
 			definitions,
 			canonicalSchemaKeys,
-			commandField,
 			logger
 		});
 		if (entries.length > 0) out[copilotEventName] = entries;
@@ -13355,6 +13792,13 @@ function importPassthrough(entry) {
 	if (entry.env !== void 0) passthrough.env = entry.env;
 	return passthrough;
 }
+/**
+* Resolve the canonical command and its `shell` selector from an imported entry.
+*
+* A shell-specific field carries its `shell` through so re-export writes the
+* same field back. An entry using only the portable `command` field leaves
+* `shell` unset, which re-export renders as the portable field again.
+*/
 function resolveImportCommand(entry, logger) {
 	const hasBash = typeof entry.bash === "string";
 	const hasPowershell = typeof entry.powershell === "string";
@@ -13363,9 +13807,22 @@ function resolveImportCommand(entry, logger) {
 		const chosen = isWindows ? "powershell" : "bash";
 		const ignored = isWindows ? "bash" : "powershell";
 		logger?.warn(`Copilot CLI hook has both bash and powershell commands; using ${chosen} and ignoring ${ignored} on this platform.`);
-		return isWindows ? entry.powershell : entry.bash;
-	} else if (hasBash) return entry.bash;
-	else if (hasPowershell) return entry.powershell;
+		return isWindows ? {
+			command: entry.powershell,
+			shell: "powershell"
+		} : {
+			command: entry.bash,
+			shell: "bash"
+		};
+	} else if (hasBash) return {
+		command: entry.bash,
+		shell: "bash"
+	};
+	else if (hasPowershell) return {
+		command: entry.powershell,
+		shell: "powershell"
+	};
+	return typeof entry.command === "string" ? { command: entry.command } : {};
 }
 function copilotCliHooksToCanonical(rawHooks, logger) {
 	if (rawHooks === null || rawHooks === void 0 || typeof rawHooks !== "object") return {};
@@ -13378,7 +13835,7 @@ function copilotCliHooksToCanonical(rawHooks, logger) {
 			const parseResult = CopilotCliHookEntrySchema.safeParse(rawEntry);
 			if (!parseResult.success) continue;
 			const entry = parseResult.data;
-			const timeout = entry.timeoutSec;
+			const timeout = entry.timeoutSec ?? entry.timeout;
 			const timeoutPart = timeout !== void 0 ? { timeout } : {};
 			const matcherPart = entry.matcher !== void 0 && entry.matcher !== "" ? { matcher: entry.matcher } : {};
 			const passthrough = importPassthrough(entry);
@@ -13397,10 +13854,11 @@ function copilotCliHooksToCanonical(rawHooks, logger) {
 				...passthrough
 			});
 			else {
-				const command = resolveImportCommand(entry, logger);
+				const { command, shell } = resolveImportCommand(entry, logger);
 				defs.push({
 					type: "command",
 					...command !== void 0 && { command },
+					...shell !== void 0 && { shell },
 					...matcherPart,
 					...timeoutPart,
 					...passthrough
@@ -14540,7 +14998,23 @@ var JunieHooks = class JunieHooks extends ToolHooks {
 };
 //#endregion
 //#region src/features/hooks/opencode-style-generator.ts
-const NAMED_HOOKS = /* @__PURE__ */ new Set(["tool.execute.before", "tool.execute.after"]);
+/**
+* Tool events emitted as named `(input, ...)` hooks rather than through the
+* generic `event.type` dispatch, mapped to the expression a hook's `matcher`
+* regex is tested against — or `null` when the hook has no matchable subject,
+* in which case a matcher is dropped rather than compiled against a field that
+* does not exist.
+*
+* `experimental.session.compacting` receives `(input, output)` and exposes no
+* per-invocation identifier worth matching on, so it takes `null`.
+*
+* @see https://opencode.ai/docs/plugins/
+*/
+const NAMED_HOOK_MATCHER_SUBJECTS = {
+	"tool.execute.before": "input.tool",
+	"tool.execute.after": "input.tool",
+	"experimental.session.compacting": null
+};
 function escapeForTemplateLiteral(command) {
 	return command.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
@@ -14573,7 +15047,7 @@ function collectOpencodeStyleHandlers({ effectiveHooks, eventMap, namedEventHand
 			});
 		}
 		if (handlers.length > 0) {
-			const grouped = NAMED_HOOKS.has(toolEvent) ? namedEventHandlers : genericEventHandlers;
+			const grouped = Object.hasOwn(NAMED_HOOK_MATCHER_SUBJECTS, toolEvent) ? namedEventHandlers : genericEventHandlers;
 			const existing = grouped[toolEvent];
 			if (existing) existing.push(...handlers);
 			else grouped[toolEvent] = handlers;
@@ -14602,14 +15076,15 @@ function buildGenericEventBodyLines(genericEventHandlers) {
 function buildNamedEventBodyLines(namedEventHandlers) {
 	const bodyLines = [];
 	for (const [eventName, handlers] of Object.entries(namedEventHandlers)) {
+		const matcherSubject = NAMED_HOOK_MATCHER_SUBJECTS[eventName] ?? null;
 		bodyLines.push(`    "${eventName}": async (input) => {`);
 		for (const handler of handlers) {
 			const escapedCommand = escapeForTemplateLiteral(handler.command);
-			if (handler.matcher) {
+			if (handler.matcher && matcherSubject !== null) {
 				const safeMatcher = validateAndSanitizeMatcher(handler.matcher);
 				bodyLines.push("      {");
 				bodyLines.push(`        const __re = new RegExp("${safeMatcher}");`);
-				bodyLines.push(`        if (__re.test(input.tool)) {`);
+				bodyLines.push(`        if (__re.test(${matcherSubject})) {`);
 				bodyLines.push(`          await $\`${escapedCommand}\`;`);
 				bodyLines.push("        }");
 				bodyLines.push("      }");
@@ -16245,7 +16720,7 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		class: CopilotHooks,
 		meta: {
 			supportsProject: true,
-			supportsGlobal: false,
+			supportsGlobal: true,
 			supportsImport: true
 		},
 		supportedEvents: COPILOT_HOOK_EVENTS,
@@ -18722,8 +19197,20 @@ const RULESYNC_TO_CODEX_FIELD_MAP = {
 	disabledTools: "disabled_tools",
 	envVars: "env_vars"
 };
+const RULESYNC_TO_CODEX_SCALAR_FIELD_MAP = { experimentalEnvironment: "experimental_environment" };
+const CODEX_TO_RULESYNC_SCALAR_FIELD_MAP = Object.fromEntries(Object.entries(RULESYNC_TO_CODEX_SCALAR_FIELD_MAP).map(([canonical, codex]) => [codex, canonical]));
 const MAX_REMOVE_EMPTY_ENTRIES_DEPTH$1 = 32;
 /**
+* `env_vars` entries are either a bare variable name or `{ name, source }`,
+* where `source = "remote"` reads the variable from the remote executor
+* environment. The other renamed keys (`enabled_tools`, `disabled_tools`) stay
+* plain string arrays, so the widened check applies to `env_vars` only.
+* @see https://learn.chatgpt.com/docs/extend/mcp
+*/
+function isValidRenamedArray(key, value) {
+	return key === "env_vars" || key === "envVars" ? isEnvVarEntryArray(value) : isStringArray$1(value);
+}
+/**
 * Translate a server's `oauth` table from the canonical rulesync shape (Claude
 * Code style camelCase) into the shape Codex CLI understands. Codex expects the
 * OAuth client id under snake_case `client_id`; without it `codex mcp login`
@@ -18783,8 +19270,12 @@ function convertFromCodexFormat(codexMcp) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthFromCodex(value);
 			else if (Object.hasOwn(CODEX_TO_RULESYNC_FIELD_MAP, key)) {
 				const mappedKey = CODEX_TO_RULESYNC_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `Ignored malformed array for ${key} in MCP server ${name}`);
+			} else if (Object.hasOwn(CODEX_TO_RULESYNC_SCALAR_FIELD_MAP, key)) {
+				const mappedKey = CODEX_TO_RULESYNC_SCALAR_FIELD_MAP[key];
+				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
+				else warnWithFallback(void 0, `Ignored malformed value for ${key} in MCP server ${name}: expected a string`);
 			} else converted[key] = value;
 		}
 		result[name] = converted;
@@ -18806,8 +19297,12 @@ function convertToCodexFormat(mcpServers) {
 			} else if (key === "oauth" && isRecord(value)) converted[key] = mapOauthToCodex(value);
 			else if (Object.hasOwn(RULESYNC_TO_CODEX_FIELD_MAP, key)) {
 				const mappedKey = RULESYNC_TO_CODEX_FIELD_MAP[key];
-				if (mappedKey) if (isStringArray$1(value)) converted[mappedKey] = value;
+				if (mappedKey) if (isValidRenamedArray(key, value)) converted[mappedKey] = value;
 				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string array, got ${typeof value}`);
+			} else if (Object.hasOwn(RULESYNC_TO_CODEX_SCALAR_FIELD_MAP, key)) {
+				const mappedKey = RULESYNC_TO_CODEX_SCALAR_FIELD_MAP[key];
+				if (mappedKey) if (typeof value === "string") converted[mappedKey] = value;
+				else warnWithFallback(void 0, `[CodexCliMcp] Skipping invalid value type for mapped key '${key}': expected string, got ${typeof value}`);
 			} else converted[key] = value;
 		}
 		const previousName = originalNames.get(codexName);
@@ -18878,7 +19373,9 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			const rawServer = isRecord(rawMcpServers) ? rawMcpServers[serverName] : void 0;
 			return [serverName, {
 				...serverConfig,
-				...isRecord(rawServer) && isStringArray$1(rawServer.envVars) ? { envVars: rawServer.envVars } : {}
+				...isRecord(rawServer) && isEnvVarEntryArray(rawServer.envVars) ? { envVars: rawServer.envVars } : {},
+				...isRecord(rawServer) && typeof rawServer.experimental_environment === "string" ? { experimentalEnvironment: rawServer.experimental_environment } : {},
+				...isRecord(rawServer) && typeof rawServer.experimentalEnvironment === "string" ? { experimentalEnvironment: rawServer.experimentalEnvironment } : {}
 			}];
 		})));
 		const filteredMcpServers = this.removeEmptyEntries(converted);
@@ -18949,9 +19446,6 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/copilot-mcp.ts
-function convertToCopilotFormat(mcpServers) {
-	return { servers: mcpServers };
-}
 function convertFromCopilotFormat(copilotConfig) {
 	return copilotConfig.servers ?? {};
 }
@@ -18980,13 +19474,21 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 			validate
 		});
 	}
-	static fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true }) {
-		const copilotConfig = convertToCopilotFormat(rulesyncMcp.getMcpServers());
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true }) {
+		const paths = this.getSettablePaths();
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
 		return new CopilotMcp({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().relativeDirPath,
-			relativeFilePath: this.getSettablePaths().relativeFilePath,
-			fileContent: JSON.stringify(copilotConfig, null, 2),
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { servers: rulesyncMcp.getMcpServers() },
+				filePath
+			}),
 			validate
 		});
 	}
@@ -20669,7 +21171,7 @@ const KILO_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
 * impossible to start — no command, no URL — so it is written as the toggle it
 * resembles rather than dropped, but the loss is said out loud.
 */
-function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
+function warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger) {
 	const dropped = Object.keys(serverConfig).filter((key) => !KILO_TOGGLE_KEPT_KEYS.has(key));
 	if (dropped.length === 0) return;
 	logger?.warn(`Kilo MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
@@ -20682,7 +21184,7 @@ function convertServerToKiloFormat(serverName, serverConfig, existingEntry, logg
 	if (declaresNoTransport(serverConfig)) {
 		if (serverConfig.disabled === void 0) {
 			if (existingEntry !== void 0 && !isKiloTransportServer(existingEntry)) {
-				warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+				warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger);
 				return existingEntry;
 			}
 			return warnAndSkipMcpServer({
@@ -20692,7 +21194,7 @@ function convertServerToKiloFormat(serverName, serverConfig, existingEntry, logg
 				logger
 			});
 		}
-		warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+		warnAboutToggleDroppedKeys$1(serverName, serverConfig, logger);
 		return { enabled: !serverConfig.disabled };
 	}
 	if (isRemoteMcpServer(serverConfig)) {
@@ -21318,13 +21820,49 @@ const OpencodeMcpRemoteServerSchema = zod_mini.z.looseObject({
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	enabled: zod_mini.z._default(zod_mini.z.boolean(), true)
 });
-const OpencodeMcpServerSchema = zod_mini.z.union([OpencodeMcpLocalServerSchema, OpencodeMcpRemoteServerSchema]);
+const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
+const OPENCODE_MCP_TRANSPORT_KEYS = [
+	...Object.keys(OpencodeMcpLocalServerSchema.def.shape),
+	...Object.keys(OpencodeMcpRemoteServerSchema.def.shape),
+	...OPENCODE_PASSTHROUGH_SERVER_FIELDS
+].filter((key) => key !== "enabled");
+/**
+* A bare toggle entry: `{"enabled": <bool>}` with no transport of its own,
+* disabling a server another config layer defines. It is the third member of
+* OpenCode's own `mcp` union in the published schema, described in-source as
+* "the legacy `{ enabled: false }` form used to disable a server". Without this
+* arm the union rejects the entry and the whole MCP import aborts — taking
+* every valid server in the same file down with it.
+*
+* Loose, unlike the two transport arms, so a key OpenCode adds to a toggle
+* later does not bring that abort back — but refined to reject anything
+* carrying a key only a transport entry has. A plain loose arm would sit under
+* a malformed `local` or `remote` entry that happens to carry `enabled` and
+* swallow it, dropping its command, URL, or headers without a word instead of
+* failing the way it does today. Mirrors {@link KiloMcpToggleSchema}.
+*
+* @see https://opencode.ai/config.json
+*/
+const OpencodeMcpToggleSchema = zod_mini.z.looseObject({ enabled: zod_mini.z.boolean() }).check((0, zod_mini.refine)((entry) => OPENCODE_MCP_TRANSPORT_KEYS.every((key) => !(key in entry)), "not a valid OpenCode MCP server: expected a local server ({type: \"local\", command: [...]}), a remote server ({type: \"remote\", url: \"...\"}), or a bare toggle ({enabled: <bool>}) carrying no field of either"));
+const OpencodeMcpServerSchema = zod_mini.z.union([
+	OpencodeMcpLocalServerSchema,
+	OpencodeMcpRemoteServerSchema,
+	OpencodeMcpToggleSchema
+]);
 const OpencodeConfigSchema = zod_mini.z.looseObject({
 	$schema: zod_mini.z.optional(zod_mini.z.string()),
 	mcp: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), OpencodeMcpServerSchema)),
 	tools: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.boolean()))
 });
 /**
+* Tell the two transport arms from a toggle entry. Both carry a `type` literal
+* and a toggle never does — the schema refuses one that tries — but the toggle
+* arm is loose, so its index signature hides that from `in` narrowing.
+*/
+function isOpencodeTransportServer(server) {
+	return server.type === "local" || server.type === "remote";
+}
+/**
 * Convert OpenCode native format back to standard MCP format
 * - type: "local" -> "stdio", "remote" -> "sse"
 * - command (array) -> command (first element) + args (rest)
@@ -21349,19 +21887,31 @@ function convertFromOpencodeFormat(opencodeMcp, tools) {
 		...convertOpencodeServers(opencodeMcp, tools)
 	};
 }
+/** Split the shared top-level `tools` map into this server's own two lists. */
+function splitOpencodeServerTools(serverName, 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);
+	}
+	return {
+		enabledTools,
+		disabledTools
+	};
+}
 function convertOpencodeServers(opencodeMcp, tools) {
 	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 = [];
-		const disabledTools = [];
-		const prefix = `${serverName}_`;
-		if (tools) {
-			for (const [toolName, enabled] of Object.entries(tools)) if (toolName.startsWith(prefix)) {
-				const toolSuffix = toolName.slice(prefix.length);
-				if (enabled) enabledTools.push(toolSuffix);
-				else disabledTools.push(toolSuffix);
-			}
-		}
+		const { enabledTools, disabledTools } = splitOpencodeServerTools(serverName, tools);
+		if (!isOpencodeTransportServer(serverConfig)) return [serverName, {
+			...extraFields,
+			disabled: serverConfig.enabled === false,
+			...enabledTools.length > 0 && { enabledTools },
+			...disabledTools.length > 0 && { disabledTools }
+		}];
 		if (serverConfig.type === "remote") return [serverName, {
 			...extraFields,
 			type: "sse",
@@ -21391,7 +21941,20 @@ function convertOpencodeServers(opencodeMcp, tools) {
 		}];
 	}));
 }
-const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
+const OPENCODE_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
+	"disabled",
+	"enabledTools",
+	"disabledTools"
+]);
+/**
+* Warn about the fields a transport-less server loses by being written as a
+* bare toggle, so the drop is never silent.
+*/
+function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
+	const dropped = Object.keys(serverConfig).filter((key) => !OPENCODE_TOGGLE_KEPT_KEYS.has(key));
+	if (dropped.length === 0) return;
+	logger?.warn(`OpenCode MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
+}
 /**
 * Convert standard MCP format to OpenCode native format
 * - type: "stdio" -> "local", "sse"/"http" -> "remote"
@@ -21401,11 +21964,27 @@ const OPENCODE_PASSTHROUGH_SERVER_FIELDS = ["timeout", "oauth"];
 * - enabledTools/disabledTools -> top-level tools map (with server name prefix)
 * - OpenCode-supported extras (timeout, oauth) -> passed through verbatim
 */
-function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
+function convertServerToOpencodeFormat(serverName, serverConfig, existingEntry, logger) {
 	const serverRecord = serverConfig;
 	const passthrough = {};
 	for (const key of OPENCODE_PASSTHROUGH_SERVER_FIELDS) if (serverRecord[key] !== void 0) passthrough[key] = serverRecord[key];
 	const enabled = serverConfig.disabled !== void 0 ? !serverConfig.disabled : true;
+	if (declaresNoTransport(serverConfig)) {
+		if (serverConfig.disabled === void 0) {
+			if (existingEntry !== void 0 && !isOpencodeTransportServer(existingEntry)) {
+				warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+				return existingEntry;
+			}
+			return warnAndSkipMcpServer({
+				toolName: "OpenCode",
+				serverName,
+				reason: "no transport and no enabled state, so there is nothing to toggle",
+				logger
+			});
+		}
+		warnAboutToggleDroppedKeys(serverName, serverConfig, logger);
+		return { enabled };
+	}
 	if (isRemoteMcpServer(serverConfig)) {
 		const url = resolveRemoteMcpUrl(serverConfig);
 		if (url === void 0) return warnAndSkipMcpServer({
@@ -21426,7 +22005,7 @@ function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
 	if (commandArray.length === 0) return warnAndSkipMcpServer({
 		toolName: "OpenCode",
 		serverName,
-		reason: declaresNoTransport(serverConfig) ? "no transport at all" : "a local transport but no command",
+		reason: "a local transport but no command",
 		logger
 	});
 	return {
@@ -21438,11 +22017,11 @@ function convertServerToOpencodeFormat(serverName, serverConfig, logger) {
 		...serverConfig.cwd && { cwd: serverConfig.cwd }
 	};
 }
-function convertToOpencodeFormat(mcpServers, logger) {
+function convertToOpencodeFormat(mcpServers, existingMcp, logger) {
 	const tools = {};
 	return {
 		mcp: Object.fromEntries(Object.entries(mcpServers).map(([serverName, serverConfig]) => {
-			const converted = convertServerToOpencodeFormat(serverName, serverConfig, logger);
+			const converted = convertServerToOpencodeFormat(serverName, serverConfig, existingMcp[serverName], 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;
 			return converted === null ? null : [serverName, converted];
@@ -21512,10 +22091,12 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
-		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(convertEnvVarRefsToToolFormat({
+		const transformedServers = convertEnvVarRefsToToolFormat({
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
-		}), logger);
+		});
+		const existingMcp = OpencodeConfigSchema.safeParse((0, jsonc_parser.parse)(fileContent || "{}"));
+		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(transformedServers, (existingMcp.success ? existingMcp.data.mcp : void 0) ?? {}, logger);
 		return new OpencodeMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -23825,10 +24406,11 @@ function buildPermissionEntry$1(toolName, pattern) {
 * file (global scope only). The file holds other CLI settings besides
 * permissions, so it is never deleted.
 *
-* Two CLI-only autonomy/sandbox knobs outside the allow/ask/deny arrays —
-* `toolPermission` (the global autonomy preset) and `enableTerminalSandbox` — are
-* authored and round-tripped through the `antigravity-cli` permissions override
-* (see `AntigravityCliPermissionsOverrideSchema`).
+* Four CLI-only autonomy/sandbox knobs outside the allow/ask/deny arrays —
+* `toolPermission` (the global autonomy preset), `enableTerminalSandbox`,
+* `artifactReviewPolicy` and `allowNonWorkspaceAccess` — are authored and
+* round-tripped through the `antigravity-cli` permissions override (see
+* `AntigravityCliPermissionsOverrideSchema`).
 */
 var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPermissions {
 	constructor(params) {
@@ -23892,6 +24474,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 		const override = config["antigravity-cli"];
 		if (override?.toolPermission !== void 0) merged.toolPermission = override.toolPermission;
 		if (override?.enableTerminalSandbox !== void 0) merged.enableTerminalSandbox = override.enableTerminalSandbox;
+		if (override?.artifactReviewPolicy !== void 0) merged.artifactReviewPolicy = override.artifactReviewPolicy;
+		if (override?.allowNonWorkspaceAccess !== void 0) merged.allowNonWorkspaceAccess = override.allowNonWorkspaceAccess;
 		const fileContent = JSON.stringify(merged, null, 2);
 		return new AntigravityCliPermissions({
 			outputRoot,
@@ -23918,6 +24502,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 		const override = {};
 		if (typeof settings.toolPermission === "string") override.toolPermission = settings.toolPermission;
 		if (typeof settings.enableTerminalSandbox === "boolean") override.enableTerminalSandbox = settings.enableTerminalSandbox;
+		if (typeof settings.artifactReviewPolicy === "string") override.artifactReviewPolicy = settings.artifactReviewPolicy;
+		if (typeof settings.allowNonWorkspaceAccess === "boolean") override.allowNonWorkspaceAccess = settings.allowNonWorkspaceAccess;
 		const result = { ...config };
 		if (Object.keys(override).length > 0) result["antigravity-cli"] = override;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -24721,12 +25307,57 @@ function parseClaudePermissionEntry(entry) {
 	};
 }
 /**
+* Claude Code's file permission checks match only `Edit(path)` and `Read(path)`
+* rules. A `Write(path)`, `NotebookEdit(path)` or `Glob(path)` rule "is accepted
+* but never matched by those checks, so Claude Code warns at startup for each
+* allow, deny, or ask rule in one of these unmatched forms" — so a canonical
+* `write`/`notebookedit`/`glob` rule with a pattern is emitted in the form the
+* docs prescribe instead. A tool-name rule with no path is unaffected: it
+* matches the tool everywhere and produces no warning.
+* @see https://code.claude.com/docs/en/permissions
+*/
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Merge `patch` into `base`, recursing into plain objects so a sibling key at
+* any depth survives. Arrays and scalars are replaced, since a list the author
+* states is the list they mean.
+*/
+function deepMergeRecords(base, patch) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(patch)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+		const existing = merged[key];
+		merged[key] = isPlainRecord(existing) && isPlainRecord(value) ? deepMergeRecords(existing, value) : value;
+	}
+	return merged;
+}
+const CLAUDE_PATH_RULE_ALIASES = {
+	Write: "Edit",
+	NotebookEdit: "Edit",
+	Glob: "Read"
+};
+/**
 * Build a Claude Code permission entry like "Bash(npm run *)".
 * If the pattern is "*", returns just the tool name.
 */
 function buildClaudePermissionEntry(toolName, pattern) {
 	if (pattern === "*") return toolName;
-	return `${toolName}(${pattern})`;
+	return `${CLAUDE_PATH_RULE_ALIASES[toolName] ?? toolName}(${pattern})`;
+}
+/**
+* The Claude tool names the canonical config manages. Deliberately the tool
+* names the categories map to and *not* the aliases a path rule is rewritten
+* to: claiming `Edit` because a `write` rule exists would sweep away the
+* `Read`/`Edit` entries the ignore feature and the user wrote in the same file.
+* The rewritten entries are still rulesync's to place — `applyPermissions`
+* replaces an entry this run emits wherever it currently sits — and the
+* original name stays claimed so an entry an older rulesync wrote in the warned
+* form is cleaned up on the next generate.
+*/
+function managedClaudeToolNames(config) {
+	return new Set(Object.keys(config.permission).map((category) => toClaudeToolName(category)));
 }
 var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions {
 	constructor(params) {
@@ -24766,7 +25397,10 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 			throw new Error(`Failed to parse existing Claude settings at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
 		const config = rulesyncPermissions.getJson();
-		const { allow, ask, deny } = convertRulesyncToClaudePermissions(config);
+		const { allow, ask, deny } = convertRulesyncToClaudePermissions({
+			config,
+			logger
+		});
 		const overridePermissions = config.claudecode?.permissions;
 		if (overridePermissions && typeof overridePermissions === "object") {
 			const { allow: _a, ask: _k, deny: _d, ...nonListFields } = overridePermissions;
@@ -24775,7 +25409,9 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 				...nonListFields
 			};
 		}
-		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toClaudeToolName(category)));
+		const overrideSandbox = config.claudecode?.sandbox;
+		if (isPlainRecord(overrideSandbox)) settings.sandbox = deepMergeRecords(isPlainRecord(settings.sandbox) ? settings.sandbox : {}, overrideSandbox);
+		const managedToolNames = managedClaudeToolNames(config);
 		const merged = applyPermissions({
 			settings,
 			managedToolNames,
@@ -24809,6 +25445,11 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 		});
 		const { allow: _a, ask: _k, deny: _d, ...nonListFields } = permissions;
 		if (Object.keys(nonListFields).length > 0) config.claudecode = { permissions: nonListFields };
+		const { sandbox } = settings;
+		if (isPlainRecord(sandbox) && Object.keys(sandbox).length > 0) config.claudecode = {
+			...config.claudecode,
+			sandbox
+		};
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(config, null, 2) });
 	}
 	validate() {
@@ -24830,14 +25471,18 @@ var ClaudecodePermissions = class ClaudecodePermissions extends ToolPermissions
 /**
 * Convert rulesync permissions config to Claude Code allow/ask/deny arrays.
 */
-function convertRulesyncToClaudePermissions(config) {
+function convertRulesyncToClaudePermissions({ config, logger }) {
 	const allow = [];
 	const ask = [];
 	const deny = [];
+	const actionByEntry = /* @__PURE__ */ new Map();
 	for (const [category, rules] of Object.entries(config.permission)) {
 		const claudeToolName = toClaudeToolName(category);
 		for (const [pattern, action] of Object.entries(rules)) {
 			const entry = buildClaudePermissionEntry(claudeToolName, pattern);
+			const previous = actionByEntry.get(entry);
+			if (previous !== void 0 && previous !== action) logger?.warn(`Claude Code permissions: rules from different categories both resolve to "${entry}" with conflicting actions (${previous} and ${action}). Both are written; Claude Code applies deny first, then ask, then allow.`);
+			actionByEntry.set(entry, action);
 			switch (action) {
 				case "allow":
 					allow.push(entry);
@@ -25650,19 +26295,24 @@ function mapBashActionToDecision(action) {
 //#endregion
 //#region src/features/permissions/copilot-permissions.ts
 /**
-* The flat, dotted VS Code setting key this adapter manages. VS Code stores
-* settings with dotted keys flat at the document top level, so this is a single
-* literal key — not a nested `chat.tools.terminal` path.
+* The flat, dotted VS Code setting keys this adapter manages, one per canonical
+* permission category. VS Code stores settings with dotted keys flat at the
+* document top level, so each is a single literal key — not a nested
+* `chat.tools.terminal` path. All three share the same
+* pattern-to-boolean shape, so one conversion covers them.
+*
+* The canonical `read` and `write` categories stay unmapped: VS Code has no
+* read-approval surface, and folding `write` into the edits map alongside
+* `edit` would make the two indistinguishable on import.
+*
 * @see https://code.visualstudio.com/docs/agents/approvals
+* @see https://code.visualstudio.com/docs/copilot/chat/review-code-edits
 */
-const AUTO_APPROVE_KEY = "chat.tools.terminal.autoApprove";
-/**
-* The canonical permission category this adapter maps. Only shell/terminal
-* commands (`bash`) have a clean, high-fidelity representation in VS Code's
-* `chat.tools.terminal.autoApprove` map; other categories (read/edit/webfetch/
-* …) have no terminal-command equivalent and are intentionally not mapped.
-*/
-const TERMINAL_CATEGORY = "bash";
+const AUTO_APPROVE_KEYS = {
+	bash: "chat.tools.terminal.autoApprove",
+	edit: "chat.tools.edits.autoApprove",
+	webfetch: "chat.tools.urls.autoApprove"
+};
 function asAutoApproveMap(value) {
 	if (!isPlainObject$1(value)) return {};
 	const result = {};
@@ -25670,6 +26320,21 @@ function asAutoApproveMap(value) {
 	return result;
 }
 /**
+* Render one canonical category's rules as a VS Code auto-approve map. Returns
+* `undefined` when the category contributes nothing, so the key is retracted
+* rather than written as an empty object.
+*
+* The resulting map replaces the file's existing value wholesale — rulesync
+* owns these keys, so a rule dropped from the canonical config disappears from
+* the settings file too.
+*/
+function buildAutoApproveValue(rules) {
+	const autoApprove = {};
+	for (const [pattern, action] of Object.entries(rules)) if (action === "allow") autoApprove[pattern] = true;
+	else if (action === "deny") autoApprove[pattern] = false;
+	return Object.keys(autoApprove).length > 0 ? autoApprove : void 0;
+}
+/**
 * Permissions generator for GitHub Copilot Chat in VS Code.
 *
 * VS Code has no standalone, environment-agnostic Copilot policy file (like
@@ -25679,13 +26344,16 @@ function asAutoApproveMap(value) {
 * many unrelated keys, so reads and writes merge into the existing JSON
 * (touching only the one managed key) and the file is never deleted.
 *
-* Scope is deliberately limited to `chat.tools.terminal.autoApprove` — the one
-* clean, non-lossy mapping. The canonical `bash` category's per-pattern rules
-* map as: `allow` → `true` (auto-approve), `deny` → `false` (never approve),
-* and `ask` → the entry is OMITTED (VS Code then falls through to its default
-* in-chat approval prompt, i.e. "ask"). Only project scope is modeled: VS Code's
-* user-scope settings.json lives at a platform-dependent path outside rulesync's
-* home-relative global model.
+* Three canonical categories have a clean, non-lossy representation and are
+* mapped (see {@link AUTO_APPROVE_KEYS}): `bash`, `edit` and `webfetch`. In
+* every one, per-pattern rules map as: `allow` → `true` (auto-approve), `deny`
+* → `false` (VS Code then always prompts — note this is "never auto-approve",
+* not a hard block), and `ask` → the entry is OMITTED (VS Code falls through to
+* the same default prompt). A key whose canonical category is absent entirely
+* is left untouched, so authoring only `bash` rules never disturbs a
+* hand-written edits or urls map.
+* Only project scope is modeled: VS Code's user-scope settings.json lives at a
+* platform-dependent path outside rulesync's home-relative global model.
 */
 var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 	constructor(params) {
@@ -25722,11 +26390,13 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 		const paths = CopilotPermissions.getSettablePaths();
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
-		const rules = rulesyncPermissions.getJson().permission[TERMINAL_CATEGORY] ?? {};
-		const autoApprove = {};
-		for (const [pattern, action] of Object.entries(rules)) if (action === "allow") autoApprove[pattern] = true;
-		else if (action === "deny") autoApprove[pattern] = false;
-		const patchValue = Object.keys(autoApprove).length > 0 ? autoApprove : void 0;
+		const config = rulesyncPermissions.getJson();
+		const patch = {};
+		for (const [category, settingKey] of Object.entries(AUTO_APPROVE_KEYS)) {
+			const rules = config.permission[category];
+			if (rules === void 0) continue;
+			patch[settingKey] = buildAutoApproveValue(rules);
+		}
 		return new CopilotPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -25735,7 +26405,7 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "permissions",
 				existingContent,
-				patch: { [AUTO_APPROVE_KEY]: patchValue },
+				patch,
 				filePath
 			}),
 			validate: true
@@ -25754,10 +26424,13 @@ var CopilotPermissions = class CopilotPermissions extends ToolPermissions {
 		} catch (error) {
 			throw new Error(`Failed to parse Copilot VS Code settings in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
-		const autoApprove = asAutoApproveMap(settings[AUTO_APPROVE_KEY]);
-		const rules = {};
-		for (const [pattern, flag] of Object.entries(autoApprove)) rules[pattern] = flag ? "allow" : "deny";
-		const permission = Object.keys(rules).length > 0 ? { [TERMINAL_CATEGORY]: rules } : {};
+		const permission = {};
+		for (const [category, settingKey] of Object.entries(AUTO_APPROVE_KEYS)) {
+			const autoApprove = asAutoApproveMap(settings[settingKey]);
+			const rules = {};
+			for (const [pattern, flag] of Object.entries(autoApprove)) rules[pattern] = flag ? "allow" : "deny";
+			if (Object.keys(rules).length > 0) permission[category] = rules;
+		}
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
 	}
 	validate() {
@@ -31777,6 +32450,7 @@ const ClaudecodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	arguments: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
 	context: zod_mini.z.optional(zod_mini.z.string()),
 	agent: zod_mini.z.optional(zod_mini.z.string()),
+	background: zod_mini.z.optional(zod_mini.z.boolean()),
 	hooks: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	shell: zod_mini.z.optional(zod_mini.z.string()),
 	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
@@ -31803,6 +32477,7 @@ function buildClaudecodeSkillFrontmatter({ rulesyncFrontmatter, resolvedDisableM
 		shell: section.shell
 	};
 	const definedFields = {
+		background: section.background,
 		arguments: section.arguments,
 		hooks: section.hooks,
 		"disable-model-invocation": resolvedDisableModelInvocation,
@@ -31880,6 +32555,7 @@ var ClaudecodeSkill = class extends ToolSkill {
 			...frontmatter.arguments !== void 0 && { arguments: frontmatter.arguments },
 			...frontmatter.context && { context: frontmatter.context },
 			...frontmatter.agent && { agent: frontmatter.agent },
+			...frontmatter.background !== void 0 && { background: frontmatter.background },
 			...frontmatter.hooks !== void 0 && { hooks: frontmatter.hooks },
 			...frontmatter.shell && { shell: frontmatter.shell },
 			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
@@ -32489,7 +33165,9 @@ const CopilotcliSkillFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.string(),
 	license: zod_mini.z.optional(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())])),
-	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * Represents a GitHub Copilot CLI skill directory.
@@ -32548,7 +33226,9 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		const copilotcliSection = {
 			...frontmatter.license !== void 0 && { license: frontmatter.license },
 			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] },
-			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] }
+			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] },
+			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
+			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -32575,7 +33255,9 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			description: rulesyncFrontmatter.description,
 			...rulesyncFrontmatter.copilotcli?.license !== void 0 && { license: rulesyncFrontmatter.copilotcli.license },
 			...rulesyncFrontmatter.copilotcli?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilotcli["allowed-tools"] },
-			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] }
+			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] },
+			...rulesyncFrontmatter.copilotcli?.["user-invocable"] !== void 0 && { "user-invocable": rulesyncFrontmatter.copilotcli["user-invocable"] },
+			...rulesyncFrontmatter.copilotcli?.["disable-model-invocation"] !== void 0 && { "disable-model-invocation": rulesyncFrontmatter.copilotcli["disable-model-invocation"] }
 		};
 		return new CopilotcliSkill({
 			outputRoot,
@@ -34245,6 +34927,37 @@ var OpenCodeSkill = class OpenCodeSkill extends ToolSkill {
 			alternativeSkillRoots: [global ? OPENCODE_GLOBAL_SKILL_DIR_PATH : OPENCODE_SKILL_DIR_PATH]
 		};
 	}
+	/**
+	* Extra skill roots the project configured in `opencode.json` /
+	* `opencode.jsonc` via `skills.paths` ("Additional paths to skill folders").
+	* Without these, skills a project keeps outside `.opencode/skills/` are
+	* invisible to `rulesync import` even though OpenCode loads them.
+	*
+	* Import-only: rulesync keeps writing to its own managed root, so a
+	* configured path is read but never generated into. `skills.urls` is a
+	* remote-fetch surface and is out of scope for a file-based generator.
+	*
+	* Absolute paths and paths escaping the output root are dropped — an import
+	* root is joined onto `outputRoot`, and reaching outside it is not something
+	* a project config should be able to ask for.
+	*
+	* @see https://opencode.ai/config.json
+	*/
+	static async getConfiguredImportRoots({ outputRoot, global = false }) {
+		const skills = asOpencodeEntries((await readOpencodeConfig({
+			outputRoot,
+			global
+		})).skills);
+		if (skills === null || !Array.isArray(skills.paths)) return [];
+		const configDir = getOpencodeConfigDir({
+			outputRoot,
+			global
+		});
+		return skills.paths.filter((candidate) => typeof candidate === "string" && candidate !== "" && !(0, node_path.isAbsolute)(candidate) && !(0, node_path.normalize)(candidate).startsWith("..")).map((relativeDirPath) => ({
+			outputRoot: configDir,
+			relativeDirPath
+		}));
+	}
 	getFrontmatter() {
 		return OpenCodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
@@ -36178,12 +36891,19 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 	*/
 	async loadToolDirs() {
 		const factory = this.getFactory(this.toolTarget);
-		const roots = toolSkillImportRoots(factory.class.getSettablePaths({ global: this.global }));
+		const paths = factory.class.getSettablePaths({ global: this.global });
+		const configuredRoots = factory.class.getConfiguredImportRoots ? await factory.class.getConfiguredImportRoots({
+			outputRoot: this.outputRoot,
+			global: this.global
+		}) : [];
+		const configuredRootPaths = new Set(configuredRoots.map((root) => root.relativeDirPath));
+		const roots = [...toolSkillImportRoots(paths), ...configuredRoots];
 		const seenSkillNames = /* @__PURE__ */ new Set();
 		const toolSkills = [];
 		for (const root of roots) {
 			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
 			const relativeDirPath = typeof root === "string" ? root : root.relativeDirPath;
+			const isConfiguredRoot = configuredRootPaths.has(relativeDirPath);
 			const skillsDirPath = (0, node_path.join)(rootOutputRoot, relativeDirPath);
 			if (!await directoryExists(skillsDirPath)) continue;
 			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
@@ -36198,12 +36918,20 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 				})) continue;
 				ownedDirNames.push(dirName);
 			}
-			const directorySkills = await Promise.all(ownedDirNames.map((dirName) => factory.class.fromDir({
-				outputRoot: rootOutputRoot,
-				relativeDirPath,
-				dirName,
-				global: this.global
-			})));
+			const directorySkills = (await Promise.all(ownedDirNames.map(async (dirName) => {
+				try {
+					return await factory.class.fromDir({
+						outputRoot: rootOutputRoot,
+						relativeDirPath,
+						dirName,
+						global: this.global
+					});
+				} catch (error) {
+					if (!isConfiguredRoot) throw error;
+					this.logger.warn(`Skipping ${(0, node_path.join)(relativeDirPath, dirName)}: ${formatError(error)}`);
+					return null;
+				}
+			}))).filter((skill) => skill !== null);
 			for (const skill of directorySkills) {
 				const skillName = skill.getImportIdentity();
 				if (seenSkillNames.has(skillName)) continue;
@@ -36728,6 +37456,242 @@ var RovodevSubagent = class RovodevSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/antigravity-shared-subagent.ts
+/**
+* Frontmatter of an Antigravity custom agent (Markdown format, CLI v1.1.6+).
+*
+* `name` and `description` are required upstream; the rest are optional and
+* documented with defaults (`tools: []`, `mainAgent: true`, `subagent: true`,
+* `model: inherit`, `commandExecutionPolicy: sandbox`, `mcpServers: []`,
+* `skills`/`plugins`: `[]`). `hidden` and `inheritMcp` appear in the v1.1.6
+* release notes but not in the documented frontmatter table, so they are
+* accepted as verbatim passthrough without any behavior modeled around them.
+* `looseObject` keeps unknown future fields round-tripping.
+*
+* @see https://antigravity.google/docs/subagents
+*/
+const AntigravitySubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string().check(zod_mini.z.minLength(1)),
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	mainAgent: zod_mini.z.optional(zod_mini.z.boolean()),
+	subagent: zod_mini.z.optional(zod_mini.z.boolean()),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	commandExecutionPolicy: zod_mini.z.optional(zod_mini.z.string()),
+	mcpServers: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.unknown())),
+	skills: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	plugins: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	hidden: zod_mini.z.optional(zod_mini.z.boolean()),
+	inheritMcp: zod_mini.z.optional(zod_mini.z.boolean())
+});
+/**
+* Shared custom-agent (subagent) implementation for Google Antigravity 2.0,
+* used by the IDE, the CLI and plugin bundles.
+*
+* Antigravity discovers agents at `.agents/agents/<name>.md` (project) and
+* `~/.gemini/config/agents/<name>.md` (global, shared by the IDE and the CLI
+* exactly like `~/.gemini/config/hooks.json`). The directory form
+* (`<name>/agent.md`) is an equivalent alternative upstream; rulesync emits and
+* imports the flat file form. The body after the frontmatter is the agent's
+* system prompt.
+*
+* Concrete subclasses only supply the rulesync target name they answer to via
+* {@link AntigravitySharedSubagent.getToolTarget} and, where the shared file is
+* not involved, the sections they read via
+* {@link AntigravitySharedSubagent.getReadSectionKeys}.
+*
+* @see https://antigravity.google/docs/subagents
+*/
+var AntigravitySharedSubagent = class extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = AntigravitySubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true })
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	/** The rulesync target name this subagent answers to. */
+	static getToolTarget() {
+		throw new Error("Please implement this method in the subclass.");
+	}
+	/**
+	* Tool-specific sections this target reads, in increasing precedence order.
+	*
+	* `antigravity-ide` and `antigravity-cli` write the very same file, so a
+	* target that read only its own section would silently drop the other's keys
+	* — and which one survived would depend on `--targets` order. Every target
+	* therefore merges the shared `antigravity-ide` → `antigravity-cli` sections
+	* (the CLI block wins, matching the fixed order the MCP feature already uses
+	* for the same shared-output reason), and the plugin target layers its own
+	* section on top of that. Only `getToolTarget()` decides which section an
+	* import writes back into.
+	*/
+	static getReadSectionKeys() {
+		return ["antigravity-ide", "antigravity-cli"];
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { relativeDirPath: global ? ANTIGRAVITY_GLOBAL_AGENTS_DIR_PATH : ANTIGRAVITY_AGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, ...restFields } = this.frontmatter;
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name,
+				description,
+				...Object.keys(restFields).length > 0 && { [this.constructor.getToolTarget()]: restFields }
+			},
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const mergedSection = Object.assign({}, ...this.getReadSectionKeys().map((key) => rulesyncFrontmatter[key] ?? {}));
+		const toolSection = this.filterToolSpecificSection(mergedSection, ["name", "description"]);
+		const rawFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description || `${rulesyncFrontmatter.name} subagent`,
+			...toolSection
+		};
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(rawFrontmatter);
+		if (!result.success) throw new Error(`Invalid ${this.getToolTarget()} subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
+		const frontmatter = result.data;
+		const body = rulesyncSubagent.getBody();
+		const paths = this.getSettablePaths({ global });
+		return new this({
+			outputRoot,
+			frontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent: stringifyFrontmatter(body, frontmatter, { avoidBlockScalars: true }),
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: this.getToolTarget()
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const result = AntigravitySubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new this({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new this({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-cli-subagent.ts
+/**
+* Google Antigravity CLI custom agent (subagent), shipped in CLI v1.1.6.
+*
+* Shares all behavior with {@link AntigravitySharedSubagent}; the CLI reads the
+* same `.agents/agents/` and `~/.gemini/config/agents/` roots as the IDE and
+* exposes them through the `agy agents` subcommand and the `--agent` flag. It
+* answers to the `antigravity-cli` target.
+*/
+var AntigravityCliSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-cli";
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-ide-subagent.ts
+/**
+* Google Antigravity IDE custom agent (subagent).
+*
+* Shares all behavior with {@link AntigravitySharedSubagent} — the subagents
+* documentation is product-wide and lists the same `.agents/agents/` and
+* `~/.gemini/config/agents/` roots for the IDE and the CLI. It answers to the
+* `antigravity-ide` target.
+*/
+var AntigravityIdeSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-ide";
+	}
+};
+//#endregion
+//#region src/features/subagents/antigravity-plugin-subagent.ts
+/**
+* Custom agent inside an Antigravity plugin bundle
+* (`<plugin_name>/agents/<name>.md`). Plugin bundles are project-scope output
+* only; they are staged into `~/.gemini/antigravity-cli/plugins/` by the user.
+*
+* @see https://antigravity.google/docs/cli/plugins
+*/
+var AntigravityPluginSubagent = class extends AntigravitySharedSubagent {
+	static getToolTarget() {
+		return "antigravity-plugin";
+	}
+	static getReadSectionKeys() {
+		return [...super.getReadSectionKeys(), "antigravity-plugin"];
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: ANTIGRAVITY_PLUGIN_AGENTS_DIR };
+	}
+};
+//#endregion
 //#region src/features/subagents/augmentcode-subagent.ts
 const AugmentcodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -40305,6 +41269,30 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["antigravity-cli", {
+		class: AntigravityCliSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
+	["antigravity-ide", {
+		class: AntigravityIdeSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
+	["antigravity-plugin", {
+		class: AntigravityPluginSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: false,
+			filePattern: "*.md"
+		}
+	}],
 	["augmentcode", {
 		class: AugmentcodeSubagent,
 		meta: {
@@ -42518,6 +43506,7 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 const CopilotRuleFrontmatterSchema = zod_mini.z.object({
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	applyTo: zod_mini.z.optional(zod_mini.z.string()),
+	name: zod_mini.z.optional(zod_mini.z.string()),
 	excludeAgent: zod_mini.z.optional(zod_mini.z.union([
 		zod_mini.z.literal("code-review"),
 		zod_mini.z.literal("cloud-agent"),
@@ -42575,7 +43564,10 @@ var CopilotRule = class CopilotRule extends ToolRule {
 			root: this.isRoot(),
 			description: this.frontmatter.description,
 			globs,
-			...this.frontmatter.excludeAgent && { copilot: { excludeAgent: this.frontmatter.excludeAgent } }
+			...(this.frontmatter.excludeAgent || this.frontmatter.name) && { copilot: {
+				...this.frontmatter.excludeAgent && { excludeAgent: this.frontmatter.excludeAgent },
+				...this.frontmatter.name && { name: this.frontmatter.name }
+			} }
 		};
 		const relativeFilePath = this.getRelativeFilePath().replace(/\.instructions\.md$/, ".md");
 		return new RulesyncRule({
@@ -42594,7 +43586,8 @@ var CopilotRule = class CopilotRule extends ToolRule {
 		const copilotFrontmatter = {
 			description: rulesyncFrontmatter.description,
 			applyTo: rulesyncFrontmatter.globs?.length ? rulesyncFrontmatter.globs.join(",") : void 0,
-			excludeAgent: rulesyncFrontmatter.copilot?.excludeAgent
+			excludeAgent: rulesyncFrontmatter.copilot?.excludeAgent,
+			name: rulesyncFrontmatter.copilot?.name
 		};
 		const body = rulesyncRule.getBody();
 		if (root) return new CopilotRule({