rulesync 16.30.2 → 16.31.0

package/dist/{import-auwKp4Mm.cjs → import-Cwe8RKJs.cjs}

@@ -444,34 +444,36 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$310 } = node_path.posix;
+const { join: join$332 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
+const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
+const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$310(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$332(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$310(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$310(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$332(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$332(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$332(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$310(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$310(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -495,6 +497,7 @@ const rulesProcessorToolTargetTuple = [
 	"antigravity-plugin",
 	"augmentcode",
 	"augmentcode-legacy",
+	"bob",
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
@@ -502,6 +505,7 @@ const rulesProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"crush",
 	"cursor",
 	"deepagents",
@@ -523,6 +527,7 @@ const rulesProcessorToolTargetTuple = [
 	"replit",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -537,6 +542,7 @@ const ignoreProcessorToolTargetTuple = [
 	"aiassistant",
 	"antigravity-cli",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
@@ -551,6 +557,7 @@ const ignoreProcessorToolTargetTuple = [
 	"qwencode",
 	"reasonix",
 	"roo",
+	"tabnine",
 	"devin",
 	"vibe",
 	"warp",
@@ -564,6 +571,7 @@ const mcpProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"antigravity-plugin",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -571,6 +579,7 @@ const mcpProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"cursor",
 	"deepagents",
 	"factorydroid",
@@ -589,6 +598,7 @@ const mcpProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -602,6 +612,7 @@ const commandsProcessorToolTargetTuple = [
 	"antigravity-cli",
 	"antigravity-ide",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -625,6 +636,7 @@ const commandsProcessorToolTargetTuple = [
 	"roo",
 	"zoocode",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"devin",
 	"warp",
@@ -644,6 +656,7 @@ const subagentsProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"cursor",
 	"deepagents",
 	"devin",
@@ -662,6 +675,7 @@ const subagentsProcessorToolTargetTuple = [
 	"roo",
 	"zoocode",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"zcode"
@@ -675,6 +689,7 @@ const skillsProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"antigravity-plugin",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -682,6 +697,7 @@ const skillsProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"crush",
 	"cursor",
 	"deepagents",
@@ -703,6 +719,7 @@ const skillsProcessorToolTargetTuple = [
 	"replit",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -725,6 +742,7 @@ const hooksProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"opencode",
 	"pi",
 	"factorydroid",
@@ -737,10 +755,12 @@ const hooksProcessorToolTargetTuple = [
 	"kiro-ide",
 	"devin",
 	"augmentcode",
+	"bob",
 	"junie",
 	"vibe",
 	"qwencode",
 	"reasonix",
+	"tabnine",
 	"grokcli",
 	"zcode"
 ];
@@ -773,6 +793,7 @@ const permissionsProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -3258,16 +3279,21 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".amp/settings.json",
 	".amp/settings.jsonc",
 	".antigravity/settings.json",
+	".bob/settings.json",
+	".bob/settings/settings.json",
 	".claude/settings.json",
 	".claude/settings.local.json",
 	".codex/config.toml",
 	".copilot/settings.json",
 	".github/copilot/settings.json",
+	".cortex/settings.json",
+	".snowflake/cortex/hooks.json",
 	".devin/config.json",
 	".factory/settings.json",
 	".grok/config.toml",
 	".rovodev/config.yml",
 	".rovodev/mcp.json",
+	".tabnine/agent/settings.json",
 	".vibe/config.toml",
 	".zcode/config.json",
 	".zcode/cli/config.json",
@@ -4778,6 +4804,110 @@ const CANONICAL_TO_ZCODE_EVENT_NAMES = {
 };
 const ZCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_ZCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
 /**
+* Hook events supported by IBM Bob's lifecycle hooks.
+*
+* Bob reads `hooks` from `.bob/settings.json` (project) and
+* `~/.bob/settings/settings.json` (user) in the Claude-Code shape and fires
+* five events: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse and
+* Stop. Only `command` hooks exist, and `matcher` (a regex over the tool
+* name) applies to the two tool events.
+*
+* @see https://bob.ibm.com/docs/ide/configuration/lifecycle-hooks
+*/
+const BOB_HOOK_EVENTS = [
+	"sessionStart",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"stop"
+];
+const CANONICAL_TO_BOB_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	stop: "Stop"
+};
+const BOB_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_BOB_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
+* Hook events supported by Tabnine CLI.
+*
+* Tabnine CLI reads `hooks` from `.tabnine/agent/settings.json` (project) and
+* `~/.tabnine/agent/settings.json` (user) and fires eleven events with
+* PascalCase names. Only `command` hooks exist; `matcher` is a regex over the
+* tool name for the two tool events and an exact string for the lifecycle
+* events, and `timeout` is expressed in milliseconds.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/hooks
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/hooks/configuration
+*/
+const TABNINE_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"beforeSubmitPrompt",
+	"stop",
+	"preModelInvocation",
+	"postModelInvocation",
+	"beforeToolSelection",
+	"preToolUse",
+	"postToolUse",
+	"preCompact",
+	"notification"
+];
+const CANONICAL_TO_TABNINE_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	beforeSubmitPrompt: "BeforeAgent",
+	stop: "AfterAgent",
+	preModelInvocation: "BeforeModel",
+	postModelInvocation: "AfterModel",
+	beforeToolSelection: "BeforeToolSelection",
+	preToolUse: "BeforeTool",
+	postToolUse: "AfterTool",
+	preCompact: "PreCompress",
+	notification: "Notification"
+};
+const TABNINE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_TABNINE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
+* Hook events supported by Snowflake Cortex Code.
+*
+* Cortex Code reads `hooks` from `.cortex/settings.json` (project) and
+* `~/.snowflake/cortex/hooks.json` (user) in the Claude-Code-shaped layout:
+* PascalCase event names, a regex `matcher` over the tool name, and `command`
+* or `prompt` hooks with a `timeout` in seconds and an optional `enabled`
+* flag. `$CORTEX_PROJECT_DIR` resolves to the project root inside commands.
+*
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/settings
+*/
+const CORTEXCODE_HOOK_EVENTS = [
+	"preToolUse",
+	"postToolUse",
+	"permissionRequest",
+	"beforeSubmitPrompt",
+	"sessionStart",
+	"sessionEnd",
+	"preCompact",
+	"stop",
+	"subagentStop",
+	"notification",
+	"setup"
+];
+const CANONICAL_TO_CORTEXCODE_EVENT_NAMES = {
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	permissionRequest: "PermissionRequest",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	preCompact: "PreCompact",
+	stop: "Stop",
+	subagentStop: "SubagentStop",
+	notification: "Notification",
+	setup: "Setup"
+};
+const CORTEXCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CORTEXCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
 *
 * Hermes validates hook events against a fixed `VALID_HOOKS` set — 37 entries as
@@ -4930,6 +5060,9 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	"kimi-code": zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	zcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	bob: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	tabnine: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
 		disableAllHooks: zod_mini.z.optional(zod_mini.z.boolean())
@@ -5931,6 +6064,7 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	"antigravity-ide": zod_mini.z.optional(toolScopedMcpSchema),
 	aiassistant: zod_mini.z.optional(toolScopedMcpSchema),
 	augmentcode: zod_mini.z.optional(toolScopedMcpSchema),
+	bob: zod_mini.z.optional(toolScopedMcpSchema),
 	claudecode: zod_mini.z.optional(toolScopedMcpSchema),
 	cline: zod_mini.z.optional(toolScopedMcpSchema),
 	codexcli: zod_mini.z.optional(toolScopedMcpSchema),
@@ -5952,6 +6086,8 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	reasonix: zod_mini.z.optional(toolScopedMcpSchema),
 	roo: zod_mini.z.optional(toolScopedMcpSchema),
 	rovodev: zod_mini.z.optional(toolScopedMcpSchema),
+	cortexcode: zod_mini.z.optional(toolScopedMcpSchema),
+	tabnine: zod_mini.z.optional(toolScopedMcpSchema),
 	takt: zod_mini.z.optional(toolScopedMcpSchema),
 	vibe: zod_mini.z.optional(toolScopedMcpSchema),
 	warp: zod_mini.z.optional(toolScopedMcpSchema),
@@ -6773,6 +6909,27 @@ const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
 	autoMode: zod_mini.z.optional(zod_mini.z.looseObject({}))
 });
 /**
+* Tool-scoped override block for Tabnine CLI. The canonical `permission` block
+* drives only the `tools.allowed` / `tools.exclude` lists of
+* `.tabnine/agent/settings.json`; the other `tools.*` keys (`core`,
+* `enableCoaching`, `useRipgrep`, `shell.*`, `enableWebTools`, ...) and the
+* `general.defaultApprovalMode` switch have no canonical category, so they are
+* authored here, deep-merged into the settings file, and emitted only for
+* Tabnine. Import lifts the entries rulesync cannot map back onto a canonical
+* category into this block so a regenerate does not drop them. Kept
+* `looseObject` (verbatim passthrough). Both project and global scope are
+* supported.
+*
+* @example
+* { "tools": { "core": ["read_file", "run_shell_command(git)"] },
+*   "general": { "defaultApprovalMode": "plan" } }
+*/
+const TabninePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	tools: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	general: zod_mini.z.optional(zod_mini.z.looseObject({}))
+});
+/**
 * Tool-scoped override block for Reasonix. Reasonix has security axes orthogonal
 * to per-tool allow/ask/deny with no canonical category — the `[sandbox]`
 * enforcement table (`workspace_root`, `allow_write`, `forbid_read`, `bash`,
@@ -7533,6 +7690,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	factorydroid: zod_mini.z.optional(FactorydroidPermissionsOverrideSchema),
 	warp: zod_mini.z.optional(WarpPermissionsOverrideSchema),
 	junie: zod_mini.z.optional(JuniePermissionsOverrideSchema),
+	tabnine: zod_mini.z.optional(TabninePermissionsOverrideSchema),
 	takt: zod_mini.z.optional(TaktPermissionsOverrideSchema),
 	amp: zod_mini.z.optional(AmpPermissionsOverrideSchema),
 	"antigravity-cli": zod_mini.z.optional(AntigravityCliPermissionsOverrideSchema),
@@ -9180,6 +9338,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	})),
 	cline: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	roo: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	bob: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	amp: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	devin: zod_mini.z.optional(zod_mini.z.looseObject({
 		"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
@@ -9257,6 +9416,8 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 	})),
+	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	tabnine: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	takt: zod_mini.z.optional(zod_mini.z.looseObject({
 		name: zod_mini.z.optional(zod_mini.z.string()),
 		extends: zod_mini.z.optional(zod_mini.z.string())
@@ -12819,6 +12980,53 @@ const SHARED_CONFIG_OWNERSHIP = {
 	},
 	".zcode/config.json": ZCODE_WORKSPACE_CONFIG_DECLARATION,
 	".zcode/cli/config.json": ZCODE_USER_CONFIG_DECLARATION,
+	".bob/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
+	".bob/settings/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
+	".cortex/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
+	".snowflake/cortex/hooks.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
+	".tabnine/agent/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcpServers"]
+			},
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: { kind: "deep-merge" }
+		}
+	},
 	".kiro/agents/default.json": {
 		format: "json",
 		features: {
@@ -14511,6 +14719,140 @@ var AugmentcodeCommand = class AugmentcodeCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/bob-paths.ts
+const BOB_DIR = ".bob";
+const BOB_RULE_FILE_NAME = "AGENTS.md";
+(0, node_path.join)(BOB_DIR, "rules");
+const BOB_IGNORE_FILE_NAME = ".bobignore";
+const BOB_MCP_FILE_NAME = "mcp.json";
+const BOB_COMMANDS_DIR_PATH = (0, node_path.join)(BOB_DIR, "commands");
+const BOB_SKILLS_DIR_PATH = (0, node_path.join)(BOB_DIR, "skills");
+const BOB_SETTINGS_FILE_NAME = "settings.json";
+const BOB_GLOBAL_SETTINGS_DIR_PATH = (0, node_path.join)(BOB_DIR, "settings");
+//#endregion
+//#region src/features/commands/bob-command.ts
+/**
+* IBM Bob slash commands are Markdown files under `<project>/.bob/commands/`
+* (project scope) and `~/.bob/commands/` (user scope), invoked from the chat
+* input with `/`. The file name is the command name; the optional
+* `description` / `argument-hint` frontmatter keys are the same ones the
+* Claude-Code-lineage tools use, and the body is the prompt Bob runs.
+*
+* @see https://bob.ibm.com/docs/ide/features/slash-commands
+* @see https://bob.ibm.com/docs/shell/features/slash-commands
+*/
+const BobCommandFrontmatterSchema = zod_mini.z.looseObject({
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
+});
+var BobCommand = class BobCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = BobCommandFrontmatterSchema.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: stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: BOB_COMMANDS_DIR_PATH };
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	toRulesyncCommand() {
+		const { description, ...restFields } = this.frontmatter;
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description,
+			...Object.keys(restFields).length > 0 && { bob: restFields }
+		};
+		const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent,
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const bobFields = rulesyncFrontmatter.bob ?? {};
+		const bobFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			...bobFields
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
+		return new BobCommand({
+			outputRoot,
+			frontmatter: bobFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = BobCommandFrontmatterSchema.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 isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "bob"
+		});
+	}
+	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 { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = BobCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new BobCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new BobCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/commands/claudecode-command.ts
 const ClaudecodeCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
@@ -18237,6 +18579,193 @@ var RovodevPromptsManifest = class extends ToolFile {
 	}
 };
 //#endregion
+//#region src/constants/tabnine-paths.ts
+const TABNINE_DIR = ".tabnine";
+const TABNINE_AGENT_DIR_PATH = (0, node_path.join)(TABNINE_DIR, "agent");
+const TABNINE_RULE_FILE_NAME = "TABNINE.md";
+(0, node_path.join)(TABNINE_DIR, "guidelines");
+const TABNINE_IGNORE_FILE_NAME = ".tabnineignore";
+const TABNINE_SETTINGS_FILE_NAME = "settings.json";
+const TABNINE_COMMANDS_DIR_PATH = (0, node_path.join)(TABNINE_AGENT_DIR_PATH, "commands");
+const TABNINE_AGENTS_DIR_PATH = (0, node_path.join)(TABNINE_AGENT_DIR_PATH, "agents");
+const TABNINE_SKILLS_DIR_PATH = (0, node_path.join)(TABNINE_AGENT_DIR_PATH, "skills");
+//#endregion
+//#region src/features/commands/tabnine-command.ts
+const TabnineCommandFrontmatterSchema = zod_mini.z.looseObject({
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	prompt: zod_mini.z.string()
+});
+/**
+* Translate rulesync universal command syntax (Claude Code compatible) into
+* Tabnine CLI's native syntax. See docs/reference/command-syntax.md. Tabnine
+* CLI is a Gemini CLI derivative and documents the same placeholders:
+* `{{args}}` for the user's arguments and `!{cmd}` for shell injection. Its
+* `@{path}` file-injection form has no universal counterpart and passes
+* through untouched in both directions.
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/commands
+*
+* Replacement order:
+*   1. `` !`cmd` `` → `!{cmd}`  (backtick shell expansion → brace form)
+*   2. `$ARGUMENTS` → `{{args}}` (handled after step 1 so that
+*      `` !`echo $ARGUMENTS` `` survives as `!{echo {{args}}}` rather than
+*      requiring two passes).
+*
+* `$ARGUMENTS\b` uses a trailing word boundary so `$ARGUMENTSx` and
+* `$ARGUMENTS_FOO` are left alone, while `$ARGUMENTS-foo` (hyphen is not a
+* word char) is rewritten. There is no leading anchor, so `prefix$ARGUMENTS`
+* is rewritten to `prefix{{args}}`.
+*
+* Bodies that already contain Tabnine-native forms (`{{args}}` or `!{cmd}`)
+* are left untouched, which gives us the documented "we do not re-translate
+* already-Tabnine-native forms" property.
+*/
+function translateRulesyncBodyToTabnine(body) {
+	return body.replace(/!`([^`\n]+)`/g, "!{$1}").replace(/\$ARGUMENTS\b/g, "{{args}}");
+}
+/**
+* Inverse of {@link translateRulesyncBodyToTabnine}, used when importing a
+* Tabnine CLI command file back into rulesync's universal syntax.
+*
+* Replacement order is intentionally inverted from the forward direction:
+*   1. `{{args}}` → `$ARGUMENTS` (handled first)
+*   2. `!{cmd}` → `` !`cmd` `` (handled second, with a non-greedy body
+*      `[^}\n]+?`)
+*
+* Doing `{{args}}` first ensures that nested forms like
+* `!{echo {{args}}}` round-trip back to `` !`echo $ARGUMENTS` `` in a single
+* pass: the inner `{{args}}` is rewritten to `$ARGUMENTS`, and then the
+* non-greedy `!{...}` match consumes the smallest possible body.
+*/
+function translateTabnineBodyToRulesync(body) {
+	return body.replace(/\{\{\s*args\s*\}\}/g, "$ARGUMENTS").replace(/!\{([^}\n]+?)\}/g, "!`$1`");
+}
+/**
+* Tabnine CLI custom slash commands: TOML files with `description` and
+* `prompt` under `<project>/.tabnine/agent/commands/` (project) and
+* `~/.tabnine/agent/commands/` (user). The relative path names the command:
+* `review.toml` → `/review`, `code/review.toml` → `/code:review`.
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/commands
+*/
+var TabnineCommand = class TabnineCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor(params) {
+		super(params);
+		const parsed = this.parseTomlContent(this.fileContent);
+		this.frontmatter = parsed;
+		this.body = parsed.prompt;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: TABNINE_COMMANDS_DIR_PATH };
+	}
+	parseTomlContent(content) {
+		try {
+			const parsed = (0, smol_toml.parse)(content);
+			const result = TabnineCommandFrontmatterSchema.safeParse(parsed);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`);
+			return {
+				...result.data,
+				description: result.data.description
+			};
+		} catch (error) {
+			throw new Error(`Failed to parse TOML command file (${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}): ${formatError(error)}`, { cause: error });
+		}
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return {
+			description: this.frontmatter.description,
+			prompt: this.frontmatter.prompt
+		};
+	}
+	toRulesyncCommand() {
+		const { description, prompt: _prompt, ...restFields } = this.frontmatter;
+		const rulesyncFrontmatter = {
+			targets: ["tabnine"],
+			description,
+			...Object.keys(restFields).length > 0 && { tabnine: restFields }
+		};
+		const universalBody = translateTabnineBodyToRulesync(this.body);
+		const fileContent = stringifyFrontmatter(universalBody, rulesyncFrontmatter);
+		return new RulesyncCommand({
+			outputRoot: process.cwd(),
+			frontmatter: rulesyncFrontmatter,
+			body: universalBody,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath.replace(/\.toml$/, ".md"),
+			fileContent,
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const tabnineFields = rulesyncFrontmatter.tabnine ?? {};
+		const translatedPrompt = typeof tabnineFields.prompt === "string" ? "" : translateRulesyncBodyToTabnine(rulesyncCommand.getBody());
+		const tabnineFrontmatter = {
+			description: rulesyncFrontmatter.description,
+			prompt: translatedPrompt,
+			...tabnineFields
+		};
+		const tomlObject = {};
+		if (tabnineFrontmatter.description !== void 0) tomlObject.description = tabnineFrontmatter.description;
+		tomlObject.prompt = tabnineFrontmatter.prompt.endsWith("\n") ? tabnineFrontmatter.prompt : `${tabnineFrontmatter.prompt}\n`;
+		const { description: _description, prompt: _prompt, ...extraFields } = tabnineFrontmatter;
+		for (const [key, value] of Object.entries(omitPrototypePollutionKeys(extraFields))) if (value !== void 0) tomlObject[key] = value;
+		const tomlContent = (0, smol_toml.stringify)(tomlObject);
+		const paths = this.getSettablePaths({ global });
+		return new TabnineCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath().replace(/\.md$/, ".toml"),
+			fileContent: tomlContent,
+			validate
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath));
+		return new TabnineCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	validate() {
+		try {
+			this.parseTomlContent(this.fileContent);
+			return {
+				success: true,
+				error: null
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "tabnine"
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new TabnineCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: `description = ""
+prompt = ""`,
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/takt-shared.ts
 /**
 * Shared utilities for all TAKT-* tool file classes.
@@ -18708,6 +19237,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			matchAdditionalImportsByBasename: true
 		}
 	}],
+	["bob", {
+		class: BobCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeCommand,
 		meta: {
@@ -18939,6 +19478,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["tabnine", {
+		class: TabnineCommand,
+		meta: {
+			extension: "toml",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["takt", {
 		class: TaktCommand,
 		meta: {
@@ -20978,6 +21527,135 @@ var AugmentcodeHooks = class AugmentcodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/bob-hooks.ts
+const BOB_CONVERTER_CONFIG = {
+	supportedEvents: BOB_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_BOB_EVENT_NAMES,
+	toolToCanonicalEventNames: BOB_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"sessionStart",
+		"beforeSubmitPrompt",
+		"stop"
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	wildcardMatcherMeansAll: true
+};
+/**
+* Single spelling of the settings.json codec/policy: fail closed on an
+* unparseable root rather than replacing the user's Bob settings with
+* generated output.
+*/
+function parseBobSettings(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* IBM Bob lifecycle hooks.
+*
+* Hooks live under the top-level `hooks` key of Bob's settings file —
+* `<project>/.bob/settings.json` (project scope) and
+* `~/.bob/settings/settings.json` (user scope) — in the Claude-Code shape:
+* `{ "<Event>": [{ "matcher"?: "<regex>", "hooks": [{ "type": "command",
+* "command": "...", "timeout"?: <seconds> }] }] }`. The file also holds
+* settings rulesync does not own, so generation merges the `hooks` key into it
+* (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting the file.
+*
+* @see https://bob.ibm.com/docs/ide/configuration/lifecycle-hooks
+*/
+var BobHooks = class BobHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: global ? BOB_GLOBAL_SETTINGS_DIR_PATH : BOB_DIR,
+			relativeFilePath: BOB_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = BobHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new BobHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = BobHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+		const config = rulesyncHooks.getJson();
+		const hooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.bob?.hooks,
+			converterConfig: BOB_CONVERTER_CONFIG,
+			logger
+		});
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks },
+			filePath,
+			logger
+		});
+		return new BobHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks({ logger } = {}) {
+		const configPath = (0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath());
+		let settings;
+		try {
+			settings = parseBobSettings(this.getFileContent(), configPath);
+		} catch (error) {
+			throw new Error(`Failed to parse Bob hooks content in ${configPath}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			logger,
+			hooks: settings.hooks,
+			converterConfig: BOB_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "bob"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new BobHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/preserve-unowned-hook-commands.ts
 /**
 * Read the `hooks` value from a destination JSON file.
@@ -22543,6 +23221,151 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/constants/cortexcode-paths.ts
+const CORTEXCODE_DIR = ".cortex";
+const CORTEXCODE_GLOBAL_DIR_PATH = (0, node_path.join)(".snowflake", "cortex");
+const CORTEXCODE_RULE_FILE_NAME = "AGENTS.md";
+const CORTEXCODE_SETTINGS_FILE_NAME = "settings.json";
+const CORTEXCODE_GLOBAL_HOOKS_FILE_NAME = "hooks.json";
+const CORTEXCODE_MCP_FILE_NAME = "mcp.json";
+const CORTEXCODE_AGENTS_DIR_PATH = (0, node_path.join)(CORTEXCODE_DIR, "agents");
+const CORTEXCODE_GLOBAL_AGENTS_DIR_PATH = (0, node_path.join)(CORTEXCODE_GLOBAL_DIR_PATH, "agents");
+const CORTEXCODE_SKILLS_DIR_PATH = (0, node_path.join)(CORTEXCODE_DIR, "skills");
+const CORTEXCODE_GLOBAL_SKILLS_DIR_PATH = (0, node_path.join)(CORTEXCODE_GLOBAL_DIR_PATH, "skills");
+//#endregion
+//#region src/features/hooks/cortexcode-hooks.ts
+const CORTEXCODE_CONVERTER_CONFIG = {
+	supportedEvents: CORTEXCODE_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_CORTEXCODE_EVENT_NAMES,
+	toolToCanonicalEventNames: CORTEXCODE_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "$CORTEX_PROJECT_DIR",
+	prefixDotRelativeCommandsOnly: true,
+	noMatcherEvents: /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command", "prompt"]),
+	booleanPassthroughFields: [{
+		canonical: "enabled",
+		tool: "enabled"
+	}]
+};
+/**
+* Single spelling of the settings/hooks codec/policy: fail closed on an
+* unparseable root rather than replacing the user's Cortex Code settings with
+* generated output.
+*/
+function parseCortexcodeSettings(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Snowflake Cortex Code hooks.
+*
+* Hooks live under the top-level `hooks` key of `<project>/.cortex/settings.json`
+* (project scope) and of the dedicated `~/.snowflake/cortex/hooks.json` (user
+* scope), both in the Claude-Code shape: `{ "<Event>": [{ "matcher"?:
+* "<regex>", "hooks": [{ "type": "command" | "prompt", ..., "timeout"?:
+* <seconds>, "enabled"?: <boolean> }] }] }`. The project file also holds
+* settings rulesync does not own, so generation merges the `hooks` key into
+* either file (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting it.
+*
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/settings
+*/
+var CortexcodeHooks = class CortexcodeHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return global ? {
+			relativeDirPath: CORTEXCODE_GLOBAL_DIR_PATH,
+			relativeFilePath: CORTEXCODE_GLOBAL_HOOKS_FILE_NAME
+		} : {
+			relativeDirPath: CORTEXCODE_DIR,
+			relativeFilePath: CORTEXCODE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = CortexcodeHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new CortexcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = CortexcodeHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+		const config = rulesyncHooks.getJson();
+		const hooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.cortexcode?.hooks,
+			converterConfig: CORTEXCODE_CONVERTER_CONFIG,
+			logger
+		});
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks },
+			filePath,
+			logger
+		});
+		return new CortexcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks({ logger } = {}) {
+		const configPath = (0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath());
+		let settings;
+		try {
+			settings = parseCortexcodeSettings(this.getFileContent(), configPath);
+		} catch (error) {
+			throw new Error(`Failed to parse Cortex Code hooks content in ${configPath}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			logger,
+			hooks: settings.hooks,
+			converterConfig: CORTEXCODE_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "cortexcode"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CortexcodeHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/cursor-hooks.ts
 var CursorHooks = class CursorHooks extends ToolHooks {
 	constructor(params) {
@@ -25770,6 +26593,270 @@ var ReasonixHooks = class ReasonixHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/tabnine-hooks.ts
+/**
+* Environment block safe to hand Tabnine for a hook. A tool rebuilds each
+* entry into `KEY=VALUE` for the spawned process, so a key holding `=`, a
+* control character or nothing at all names a different variable than it
+* appears to; such entries are dropped in both directions (with a warning on
+* export, where the value came from an authored `.rulesync/hooks.*`).
+*/
+function sanitizeEnv({ env, warn }) {
+	if (env === null || env === void 0 || typeof env !== "object" || Array.isArray(env)) return;
+	const result = {};
+	for (const [key, value] of Object.entries(env)) {
+		const unsafeKey = key === "" || key.includes("=") || CONTROL_CHARS.some((char) => key.includes(char));
+		const unsafeValue = typeof value !== "string" || CONTROL_CHARS.some((char) => value.includes(char));
+		if (unsafeKey || unsafeValue) {
+			warn?.(`Tabnine CLI hook env entry ${JSON.stringify(key)} is not a safe KEY=VALUE pair; skipping it.`);
+			continue;
+		}
+		result[key] = value;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Build one Tabnine hook configuration from a canonical command definition.
+* Canonical `timeout` is seconds (docs/reference/file-formats.md); Tabnine's is
+* milliseconds.
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/hooks/configuration
+*/
+function canonicalDefToTabnineHook({ def, warn }) {
+	return {
+		type: "command",
+		...compact({
+			command: def.command,
+			name: def.name,
+			description: def.description,
+			timeout: typeof def.timeout === "number" && Number.isFinite(def.timeout) ? Math.round(def.timeout * 1e3) : void 0,
+			env: sanitizeEnv({
+				env: def.env,
+				warn
+			})
+		})
+	};
+}
+/**
+* Convert the canonical hooks config to Tabnine's `hooks` map: PascalCase
+* event names, matcher groups with an optional `sequential` flag, and
+* command-only hook entries. Tabnine treats an omitted `matcher` as match-all
+* and compiles tool-event matchers as regular expressions, so the canonical
+* catch-all `"*"` (not a valid regex) is emitted as no matcher. Commands are
+* passed through verbatim; Tabnine expands `$TABNINE_PROJECT_DIR` itself.
+*/
+function canonicalToTabnineHooks({ config, logger }) {
+	const warn = (message) => logger?.warn(message);
+	const supported = new Set(TABNINE_HOOK_EVENTS);
+	const sharedHooks = {};
+	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) sharedHooks[event] = defs;
+	const effectiveHooks = {
+		...sharedHooks,
+		...config.tabnine?.hooks
+	};
+	const tabnine = {};
+	for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
+		const tabnineEventName = lookupOwn({
+			record: CANONICAL_TO_TABNINE_EVENT_NAMES,
+			key: eventName
+		}) ?? eventName;
+		const byMatcher = /* @__PURE__ */ new Map();
+		for (const def of definitions) {
+			if ((def.type ?? "command") !== "command") continue;
+			if (typeof def.command !== "string" || def.command === "") {
+				warn(`Tabnine CLI hook on '${eventName}' has no 'command'; Tabnine would discard it, so it is skipped.`);
+				continue;
+			}
+			const key = def.matcher === void 0 || def.matcher === "*" ? "" : def.matcher;
+			const list = byMatcher.get(key);
+			if (list) list.push(def);
+			else byMatcher.set(key, [def]);
+		}
+		const entries = [];
+		for (const [matcherKey, defs] of byMatcher) {
+			const hooks = defs.map((def) => canonicalDefToTabnineHook({
+				def,
+				warn
+			}));
+			const sequential = defs.some((def) => def.sequential === true);
+			const group = matcherKey ? {
+				matcher: matcherKey,
+				hooks
+			} : { hooks };
+			if (sequential) group.sequential = true;
+			entries.push(group);
+		}
+		if (entries.length > 0) tabnine[tabnineEventName] = entries;
+	}
+	return tabnine;
+}
+/**
+* Tabnine hook configuration as stored in each matcher group's `hooks` array.
+* `z.looseObject` keeps fields added by future Tabnine releases.
+*/
+const TabnineHookEntrySchema = zod_mini.z.looseObject({
+	type: zod_mini.z.optional(zod_mini.z.string()),
+	command: zod_mini.z.optional(zod_mini.z.string()),
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	timeout: zod_mini.z.optional(zod_mini.z.number()),
+	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string()))
+});
+const TabnineMatcherEntrySchema = zod_mini.z.looseObject({
+	matcher: zod_mini.z.optional(zod_mini.z.string()),
+	sequential: zod_mini.z.optional(zod_mini.z.boolean()),
+	hooks: zod_mini.z.optional(zod_mini.z.array(TabnineHookEntrySchema))
+});
+function tabnineMatcherEntryToCanonical(entry) {
+	const sequential = entry.sequential === true;
+	const matcher = entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" ? entry.matcher : void 0;
+	const defs = [];
+	for (const hook of entry.hooks ?? []) {
+		if (hook.type !== "command" || typeof hook.command !== "string" || hook.command === "") continue;
+		defs.push({
+			type: "command",
+			...compact({
+				command: hook.command,
+				name: hook.name,
+				description: hook.description,
+				timeout: typeof hook.timeout === "number" && Number.isFinite(hook.timeout) ? hook.timeout / 1e3 : void 0,
+				env: sanitizeEnv({ env: hook.env }),
+				sequential: sequential ? true : void 0,
+				matcher
+			})
+		});
+	}
+	return defs;
+}
+/**
+* Extract the `hooks` map of a Tabnine settings file into canonical form.
+*/
+function tabnineHooksToCanonical(tabnineHooks) {
+	if (tabnineHooks === null || tabnineHooks === void 0 || typeof tabnineHooks !== "object") return {};
+	const canonical = {};
+	for (const [tabnineEventName, matcherEntries] of Object.entries(tabnineHooks)) {
+		const eventName = lookupOwn({
+			record: TABNINE_TO_CANONICAL_EVENT_NAMES,
+			key: tabnineEventName
+		}) ?? tabnineEventName;
+		if (!Array.isArray(matcherEntries)) continue;
+		const defs = [];
+		for (const rawEntry of matcherEntries) {
+			const parseResult = TabnineMatcherEntrySchema.safeParse(rawEntry);
+			if (!parseResult.success) continue;
+			defs.push(...tabnineMatcherEntryToCanonical(parseResult.data));
+		}
+		if (defs.length > 0) canonical[eventName] = defs;
+	}
+	return canonical;
+}
+/**
+* Fail closed on an unparseable settings root rather than replacing the
+* user's Tabnine settings with generated output.
+*/
+function parseTabnineSettings(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Tabnine CLI hooks.
+*
+* Hooks live under the top-level `hooks` key of Tabnine's settings file —
+* `<project>/.tabnine/agent/settings.json` (project scope) and
+* `~/.tabnine/agent/settings.json` (user scope). The file also carries
+* `mcpServers`, `tools` and other user-managed settings, so generation merges
+* the `hooks` key into it (see `SHARED_CONFIG_OWNERSHIP`) instead of
+* overwriting the file. The sibling `hooksConfig` block (master toggle,
+* disabled list, notifications) is left to the user.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/hooks
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/hooks/configuration
+*/
+var TabnineHooks = class TabnineHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: TABNINE_AGENT_DIR_PATH,
+			relativeFilePath: TABNINE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = TabnineHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new TabnineHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = TabnineHooks.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+		const hooks = canonicalToTabnineHooks({
+			config: rulesyncHooks.getJson(),
+			logger
+		});
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks },
+			filePath,
+			logger
+		});
+		return new TabnineHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		const configPath = (0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath());
+		let settings;
+		try {
+			settings = parseTabnineSettings(this.getFileContent(), configPath);
+		} catch (error) {
+			throw new Error(`Failed to parse Tabnine CLI hooks content in ${configPath}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = tabnineHooksToCanonical(settings.hooks);
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "tabnine"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new TabnineHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/vibe-hooks.ts
 const VIBE_DIR = ".vibe";
 const VIBE_HOOKS_FILE_NAME = "hooks.toml";
@@ -26529,6 +27616,40 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["bob", {
+		class: BobHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: BOB_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true,
+		matcherEvents: ["preToolUse", "postToolUse"]
+	}],
+	["cortexcode", {
+		class: CortexcodeHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: CORTEXCODE_HOOK_EVENTS,
+		supportedHookTypes: ["command", "prompt"],
+		supportsMatcher: true,
+		matcherEvents: [
+			"preToolUse",
+			"postToolUse",
+			"permissionRequest",
+			"sessionStart",
+			"sessionEnd",
+			"preCompact",
+			"subagentStop",
+			"notification",
+			"setup"
+		]
+	}],
 	["junie", {
 		class: JunieHooks,
 		meta: {
@@ -26540,6 +27661,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["tabnine", {
+		class: TabnineHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: TABNINE_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
+	}],
 	["vibe", {
 		class: VibeHooks,
 		meta: {
@@ -26986,6 +28118,58 @@ var AugmentcodeIgnore = class AugmentcodeIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/ignore/bob-ignore.ts
+/**
+* BobIgnore represents the `.bobignore` file of IBM Bob.
+*
+* - File location: workspace root only (`.bobignore`); no user-scope variant
+*   is documented, so the feature is project-only.
+* - Syntax: the same as `.gitignore`.
+* - Matching files are hidden from Bob's file reads and listings.
+*
+* @see https://bob.ibm.com/docs/ide/configuration/bobignore
+*/
+var BobIgnore = class BobIgnore extends ToolIgnore {
+	static getSettablePaths() {
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: BOB_IGNORE_FILE_NAME
+		};
+	}
+	toRulesyncIgnore() {
+		return this.toRulesyncIgnoreDefault();
+	}
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore }) {
+		const paths = this.getSettablePaths();
+		return new BobIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent()
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
+		const paths = this.getSettablePaths();
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
+		return new BobIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new BobIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/claudecode-ignore.ts
 const DEFAULT_FILE_MODE = "shared";
 /**
@@ -28015,6 +29199,60 @@ var RooIgnore = class RooIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/ignore/tabnine-ignore.ts
+/**
+* TabnineIgnore represents the `.tabnineignore` file of Tabnine CLI.
+*
+* - File location: project root only (`.tabnineignore`); no user-scope
+*   variant is documented, so the feature is project-only.
+* - Syntax: the same as `.gitignore`.
+* - Matching files are excluded from the CLI's file searches and directory
+*   listings while `context.fileFiltering.respectGeminiIgnore` (the default)
+*   is enabled.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/settings/settings-reference
+*/
+var TabnineIgnore = class TabnineIgnore extends ToolIgnore {
+	static getSettablePaths() {
+		return {
+			relativeDirPath: ".",
+			relativeFilePath: TABNINE_IGNORE_FILE_NAME
+		};
+	}
+	toRulesyncIgnore() {
+		return this.toRulesyncIgnoreDefault();
+	}
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore }) {
+		const paths = this.getSettablePaths();
+		return new TabnineIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent()
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
+		const paths = this.getSettablePaths();
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
+		return new TabnineIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new TabnineIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/ignore/vibe-ignore.ts
 var VibeIgnore = class VibeIgnore extends ToolIgnore {
 	static getSettablePaths() {
@@ -28220,6 +29458,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["aiassistant", { class: AiassistantIgnore }],
 	["antigravity-cli", { class: AntigravityCliIgnore }],
 	["augmentcode", { class: AugmentcodeIgnore }],
+	["bob", { class: BobIgnore }],
 	["claudecode", { class: ClaudecodeIgnore }],
 	["claudecode-legacy", { class: ClaudecodeIgnore }],
 	["cline", { class: ClineIgnore }],
@@ -28236,6 +29475,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["roo", { class: RooIgnore }],
 	["zoocode", { class: RooIgnore }],
 	["devin", { class: DevinIgnore }],
+	["tabnine", { class: TabnineIgnore }],
 	["vibe", { class: VibeIgnore }],
 	["warp", { class: WarpIgnore }],
 	["zed", { class: ZedIgnore }]
@@ -28970,6 +30210,343 @@ var AugmentcodeMcp = class AugmentcodeMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/mcp-transport.ts
+/**
+* A server that names no way to be reached at all. It is what a Kilo bare
+* `{"enabled": <bool>}` entry imports as — a switch for a server another config
+* layer defines, which only Kilo's config spells this way. Every other tool's
+* config defines the servers it lists, so there the entry has no equivalent and
+* must be skipped rather than written as a server with an empty command.
+*/
+function declaresNoTransport(serverConfig) {
+	return serverConfig.type === void 0 && serverConfig.transport === void 0 && serverConfig.command === void 0 && serverConfig.url === void 0 && serverConfig.httpUrl === void 0;
+}
+const REMOTE_TRANSPORTS = /* @__PURE__ */ new Set([
+	"sse",
+	"http",
+	"streamable-http",
+	"ws"
+]);
+/**
+* Whether the server speaks over the network rather than over a spawned
+* process. `httpUrl`, the Claude-specific alias several adapters accept, counts
+* as much as `url` does, and so does `transport`, the alias `type` has
+* everywhere in the canonical config.
+*/
+function isRemoteMcpServer(serverConfig) {
+	return REMOTE_TRANSPORTS.has(serverConfig.type ?? "") || REMOTE_TRANSPORTS.has(serverConfig.transport ?? "") || serverConfig.url !== void 0 || serverConfig.httpUrl !== void 0;
+}
+/** The URL a remote server is reached at, or `undefined` if it states none. */
+function resolveRemoteMcpUrl(serverConfig) {
+	return serverConfig.url || serverConfig.httpUrl || void 0;
+}
+/** The `command` array a `local` server is spawned with, `args` merged in. */
+function resolveLocalMcpCommand(serverConfig) {
+	const commandArray = [];
+	if (serverConfig.command) {
+		if (Array.isArray(serverConfig.command)) commandArray.push(...serverConfig.command);
+		else commandArray.push(serverConfig.command);
+	}
+	if (serverConfig.args) commandArray.push(...serverConfig.args);
+	return commandArray;
+}
+/**
+* A server that names a transport but carries nothing to reach it — a `type`
+* with no `command`, an `http` with no `url` — has no form in a config that
+* spells the transport out. Writing `{type: "local", command: []}` for it would
+* give the tool a server it cannot start and the importer a file it cannot read
+* back, so it is skipped out loud instead.
+*/
+function warnAndSkipMcpServer({ toolName, serverName, reason, logger }) {
+	logger?.warn(`${toolName} MCP: skipping "${serverName}" because it declares ${reason}.`);
+	return null;
+}
+/**
+* The `tools` map Kilo and OpenCode keep beside `mcp` is keyed `<server>_<tool>`
+* and reaches servers `mcp` does not list — ones the global config or a
+* marketplace defines — so entries naming no listed
+* server are filters that would be dropped by a walk over `mcp` alone, and
+* deleted from the file on the next generate. They come back as transport-less
+* servers carrying nothing but the filters.
+*
+* The split is at the first `_`, which is where the write side joined them. A
+* server whose own name contains one is reconstructed under a shorter name, but
+* the key it is written back as is character-for-character the one that was
+* read, so Kilo sees exactly what it saw before.
+*/
+function orphanMcpToolFiltersToRulesync(servers, tools) {
+	const orphans = {};
+	for (const [toolName, enabled] of Object.entries(tools ?? {})) {
+		if (Object.keys(servers).some((serverName) => toolName.startsWith(`${serverName}_`))) continue;
+		const separator = toolName.indexOf("_");
+		if (separator <= 0 || separator === toolName.length - 1) continue;
+		const serverName = toolName.slice(0, separator);
+		const toolSuffix = toolName.slice(separator + 1);
+		if (!Object.hasOwn(orphans, serverName)) orphans[serverName] = {};
+		const server = orphans[serverName];
+		if (enabled) server.enabledTools = [...server.enabledTools ?? [], toolSuffix];
+		else server.disabledTools = [...server.disabledTools ?? [], toolSuffix];
+	}
+	return orphans;
+}
+/**
+* Split imported servers into the ones every tool can use and the ones only the
+* importing tool can. A server with no transport is a Kilo/OpenCode idea — a
+* switch for a server another config layer defines, or a filter for one — and
+* nothing else knows what to do with it: written to `.mcp.json` and the rest,
+* it is an entry no tool can start. It goes into the tool-scoped
+* `{tool}.mcpServers` block instead, which only that tool reads.
+*/
+function splitMcpServersByTransport(servers) {
+	const shared = {};
+	const toolOnly = {};
+	for (const [serverName, serverConfig] of Object.entries(servers)) if (declaresNoTransport(serverConfig)) toolOnly[serverName] = serverConfig;
+	else shared[serverName] = serverConfig;
+	return {
+		shared,
+		toolOnly
+	};
+}
+//#endregion
+//#region src/features/mcp/bob-mcp.ts
+/**
+* Parse a Bob MCP file, failing closed on malformed JSON or a non-object root
+* (`null`, an array, a scalar) rather than spreading whatever came back into
+* the regenerated file.
+*/
+function parseBobMcpConfig({ fileContent, relativePath }) {
+	let parsed;
+	try {
+		parsed = JSON.parse(fileContent);
+	} catch (error) {
+		throw new Error(`Failed to parse Bob MCP config at ${relativePath}: ${formatError(error)}`, { cause: error });
+	}
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Bob MCP config at ${relativePath}: expected a JSON object at the root`);
+	return parsed;
+}
+/** The `type` Bob IDE writes for a streamable HTTP server. */
+const BOB_STREAMABLE_HTTP_TYPE = "streamable-http";
+/**
+* The remote transport Bob IDE reads a server as, spelled the way it writes
+* it: `streamable-http` needs an explicit `type`, while SSE (legacy) is a bare
+* `url` with no `type`. `http` is the canonical rulesync alias for streamable
+* HTTP and a bare `url` defaults to it, streamable HTTP being the current MCP
+* transport. A `ws(s)://` URL or any other stated transport is something Bob
+* cannot reach, so `undefined` tells the caller to skip the server.
+* @see https://bob.ibm.com/docs/ide/configuration/mcp/mcp-in-bob
+*/
+function asBobRemoteType(stated, url) {
+	if (stated === "sse") return "sse";
+	if (stated === "http" || stated === BOB_STREAMABLE_HTTP_TYPE) return BOB_STREAMABLE_HTTP_TYPE;
+	if (stated === void 0) return /^wss?:\/\//i.test(url) ? void 0 : BOB_STREAMABLE_HTTP_TYPE;
+}
+/**
+* Convert the canonical server map to the shape Bob IDE documents for
+* `.bob/mcp.json`: a stdio server carries `command` (plus `args`), a
+* streamable HTTP server carries `type: "streamable-http"` and `url`, and an
+* SSE server carries a bare `url`. The canonical `transport` alias and the
+* Claude-style `httpUrl` alias are folded into `type`/`url`; `env`, `cwd`,
+* `headers`, `timeout`, `alwaysAllow` and `disabled` pass through unchanged,
+* as Bob documents all of them.
+*
+* Bob Shell documents the same file with an `httpURL` key instead of
+* `type` + `url` for streamable HTTP. rulesync writes the IDE spelling (the two
+* products share the project file, and the IDE is the one whose global file
+* rulesync targets) and accepts the Shell spelling on import.
+*
+* A server Bob cannot start or reach — no transport at all, a remote transport
+* without a URL, a WebSocket URL, or a stdio entry without a command — is
+* skipped with a warning rather than written in a broken form.
+* @see https://bob.ibm.com/docs/ide/configuration/mcp/mcp-in-bob
+* @see https://bob.ibm.com/docs/shell/configuration/mcp/mcp-bobshell
+*/
+function convertToBobFormat(mcpServers, logger) {
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		if (declaresNoTransport(serverConfig)) {
+			warnAndSkipMcpServer({
+				toolName: "Bob",
+				serverName,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const { type, transport, url: _url, httpUrl: _httpUrl, command: _command, args: _args, ...rest } = serverConfig;
+		const converted = {};
+		if (isRemoteMcpServer(serverConfig)) {
+			const url = resolveRemoteMcpUrl(serverConfig);
+			if (!url) {
+				warnAndSkipMcpServer({
+					toolName: "Bob",
+					serverName,
+					reason: "a remote transport without a url",
+					logger
+				});
+				continue;
+			}
+			const stated = type ?? transport;
+			const remoteType = asBobRemoteType(stated, url);
+			if (remoteType === void 0) {
+				warnAndSkipMcpServer({
+					toolName: "Bob",
+					serverName,
+					reason: stated === void 0 ? "a WebSocket url, which Bob's remote transports (streamable-http and sse) cannot reach" : `the "${stated}" transport, which Bob does not offer for remote servers (only streamable-http and sse)`,
+					logger
+				});
+				continue;
+			}
+			if (remoteType === BOB_STREAMABLE_HTTP_TYPE) converted.type = BOB_STREAMABLE_HTTP_TYPE;
+			converted.url = url;
+		} else {
+			const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+			if (!command) {
+				warnAndSkipMcpServer({
+					toolName: "Bob",
+					serverName,
+					reason: "a stdio transport without a command",
+					logger
+				});
+				continue;
+			}
+			converted.command = command;
+			if (args.length > 0) converted.args = args;
+		}
+		for (const [key, value] of Object.entries(rest)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			converted[key] = (key === "env" || key === "headers") && isRecord$1(value) ? omitPrototypePollutionKeys(value) : value;
+		}
+		result[serverName] = converted;
+	}
+	return result;
+}
+/**
+* Convert Bob's server map back to the canonical shape. The IDE spelling
+* (`type: "streamable-http"` + `url`) is already canonical and passes through;
+* the Bob Shell spelling `httpURL` becomes `url` with `type: "http"`; a bare
+* `url` is an SSE server in Bob, so it gains `type: "sse"` to keep that reading
+* on the next generate.
+*/
+function convertFromBobFormat(mcpServers) {
+	if (!isMcpServers(mcpServers)) return {};
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		const converted = {};
+		let httpURL;
+		for (const [key, value] of Object.entries(serverConfig)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			if (key === "httpURL") {
+				if (typeof value === "string") httpURL = value;
+				continue;
+			}
+			converted[key] = value;
+		}
+		if (httpURL !== void 0) {
+			converted.url = httpURL;
+			converted.type = "http";
+		} else if (typeof converted.url === "string" && converted.type === void 0) converted.type = "sse";
+		result[serverName] = converted;
+	}
+	return result;
+}
+/**
+* IBM Bob MCP configuration.
+*
+* Bob IDE reads `mcpServers` from `<project>/.bob/mcp.json` (project scope)
+* and `~/.bob/mcp.json` (user scope); the project entry wins when both define
+* the same server name. Both files are dedicated to MCP. The project one is
+* deletable; the user one is created and edited by Bob IDE's own MCP settings
+* UI, so `--delete` leaves it in place rather than removing a file the user
+* did not create through rulesync. (Bob Shell reads its user-scoped servers
+* from `~/.bob/mcp_settings.json` instead, which rulesync does not write.)
+*
+* @see https://bob.ibm.com/docs/ide/configuration/mcp/mcp-in-bob
+* @see https://bob.ibm.com/docs/shell/configuration/mcp/mcp-bobshell
+*/
+var BobMcp = class BobMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = this.fileContent === void 0 ? {} : parseBobMcpConfig({
+			fileContent: this.fileContent,
+			relativePath: (0, node_path.join)(this.relativeDirPath, this.relativeFilePath)
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	isDeletable() {
+		return !this.global;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: BOB_DIR,
+			relativeFilePath: BOB_MCP_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const json = parseBobMcpConfig({
+			fileContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const newJson = {
+			...json,
+			mcpServers: json.mcpServers ?? {}
+		};
+		return new BobMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(newJson, null, 2),
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const json = parseBobMcpConfig({
+			fileContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2),
+			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const mcpServers = convertToBobFormat(rulesyncMcp.getMcpServers(), logger);
+		const bobConfig = {
+			...json,
+			mcpServers
+		};
+		return new BobMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(bobConfig, null, 2),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromBobFormat(this.json.mcpServers);
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new BobMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/claudecode-mcp.ts
 var ClaudecodeMcp = class ClaudecodeMcp extends ToolMcp {
 	json;
@@ -29677,104 +31254,6 @@ var CopilotMcp = class CopilotMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/features/mcp/mcp-transport.ts
-/**
-* A server that names no way to be reached at all. It is what a Kilo bare
-* `{"enabled": <bool>}` entry imports as — a switch for a server another config
-* layer defines, which only Kilo's config spells this way. Every other tool's
-* config defines the servers it lists, so there the entry has no equivalent and
-* must be skipped rather than written as a server with an empty command.
-*/
-function declaresNoTransport(serverConfig) {
-	return serverConfig.type === void 0 && serverConfig.transport === void 0 && serverConfig.command === void 0 && serverConfig.url === void 0 && serverConfig.httpUrl === void 0;
-}
-const REMOTE_TRANSPORTS = /* @__PURE__ */ new Set([
-	"sse",
-	"http",
-	"streamable-http",
-	"ws"
-]);
-/**
-* Whether the server speaks over the network rather than over a spawned
-* process. `httpUrl`, the Claude-specific alias several adapters accept, counts
-* as much as `url` does, and so does `transport`, the alias `type` has
-* everywhere in the canonical config.
-*/
-function isRemoteMcpServer(serverConfig) {
-	return REMOTE_TRANSPORTS.has(serverConfig.type ?? "") || REMOTE_TRANSPORTS.has(serverConfig.transport ?? "") || serverConfig.url !== void 0 || serverConfig.httpUrl !== void 0;
-}
-/** The URL a remote server is reached at, or `undefined` if it states none. */
-function resolveRemoteMcpUrl(serverConfig) {
-	return serverConfig.url || serverConfig.httpUrl || void 0;
-}
-/** The `command` array a `local` server is spawned with, `args` merged in. */
-function resolveLocalMcpCommand(serverConfig) {
-	const commandArray = [];
-	if (serverConfig.command) {
-		if (Array.isArray(serverConfig.command)) commandArray.push(...serverConfig.command);
-		else commandArray.push(serverConfig.command);
-	}
-	if (serverConfig.args) commandArray.push(...serverConfig.args);
-	return commandArray;
-}
-/**
-* A server that names a transport but carries nothing to reach it — a `type`
-* with no `command`, an `http` with no `url` — has no form in a config that
-* spells the transport out. Writing `{type: "local", command: []}` for it would
-* give the tool a server it cannot start and the importer a file it cannot read
-* back, so it is skipped out loud instead.
-*/
-function warnAndSkipMcpServer({ toolName, serverName, reason, logger }) {
-	logger?.warn(`${toolName} MCP: skipping "${serverName}" because it declares ${reason}.`);
-	return null;
-}
-/**
-* The `tools` map Kilo and OpenCode keep beside `mcp` is keyed `<server>_<tool>`
-* and reaches servers `mcp` does not list — ones the global config or a
-* marketplace defines — so entries naming no listed
-* server are filters that would be dropped by a walk over `mcp` alone, and
-* deleted from the file on the next generate. They come back as transport-less
-* servers carrying nothing but the filters.
-*
-* The split is at the first `_`, which is where the write side joined them. A
-* server whose own name contains one is reconstructed under a shorter name, but
-* the key it is written back as is character-for-character the one that was
-* read, so Kilo sees exactly what it saw before.
-*/
-function orphanMcpToolFiltersToRulesync(servers, tools) {
-	const orphans = {};
-	for (const [toolName, enabled] of Object.entries(tools ?? {})) {
-		if (Object.keys(servers).some((serverName) => toolName.startsWith(`${serverName}_`))) continue;
-		const separator = toolName.indexOf("_");
-		if (separator <= 0 || separator === toolName.length - 1) continue;
-		const serverName = toolName.slice(0, separator);
-		const toolSuffix = toolName.slice(separator + 1);
-		if (!Object.hasOwn(orphans, serverName)) orphans[serverName] = {};
-		const server = orphans[serverName];
-		if (enabled) server.enabledTools = [...server.enabledTools ?? [], toolSuffix];
-		else server.disabledTools = [...server.disabledTools ?? [], toolSuffix];
-	}
-	return orphans;
-}
-/**
-* Split imported servers into the ones every tool can use and the ones only the
-* importing tool can. A server with no transport is a Kilo/OpenCode idea — a
-* switch for a server another config layer defines, or a filter for one — and
-* nothing else knows what to do with it: written to `.mcp.json` and the rest,
-* it is an entry no tool can start. It goes into the tool-scoped
-* `{tool}.mcpServers` block instead, which only that tool reads.
-*/
-function splitMcpServersByTransport(servers) {
-	const shared = {};
-	const toolOnly = {};
-	for (const [serverName, serverConfig] of Object.entries(servers)) if (declaresNoTransport(serverConfig)) toolOnly[serverName] = serverConfig;
-	else shared[serverName] = serverConfig;
-	return {
-		shared,
-		toolOnly
-	};
-}
-//#endregion
 //#region src/features/mcp/copilotcli-mcp.ts
 /**
 * Reached over WebSocket, which Copilot CLI has no transport for. The url is
@@ -30043,6 +31522,222 @@ var CopilotcliMcp = class CopilotcliMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/cortexcode-mcp.ts
+const CORTEXCODE_GLOBAL_ONLY_MESSAGE = "Snowflake Cortex Code MCP is global-only; use --global to sync ~/.snowflake/cortex/mcp.json";
+/**
+* Parse a Cortex Code MCP file, failing closed on malformed JSON or a
+* non-object root (`null`, an array, a scalar) rather than spreading whatever
+* came back into the regenerated file.
+*/
+function parseCortexcodeMcpConfig({ fileContent, relativePath }) {
+	let parsed;
+	try {
+		parsed = JSON.parse(fileContent);
+	} catch (error) {
+		throw new Error(`Failed to parse Cortex Code MCP config at ${relativePath}: ${formatError(error)}`, { cause: error });
+	}
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Cortex Code MCP config at ${relativePath}: expected a JSON object at the root`);
+	return parsed;
+}
+/**
+* The remote transport Cortex Code reads a server as. Cortex Code documents
+* exactly three transports — `stdio`, `http` and `sse` — each spelled out in
+* an explicit `type` key. `http` is also the canonical rulesync spelling, and
+* a bare `url` defaults to it, streamable HTTP being the current MCP
+* transport. `streamable-http` is folded into `http`. A `ws(s)://` URL or any
+* other stated transport is something Cortex Code cannot reach, so
+* `undefined` tells the caller to skip the server.
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility#transport-types
+*/
+function asCortexcodeRemoteType(stated, url) {
+	if (stated === "sse") return "sse";
+	if (stated === "http" || stated === "streamable-http") return "http";
+	if (stated === void 0) return /^wss?:\/\//i.test(url) ? void 0 : "http";
+}
+/**
+* Convert the canonical server map to the shape Cortex Code documents for
+* `~/.snowflake/cortex/mcp.json`: every server carries an explicit `type`
+* (`stdio`, `http` or `sse`); a stdio server carries `command` (plus `args`)
+* and a remote server carries `url`. The canonical `transport` alias and the
+* Claude-style `httpUrl` alias are folded into `type`/`url`; `env`, `headers`,
+* `oauth` and `timeout` pass through, as Cortex Code documents all of them.
+*
+* A server Cortex Code cannot start or reach — no transport at all, a remote
+* transport without a URL, a WebSocket URL, or a stdio entry without a
+* command — is skipped with a warning rather than written in a broken form.
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility#mcp-configuration
+*/
+function convertToCortexcodeFormat(mcpServers, logger) {
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		if (declaresNoTransport(serverConfig)) {
+			warnAndSkipMcpServer({
+				toolName: "Cortex Code",
+				serverName,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const { type, transport, url: _url, httpUrl: _httpUrl, command: _command, args: _args, ...rest } = serverConfig;
+		const converted = {};
+		if (isRemoteMcpServer(serverConfig)) {
+			const url = resolveRemoteMcpUrl(serverConfig);
+			if (!url) {
+				warnAndSkipMcpServer({
+					toolName: "Cortex Code",
+					serverName,
+					reason: "a remote transport without a url",
+					logger
+				});
+				continue;
+			}
+			const stated = type ?? transport;
+			const remoteType = asCortexcodeRemoteType(stated, url);
+			if (remoteType === void 0) {
+				warnAndSkipMcpServer({
+					toolName: "Cortex Code",
+					serverName,
+					reason: stated === void 0 ? "a WebSocket url, which Cortex Code's remote transports (http and sse) cannot reach" : `the "${stated}" transport, which Cortex Code does not offer for remote servers (only http and sse)`,
+					logger
+				});
+				continue;
+			}
+			converted.type = remoteType;
+			converted.url = url;
+		} else {
+			const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+			if (!command) {
+				warnAndSkipMcpServer({
+					toolName: "Cortex Code",
+					serverName,
+					reason: "a stdio transport without a command",
+					logger
+				});
+				continue;
+			}
+			converted.type = "stdio";
+			converted.command = command;
+			if (args.length > 0) converted.args = args;
+		}
+		for (const [key, value] of Object.entries(rest)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			converted[key] = (key === "env" || key === "headers") && isRecord$1(value) ? omitPrototypePollutionKeys(value) : value;
+		}
+		result[serverName] = converted;
+	}
+	return result;
+}
+/**
+* Convert Cortex Code's server map back to the canonical shape. The
+* documented spelling (`type` + `command`/`url`) is already canonical, so
+* entries pass through with only prototype-pollution keys dropped.
+*/
+function convertFromCortexcodeFormat(mcpServers) {
+	if (!isMcpServers(mcpServers)) return {};
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		result[serverName] = omitPrototypePollutionKeys(serverConfig);
+	}
+	return result;
+}
+/**
+* Snowflake Cortex Code MCP configuration.
+*
+* Cortex Code reads `mcpServers` only from the single user-scoped file
+* `~/.snowflake/cortex/mcp.json`; no project-scoped MCP location is
+* documented, so the target is global-only. The file is created and edited by
+* `cortex mcp add` as well, so `--delete` leaves it in place rather than
+* removing a file the user did not create through rulesync.
+*
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility#mcp-configuration
+*/
+var CortexcodeMcp = class CortexcodeMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = this.fileContent === void 0 ? {} : parseCortexcodeMcpConfig({
+			fileContent: this.fileContent,
+			relativePath: (0, node_path.join)(this.relativeDirPath, this.relativeFilePath)
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: CORTEXCODE_GLOBAL_DIR_PATH,
+			relativeFilePath: CORTEXCODE_MCP_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		if (!global) throw new Error(CORTEXCODE_GLOBAL_ONLY_MESSAGE);
+		const paths = this.getSettablePaths({ global });
+		const json = parseCortexcodeMcpConfig({
+			fileContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const newJson = {
+			...json,
+			mcpServers: json.mcpServers ?? {}
+		};
+		return new CortexcodeMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(newJson, null, 2),
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
+		if (!global) throw new Error(CORTEXCODE_GLOBAL_ONLY_MESSAGE);
+		const paths = this.getSettablePaths({ global });
+		const json = parseCortexcodeMcpConfig({
+			fileContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2),
+			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const mcpServers = convertToCortexcodeFormat(rulesyncMcp.getMcpServers(), logger);
+		const cortexcodeConfig = {
+			...json,
+			mcpServers
+		};
+		return new CortexcodeMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(cortexcodeConfig, null, 2),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromCortexcodeFormat(this.json.mcpServers);
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new CortexcodeMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/mcp-env-var-format.ts
 /**
 * Canonical rulesync env var reference pattern: `${VAR}` (but not `${env:VAR}`,
@@ -34004,6 +35699,211 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/tabnine-mcp.ts
+/**
+* The remote `type` Tabnine CLI reads a server as. Tabnine documents `"http"`
+* (streamable HTTP, the default for a bare `url`) and `"sse"`; `streamable-http`
+* is the canonical alias for the former. A `ws(s)://` URL or any other stated
+* transport is something Tabnine cannot reach, so `undefined` tells the caller
+* to skip the server. `null` means "omit `type`": Tabnine then tries
+* streamable HTTP first and falls back to SSE on its own.
+* @see https://docs.tabnine.com/main/getting-started/tabnine-agent/mcp-intro-and-setup/mcp-server-config
+*/
+function asTabnineRemoteType(stated, url) {
+	if (stated === "sse") return "sse";
+	if (stated === "http" || stated === "streamable-http") return "http";
+	if (stated === void 0) return /^wss?:\/\//i.test(url) ? void 0 : null;
+}
+/**
+* Convert the canonical server map to the shape Tabnine CLI documents for the
+* `mcpServers` block of `settings.json`: a stdio server carries `command` (plus
+* `args`), a remote one carries `url` and an optional `type` (`"http"` or
+* `"sse"`). The canonical `transport` alias and the Claude-style `httpUrl`
+* alias are folded into `type`/`url`; `enabledTools`/`disabledTools` become
+* Tabnine's `includeTools`/`excludeTools`; `env`, `cwd`, `headers`, `timeout`
+* and `trust` pass through as documented.
+*
+* A server Tabnine cannot start or reach — no transport at all, a remote
+* transport without a URL, a WebSocket URL, or a stdio entry without a command
+* — is skipped with a warning rather than written in a broken form.
+*/
+function convertToTabnineFormat(mcpServers, logger) {
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		if (declaresNoTransport(serverConfig)) {
+			warnAndSkipMcpServer({
+				toolName: "Tabnine CLI",
+				serverName,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const { type, transport, url: _url, httpUrl: _httpUrl, command: _command, args: _args, enabledTools, disabledTools, ...rest } = serverConfig;
+		const converted = {};
+		if (isRemoteMcpServer(serverConfig)) {
+			const url = resolveRemoteMcpUrl(serverConfig);
+			if (!url) {
+				warnAndSkipMcpServer({
+					toolName: "Tabnine CLI",
+					serverName,
+					reason: "a remote transport without a url",
+					logger
+				});
+				continue;
+			}
+			const stated = type ?? transport;
+			const remoteType = asTabnineRemoteType(stated, url);
+			if (remoteType === void 0) {
+				warnAndSkipMcpServer({
+					toolName: "Tabnine CLI",
+					serverName,
+					reason: stated === void 0 ? "a WebSocket url, which Tabnine CLI's remote transports (http and sse) cannot reach" : `the "${stated}" transport, which Tabnine CLI does not offer for remote servers (only http and sse)`,
+					logger
+				});
+				continue;
+			}
+			converted.url = url;
+			if (remoteType !== null) converted.type = remoteType;
+		} else {
+			const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+			if (!command) {
+				warnAndSkipMcpServer({
+					toolName: "Tabnine CLI",
+					serverName,
+					reason: "a stdio transport without a command",
+					logger
+				});
+				continue;
+			}
+			converted.command = command;
+			if (args.length > 0) converted.args = args;
+		}
+		for (const [key, value] of Object.entries(rest)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			converted[key] = (key === "env" || key === "headers") && isRecord$1(value) ? omitPrototypePollutionKeys(value) : value;
+		}
+		if (enabledTools !== void 0) converted.includeTools = enabledTools;
+		if (disabledTools !== void 0) converted.excludeTools = disabledTools;
+		result[serverName] = converted;
+	}
+	return result;
+}
+/**
+* Convert Tabnine's server map back to the canonical shape: `includeTools` /
+* `excludeTools` become `enabledTools` / `disabledTools`; `type` (`stdio`,
+* `sse`, `http`) and every other documented field are already canonical.
+*/
+function convertFromTabnineFormat(mcpServers) {
+	if (!isMcpServers(mcpServers)) return {};
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		const converted = {};
+		for (const [key, value] of Object.entries(serverConfig)) {
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+			if (key === "includeTools") converted.enabledTools = value;
+			else if (key === "excludeTools") converted.disabledTools = value;
+			else converted[key] = value;
+		}
+		result[serverName] = converted;
+	}
+	return result;
+}
+/**
+* Tabnine CLI MCP configuration.
+*
+* Tabnine CLI reads `mcpServers` from `<project>/.tabnine/agent/settings.json`
+* (project scope) and `~/.tabnine/agent/settings.json` (user scope); the
+* project entry wins when both define the same server name. Both files hold
+* the user's other settings (`general`, `tools`, `hooks`, ...), so writes go
+* through the shared-config gateway with `mcpServers` as the only owned key
+* and the file is never deleted.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-agent/mcp-intro-and-setup/mcp-server-config
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/settings
+*/
+var TabnineMcp = class TabnineMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = parseSharedConfig({
+			format: "json",
+			fileContent: this.fileContent || "{}",
+			filePath: (0, node_path.join)(this.relativeDirPath, this.relativeFilePath),
+			invalidRootPolicy: "error"
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	/**
+	* settings.json carries the user's other Tabnine settings, so it must not
+	* be deleted.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: TABNINE_AGENT_DIR_PATH,
+			relativeFilePath: TABNINE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}";
+		return new TabnineMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({ mcpServers: {} }, null, 2);
+		return new TabnineMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { mcpServers: convertToTabnineFormat(rulesyncMcp.getMcpServers(), logger) },
+				filePath
+			}),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromTabnineFormat(this.json.mcpServers);
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new TabnineMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/takt-mcp.ts
 /**
 * MCP adapter for Takt (`.takt/config.yaml` project / `~/.takt/config.yaml`
@@ -34963,6 +36863,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["bob", {
+		class: BobMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeMcp,
 		meta: {
@@ -35026,6 +36935,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeMcp,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["cursor", {
 		class: CursorMcp,
 		meta: {
@@ -35197,6 +37115,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["tabnine", {
+		class: TabnineMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
+		}
+	}],
 	["takt", {
 		class: TaktMcp,
 		meta: {
@@ -36401,7 +38328,7 @@ const ANTIGRAVITY_CLI_OVERRIDE_KEYS = [
 	"allowNonWorkspaceAccess",
 	"agentMode"
 ];
-const moduleLogger$3 = fallbackLogger;
+const moduleLogger$4 = fallbackLogger;
 /**
 * Narrow an imported `settings.json` value to one of the documented values of
 * an enum-typed override key. The override schema declares `toolPermission`,
@@ -36415,7 +38342,7 @@ const moduleLogger$3 = fallbackLogger;
 function pickDocumentedValue({ key, value, documented }) {
 	if (typeof value !== "string") return void 0;
 	if (documented.includes(value)) return value;
-	moduleLogger$3.warn(`Antigravity CLI permissions: dropping '${key}: ${value}' on import — it is not one of the documented values (${documented.join(", ")}), and carrying it through would fail validation of the whole permissions file. Author it under the 'antigravity-cli' override by hand once rulesync supports it.`);
+	moduleLogger$4.warn(`Antigravity CLI permissions: dropping '${key}: ${value}' on import — it is not one of the documented values (${documented.join(", ")}), and carrying it through would fail validation of the whole permissions file. Author it under the 'antigravity-cli' override by hand once rulesync supports it.`);
 }
 /**
 * Deliberate mapping from rulesync canonical permission categories to the
@@ -36887,7 +38814,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 }
 //#endregion
 //#region src/features/permissions/augmentcode-permissions.ts
-const moduleLogger$2 = fallbackLogger;
+const moduleLogger$3 = fallbackLogger;
 zod_mini.z.enum([
 	"allow",
 	"deny",
@@ -37186,7 +39113,7 @@ var AugmentcodePermissions = class AugmentcodePermissions extends ToolPermission
 		const specialEntries = allEntries.filter((entry) => isSpecialEntry(entry));
 		const result = { ...convertAugmentToRulesyncPermissions({
 			entries: allEntries.filter((entry) => !isSpecialEntry(entry)),
-			logger: moduleLogger$2
+			logger: moduleLogger$3
 		}) };
 		if (specialEntries.length > 0) result.augmentcode = { toolPermissions: specialEntries };
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -37560,6 +39487,14 @@ function collectRestrictionLosingSandboxEntries({ existing, merged, paths, toolL
 	return entries;
 }
 /**
+* The `'<label>' — <reason>` list a trust-affecting warning ends with, shared so
+* an adapter that phrases the rest of the sentence itself (an import that lifts
+* the settings rather than writes them) prints the entries the same way.
+*/
+function formatTrustAffectingEntries(entries) {
+	return entries.map(({ label, reason }) => `'${label}' — ${reason}`).join("; ");
+}
+/**
 * The one warning that names every trust-affecting setting this generate wrote
 * to `relativeFilePath`. Emitted once per file: the individual reasons are what
 * matter, but the "review this as you would a hook" framing only needs saying
@@ -37570,7 +39505,7 @@ function collectRestrictionLosingSandboxEntries({ existing, merged, paths, toolL
 function warnOnTrustAffectingEntries({ toolLabel, noun = "setting", entries, relativeFilePath, logger }) {
 	if (entries.length === 0) return;
 	const one = entries.length === 1;
-	const details = entries.map(({ label, reason }) => `'${label}' — ${reason}`).join("; ");
+	const details = formatTrustAffectingEntries(entries);
 	logger?.warn(`${toolLabel} permissions: writing ${entries.length} trust-affecting ${noun}${one ? "" : "s"} to ${relativeFilePath}; review ${one ? "it" : "them"} as you would a hook, especially if this permissions file came from 'rulesync fetch'. ${details}.`);
 }
 //#endregion
@@ -43692,7 +45627,7 @@ const QwenSettingsPermissionsSchema = zod_mini.z.looseObject({
 	deny: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
 const QwenSettingsSchema = zod_mini.z.looseObject({ permissions: zod_mini.z.optional(QwenSettingsPermissionsSchema) });
-const moduleLogger$1 = fallbackLogger;
+const moduleLogger$2 = fallbackLogger;
 /**
 * Mapping from rulesync canonical tool category names (lowercase) to Qwen Code tool names (PascalCase).
 * Unknown names pass through as-is (e.g., mcp__server__tool).
@@ -44055,7 +45990,7 @@ function warnAboutImportedScopedKeys(groups) {
 			if (!announceOnImport) continue;
 			if (announceOnlyGrants && !grantsSomething(value, scopedKey)) continue;
 			const globalNote = scopedKey.globalNote ?? QWEN_SCOPE_RULES[rule].globalNote;
-			moduleLogger$1.warn(`Qwen permissions: imported ${quoteQualifiedKey({
+			moduleLogger$2.warn(`Qwen permissions: imported ${quoteQualifiedKey({
 				groupName,
 				key
 			})} = ${quoteValueForWarning(value)}. ${globalNote} Review it before generating with the global scope.`);
@@ -44248,7 +46183,7 @@ function convertRulesyncToQwenPermissions(config) {
 }
 function convertQwenToRulesyncPermissions(params) {
 	const permission = {};
-	const logger = params.logger ?? moduleLogger$1;
+	const logger = params.logger ?? moduleLogger$2;
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const parsed = parseQwenPermissionEntry(entry, { logger });
@@ -45574,6 +47509,585 @@ function isPermissionAction(value) {
 	return PermissionActionSchema.safeParse(value).success;
 }
 //#endregion
+//#region src/features/permissions/tabnine-permissions.ts
+/** The `settings.json` key group that carries the two tool lists. */
+const TOOLS_KEY = "tools";
+/** `tools.allowed`: tool names (and `run_shell_command(<prefix>)`) that skip the confirmation prompt. */
+const ALLOWED_KEY = "allowed";
+/** `tools.exclude`: tool names removed from discovery entirely. */
+const EXCLUDE_KEY = "exclude";
+/** The `settings.json` key group whose keys the `tabnine` override may author. */
+const GENERAL_KEY = "general";
+/** The Tabnine CLI built-in that runs shell commands. */
+const SHELL_TOOL_NAME = "run_shell_command";
+/**
+* The paths of the `tabnine` override that are refused with a warning rather
+* than written — the line Claude Code's sandbox paths draw. Under `tools`, the
+* values Tabnine CLI spawns as a command (`discoveryCommand` and `callCommand`
+* at startup, `shell.pager` on every shell output, `sandbox.command` to start
+* the sandbox); under `general`, the host every login and API call goes to
+* (`tabnineHost`) and the editor executable (`preferredEditor`, "any editor
+* path"). A fetched `.rulesync/permissions.jsonc` must not be able to point
+* Tabnine CLI at an executable, or a server, of its choosing.
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/settings/settings-reference
+*/
+const REFUSED_OVERRIDE_PATHS = {
+	[TOOLS_KEY]: [
+		["discoveryCommand"],
+		["callCommand"],
+		["shell", "pager"],
+		["sandbox", "command"]
+	],
+	[GENERAL_KEY]: [["tabnineHost"], ["preferredEditor"]]
+};
+/** `tools.sandbox`: `true` keeps tool calls contained; anything else disables or picks the sandbox. */
+const SANDBOX_KEY = "sandbox";
+/** `general.defaultApprovalMode`: the modes that still ask before a tool call runs. */
+const DEFAULT_APPROVAL_MODE_KEY = "defaultApprovalMode";
+const PROMPTING_APPROVAL_MODES = /* @__PURE__ */ new Set(["default", "plan"]);
+/**
+* Canonical categories with a one-to-one Tabnine CLI built-in tool. `bash` is
+* handled separately because it is the only tool whose list entries carry a
+* command prefix.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/built-in-tools
+*/
+const CANONICAL_TO_TABNINE_TOOL_NAMES = {
+	read: "read_file",
+	edit: "replace",
+	write: "write_file",
+	webfetch: "web_fetch",
+	websearch: "google_web_search",
+	grep: "grep_search",
+	glob: "glob"
+};
+const TABNINE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_TABNINE_TOOL_NAMES).map(([canonical, tabnine]) => [tabnine, canonical]));
+const moduleLogger$1 = fallbackLogger;
+/**
+* Turn a canonical `bash` glob into the command prefix a
+* `run_shell_command(<prefix>)` entry carries. Tabnine matches the prefix
+* against the start of the command line, so only two glob shapes map cleanly:
+* `<prefix> *` and a bare `<prefix>` with no wildcard at all. Anything else
+* (`git * push`, `*.sh`, `npm run:*`) matches commands a prefix cannot name, so
+* it is reported and left out rather than approximated. `*` alone names the
+* tool itself and is returned as the empty prefix.
+*/
+function toShellPrefix(pattern) {
+	if (pattern === "*") return "";
+	const prefix = pattern.endsWith(" *") ? pattern.slice(0, -2) : pattern;
+	if (prefix.length === 0 || /[*?[\]]/.test(prefix)) return;
+	return prefix;
+}
+/**
+* The Tabnine tool a canonical category names. An unknown category is passed
+* through as a tool name (that is how an MCP tool is named); the read is an
+* own-property lookup so a category spelled `toString` does not pick up an
+* `Object.prototype` member.
+*/
+function toTabnineToolName(category) {
+	return lookupOwn({
+		record: CANONICAL_TO_TABNINE_TOOL_NAMES,
+		key: category
+	}) ?? category;
+}
+/**
+* The widest glob a `bash` pattern stands for once it is written as a
+* `run_shell_command(<prefix>)` entry: the prefix matches the start of the
+* command line, so a bare `pnpm` also covers `pnpm install`. Used only to
+* compare allows against the restrictions (`bash` deny and `ask` rules, and
+* the rules of `*`), where widening can only withhold more, never fail open.
+*/
+function widenToPrefixGlob(pattern) {
+	const prefix = toShellPrefix(pattern);
+	if (prefix === void 0) return pattern;
+	return prefix === "" ? "*" : `${prefix}*`;
+}
+function toShellEntry(prefix) {
+	return prefix === "" ? SHELL_TOOL_NAME : `${SHELL_TOOL_NAME}(${prefix})`;
+}
+/** The `bash` pattern a `run_shell_command(<prefix>)` entry stands for. */
+function toShellPattern(prefix) {
+	return prefix === void 0 || prefix === "" ? "*" : `${prefix} *`;
+}
+/**
+* Split a `tools.allowed`/`tools.exclude` entry into its tool name and the
+* optional `(<prefix>)` suffix. An entry whose parenthesis never closes, or
+* that carries text after the closing one, is malformed and yields `undefined`.
+*/
+function parseTabnineEntry(entry) {
+	const open = entry.indexOf("(");
+	if (open === -1) return entry.length > 0 ? {
+		toolName: entry,
+		prefix: void 0
+	} : void 0;
+	if (open === 0 || !entry.endsWith(")")) return;
+	return {
+		toolName: entry.slice(0, open),
+		prefix: entry.slice(open + 1, -1)
+	};
+}
+/**
+* `record` without the value at `path`, when there is one, and without any
+* container the removal emptied. Containers on the way are copied, never
+* mutated, so the override the caller read stays intact.
+*/
+function omitPath({ record, path }) {
+	const [head, ...rest] = path;
+	if (head === void 0 || !Object.hasOwn(record, head)) return {
+		record,
+		removed: false
+	};
+	if (rest.length === 0) {
+		const { [head]: _removed, ...others } = record;
+		return {
+			record: others,
+			removed: true
+		};
+	}
+	const child = record[head];
+	if (!isRecord$1(child)) return {
+		record,
+		removed: false
+	};
+	const inner = omitPath({
+		record: child,
+		path: rest
+	});
+	if (!inner.removed) return {
+		record,
+		removed: false
+	};
+	if (Object.keys(inner.record).length === 0) {
+		const { [head]: _emptied, ...others } = record;
+		return {
+			record: others,
+			removed: true
+		};
+	}
+	return {
+		record: {
+			...record,
+			[head]: inner.record
+		},
+		removed: true
+	};
+}
+/**
+* The `tabnine.<group>` record with every refused path removed, and the dotted
+* names of the paths that were there. Nothing else of the group is touched:
+* the rest is written verbatim (and announced where it widens trust).
+*/
+function stripRefusedPaths({ group, record }) {
+	const refused = [];
+	let stripped = record;
+	for (const path of REFUSED_OVERRIDE_PATHS[group]) {
+		const result = omitPath({
+			record: stripped,
+			path
+		});
+		if (result.removed) {
+			refused.push(`${group}.${path.join(".")}`);
+			stripped = result.record;
+		}
+	}
+	return {
+		record: stripped,
+		refused
+	};
+}
+/**
+* The `tools` and `general` groups of an override with the refused paths taken
+* out, and every refused path named. A `general` that is absent or that the
+* refusals emptied is reported as absent so no `general: {}` is written or
+* lifted. (The `TabninePermissionsOverrideSchema` already rejects a group that
+* is not an object; the `isRecord` guards only keep an unvalidated file from
+* throwing.)
+*/
+function stripRefusedOverridePaths(override) {
+	const tools = stripRefusedPaths({
+		group: TOOLS_KEY,
+		record: isRecord$1(override[TOOLS_KEY]) ? override[TOOLS_KEY] : {}
+	});
+	const general = isRecord$1(override[GENERAL_KEY]) ? stripRefusedPaths({
+		group: GENERAL_KEY,
+		record: override[GENERAL_KEY]
+	}) : void 0;
+	return {
+		tools: tools.record,
+		general: general !== void 0 && Object.keys(general.record).length > 0 ? general.record : void 0,
+		refused: [...tools.refused, ...general?.refused ?? []]
+	};
+}
+/**
+* The settings of a `tabnine` override that widen what Tabnine CLI does without
+* asking, so the generate can name them. `tools.allowed` counts because an
+* override-authored entry skips the confirmation prompt on the strength of the
+* override alone (its `run_shell_command(...)` entries are not here: they are
+* compared as `bash` allows and withheld like them); `tools.sandbox` and
+* `general.defaultApprovalMode` decide whether tool calls are contained and
+* whether they are confirmed at all. Called on the override, not the file, so a
+* value the file already held is not reported as something rulesync opened.
+*/
+function collectTrustAffectingOverrideEntries({ tools, general }) {
+	const entries = [];
+	const allowed = isStringArray$2(tools[ALLOWED_KEY]) ? tools[ALLOWED_KEY] : [];
+	if (allowed.length > 0) entries.push({
+		label: `tools.allowed (${allowed.map(quoteValueForWarning).join(", ")})`,
+		reason: "auto-approves what it names as the override spells it; a non-shell entry has no canonical rule to be checked against"
+	});
+	if (Object.hasOwn(tools, SANDBOX_KEY) && isNotTrue(tools[SANDBOX_KEY])) entries.push({
+		label: `tools.sandbox = ${quoteValueForWarning(tools[SANDBOX_KEY])}`,
+		reason: "is not the plain `true` that keeps tool calls contained, so it either disables the sandbox or picks the command, image, paths and network that contain them"
+	});
+	const approvalMode = general?.[DEFAULT_APPROVAL_MODE_KEY];
+	if (general !== void 0 && Object.hasOwn(general, DEFAULT_APPROVAL_MODE_KEY) && !PROMPTING_APPROVAL_MODES.has(approvalMode)) entries.push({
+		label: `general.defaultApprovalMode = ${quoteValueForWarning(approvalMode)}`,
+		reason: "auto-approves tool calls instead of asking; only `default` and `plan` keep the prompt"
+	});
+	return entries;
+}
+/**
+* What a later generate would announce from the override an import builds,
+* said now, so the file the import writes into `.rulesync/` is read with the
+* same eyes as one that arrived with a clone. `refused` names the paths the
+* import left in `settings.json`, the ones generate refuses to write — an
+* override must not carry a value that only ever produces a warning.
+*/
+function announceLiftedOverride({ tools, general, refused }) {
+	if (refused.length > 0) {
+		const one = refused.length === 1;
+		moduleLogger$1.info(`Tabnine CLI permissions: left ${refused.join(", ")} in settings.json rather than lifting ${one ? "it" : "them"} into the tabnine override; Tabnine CLI runs ${one ? "that value" : "those values"} as a command or sends its traffic there, and 'rulesync generate' refuses to write ${one ? "it" : "them"} from the override.`);
+	}
+	const trustAffecting = collectTrustAffectingOverrideEntries({
+		tools,
+		general
+	});
+	if (trustAffecting.length > 0) {
+		const one = trustAffecting.length === 1;
+		moduleLogger$1.warn(`Tabnine CLI permissions: the tabnine override now carries ${trustAffecting.length} trust-affecting setting${one ? "" : "s"} that 'rulesync generate' writes back as authored: ${formatTrustAffectingEntries(trustAffecting)}.`);
+	}
+}
+/**
+* Build the two tool lists from the canonical block; the rules that could not
+* be carried are reported through `logger` here.
+*/
+function buildToolLists({ permission, overrideShellAllowPatterns, logger }) {
+	const allowed = [];
+	const exclude = [];
+	const { rules: canonicalRules, ignoredAllToolsAllowPatterns } = collectShellCommandRules(permission);
+	const { allow: shellAllow, deny: shellDeny, shadowedAllowPatterns, unwrittenDenyPatterns, unenforcedAllToolsAskPatterns, intersectionBudgetExhausted } = partitionCommandRules({
+		rules: [...canonicalRules, ...overrideShellAllowPatterns.map((pattern) => ({
+			pattern,
+			action: "allow",
+			fromAllToolsCategory: false
+		}))],
+		writesAllToolsDeny: false,
+		normalizePattern: widenToPrefixGlob
+	});
+	warnAboutUnwrittenCommandRules({
+		toolLabel: "Tabnine CLI",
+		surfaceLabel: "tools.allowed/tools.exclude",
+		foreignRestrictingCategories: [],
+		shadowedAllowPatterns,
+		unwrittenDenyPatterns,
+		unwrittenDenyReason: "tools.exclude removes a tool from discovery, and a pattern written under '*' need not be a command at all.",
+		unenforcedAllToolsAskPatterns,
+		ignoredAllToolsAllowPatterns,
+		intersectionBudgetExhausted,
+		logger
+	});
+	const unmappedShellPatterns = [];
+	for (const pattern of shellDeny) {
+		const prefix = toShellPrefix(pattern);
+		if (prefix === void 0) {
+			unmappedShellPatterns.push(pattern);
+			continue;
+		}
+		exclude.push(toShellEntry(prefix));
+	}
+	const shadowingShellDenies = createShadowingRestrictionsTest(shellDeny.map((pattern) => ({
+		pattern,
+		fromAllToolsCategory: false
+	})), { normalizePattern: widenToPrefixGlob });
+	const withheldAllowPatterns = [];
+	for (const pattern of shellAllow) {
+		const prefix = toShellPrefix(pattern);
+		if (prefix === void 0) {
+			unmappedShellPatterns.push(pattern);
+			continue;
+		}
+		if (shadowingShellDenies(pattern).length > 0) {
+			withheldAllowPatterns.push(pattern);
+			continue;
+		}
+		allowed.push(toShellEntry(prefix));
+	}
+	if (unmappedShellPatterns.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: skipped ${unmappedShellPatterns.length} 'bash' rule(s) whose pattern is not a command prefix (${unmappedShellPatterns.map(quoteValueForWarning).join(", ")}). run_shell_command(<prefix>) matches the start of the command line, so only '<prefix> *' and a bare '<prefix>' can be written.`);
+	if (withheldAllowPatterns.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: withheld ${withheldAllowPatterns.length} 'bash' allow rule(s) (${withheldAllowPatterns.map(quoteValueForWarning).join(", ")}) that overlap a 'bash' deny rule; writing them could auto-approve the denied commands, since tools.exclude is not documented to narrow run_shell_command to a prefix.`);
+	const unmappedPatterns = [];
+	for (const [category, categoryRules] of Object.entries(permission)) {
+		if (category === "bash" || category === "*") continue;
+		const toolName = toTabnineToolName(category);
+		for (const [pattern, action] of Object.entries(categoryRules)) {
+			if (pattern !== "*") {
+				unmappedPatterns.push(`${category}: ${pattern}`);
+				continue;
+			}
+			if (action === "allow") allowed.push(toolName);
+			else if (action === "deny") exclude.push(toolName);
+		}
+	}
+	if (unmappedPatterns.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: skipped ${unmappedPatterns.length} rule(s) with a pattern other than '*' (${unmappedPatterns.map(quoteValueForWarning).join(", ")}). tools.allowed/tools.exclude name whole tools; only run_shell_command takes a prefix.`);
+	return {
+		allowed: (0, es_toolkit.uniq)(allowed),
+		exclude: (0, es_toolkit.uniq)(exclude)
+	};
+}
+/**
+* Permissions generator for the Tabnine CLI.
+*
+* Tabnine CLI keeps its tool policy in `.tabnine/agent/settings.json` (project)
+* and `~/.tabnine/agent/settings.json` (user), a shared file that also carries
+* `mcpServers`, `hooks`, `general.*`, `context.*` and more, so writes go through
+* the shared-config gateway as a deep merge and the file is never deleted.
+*
+* Two keys are driven by the canonical block:
+* - `tools.allowed` — `allow` rules. A tool name skips the confirmation prompt;
+*   `run_shell_command(<prefix>)` narrows that to one command prefix.
+* - `tools.exclude` — `deny` rules. A tool name removes the tool from discovery.
+*   A `bash` deny is written as `run_shell_command(<prefix>)` there, the form
+*   Gemini CLI's `excludeTools` (which Tabnine derives from) honors, but Tabnine
+*   documents the prefix for `tools.allowed` only — so the entry is not relied
+*   on, and every allow the deny overlaps is withheld as well.
+*
+* `ask` writes nothing: a tool that is in neither list keeps Tabnine's default
+* prompt. Every other `tools.*` key (`core`, `shell.*`, `enableWebTools`, ...)
+* and the `general.*` group are authored through the `tabnine` override, which
+* is deep-merged beneath the two canonical lists; entries in the lists that
+* cannot be mapped back (a prefix on a non-shell tool, an MCP tool name) round
+* trip through the override too.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/built-in-tools
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/settings/settings-reference
+*/
+var TabninePermissions = class TabninePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	/**
+	* `settings.json` holds unrelated user settings (`mcpServers`, `hooks`,
+	* `general`, ...), so it must not be deleted.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: TABNINE_AGENT_DIR_PATH,
+			relativeFilePath: TABNINE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = TabninePermissions.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new TabninePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, global = false, logger }) {
+		const paths = TabninePermissions.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const config = rulesyncPermissions.getJson();
+		const override = isRecord$1(config.tabnine) ? config.tabnine : {};
+		const { tools: overrideTools, general: overrideGeneral, refused: refusedPaths } = stripRefusedOverridePaths(override);
+		if (refusedPaths.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: refused to write ${refusedPaths.join(", ")} from the tabnine override; Tabnine CLI runs that value as a command or sends its traffic to it, and a permissions file (one that came from 'rulesync fetch' included) must not be able to point it at an executable or a server of its choosing. Set it by hand in ${(0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)} if you need it.`);
+		const overrideList = (key) => {
+			const value = overrideTools[key];
+			if (value === void 0 || isStringArray$2(value)) return value ?? [];
+			warnWithFallback(logger, `Tabnine CLI permissions: ignored tools.${key} of the tabnine override (${quoteValueForWarning(value)}); it must be a list of tool names.`);
+			return [];
+		};
+		const overrideShellAllowPatterns = [];
+		const overrideVerbatimAllowed = [];
+		for (const entry of overrideList(ALLOWED_KEY)) {
+			const parsed = parseTabnineEntry(entry);
+			if (parsed?.toolName === SHELL_TOOL_NAME) overrideShellAllowPatterns.push(toShellPattern(parsed.prefix));
+			else overrideVerbatimAllowed.push(entry);
+		}
+		const overrideExclude = overrideList(EXCLUDE_KEY);
+		const { allowed, exclude } = buildToolLists({
+			permission: config.permission,
+			overrideShellAllowPatterns,
+			logger
+		});
+		const ignoredOverrideKeys = Object.keys(override).filter((key) => key !== TOOLS_KEY && key !== GENERAL_KEY);
+		if (ignoredOverrideKeys.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: ignored ${ignoredOverrideKeys.length} key(s) of the tabnine override (${ignoredOverrideKeys.map(quoteValueForWarning).join(", ")}); only 'tools' and 'general' are written through the permissions feature.`);
+		const existingTools = this.existingToolsGroup(existingContent);
+		const managedToolNames = new Set(Object.keys(config.permission).map((category) => category === "bash" || category === "*" ? SHELL_TOOL_NAME : toTabnineToolName(category)));
+		const preservedEntries = (key) => (isStringArray$2(existingTools?.[key]) ? existingTools[key] : []).filter((entry) => {
+			const toolName = parseTabnineEntry(entry)?.toolName;
+			return toolName === void 0 || !managedToolNames.has(toolName);
+		});
+		const allowedList = (0, es_toolkit.uniq)([
+			...allowed,
+			...overrideVerbatimAllowed,
+			...preservedEntries(ALLOWED_KEY)
+		]);
+		const excludeList = (0, es_toolkit.uniq)([
+			...exclude,
+			...overrideExclude,
+			...preservedEntries(EXCLUDE_KEY)
+		]);
+		const droppedExcludeEntries = (0, es_toolkit.uniq)(isStringArray$2(existingTools?.[EXCLUDE_KEY]) ? existingTools[EXCLUDE_KEY] : []).filter((entry) => {
+			if (excludeList.includes(entry)) return false;
+			const toolName = parseTabnineEntry(entry)?.toolName;
+			return toolName === void 0 || !excludeList.includes(toolName);
+		});
+		if (droppedExcludeEntries.length > 0) warnWithFallback(logger, `Tabnine CLI permissions: removed ${droppedExcludeEntries.length} existing tools.exclude entry(ies) (${droppedExcludeEntries.map(quoteValueForWarning).join(", ")}) of a tool the canonical block manages; add a deny rule to .rulesync/permissions.jsonc to keep them.`);
+		const tools = {
+			...overrideTools,
+			[ALLOWED_KEY]: allowedList.length > 0 ? allowedList : void 0,
+			[EXCLUDE_KEY]: excludeList.length > 0 ? excludeList : void 0
+		};
+		const patch = {};
+		if (overrideGeneral !== void 0) patch[GENERAL_KEY] = overrideGeneral;
+		if (Object.values(tools).some((value) => value !== void 0) || existingTools !== void 0) patch[TOOLS_KEY] = tools;
+		warnOnTrustAffectingEntries({
+			toolLabel: "Tabnine CLI",
+			entries: collectTrustAffectingOverrideEntries({
+				tools: {
+					...overrideTools,
+					[ALLOWED_KEY]: overrideVerbatimAllowed
+				},
+				general: overrideGeneral
+			}),
+			relativeFilePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath),
+			logger
+		});
+		return new TabninePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch,
+				filePath
+			}),
+			validate: true,
+			global
+		});
+	}
+	/** The `tools` group of the existing file, or `undefined` when it has none. */
+	static existingToolsGroup(existingContent) {
+		try {
+			const existing = parseSharedConfig({
+				format: "json",
+				fileContent: existingContent || "{}",
+				invalidRootPolicy: "error"
+			});
+			return isRecord$1(existing[TOOLS_KEY]) ? existing[TOOLS_KEY] : void 0;
+		} catch {
+			return;
+		}
+	}
+	toRulesyncPermissions() {
+		const settings = this.parseSettings();
+		const tools = isRecord$1(settings[TOOLS_KEY]) ? settings[TOOLS_KEY] : {};
+		const permission = {};
+		const leftovers = {};
+		const setRule = (category, pattern, action) => {
+			const rules = Object.hasOwn(permission, category) ? permission[category] : permission[category] = {};
+			if (rules !== void 0 && !Object.hasOwn(rules, pattern)) rules[pattern] = action;
+		};
+		for (const [key, action] of [[EXCLUDE_KEY, "deny"], [ALLOWED_KEY, "allow"]]) {
+			const entries = isStringArray$2(tools[key]) ? tools[key] : [];
+			for (const entry of entries) {
+				const parsed = parseTabnineEntry(entry);
+				if (parsed === void 0) {
+					moduleLogger$1.warn(`Tabnine CLI permissions: kept malformed tools.${key} entry ${quoteValueForWarning(entry)} in the tabnine override.`);
+					(leftovers[key] ??= []).push(entry);
+					continue;
+				}
+				const { toolName, prefix } = parsed;
+				if (toolName === SHELL_TOOL_NAME) {
+					setRule(SHELL_PERMISSION_CATEGORY, toShellPattern(prefix), action);
+					continue;
+				}
+				if (prefix !== void 0) {
+					(leftovers[key] ??= []).push(entry);
+					continue;
+				}
+				const category = lookupOwn({
+					record: TABNINE_TO_CANONICAL_TOOL_NAMES,
+					key: toolName
+				}) ?? toolName;
+				if (isPrototypePollutionKey(category)) {
+					moduleLogger$1.warn(`Tabnine CLI permissions: kept tools.${key} entry ${quoteValueForWarning(entry)} in the tabnine override; its name cannot be a permission category.`);
+					(leftovers[key] ??= []).push(entry);
+					continue;
+				}
+				setRule(category, "*", action);
+			}
+		}
+		const { tools: overrideTools, general, refused } = stripRefusedOverridePaths({
+			[TOOLS_KEY]: Object.fromEntries(Object.entries(tools).filter(([key]) => key !== ALLOWED_KEY && key !== EXCLUDE_KEY)),
+			[GENERAL_KEY]: settings[GENERAL_KEY]
+		});
+		for (const [key, entries] of Object.entries(leftovers)) overrideTools[key] = entries;
+		const override = {};
+		if (Object.keys(overrideTools).length > 0) override[TOOLS_KEY] = overrideTools;
+		if (general !== void 0) override[GENERAL_KEY] = general;
+		announceLiftedOverride({
+			tools: overrideTools,
+			general,
+			refused
+		});
+		const imported = { permission };
+		if (Object.keys(override).length > 0) imported.tabnine = override;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(imported, null, 2) });
+	}
+	parseSettings() {
+		const relativePath = (0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath());
+		try {
+			return parseSharedConfig({
+				format: "json",
+				fileContent: this.getFileContent() || "{}",
+				filePath: relativePath,
+				invalidRootPolicy: "error"
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse Tabnine CLI settings in ${relativePath}: ${formatError(error)}`, { cause: error });
+		}
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new TabninePermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/permissions/takt-permissions.ts
 const TAKT_PROVIDER_KEY = "provider";
 const TAKT_PROVIDER_PROFILES_KEY = "provider_profiles";
@@ -48953,6 +51467,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["tabnine", {
+		class: TabninePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["takt", {
 		class: TaktPermissions,
 		meta: {
@@ -50250,16 +52772,198 @@ var AntigravitySharedSkill = class extends ToolSkill {
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-		const antigravityFrontmatter = {
+		const antigravityFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		const settablePaths = this.getSettablePaths({ global });
+		return new this({
+			outputRoot,
+			relativeDirPath: settablePaths.relativeDirPath,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: antigravityFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes(this.getToolTarget());
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: (options) => this.getSettablePaths(options)
+		});
+		const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) {
+			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		return new this({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new this({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
+//#region src/features/skills/antigravity-cli-skill.ts
+/**
+* Represents a Google Antigravity CLI skill directory (Antigravity 2.0).
+*
+* Shares all behavior with {@link AntigravitySharedSkill}; the CLI keeps its
+* own global skills tree at `~/.gemini/antigravity-cli/skills/` and answers to
+* the `antigravity-cli` target.
+*/
+var AntigravityCliSkill = class extends AntigravitySharedSkill {
+	static getGlobalSubdir() {
+		return ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR;
+	}
+	static getToolTarget() {
+		return "antigravity-cli";
+	}
+};
+//#endregion
+//#region src/features/skills/antigravity-ide-skill.ts
+/**
+* Represents a Google Antigravity IDE skill directory (Antigravity 2.0).
+*
+* Shares all behavior with {@link AntigravitySharedSkill}. As of Antigravity
+* 2.0 the IDE reads its global skills from the shared `~/.gemini/config/skills/`
+* location (the Skills doc lists `~/.gemini/config/skills/<skill-folder>/` as
+* the global scope); the legacy `~/.gemini/antigravity/skills/` path is no
+* longer used. It answers to the `antigravity-ide` target.
+*/
+var AntigravityIdeSkill = class extends AntigravitySharedSkill {
+	static getGlobalSubdir() {
+		return ANTIGRAVITY_IDE_GLOBAL_CONFIG_SUBDIR;
+	}
+	static getToolTarget() {
+		return "antigravity-ide";
+	}
+};
+//#endregion
+//#region src/features/skills/antigravity-plugin-skill.ts
+var AntigravityPluginSkill = class extends AntigravityIdeSkill {
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("antigravity-plugin");
+	}
+	static getSettablePaths() {
+		return { relativeDirPath: ANTIGRAVITY_PLUGIN_SKILLS_DIR };
+	}
+};
+//#endregion
+//#region src/features/skills/augmentcode-skill.ts
+const AugmentcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string()
+});
+/**
+* Represents an AugmentCode (Auggie CLI) skill directory.
+* Auggie has native skill support — it reads `<name>/SKILL.md` directories under
+* `.augment/skills/` (project) and `~/.augment/skills/` (global).
+* See https://docs.augmentcode.com/cli/skills
+*/
+var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = AugmentcodeSkill.getSettablePaths().relativeDirPath, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return {
+			relativeDirPath: AUGMENTCODE_SKILLS_DIR_PATH,
+			alternativeSkillRoots: [AUGMENTCODE_AGENTS_SKILLS_DIR_PATH]
+		};
+	}
+	getFrontmatter() {
+		return AugmentcodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (this.mainFile === void 0) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = AugmentcodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const frontmatter = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			targets: ["*"]
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const settablePaths = AugmentcodeSkill.getSettablePaths({ global });
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const augmentcodeFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description
 		};
-		const settablePaths = this.getSettablePaths({ global });
-		return new this({
+		return new AugmentcodeSkill({
 			outputRoot,
 			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
-			frontmatter: antigravityFrontmatter,
+			frontmatter: augmentcodeFrontmatter,
 			body: rulesyncSkill.getBody(),
 			otherFiles: rulesyncSkill.getOtherFiles(),
 			validate,
@@ -50268,19 +52972,19 @@ var AntigravitySharedSkill = class extends ToolSkill {
 	}
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		const targets = rulesyncSkill.getFrontmatter().targets;
-		return targets.includes("*") || targets.includes(this.getToolTarget());
+		return targets.includes("*") || targets.includes("augmentcode");
 	}
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
-			getSettablePaths: (options) => this.getSettablePaths(options)
+			getSettablePaths: AugmentcodeSkill.getSettablePaths
 		});
-		const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		const result = AugmentcodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new this({
+		return new AugmentcodeSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -50292,9 +52996,10 @@ var AntigravitySharedSkill = class extends ToolSkill {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
-		return new this({
+		const settablePaths = AugmentcodeSkill.getSettablePaths({ global });
+		return new AugmentcodeSkill({
 			outputRoot,
-			relativeDirPath,
+			relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
 			dirName,
 			frontmatter: {
 				name: "",
@@ -50308,66 +53013,24 @@ var AntigravitySharedSkill = class extends ToolSkill {
 	}
 };
 //#endregion
-//#region src/features/skills/antigravity-cli-skill.ts
-/**
-* Represents a Google Antigravity CLI skill directory (Antigravity 2.0).
-*
-* Shares all behavior with {@link AntigravitySharedSkill}; the CLI keeps its
-* own global skills tree at `~/.gemini/antigravity-cli/skills/` and answers to
-* the `antigravity-cli` target.
-*/
-var AntigravityCliSkill = class extends AntigravitySharedSkill {
-	static getGlobalSubdir() {
-		return ANTIGRAVITY_CLI_PERMISSIONS_SUBDIR;
-	}
-	static getToolTarget() {
-		return "antigravity-cli";
-	}
-};
-//#endregion
-//#region src/features/skills/antigravity-ide-skill.ts
-/**
-* Represents a Google Antigravity IDE skill directory (Antigravity 2.0).
-*
-* Shares all behavior with {@link AntigravitySharedSkill}. As of Antigravity
-* 2.0 the IDE reads its global skills from the shared `~/.gemini/config/skills/`
-* location (the Skills doc lists `~/.gemini/config/skills/<skill-folder>/` as
-* the global scope); the legacy `~/.gemini/antigravity/skills/` path is no
-* longer used. It answers to the `antigravity-ide` target.
-*/
-var AntigravityIdeSkill = class extends AntigravitySharedSkill {
-	static getGlobalSubdir() {
-		return ANTIGRAVITY_IDE_GLOBAL_CONFIG_SUBDIR;
-	}
-	static getToolTarget() {
-		return "antigravity-ide";
-	}
-};
-//#endregion
-//#region src/features/skills/antigravity-plugin-skill.ts
-var AntigravityPluginSkill = class extends AntigravityIdeSkill {
-	static isTargetedByRulesyncSkill(rulesyncSkill) {
-		const targets = rulesyncSkill.getFrontmatter().targets;
-		return targets.includes("*") || targets.includes("antigravity-plugin");
-	}
-	static getSettablePaths() {
-		return { relativeDirPath: ANTIGRAVITY_PLUGIN_SKILLS_DIR };
-	}
-};
-//#endregion
-//#region src/features/skills/augmentcode-skill.ts
-const AugmentcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
+//#region src/features/skills/bob-skill.ts
+const BobSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string()
 });
 /**
-* Represents an AugmentCode (Auggie CLI) skill directory.
-* Auggie has native skill support — it reads `<name>/SKILL.md` directories under
-* `.augment/skills/` (project) and `~/.augment/skills/` (global).
-* See https://docs.augmentcode.com/cli/skills
+* Represents an IBM Bob skill directory.
+*
+* Bob discovers Anthropic-style `<name>/SKILL.md` directories under
+* `<project>/.bob/skills/` (project scope) and `~/.bob/skills/` (user scope);
+* the project copy wins on a name clash. The frontmatter requires `name`
+* (matching the directory name) and `description`; supporting files next to
+* `SKILL.md` are carried along.
+*
+* @see https://bob.ibm.com/docs/ide/features/skills
 */
-var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
-	constructor({ outputRoot = process.cwd(), relativeDirPath = AugmentcodeSkill.getSettablePaths().relativeDirPath, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+var BobSkill = class BobSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = BOB_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
 		super({
 			outputRoot,
 			relativeDirPath,
@@ -50386,38 +53049,40 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 		}
 	}
 	static getSettablePaths({ global: _global = false } = {}) {
-		return {
-			relativeDirPath: AUGMENTCODE_SKILLS_DIR_PATH,
-			alternativeSkillRoots: [AUGMENTCODE_AGENTS_SKILLS_DIR_PATH]
-		};
+		return { relativeDirPath: BOB_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
-		return AugmentcodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+		return BobSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
 	getBody() {
 		return this.mainFile?.body ?? "";
 	}
 	validate() {
-		if (this.mainFile === void 0) return {
+		if (!this.mainFile) return {
 			success: false,
 			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
 		};
-		const result = AugmentcodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		const result = BobSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
 			success: false,
 			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
 		};
+		if (result.data.name !== this.getDirName()) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: frontmatter name (${result.data.name}) must match directory name (${this.getDirName()})`)
+		};
 		return {
 			success: true,
 			error: null
 		};
 	}
 	toRulesyncSkill() {
-		const frontmatter = this.getFrontmatter();
+		const { name, description, ...bobSection } = this.getFrontmatter();
 		const rulesyncFrontmatter = {
-			name: frontmatter.name,
-			description: frontmatter.description,
-			targets: ["*"]
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(bobSection).length > 0 && { bob: bobSection }
 		};
 		return new RulesyncSkill({
 			outputRoot: this.outputRoot,
@@ -50431,17 +53096,19 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 		});
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
-		const settablePaths = AugmentcodeSkill.getSettablePaths({ global });
+		const settablePaths = BobSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-		const augmentcodeFrontmatter = {
+		const { name: _sectionName, description: _sectionDescription, ...bobSection } = rulesyncFrontmatter.bob ?? {};
+		const bobFrontmatter = {
+			...bobSection,
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description
 		};
-		return new AugmentcodeSkill({
+		return new BobSkill({
 			outputRoot,
 			relativeDirPath: settablePaths.relativeDirPath,
-			dirName: rulesyncSkill.getDirName(),
-			frontmatter: augmentcodeFrontmatter,
+			dirName: bobFrontmatter.name,
+			frontmatter: bobFrontmatter,
 			body: rulesyncSkill.getBody(),
 			otherFiles: rulesyncSkill.getOtherFiles(),
 			validate,
@@ -50450,19 +53117,23 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 	}
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		const targets = rulesyncSkill.getFrontmatter().targets;
-		return targets.includes("*") || targets.includes("augmentcode");
+		return targets.includes("*") || targets.includes("bob");
 	}
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
-			getSettablePaths: AugmentcodeSkill.getSettablePaths
+			getSettablePaths: BobSkill.getSettablePaths
 		});
-		const result = AugmentcodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		const result = BobSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new AugmentcodeSkill({
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
+		}
+		return new BobSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -50474,10 +53145,9 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
-		const settablePaths = AugmentcodeSkill.getSettablePaths({ global });
-		return new AugmentcodeSkill({
+		return new BobSkill({
 			outputRoot,
-			relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
+			relativeDirPath,
 			dirName,
 			frontmatter: {
 				name: "",
@@ -51422,7 +54092,167 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		return { relativeDirPath: COPILOT_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
-		return CopilotSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+		return CopilotSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (!this.mainFile) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = CopilotSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const { name, description, ...copilotSection } = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(copilotSection).length > 0 && { copilot: copilotSection }
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const settablePaths = CopilotSkill.getSettablePaths({ global });
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const copilotSection = rulesyncFrontmatter.copilot;
+		const resolvedUserInvocable = resolveUserInvocable({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
+		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
+		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotFields } = copilotSection ?? {};
+		const copilotFrontmatter = {
+			...copilotFields,
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...license !== void 0 && { license },
+			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
+			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
+		};
+		return new CopilotSkill({
+			outputRoot,
+			relativeDirPath: settablePaths.relativeDirPath,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: copilotFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("copilot");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: CopilotSkill.getSettablePaths
+		});
+		const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) {
+			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		return new CopilotSkill({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		const settablePaths = CopilotSkill.getSettablePaths({ global });
+		return new CopilotSkill({
+			outputRoot,
+			relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
+//#region src/features/skills/copilotcli-skill.ts
+const CopilotcliSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	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()),
+	"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.
+*
+* Copilot CLI discovers project skills from `.github/skills/` (shared with the
+* Copilot IDE target) and personal/global skills from `~/.copilot/skills/`. Each
+* skill is a directory containing a `SKILL.md` file with `name`/`description`
+* frontmatter. https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-skills
+*/
+var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = COPILOT_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths(options) {
+		if (options?.global) return { relativeDirPath: COPILOT_SKILLS_GLOBAL_DIR_PATH };
+		return { relativeDirPath: COPILOT_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return CopilotcliSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
 	getBody() {
 		return this.mainFile?.body ?? "";
@@ -51432,7 +54262,7 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 			success: false,
 			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
 		};
-		const result = CopilotSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		const result = CopilotcliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
 			success: false,
 			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
@@ -51443,12 +54273,12 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		};
 	}
 	toRulesyncSkill() {
-		const { name, description, ...copilotSection } = this.getFrontmatter();
+		const { name, description, ...copilotcliSection } = this.getFrontmatter();
 		const rulesyncFrontmatter = {
 			name,
 			description,
 			targets: ["*"],
-			...Object.keys(copilotSection).length > 0 && { copilot: copilotSection }
+			...Object.keys(copilotcliSection).length > 0 && { copilotcli: copilotcliSection }
 		};
 		return new RulesyncSkill({
 			outputRoot: this.outputRoot,
@@ -51462,35 +54292,35 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		});
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
-		const settablePaths = CopilotSkill.getSettablePaths({ global });
+		const settablePaths = CopilotcliSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-		const copilotSection = rulesyncFrontmatter.copilot;
+		const copilotcliSection = rulesyncFrontmatter.copilotcli;
 		const resolvedUserInvocable = resolveUserInvocable({
 			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotSection
+			section: copilotcliSection
 		});
 		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
 			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotSection
+			section: copilotcliSection
 		});
 		const license = resolveLicense({
 			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotSection
+			section: copilotcliSection
 		});
-		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotFields } = copilotSection ?? {};
-		const copilotFrontmatter = {
-			...copilotFields,
+		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotcliFields } = copilotcliSection ?? {};
+		const copilotcliFrontmatter = {
+			...copilotcliFields,
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...license !== void 0 && { license },
 			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
-		return new CopilotSkill({
+		return new CopilotcliSkill({
 			outputRoot,
 			relativeDirPath: settablePaths.relativeDirPath,
 			dirName: rulesyncSkill.getDirName(),
-			frontmatter: copilotFrontmatter,
+			frontmatter: copilotcliFrontmatter,
 			body: rulesyncSkill.getBody(),
 			otherFiles: rulesyncSkill.getOtherFiles(),
 			validate,
@@ -51499,19 +54329,19 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 	}
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		const targets = rulesyncSkill.getFrontmatter().targets;
-		return targets.includes("*") || targets.includes("copilot");
+		return targets.includes("*") || targets.includes("copilotcli");
 	}
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
-			getSettablePaths: CopilotSkill.getSettablePaths
+			getSettablePaths: CopilotcliSkill.getSettablePaths
 		});
-		const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		const result = CopilotcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new CopilotSkill({
+		return new CopilotcliSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -51523,8 +54353,8 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
-		const settablePaths = CopilotSkill.getSettablePaths({ global });
-		return new CopilotSkill({
+		const settablePaths = CopilotcliSkill.getSettablePaths({ global });
+		return new CopilotcliSkill({
 			outputRoot,
 			relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
 			dirName,
@@ -51540,26 +54370,25 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 	}
 };
 //#endregion
-//#region src/features/skills/copilotcli-skill.ts
-const CopilotcliSkillFrontmatterSchema = zod_mini.z.looseObject({
+//#region src/features/skills/cortexcode-skill.ts
+const CortexcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	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()),
-	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
-	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
+	/** Tool names the skill may use; omitted = every tool. */
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
 /**
-* Represents a GitHub Copilot CLI skill directory.
+* Represents a Snowflake Cortex Code skill directory.
 *
-* Copilot CLI discovers project skills from `.github/skills/` (shared with the
-* Copilot IDE target) and personal/global skills from `~/.copilot/skills/`. Each
-* skill is a directory containing a `SKILL.md` file with `name`/`description`
-* frontmatter. https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-skills
+* Cortex Code discovers Anthropic-style `<name>/SKILL.md` directories under
+* `<project>/.cortex/skills/` (project scope) and `~/.snowflake/cortex/skills/`
+* (user scope). The frontmatter requires `name` (matching the directory name)
+* and `description`; supporting files next to `SKILL.md` are carried along.
+*
+* @see https://docs.snowflake.com/en/user-guide/cortex-code/extensibility
 */
-var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
-	constructor({ outputRoot = process.cwd(), relativeDirPath = COPILOT_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+var CortexcodeSkill = class CortexcodeSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = CORTEXCODE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
 		super({
 			outputRoot,
 			relativeDirPath,
@@ -51577,12 +54406,11 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			if (!result.success) throw result.error;
 		}
 	}
-	static getSettablePaths(options) {
-		if (options?.global) return { relativeDirPath: COPILOT_SKILLS_GLOBAL_DIR_PATH };
-		return { relativeDirPath: COPILOT_SKILLS_DIR_PATH };
+	static getSettablePaths({ global = false } = {}) {
+		return { relativeDirPath: global ? CORTEXCODE_GLOBAL_SKILLS_DIR_PATH : CORTEXCODE_SKILLS_DIR_PATH };
 	}
 	getFrontmatter() {
-		return CopilotcliSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+		return CortexcodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
 	getBody() {
 		return this.mainFile?.body ?? "";
@@ -51592,23 +54420,27 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 			success: false,
 			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
 		};
-		const result = CopilotcliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		const result = CortexcodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
 		if (!result.success) return {
 			success: false,
 			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
 		};
+		if (result.data.name !== this.getDirName()) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: frontmatter name (${result.data.name}) must match directory name (${this.getDirName()})`)
+		};
 		return {
 			success: true,
 			error: null
 		};
 	}
 	toRulesyncSkill() {
-		const { name, description, ...copilotcliSection } = this.getFrontmatter();
+		const { name, description, ...cortexcodeSection } = this.getFrontmatter();
 		const rulesyncFrontmatter = {
 			name,
 			description,
 			targets: ["*"],
-			...Object.keys(copilotcliSection).length > 0 && { copilotcli: copilotcliSection }
+			...Object.keys(cortexcodeSection).length > 0 && { cortexcode: cortexcodeSection }
 		};
 		return new RulesyncSkill({
 			outputRoot: this.outputRoot,
@@ -51622,35 +54454,19 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		});
 	}
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
-		const settablePaths = CopilotcliSkill.getSettablePaths({ global });
+		const settablePaths = CortexcodeSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-		const copilotcliSection = rulesyncFrontmatter.copilotcli;
-		const resolvedUserInvocable = resolveUserInvocable({
-			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotcliSection
-		});
-		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
-			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotcliSection
-		});
-		const license = resolveLicense({
-			rootFrontmatter: rulesyncFrontmatter,
-			section: copilotcliSection
-		});
-		const { "user-invocable": _userInvocable, "disable-model-invocation": _disableModelInvocation, license: _license, ...copilotcliFields } = copilotcliSection ?? {};
-		const copilotcliFrontmatter = {
-			...copilotcliFields,
+		const { name: _sectionName, description: _sectionDescription, ...cortexcodeSection } = rulesyncFrontmatter.cortexcode ?? {};
+		const cortexcodeFrontmatter = {
+			...cortexcodeSection,
 			name: rulesyncFrontmatter.name,
-			description: rulesyncFrontmatter.description,
-			...license !== void 0 && { license },
-			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
-			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
+			description: rulesyncFrontmatter.description
 		};
-		return new CopilotcliSkill({
+		return new CortexcodeSkill({
 			outputRoot,
 			relativeDirPath: settablePaths.relativeDirPath,
-			dirName: rulesyncSkill.getDirName(),
-			frontmatter: copilotcliFrontmatter,
+			dirName: cortexcodeFrontmatter.name,
+			frontmatter: cortexcodeFrontmatter,
 			body: rulesyncSkill.getBody(),
 			otherFiles: rulesyncSkill.getOtherFiles(),
 			validate,
@@ -51659,19 +54475,23 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 	}
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		const targets = rulesyncSkill.getFrontmatter().targets;
-		return targets.includes("*") || targets.includes("copilotcli");
+		return targets.includes("*") || targets.includes("cortexcode");
 	}
 	static async fromDir(params) {
 		const loaded = await this.loadSkillDirContent({
 			...params,
-			getSettablePaths: CopilotcliSkill.getSettablePaths
+			getSettablePaths: CortexcodeSkill.getSettablePaths
 		});
-		const result = CopilotcliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		const result = CortexcodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new CopilotcliSkill({
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
+		}
+		return new CortexcodeSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -51683,10 +54503,9 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
-		const settablePaths = CopilotcliSkill.getSettablePaths({ global });
-		return new CopilotcliSkill({
+		return new CortexcodeSkill({
 			outputRoot,
-			relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
+			relativeDirPath,
 			dirName,
 			frontmatter: {
 				name: "",
@@ -55010,6 +57829,154 @@ var RooSkill = class RooSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/tabnine-skill.ts
+const TabnineSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string()
+});
+/**
+* Represents a Tabnine CLI skill directory.
+*
+* Tabnine CLI discovers Anthropic-style `<name>/SKILL.md` directories under
+* `<project>/.tabnine/agent/skills/` (workspace scope) and
+* `~/.tabnine/agent/skills/` (user scope); the workspace copy wins on a name
+* clash. The frontmatter requires `name` (matching the directory name) and
+* `description`; supporting files next to `SKILL.md` are carried along.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/agent-skills
+*/
+var TabnineSkill = class TabnineSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = TABNINE_SKILLS_DIR_PATH, dirName, frontmatter, body, otherFiles = [], validate = true, global = false }) {
+		super({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			mainFile: {
+				name: SKILL_FILE_NAME,
+				body,
+				frontmatter: { ...frontmatter }
+			},
+			otherFiles,
+			global
+		});
+		if (validate) {
+			const result = this.validate();
+			if (!result.success) throw result.error;
+		}
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: TABNINE_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return TabnineSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
+	}
+	getBody() {
+		return this.mainFile?.body ?? "";
+	}
+	validate() {
+		if (!this.mainFile) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+		};
+		const result = TabnineSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+		if (!result.success) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`)
+		};
+		if (result.data.name !== this.getDirName()) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`${this.getDirPath()}: frontmatter name (${result.data.name}) must match directory name (${this.getDirName()})`)
+		};
+		return {
+			success: true,
+			error: null
+		};
+	}
+	toRulesyncSkill() {
+		const { name, description, ...tabnineSection } = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(tabnineSection).length > 0 && { tabnine: tabnineSection }
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const settablePaths = TabnineSkill.getSettablePaths({ global });
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const { name: _sectionName, description: _sectionDescription, ...tabnineSection } = rulesyncFrontmatter.tabnine ?? {};
+		const tabnineFrontmatter = {
+			...tabnineSection,
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		return new TabnineSkill({
+			outputRoot,
+			relativeDirPath: settablePaths.relativeDirPath,
+			dirName: tabnineFrontmatter.name,
+			frontmatter: tabnineFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("tabnine");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: TabnineSkill.getSettablePaths
+		});
+		const result = TabnineSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		if (!result.success) {
+			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
+		}
+		return new TabnineSkill({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: result.data,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new TabnineSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/skills/takt-skill.ts
 /**
 * Skill generator for TAKT.
@@ -55898,6 +58865,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["bob", {
+		class: BobSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeSkill,
 		meta: {
@@ -55954,6 +58929,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["crush", {
 		class: CrushSkill,
 		meta: {
@@ -56131,6 +59114,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["tabnine", {
+		class: TabnineSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["takt", {
 		class: TaktSkill,
 		meta: {
@@ -58325,6 +61316,135 @@ var CopilotcliSubagent = class CopilotcliSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/cortexcode-subagent.ts
+const CortexcodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	/** Tool names the subagent may use; omitted = every tool. */
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	model: zod_mini.z.optional(zod_mini.z.string())
+});
+/**
+* Snowflake Cortex Code subagent: a Markdown file with YAML frontmatter under
+* `.cortex/agents/` (project) or `~/.snowflake/cortex/agents/` (user).
+*/
+var CortexcodeSubagent = class CortexcodeSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = CortexcodeSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { relativeDirPath: global ? CORTEXCODE_GLOBAL_AGENTS_DIR_PATH : CORTEXCODE_AGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, ...rest } = this.frontmatter;
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name,
+				description,
+				cortexcode: { ...rest }
+			},
+			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 cortexcodeSection = rulesyncFrontmatter.cortexcode ?? {};
+		const cortexcodeSubagentFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...cortexcodeSection
+		};
+		const body = rulesyncSubagent.getBody();
+		const fileContent = stringifyFrontmatter(body, cortexcodeSubagentFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
+		return new CortexcodeSubagent({
+			outputRoot,
+			frontmatter: cortexcodeSubagentFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = CortexcodeSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else 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: "cortexcode"
+		});
+	}
+	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 = CortexcodeSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new CortexcodeSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CortexcodeSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/cursor-subagent.ts
 const CursorSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -60777,6 +63897,145 @@ var RooSubagent = class extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/tabnine-subagent.ts
+const TabnineSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	/** "local" (default) runs inside the CLI; "remote" delegates to a Tabnine cloud agent. */
+	kind: zod_mini.z.optional(zod_mini.z.string()),
+	/** Built-in tool names the subagent may use; omitted = every tool. */
+	tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	/** Sampling temperature, 0.0-2.0. */
+	temperature: zod_mini.z.optional(zod_mini.z.number()),
+	/** Maximum agent turns (Tabnine default: 15). */
+	max_turns: zod_mini.z.optional(zod_mini.z.number()),
+	/** Wall-clock budget in minutes (Tabnine default: 5). */
+	timeout_mins: zod_mini.z.optional(zod_mini.z.number())
+});
+/**
+* Tabnine CLI subagent: a Markdown file with YAML frontmatter under
+* `.tabnine/agent/agents/` (project) or `~/.tabnine/agent/agents/` (user).
+* Tabnine only loads these when `experimental.enableAgents` is `true` in its
+* settings; rulesync writes the files and leaves that flag to the user.
+*/
+var TabnineSubagent = class TabnineSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = TabnineSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: TABNINE_AGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, ...rest } = this.frontmatter;
+		return new RulesyncSubagent({
+			outputRoot: ".",
+			frontmatter: {
+				targets: ["*"],
+				name,
+				description,
+				tabnine: { ...rest }
+			},
+			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 tabnineSection = rulesyncFrontmatter.tabnine ?? {};
+		const tabnineSubagentFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...tabnineSection
+		};
+		const body = rulesyncSubagent.getBody();
+		const fileContent = stringifyFrontmatter(body, tabnineSubagentFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
+		return new TabnineSubagent({
+			outputRoot,
+			frontmatter: tabnineSubagentFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = TabnineSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else 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: "tabnine"
+		});
+	}
+	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 = TabnineSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new TabnineSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new TabnineSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/takt-subagent.ts
 /**
 * Subagent generator for TAKT.
@@ -61408,6 +64667,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.agent.md"
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["cursor", {
 		class: CursorSubagent,
 		meta: {
@@ -61579,6 +64847,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["tabnine", {
+		class: TabnineSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["takt", {
 		class: TaktSubagent,
 		meta: {
@@ -63130,6 +66407,95 @@ var AugmentcodeRule = class AugmentcodeRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/bob-rule.ts
+/**
+* Rule generator for IBM Bob (Bob IDE and Bob Shell).
+*
+* Bob auto-loads plain-markdown instruction files with no frontmatter:
+*
+* - Project scope: the cross-tool `AGENTS.md` at the project root plus every
+*   `.bob/rules/*.md` file (read recursively in alphabetical order).
+* - Global scope: `~/.bob/AGENTS.md` plus `~/.bob/rules/*.md`.
+*
+* The workspace files override the user files. Bob's mode-specific
+* `.bob/rules-{mode}/` directories are left alone: rulesync has no notion of
+* Bob's modes, and a rule that should apply everywhere belongs in `.bob/rules/`.
+*
+* @see https://bob.ibm.com/docs/ide/configuration/rules
+* @see https://bob.ibm.com/docs/shell/configuration/configuring (user-scoped `~/.bob/AGENTS.md`)
+*/
+var BobRule = class BobRule extends ToolRule {
+	static getSettablePaths({ global, excludeToolDir } = {}) {
+		return {
+			root: {
+				relativeDirPath: global ? buildToolPath(BOB_DIR, ".", excludeToolDir) : ".",
+				relativeFilePath: BOB_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(BOB_DIR, "rules", excludeToolDir) }
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		if (relativeFilePath === paths.root.relativeFilePath) {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.root.relativeDirPath, paths.root.relativeFilePath));
+			return new BobRule({
+				outputRoot,
+				relativeDirPath: paths.root.relativeDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				fileContent,
+				validate,
+				root: true
+			});
+		}
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.nonRoot.relativeDirPath, relativeFilePath));
+		return new BobRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate,
+			root: false
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		return new BobRule(this.buildToolRuleParamsDefault({
+			outputRoot,
+			rulesyncRule,
+			validate,
+			rootPath: paths.root,
+			nonRootPath: paths.nonRoot
+		}));
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath !== paths.nonRoot.relativeDirPath;
+		return new BobRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: isRoot
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "bob"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/claudecode-language-settings.ts
 /**
 * Claude Code's native home for the root `language` key of `rulesync.jsonc`.
@@ -64344,6 +67710,73 @@ var CopilotcliRule = class CopilotcliRule extends CopilotRule {
 	}
 };
 //#endregion
+//#region src/features/rules/cortexcode-rule.ts
+var CortexcodeRule = class CortexcodeRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return { root: {
+			relativeDirPath: ".",
+			relativeFilePath: CORTEXCODE_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
+		return new CortexcodeRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const { root } = this.getSettablePaths({ global });
+		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		return new CortexcodeRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: isRoot
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CortexcodeRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "AGENTS.md" && relativeDirPath === "."
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "cortexcode"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/crush-rule.ts
 var CrushRule = class CrushRule extends ToolRule {
 	constructor({ fileContent, root, ...rest }) {
@@ -67421,6 +70854,97 @@ var RovodevRule = class RovodevRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/tabnine-rule.ts
+/**
+* Rule generator for Tabnine CLI.
+*
+* - Project scope: `TABNINE.md` at the project root is the CLI's memory file
+*   (loaded on every session, refreshed with `/memory reload`). Non-root
+*   rules go to `.tabnine/guidelines/*.md`, the guideline directory the
+*   Tabnine IDE agent reads; the CLI does not auto-load that directory, so
+*   the processor lists the files from `TABNINE.md` (toon mode).
+* - Global scope: `~/.tabnine/agent/TABNINE.md` next to the other user-scoped
+*   agent assets (the CLI documents no user-level memory file, so this path
+*   mirrors the `~/.gemini/GEMINI.md` convention of the Gemini CLI it is
+*   derived from) plus `~/.tabnine/guidelines/*.md`.
+*
+* Rule files are plain Markdown without frontmatter.
+*
+* @see https://docs.tabnine.com/main/getting-started/tabnine-cli/features/settings/settings-reference (`context.fileName`, `/memory`)
+* @see https://docs.tabnine.com/main/getting-started/tabnine-agent/guidelines (`.tabnine/guidelines/`)
+*/
+var TabnineRule = class TabnineRule extends ToolRule {
+	static getSettablePaths({ global, excludeToolDir } = {}) {
+		return {
+			root: {
+				relativeDirPath: global ? buildToolPath(TABNINE_AGENT_DIR_PATH, ".", excludeToolDir) : ".",
+				relativeFilePath: TABNINE_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(TABNINE_DIR, "guidelines", excludeToolDir) }
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		if (relativeFilePath === paths.root.relativeFilePath) {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.root.relativeDirPath, paths.root.relativeFilePath));
+			return new TabnineRule({
+				outputRoot,
+				relativeDirPath: paths.root.relativeDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				fileContent,
+				validate,
+				root: true
+			});
+		}
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, paths.nonRoot.relativeDirPath, relativeFilePath));
+		return new TabnineRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate,
+			root: false
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		return new TabnineRule(this.buildToolRuleParamsDefault({
+			outputRoot,
+			rulesyncRule,
+			validate,
+			rootPath: paths.root,
+			nonRootPath: paths.nonRoot
+		}));
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath !== paths.nonRoot.relativeDirPath;
+		return new TabnineRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: isRoot
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "tabnine"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/takt-rule.ts
 /**
 * Default facet directory for TAKT rule files.
@@ -67983,6 +71507,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "toon"
 		}
 	}],
+	["bob", {
+		class: BobRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeRule,
 		meta: {
@@ -68046,6 +71578,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: false,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["crush", {
 		class: CrushRule,
 		meta: {
@@ -68252,6 +71793,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			localRootFileName: "AGENTS.local.md"
 		}
 	}],
+	["tabnine", {
+		class: TabnineRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "toon"
+		}
+	}],
 	["takt", {
 		class: TaktRule,
 		meta: {
@@ -71889,6 +75438,18 @@ Object.defineProperty(exports, "RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH", {
 		return RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH;
 	}
 });
+Object.defineProperty(exports, "RULESYNC_USER_CONFIG_DIR_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_USER_CONFIG_DIR_NAME;
+	}
+});
+Object.defineProperty(exports, "RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME", {
+	enumerable: true,
+	get: function() {
+		return RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME;
+	}
+});
 Object.defineProperty(exports, "RulesProcessor", {
 	enumerable: true,
 	get: function() {
@@ -72039,6 +75600,12 @@ Object.defineProperty(exports, "assertDirectoryIfExists", {
 		return assertDirectoryIfExists;
 	}
 });
+Object.defineProperty(exports, "assertTargetsFeaturesExclusive", {
+	enumerable: true,
+	get: function() {
+		return assertTargetsFeaturesExclusive;
+	}
+});
 Object.defineProperty(exports, "assertTreeContainsNoSymlinks", {
 	enumerable: true,
 	get: function() {