rulesync 16.30.2 → 16.31.0

package/dist/{import-BknrMODR.js → import-D2GhBXJV.js}

@@ -422,6 +422,8 @@ const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim())
 const { join: join$1 } = 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$1(RULES_FEATURE_SUBDIR, ".curated");
@@ -470,6 +472,7 @@ const rulesProcessorToolTargetTuple = [
 	"antigravity-plugin",
 	"augmentcode",
 	"augmentcode-legacy",
+	"bob",
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
@@ -477,6 +480,7 @@ const rulesProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"crush",
 	"cursor",
 	"deepagents",
@@ -498,6 +502,7 @@ const rulesProcessorToolTargetTuple = [
 	"replit",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -512,6 +517,7 @@ const ignoreProcessorToolTargetTuple = [
 	"aiassistant",
 	"antigravity-cli",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
@@ -526,6 +532,7 @@ const ignoreProcessorToolTargetTuple = [
 	"qwencode",
 	"reasonix",
 	"roo",
+	"tabnine",
 	"devin",
 	"vibe",
 	"warp",
@@ -539,6 +546,7 @@ const mcpProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"antigravity-plugin",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -546,6 +554,7 @@ const mcpProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"cursor",
 	"deepagents",
 	"factorydroid",
@@ -564,6 +573,7 @@ const mcpProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -577,6 +587,7 @@ const commandsProcessorToolTargetTuple = [
 	"antigravity-cli",
 	"antigravity-ide",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -600,6 +611,7 @@ const commandsProcessorToolTargetTuple = [
 	"roo",
 	"zoocode",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"devin",
 	"warp",
@@ -619,6 +631,7 @@ const subagentsProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"cursor",
 	"deepagents",
 	"devin",
@@ -637,6 +650,7 @@ const subagentsProcessorToolTargetTuple = [
 	"roo",
 	"zoocode",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"zcode"
@@ -650,6 +664,7 @@ const skillsProcessorToolTargetTuple = [
 	"antigravity-ide",
 	"antigravity-plugin",
 	"augmentcode",
+	"bob",
 	"claudecode",
 	"claudecode-plugin",
 	"claudecode-legacy",
@@ -657,6 +672,7 @@ const skillsProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"crush",
 	"cursor",
 	"deepagents",
@@ -678,6 +694,7 @@ const skillsProcessorToolTargetTuple = [
 	"replit",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -700,6 +717,7 @@ const hooksProcessorToolTargetTuple = [
 	"codexcli",
 	"copilot",
 	"copilotcli",
+	"cortexcode",
 	"opencode",
 	"pi",
 	"factorydroid",
@@ -712,10 +730,12 @@ const hooksProcessorToolTargetTuple = [
 	"kiro-ide",
 	"devin",
 	"augmentcode",
+	"bob",
 	"junie",
 	"vibe",
 	"qwencode",
 	"reasonix",
+	"tabnine",
 	"grokcli",
 	"zcode"
 ];
@@ -748,6 +768,7 @@ const permissionsProcessorToolTargetTuple = [
 	"reasonix",
 	"roo",
 	"rovodev",
+	"tabnine",
 	"takt",
 	"vibe",
 	"warp",
@@ -3233,16 +3254,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",
@@ -4753,6 +4779,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
@@ -4905,6 +5035,9 @@ const HooksConfigSchema = z.looseObject({
 	grokcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	"kimi-code": z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	zcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	bob: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	cortexcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	tabnine: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -5906,6 +6039,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	"antigravity-ide": z.optional(toolScopedMcpSchema),
 	aiassistant: z.optional(toolScopedMcpSchema),
 	augmentcode: z.optional(toolScopedMcpSchema),
+	bob: z.optional(toolScopedMcpSchema),
 	claudecode: z.optional(toolScopedMcpSchema),
 	cline: z.optional(toolScopedMcpSchema),
 	codexcli: z.optional(toolScopedMcpSchema),
@@ -5927,6 +6061,8 @@ const RulesyncMcpFileSchema = z.looseObject({
 	reasonix: z.optional(toolScopedMcpSchema),
 	roo: z.optional(toolScopedMcpSchema),
 	rovodev: z.optional(toolScopedMcpSchema),
+	cortexcode: z.optional(toolScopedMcpSchema),
+	tabnine: z.optional(toolScopedMcpSchema),
 	takt: z.optional(toolScopedMcpSchema),
 	vibe: z.optional(toolScopedMcpSchema),
 	warp: z.optional(toolScopedMcpSchema),
@@ -6748,6 +6884,27 @@ const QwencodePermissionsOverrideSchema = z.looseObject({
 	autoMode: z.optional(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 = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	tools: z.optional(z.looseObject({})),
+	general: z.optional(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`,
@@ -7508,6 +7665,7 @@ const PermissionsConfigSchema = z.looseObject({
 	factorydroid: z.optional(FactorydroidPermissionsOverrideSchema),
 	warp: z.optional(WarpPermissionsOverrideSchema),
 	junie: z.optional(JuniePermissionsOverrideSchema),
+	tabnine: z.optional(TabninePermissionsOverrideSchema),
 	takt: z.optional(TaktPermissionsOverrideSchema),
 	amp: z.optional(AmpPermissionsOverrideSchema),
 	"antigravity-cli": z.optional(AntigravityCliPermissionsOverrideSchema),
@@ -9155,6 +9313,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 	})),
 	cline: z.optional(z.looseObject({})),
 	roo: z.optional(z.looseObject({})),
+	bob: z.optional(z.looseObject({})),
 	amp: z.optional(z.looseObject({})),
 	devin: z.optional(z.looseObject({
 		"argument-hint": z.optional(z.string()),
@@ -9232,6 +9391,8 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		"user-invocable": z.optional(z.boolean()),
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
 	})),
+	cortexcode: z.optional(z.looseObject({})),
+	tabnine: z.optional(z.looseObject({})),
 	takt: z.optional(z.looseObject({
 		name: z.optional(z.string()),
 		extends: z.optional(z.string())
@@ -12794,6 +12955,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: {
@@ -14486,6 +14694,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";
+join(BOB_DIR, "rules");
+const BOB_IGNORE_FILE_NAME = ".bobignore";
+const BOB_MCP_FILE_NAME = "mcp.json";
+const BOB_COMMANDS_DIR_PATH = join(BOB_DIR, "commands");
+const BOB_SKILLS_DIR_PATH = join(BOB_DIR, "skills");
+const BOB_SETTINGS_FILE_NAME = "settings.json";
+const BOB_GLOBAL_SETTINGS_DIR_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 = z.looseObject({
+	description: z.optional(z.string()),
+	"argument-hint": z.optional(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 ${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 ${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 = 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 = z.looseObject({
 	description: z.optional(z.string()),
@@ -18212,6 +18554,193 @@ var RovodevPromptsManifest = class extends ToolFile {
 	}
 };
 //#endregion
+//#region src/constants/tabnine-paths.ts
+const TABNINE_DIR = ".tabnine";
+const TABNINE_AGENT_DIR_PATH = join(TABNINE_DIR, "agent");
+const TABNINE_RULE_FILE_NAME = "TABNINE.md";
+join(TABNINE_DIR, "guidelines");
+const TABNINE_IGNORE_FILE_NAME = ".tabnineignore";
+const TABNINE_SETTINGS_FILE_NAME = "settings.json";
+const TABNINE_COMMANDS_DIR_PATH = join(TABNINE_AGENT_DIR_PATH, "commands");
+const TABNINE_AGENTS_DIR_PATH = join(TABNINE_AGENT_DIR_PATH, "agents");
+const TABNINE_SKILLS_DIR_PATH = join(TABNINE_AGENT_DIR_PATH, "skills");
+//#endregion
+//#region src/features/commands/tabnine-command.ts
+const TabnineCommandFrontmatterSchema = z.looseObject({
+	description: z.optional(z.string()),
+	prompt: 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 = parse$1(content);
+			const result = TabnineCommandFrontmatterSchema.safeParse(parsed);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${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 (${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 = 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(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.
@@ -18683,6 +19212,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: {
@@ -18914,6 +19453,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: {
@@ -20953,6 +21502,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(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 = 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 = 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.
@@ -22518,6 +23196,151 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/constants/cortexcode-paths.ts
+const CORTEXCODE_DIR = ".cortex";
+const CORTEXCODE_GLOBAL_DIR_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 = join(CORTEXCODE_DIR, "agents");
+const CORTEXCODE_GLOBAL_AGENTS_DIR_PATH = join(CORTEXCODE_GLOBAL_DIR_PATH, "agents");
+const CORTEXCODE_SKILLS_DIR_PATH = join(CORTEXCODE_DIR, "skills");
+const CORTEXCODE_GLOBAL_SKILLS_DIR_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(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 = 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 = 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) {
@@ -25745,6 +26568,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 = z.looseObject({
+	type: z.optional(z.string()),
+	command: z.optional(z.string()),
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	timeout: z.optional(z.number()),
+	env: z.optional(z.record(z.string(), z.string()))
+});
+const TabnineMatcherEntrySchema = z.looseObject({
+	matcher: z.optional(z.string()),
+	sequential: z.optional(z.boolean()),
+	hooks: z.optional(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(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 = 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 = 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";
@@ -26504,6 +27591,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: {
@@ -26515,6 +27636,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: {
@@ -26961,6 +28093,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(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";
 /**
@@ -27990,6 +29174,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(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() {
@@ -28195,6 +29433,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 }],
@@ -28211,6 +29450,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 }]
@@ -28945,6 +30185,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: 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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: 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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2),
+			relativePath: 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;
@@ -29652,104 +31229,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
@@ -30018,6 +31497,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: 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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: 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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2),
+			relativePath: 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}`,
@@ -33979,6 +35674,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: 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(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 = 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`
@@ -34938,6 +36838,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["bob", {
+		class: BobMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeMcp,
 		meta: {
@@ -35001,6 +36910,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeMcp,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["cursor", {
 		class: CursorMcp,
 		meta: {
@@ -35172,6 +37090,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["tabnine", {
+		class: TabnineMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
+		}
+	}],
 	["takt", {
 		class: TaktMcp,
 		meta: {
@@ -36376,7 +38303,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`,
@@ -36390,7 +38317,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
@@ -36862,7 +38789,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 }
 //#endregion
 //#region src/features/permissions/augmentcode-permissions.ts
-const moduleLogger$2 = fallbackLogger;
+const moduleLogger$3 = fallbackLogger;
 z.enum([
 	"allow",
 	"deny",
@@ -37161,7 +39088,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) });
@@ -37535,6 +39462,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
@@ -37545,7 +39480,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
@@ -43667,7 +45602,7 @@ const QwenSettingsPermissionsSchema = z.looseObject({
 	deny: z.optional(z.array(z.string()))
 });
 const QwenSettingsSchema = z.looseObject({ permissions: 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).
@@ -44030,7 +45965,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.`);
@@ -44223,7 +46158,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 });
@@ -45549,6 +47484,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: uniq(allowed),
+		exclude: 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(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 = 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 ${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 = uniq([
+			...allowed,
+			...overrideVerbatimAllowed,
+			...preservedEntries(ALLOWED_KEY)
+		]);
+		const excludeList = uniq([
+			...exclude,
+			...overrideExclude,
+			...preservedEntries(EXCLUDE_KEY)
+		]);
+		const droppedExcludeEntries = 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: 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 = 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";
@@ -48928,6 +51442,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["tabnine", {
+		class: TabninePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["takt", {
 		class: TaktPermissions,
 		meta: {
@@ -50225,16 +52747,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${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 = z.looseObject({
+	name: z.string(),
+	description: 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,
@@ -50243,19 +52947,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new this({
+		return new AugmentcodeSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -50267,9 +52971,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: "",
@@ -50283,66 +52988,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 = z.looseObject({
+//#region src/features/skills/bob-skill.ts
+const BobSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: 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,
@@ -50361,38 +53024,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,
@@ -50406,17 +53071,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,
@@ -50425,19 +53092,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new AugmentcodeSkill({
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = 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,
@@ -50449,10 +53120,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: "",
@@ -51397,7 +54067,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${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 = z.looseObject({
+	name: z.string(),
+	description: z.string(),
+	license: z.optional(z.string()),
+	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
+	"argument-hint": z.optional(z.string()),
+	"user-invocable": z.optional(z.boolean()),
+	"disable-model-invocation": z.optional(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 ?? "";
@@ -51407,7 +54237,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)}`)
@@ -51418,12 +54248,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,
@@ -51437,35 +54267,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,
@@ -51474,19 +54304,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new CopilotSkill({
+		return new CopilotcliSkill({
 			outputRoot: loaded.outputRoot,
 			relativeDirPath: loaded.relativeDirPath,
 			dirName: loaded.dirName,
@@ -51498,8 +54328,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,
@@ -51515,26 +54345,25 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 	}
 };
 //#endregion
-//#region src/features/skills/copilotcli-skill.ts
-const CopilotcliSkillFrontmatterSchema = z.looseObject({
+//#region src/features/skills/cortexcode-skill.ts
+const CortexcodeSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
 	description: z.string(),
-	license: z.optional(z.string()),
-	"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())])),
-	"argument-hint": z.optional(z.string()),
-	"user-invocable": z.optional(z.boolean()),
-	"disable-model-invocation": z.optional(z.boolean())
+	/** Tool names the skill may use; omitted = every tool. */
+	tools: z.optional(z.array(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,
@@ -51552,12 +54381,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 ?? "";
@@ -51567,23 +54395,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,
@@ -51597,35 +54429,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,
@@ -51634,19 +54450,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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
 		}
-		return new CopilotcliSkill({
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = 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,
@@ -51658,10 +54478,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: "",
@@ -54985,6 +57804,154 @@ var RooSkill = class RooSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/tabnine-skill.ts
+const TabnineSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: 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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = 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.
@@ -55873,6 +58840,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["bob", {
+		class: BobSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeSkill,
 		meta: {
@@ -55929,6 +58904,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["crush", {
 		class: CrushSkill,
 		meta: {
@@ -56106,6 +59089,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["tabnine", {
+		class: TabnineSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["takt", {
 		class: TaktSkill,
 		meta: {
@@ -58300,6 +61291,135 @@ var CopilotcliSubagent = class CopilotcliSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/cortexcode-subagent.ts
+const CortexcodeSubagentFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	/** Tool names the subagent may use; omitted = every tool. */
+	tools: z.optional(z.array(z.string())),
+	model: z.optional(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 ${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 ${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 = 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 = z.looseObject({
 	name: z.string(),
@@ -60752,6 +63872,145 @@ var RooSubagent = class extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/tabnine-subagent.ts
+const TabnineSubagentFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	/** "local" (default) runs inside the CLI; "remote" delegates to a Tabnine cloud agent. */
+	kind: z.optional(z.string()),
+	/** Built-in tool names the subagent may use; omitted = every tool. */
+	tools: z.optional(z.array(z.string())),
+	model: z.optional(z.string()),
+	/** Sampling temperature, 0.0-2.0. */
+	temperature: z.optional(z.number()),
+	/** Maximum agent turns (Tabnine default: 15). */
+	max_turns: z.optional(z.number()),
+	/** Wall-clock budget in minutes (Tabnine default: 5). */
+	timeout_mins: z.optional(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 ${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 ${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 = 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.
@@ -61383,6 +64642,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: {
@@ -61554,6 +64822,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["tabnine", {
+		class: TabnineSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["takt", {
 		class: TaktSubagent,
 		meta: {
@@ -63105,6 +66382,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(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(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`.
@@ -64319,6 +67685,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 = join(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent(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 }) {
@@ -67396,6 +70829,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(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(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.
@@ -67958,6 +71482,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "toon"
 		}
 	}],
+	["bob", {
+		class: BobRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["claudecode", {
 		class: ClaudecodeRule,
 		meta: {
@@ -68021,6 +71553,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
+	["cortexcode", {
+		class: CortexcodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: false,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["crush", {
 		class: CrushRule,
 		meta: {
@@ -68227,6 +71768,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			localRootFileName: "AGENTS.local.md"
 		}
 	}],
+	["tabnine", {
+		class: TabnineRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "toon"
+		}
+	}],
 	["takt", {
 		class: TaktRule,
 		meta: {
@@ -71474,6 +75023,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { RulesyncCheck as $, ALL_TOOL_TARGETS as $t, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as An, ensureDir as At, RulesyncSkill as B, quoteForLog as Bn, pathEscapesRoot as Bt, ChecksProcessor as C, RULESYNC_PERMISSIONS_FILE_NAME as Cn, applyFileMode as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_RELATIVE_DIR_PATH as Dn, checkPathTraversal as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_SCHEMA_URL as En, assertWritablePathInsideRoot as Et, AUGMENTCODE_DIR as F, DEPRECATED_FEATURE_REPLACEMENTS as Fn, isFileSystemError as Ft, RulesyncMcp as G, removeFile as Gt, RulesyncRule as H, stripControlCharactersKeepingLineFeeds as Hn, readFileContentOrNull as Ht, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as I, formatError as In, isSymlink as It, getRulesyncSourceCandidates as J, resolvePath as Jt, RulesyncIgnore as K, removeFileStrict as Kt, getLocalSkillDirNames as L, truncateText as Ln, listDirectoryEntryNames as Lt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as M, parseCommaSeparatedList as Mn, getFileSize as Mt, caseFoldIdentity as N, ALL_FEATURES as Nn, getHomeDirectory as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RULES_RELATIVE_DIR_PATH as On, createTempDirectory as Ot, groupSpellingsByCaseFoldedIdentity as P, ALL_FEATURES_WITH_WILDCARD as Pn, isFileNotFoundError as Pt, RulesyncCommandFrontmatterSchema as Q, writeFileContent as Qt, RulesyncSubagent as R, hasDeceptiveHiddenCharacters as Rn, listFilePathsRecursively as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Sn, ErrorCodes as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Tn, assertTreeContainsNoSymlinks as Tt, RulesyncRuleFrontmatterSchema as U, stripHiddenCharacters as Un, removeDirectory as Ut, RulesyncSkillFrontmatterSchema as V, stripControlCharacters as Vn, readFileContent as Vt, RulesyncPermissions as W, removeDirectoryStrict as Wt, parseJsonc as X, toPosixPath as Xt, resolveRulesyncSourceWritePath as Y, runWithDirectoryRollback as Yt, RulesyncCommand as Z, writeFileBuffer as Zt, IgnoreProcessor as _, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as _n, warnOnConflictingFlags as _t, getProcessorRegistryEntry as a, RULESYNC_AIIGNORE_FILE_NAME as an, ConfigResolver as at, CommandsProcessor as b, RULESYNC_MCP_RELATIVE_FILE_PATH as bn, withWarnOnceScope as bt, RulesProcessor as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as cn, CONFLICTING_TARGET_PAIRS as ct, CODEBUDDY_DIR as d, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as dn, SourceEntrySchema as dt, ALL_TOOL_TARGETS_WITH_WILDCARD as en, RulesyncCheckFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as fn, findControlCharacter as ft, McpProcessor as g, RULESYNC_IGNORE_RELATIVE_FILE_PATH as gn, fallbackLogger as gt, shortenToWidth as h, RULESYNC_HOOKS_RELATIVE_FILE_PATH as hn, WarningCollectingLogger as ht, inspectInputRoots as i, MAX_FILE_SIZE as in, SKILL_FILE_NAME as it, FACTORYDROID_DIR as j, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as jn, fileExists as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_SKILLS_RELATIVE_DIR_PATH as kn, directoryExists as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ln, ConfigFileSchema as lt, displayWidthOf as m, RULESYNC_HOOKS_LEGACY_FILE_NAME as mn, JsonLogger as mt, formatSourceLoadFailure as n, ToolTargetSchema as nn, loadYaml as nt, convertFromTool as o, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as on, mergeInputRootConfigs as ot, ELLIPSIS_WIDTH as p, RULESYNC_HOOKS_FILE_NAME as pn, ConsoleLogger as pt, RulesyncHooks as q, removeTempDirectory as qt, generate as r, CURATED_RULES_FEATURE_SUBDIR as rn, SHARED_USER_MANAGED_CONFIG_PATHS as rt, isPackagingToolTarget as s, RULESYNC_CHECKS_RELATIVE_DIR_PATH as sn, resolveEffectiveInputRoots as st, importFromTool as t, PACKAGING_TOOL_TARGETS as tn, stringifyFrontmatter as tt, SkillsProcessor as u, RULESYNC_CONFIG_SCHEMA_URL as un, GITIGNORE_DESTINATION_KEY as ut, CRUSH_LOCAL_RULE_FILE_NAME as v, RULESYNC_MCP_FILE_NAME as vn, withFallbackLoggerTarget as vt, CODEXCLI_BASH_RULES_FILE_NAME as w, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as wn, assertDirectoryIfExists as wt, QWENCODE_DIR as x, RULESYNC_MCP_SCHEMA_URL as xn, CLIError as xt, HooksProcessor as y, RULESYNC_MCP_LEGACY_FILE_NAME as yn, resetRunWarningState as yt, RulesyncSubagentFrontmatterSchema as z, hasEnclosingMarkOutsideKeycap as zn, listSubdirectoryNames as zt };
+export { RulesyncCheck as $, writeFileContent as $t, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SKILLS_RELATIVE_DIR_PATH as An, directoryExists as At, RulesyncSkill as B, truncateText as Bn, listSubdirectoryNames as Bt, ChecksProcessor as C, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Cn, ErrorCodes as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_PERMISSIONS_SCHEMA_URL as Dn, assertWritablePathInsideRoot as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as En, assertTreeContainsNoSymlinks as Et, AUGMENTCODE_DIR as F, parseCommaSeparatedList as Fn, isFileNotFoundError as Ft, RulesyncMcp as G, stripControlCharactersKeepingLineFeeds as Gn, removeDirectoryStrict as Gt, RulesyncRule as H, hasEnclosingMarkOutsideKeycap as Hn, readFileContent as Ht, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as I, ALL_FEATURES as In, isFileSystemError as It, getRulesyncSourceCandidates as J, removeTempDirectory as Jt, RulesyncIgnore as K, stripHiddenCharacters as Kn, removeFile as Kt, getLocalSkillDirNames as L, ALL_FEATURES_WITH_WILDCARD as Ln, isSymlink as Lt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as M, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Mn, fileExists as Mt, caseFoldIdentity as N, RULESYNC_USER_CONFIG_DIR_NAME as Nn, getFileSize as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RELATIVE_DIR_PATH as On, checkPathTraversal as Ot, groupSpellingsByCaseFoldedIdentity as P, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as Pn, getHomeDirectory as Pt, RulesyncCommandFrontmatterSchema as Q, writeFileBuffer as Qt, RulesyncSubagent as R, DEPRECATED_FEATURE_REPLACEMENTS as Rn, listDirectoryEntryNames as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_MCP_SCHEMA_URL as Sn, CLIError as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as Tn, assertDirectoryIfExists as Tt, RulesyncRuleFrontmatterSchema as U, quoteForLog as Un, readFileContentOrNull as Ut, RulesyncSkillFrontmatterSchema as V, hasDeceptiveHiddenCharacters as Vn, pathEscapesRoot as Vt, RulesyncPermissions as W, stripControlCharacters as Wn, removeDirectory as Wt, parseJsonc as X, runWithDirectoryRollback as Xt, resolveRulesyncSourceWritePath as Y, resolvePath as Yt, RulesyncCommand as Z, toPosixPath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, fallbackLogger as _t, getProcessorRegistryEntry as a, MAX_FILE_SIZE as an, ConfigResolver as at, CommandsProcessor as b, RULESYNC_MCP_LEGACY_FILE_NAME as bn, resetRunWarningState as bt, RulesProcessor as c, RULESYNC_CHECKS_RELATIVE_DIR_PATH as cn, CONFLICTING_TARGET_PAIRS as ct, CODEBUDDY_DIR as d, RULESYNC_CONFIG_SCHEMA_URL as dn, SourceEntrySchema as dt, ALL_TOOL_TARGETS as en, RulesyncCheckFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as fn, assertTargetsFeaturesExclusive as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, WarningCollectingLogger as gt, shortenToWidth as h, RULESYNC_HOOKS_LEGACY_FILE_NAME as hn, JsonLogger as ht, inspectInputRoots as i, CURATED_RULES_FEATURE_SUBDIR as in, SKILL_FILE_NAME as it, FACTORYDROID_DIR as j, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as jn, ensureDir as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_RULES_RELATIVE_DIR_PATH as kn, createTempDirectory as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ln, ConfigFileSchema as lt, displayWidthOf as m, RULESYNC_HOOKS_FILE_NAME as mn, ConsoleLogger as mt, formatSourceLoadFailure as n, PACKAGING_TOOL_TARGETS as nn, loadYaml as nt, convertFromTool as o, RULESYNC_AIIGNORE_FILE_NAME as on, mergeInputRootConfigs as ot, ELLIPSIS_WIDTH as p, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as pn, findControlCharacter as pt, RulesyncHooks as q, removeFileStrict as qt, generate as r, ToolTargetSchema as rn, SHARED_USER_MANAGED_CONFIG_PATHS as rt, isPackagingToolTarget as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as sn, resolveEffectiveInputRoots as st, importFromTool as t, ALL_TOOL_TARGETS_WITH_WILDCARD as tn, stringifyFrontmatter as tt, SkillsProcessor as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as un, GITIGNORE_DESTINATION_KEY as ut, CRUSH_LOCAL_RULE_FILE_NAME as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, warnOnConflictingFlags as vt, CODEXCLI_BASH_RULES_FILE_NAME as w, RULESYNC_PERMISSIONS_FILE_NAME as wn, applyFileMode as wt, QWENCODE_DIR as x, RULESYNC_MCP_RELATIVE_FILE_PATH as xn, withWarnOnceScope as xt, HooksProcessor as y, RULESYNC_MCP_FILE_NAME as yn, withFallbackLoggerTarget as yt, RulesyncSubagentFrontmatterSchema as z, formatError as zn, listFilePathsRecursively as zt };
 
-//# sourceMappingURL=import-BknrMODR.js.map
+//# sourceMappingURL=import-D2GhBXJV.js.map