rulesync 16.33.0 → 16.34.0

package/dist/{import-C6R-lXFF.js → import-De13gNpF.js}

@@ -478,6 +478,7 @@ const rulesProcessorToolTargetTuple = [
 	"cline",
 	"codebuddy",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -554,6 +555,7 @@ const mcpProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -597,6 +599,7 @@ const commandsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"cursor",
@@ -634,6 +637,7 @@ const subagentsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -675,6 +679,7 @@ const skillsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -722,6 +727,7 @@ const hooksProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-plugin",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -756,6 +762,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -3270,6 +3277,7 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".claude/settings.json",
 	".claude/settings.local.json",
 	".codex/config.toml",
+	".commandcode/settings.json",
 	".continue/settings.json",
 	".copilot/settings.json",
 	".github/copilot/settings.json",
@@ -4927,6 +4935,30 @@ const CANONICAL_TO_CORTEXCODE_EVENT_NAMES = {
 };
 const CORTEXCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CORTEXCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
 /**
+* Hook events supported by Command Code.
+*
+* Command Code reads hooks from the `hooks` key of `.commandcode/settings.json`
+* (project) and `~/.commandcode/settings.json` (user) in the Claude-Code shape.
+* Four events are documented: PreToolUse, PostToolUse, Stop and SessionStart.
+* Only `command` hooks exist; `timeout` is in seconds (default 30, max 600)
+* and `$COMMANDCODE_PROJECT_DIR` resolves to the project root.
+*
+* @see https://commandcode.ai/docs/hooks
+*/
+const COMMANDCODE_HOOK_EVENTS = [
+	"preToolUse",
+	"postToolUse",
+	"stop",
+	"sessionStart"
+];
+const CANONICAL_TO_COMMANDCODE_EVENT_NAMES = {
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	stop: "Stop",
+	sessionStart: "SessionStart"
+};
+const COMMANDCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_COMMANDCODE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Hook events supported by the Continue CLI (`cn`).
 *
 * Continue reads a Claude-Code-compatible `hooks` key from
@@ -5135,6 +5167,7 @@ const HooksConfigSchema = z.looseObject({
 	crush: 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) })),
+	commandcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	continue: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	tabnine: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
@@ -6154,6 +6187,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	claudecode: z.optional(toolScopedMcpSchema),
 	cline: z.optional(toolScopedMcpSchema),
 	codexcli: z.optional(toolScopedMcpSchema),
+	commandcode: z.optional(toolScopedMcpSchema),
 	continue: z.optional(toolScopedMcpSchema),
 	copilot: z.optional(toolScopedMcpSchema),
 	copilotcli: z.optional(toolScopedMcpSchema),
@@ -6549,12 +6583,16 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 	* Targets that share one output file resolve identically so the shared
 	* file's content never depends on which of them generates last — see
 	* `resolveMcpTarget` for the alias groups (kiro trio, claudecode/-legacy,
-	* and the Antigravity pair).
+	* the Antigravity pair, and the project-scope Claude Code / Command Code
+	* pair, which is why the scope is part of the resolution).
 	*
 	* Returns the same instance when neither mechanism is used.
 	*/
-	forTarget({ toolTarget, logger }) {
-		const { blockKeys, acceptedTargetNames } = resolveMcpTarget({ toolTarget });
+	forTarget({ toolTarget, global = false, logger }) {
+		const { blockKeys, acceptedTargetNames } = resolveMcpTarget({
+			toolTarget,
+			global
+		});
 		const json = this.json;
 		const sharedServers = this.json.mcpServers ?? {};
 		const serverNamesWithTargets = Object.entries(sharedServers).filter(([, serverConfig]) => serverConfig.targets !== void 0).map(([serverName]) => serverName);
@@ -6641,9 +6679,24 @@ const MCP_IGNORED_ALIAS_SOURCE_KEYS = Object.keys(MCP_BLOCK_KEY_ALIASES);
 *   `config`) — so both targets always apply both blocks in a fixed order
 *   (`antigravity-ide` first, `antigravity-cli` second — the CLI block wins
 *   per server on conflict).
-*/
-function resolveMcpTarget({ toolTarget }) {
-	if (toolTarget === "claudecode" || toolTarget === "claudecode-legacy") return {
+* - `claudecode` (and its legacy alias) and `commandcode` share the root
+*   `.mcp.json` in PROJECT mode only (their global files differ:
+*   `~/.claude.json` vs `~/.commandcode/mcp.json`), so in project mode the
+*   three apply the `claudecode` and `commandcode` blocks in that fixed order
+*   (the `commandcode` block wins per server on conflict); in global mode
+*   each reads its own block.
+*/
+function resolveMcpTarget({ toolTarget, global }) {
+	const isClaudecode = toolTarget === "claudecode" || toolTarget === "claudecode-legacy";
+	if (!global && (isClaudecode || toolTarget === "commandcode")) return {
+		blockKeys: ["claudecode", "commandcode"],
+		acceptedTargetNames: /* @__PURE__ */ new Set([
+			"claudecode",
+			"claudecode-legacy",
+			"commandcode"
+		])
+	};
+	if (isClaudecode) return {
 		blockKeys: ["claudecode"],
 		acceptedTargetNames: /* @__PURE__ */ new Set(["claudecode", "claudecode-legacy"])
 	};
@@ -7808,6 +7861,7 @@ const PermissionsConfigSchema = z.looseObject({
 	"antigravity-ide": z.optional(CanonicalPermissionsOverrideSchema),
 	continue: z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: z.optional(CanonicalPermissionsOverrideSchema),
+	commandcode: z.optional(CanonicalPermissionsOverrideSchema),
 	copilotcli: z.optional(CanonicalPermissionsOverrideSchema),
 	crush: z.optional(CanonicalPermissionsOverrideSchema),
 	goose: z.optional(CanonicalPermissionsOverrideSchema),
@@ -9530,6 +9584,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		"user-invocable": z.optional(z.boolean()),
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
 	})),
+	commandcode: z.optional(z.looseObject({})),
 	cortexcode: z.optional(z.looseObject({})),
 	continue: z.optional(z.looseObject({})),
 	tabnine: z.optional(z.looseObject({})),
@@ -13141,6 +13196,20 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: ["hooks"]
 		} }
 	},
+	".commandcode/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: {
+			hooks: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["hooks"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["permissions"]
+			}
+		}
+	},
 	".cortex/settings.json": {
 		format: "json",
 		invalidRootPolicy: "error",
@@ -15342,6 +15411,94 @@ var CodexcliCommand = class CodexcliCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/commandcode-paths.ts
+const COMMANDCODE_DIR = ".commandcode";
+const COMMANDCODE_RULE_FILE_NAME = "AGENTS.md";
+const COMMANDCODE_SETTINGS_FILE_NAME = "settings.json";
+const COMMANDCODE_PROJECT_MCP_FILE_NAME = ".mcp.json";
+const COMMANDCODE_GLOBAL_MCP_FILE_NAME = "mcp.json";
+const COMMANDCODE_COMMANDS_DIR_PATH = join(COMMANDCODE_DIR, "commands");
+const COMMANDCODE_AGENTS_DIR_PATH = join(COMMANDCODE_DIR, "agents");
+const COMMANDCODE_SKILLS_DIR_PATH = join(COMMANDCODE_DIR, "skills");
+//#endregion
+//#region src/features/commands/commandcode-command.ts
+/**
+* Custom slash command for Command Code.
+*
+* Command Code reads Markdown files from `.commandcode/commands/` (project)
+* and `~/.commandcode/commands/` (user), naming each command after the file's
+* basename; subdirectories only group the files. The file's full trimmed
+* body is the prompt that runs — YAML frontmatter is not stripped, only
+* skipped when the slash menu picks a summary line — so rulesync writes the
+* bare body. On import a hand-written file's frontmatter block is dropped
+* (Command Code would send it as prompt text; a rulesync command carries its
+* own frontmatter) and only the body is kept.
+*
+* @see https://commandcode.ai/docs/custom-slash-commands
+*/
+var CommandcodeCommand = class CommandcodeCommand extends ToolCommand {
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: COMMANDCODE_COMMANDS_DIR_PATH };
+	}
+	toRulesyncCommand() {
+		return new RulesyncCommand({
+			outputRoot: process.cwd(),
+			frontmatter: { targets: ["*"] },
+			body: this.getFileContent(),
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent: this.getFileContent(),
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true }) {
+		const paths = this.getSettablePaths();
+		return new CommandcodeCommand({
+			outputRoot,
+			fileContent: rulesyncCommand.getBody(),
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncCommand.getRelativeFilePath(),
+			validate
+		});
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	getBody() {
+		return this.getFileContent();
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "commandcode"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
+		const paths = this.getSettablePaths();
+		const filePath = join(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const { body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		return new CommandcodeCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			fileContent: content.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CommandcodeCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/constants/continue-paths.ts
 const CONTINUE_DIR = ".continue";
 const CONTINUE_ROOT_RULE_FILE_NAME = "AGENTS.md";
@@ -19585,6 +19742,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["continue", {
 		class: ContinueCommand,
 		meta: {
@@ -22955,6 +23122,132 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/commandcode-hooks.ts
+const COMMANDCODE_CONVERTER_CONFIG = {
+	supportedEvents: COMMANDCODE_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_COMMANDCODE_EVENT_NAMES,
+	toolToCanonicalEventNames: COMMANDCODE_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "$COMMANDCODE_PROJECT_DIR",
+	prefixDotRelativeCommandsOnly: true,
+	noMatcherEvents: /* @__PURE__ */ new Set(["stop", "sessionStart"]),
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
+};
+/**
+* Single spelling of the settings codec/policy: fail closed on an unparseable
+* root rather than replacing the user's Command Code settings with generated
+* output.
+*/
+function parseCommandcodeSettings$1(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Command Code hooks.
+*
+* Hooks live under the top-level `hooks` key of `<project>/.commandcode/settings.json`
+* (project scope) and `~/.commandcode/settings.json` (user scope), in the
+* Claude-Code shape: `{ "<Event>": [{ "matcher"?: "<regex>", "hooks": [{
+* "type": "command", "command": "...", "timeout"?: <seconds> }] }] }`. Both
+* files also hold settings rulesync does not own (`permissions`, `defaultMode`,
+* ...), so generation merges the `hooks` key into the existing file (see
+* `SHARED_CONFIG_OWNERSHIP`) instead of overwriting it.
+*
+* @see https://commandcode.ai/docs/hooks
+* @see https://commandcode.ai/docs/settings
+*/
+var CommandcodeHooks = class CommandcodeHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: COMMANDCODE_DIR,
+			relativeFilePath: COMMANDCODE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = CommandcodeHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new CommandcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = CommandcodeHooks.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.commandcode?.hooks,
+			converterConfig: COMMANDCODE_CONVERTER_CONFIG,
+			logger
+		});
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks },
+			filePath,
+			logger
+		});
+		return new CommandcodeHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks({ logger } = {}) {
+		const configPath = join(this.getRelativeDirPath(), this.getRelativeFilePath());
+		let settings;
+		try {
+			settings = parseCommandcodeSettings$1(this.getFileContent(), configPath);
+		} catch (error) {
+			throw new Error(`Failed to parse Command Code hooks content in ${configPath}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			logger,
+			hooks: settings.hooks,
+			converterConfig: COMMANDCODE_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "commandcode"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CommandcodeHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/continue-hooks.ts
 const CONTINUE_SPEC = {
 	displayName: "Continue",
@@ -28074,6 +28367,18 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["commandcode", {
+		class: CommandcodeHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: COMMANDCODE_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true,
+		matcherEvents: ["preToolUse", "postToolUse"]
+	}],
 	["copilot", {
 		class: CopilotHooks,
 		meta: {
@@ -31931,6 +32236,254 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/commandcode-mcp.ts
+/**
+* Parse a Command Code MCP file. The project file is the `.mcp.json` other
+* agents (Claude Code among them) share, so a hand-written file is read as
+* JSONC to tolerate comments and trailing commas; malformed content or a
+* non-object root (`null`, an array, a scalar) fails closed rather than being
+* spread into the regenerated file.
+*/
+function parseCommandcodeMcpConfig({ fileContent, relativePath }) {
+	let parsed;
+	try {
+		parsed = parseJsonc(fileContent);
+	} catch (error) {
+		throw new Error(`Failed to parse Command Code MCP config at ${relativePath}: ${formatError(error)}`, { cause: error });
+	}
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Command Code MCP config at ${relativePath}: expected a JSON object at the root`);
+	return parsed;
+}
+/**
+* The remote transport Command Code reads a server as. Its loader accepts
+* `http` (streamable HTTP) and `sse` for a `url` server; a bare `url` defaults
+* to `http`, and the canonical `streamable-http` spelling is folded into it.
+* A `ws(s)://` URL or any other stated transport has no Command Code
+* equivalent, so `undefined` tells the caller to skip the server.
+* @see https://commandcode.ai/docs/mcp
+*/
+function asCommandcodeRemoteTransport(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 Command Code's config schema
+* documents (used for the global `~/.commandcode/mcp.json` only — the project
+* `.mcp.json` is shared with Claude Code and written pass-through, see the
+* class doc): a remote server is `{ transport, url, headers?, env?, oauth? }`
+* and a stdio server is `{ transport: "stdio", command, args?, env? }`, each
+* with an optional `enabled` flag. The documented spelling is `transport`
+* (`type` is only accepted as an alias on read), so that is what is written,
+* and only the documented keys are emitted — `timeout`, rulesync-only fields
+* and anything else is left out. The canonical `disabled: true` becomes
+* Command Code's native `enabled: false` (the rulesync-source-only `enabled`
+* filter never reaches this function: `getMcpServers()` drops such a server).
+*
+* A server Command Code drops at load time — 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 form the tool
+* would silently ignore.
+* @see https://commandcode.ai/docs/mcp
+*/
+function convertToCommandcodeFormat(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: "Command Code",
+				serverName,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const converted = isRemoteMcpServer(serverConfig) ? convertRemoteServer$1({
+			serverName,
+			serverConfig,
+			logger
+		}) : convertStdioServer$1({
+			serverName,
+			serverConfig,
+			logger
+		});
+		if (converted === void 0) continue;
+		if (serverConfig.disabled === true) converted.enabled = false;
+		if (isRecord$1(serverConfig.env)) converted.env = omitPrototypePollutionKeys(serverConfig.env);
+		result[serverName] = converted;
+	}
+	return result;
+}
+function convertRemoteServer$1({ serverName, serverConfig, logger }) {
+	const url = resolveRemoteMcpUrl(serverConfig);
+	if (!url) {
+		warnAndSkipMcpServer({
+			toolName: "Command Code",
+			serverName,
+			reason: "a remote transport without a url",
+			logger
+		});
+		return;
+	}
+	const stated = serverConfig.type ?? serverConfig.transport;
+	const transport = asCommandcodeRemoteTransport(typeof stated === "string" ? stated : void 0, url);
+	if (transport === void 0) {
+		warnAndSkipMcpServer({
+			toolName: "Command Code",
+			serverName,
+			reason: stated === void 0 ? "a WebSocket url, which Command Code's remote transports (http and sse) cannot reach" : `the "${String(stated)}" transport, which Command Code does not offer for remote servers (only http and sse)`,
+			logger
+		});
+		return;
+	}
+	const converted = {
+		transport,
+		url
+	};
+	if (isRecord$1(serverConfig.headers)) converted.headers = omitPrototypePollutionKeys(serverConfig.headers);
+	if (isRecord$1(serverConfig.oauth)) converted.oauth = omitPrototypePollutionKeys(serverConfig.oauth);
+	return converted;
+}
+function convertStdioServer$1({ serverName, serverConfig, logger }) {
+	const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+	if (!command) {
+		warnAndSkipMcpServer({
+			toolName: "Command Code",
+			serverName,
+			reason: "a stdio transport without a command",
+			logger
+		});
+		return;
+	}
+	const converted = {
+		transport: "stdio",
+		command
+	};
+	if (args.length > 0) converted.args = args;
+	return converted;
+}
+/**
+* Convert Command Code's server map back to the canonical shape. Both
+* spellings Command Code accepts (`transport` and its `type` alias, with
+* `command`/`url`) are already canonical, so entries pass through with only
+* prototype-pollution keys dropped; the native `enabled: false` maps to the
+* canonical `disabled: true` (a bare `enabled` would otherwise be read back
+* as rulesync's own generation filter and silently drop the server from every
+* other target).
+*/
+function convertFromCommandcodeFormat(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 { enabled, ...rest } = omitPrototypePollutionKeys(serverConfig);
+		result[serverName] = enabled === false ? {
+			...rest,
+			disabled: true
+		} : rest;
+	}
+	return result;
+}
+/**
+* Command Code MCP configuration.
+*
+* Command Code reads `.mcp.json` at the project root (project scope, meant to
+* be committed) and `~/.commandcode/mcp.json` (user scope), both in the
+* `{ "mcpServers": { ... } }` shape the docs show; the per-machine local
+* scope under `~/.commandcode/projects/` is left to the tool. Top-level
+* sibling keys of an existing file are kept. The global file is not deleted
+* by `--delete` (it lives outside the project), while the project file is
+* rulesync's own and is.
+*
+* The project `.mcp.json` is the very file the `claudecode` target writes, so
+* at project scope the servers are written in the same pass-through shape
+* `ClaudecodeMcp` uses: whichever of the two targets generates last leaves
+* byte-identical content, and Command Code reads that shape natively (`type`
+* is an alias of `transport`, a bare `url` infers `http`, and unknown keys
+* are ignored). Only the global file — Command Code's own — gets the
+* `transport` / `enabled: false` rewrite of `convertToCommandcodeFormat`.
+*
+* @see https://commandcode.ai/docs/mcp
+*/
+var CommandcodeMcp = class CommandcodeMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = this.fileContent === void 0 ? {} : parseCommandcodeMcpConfig({
+			fileContent: this.fileContent,
+			relativePath: join(this.relativeDirPath, this.relativeFilePath)
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	isDeletable() {
+		return !this.global;
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return global ? {
+			relativeDirPath: COMMANDCODE_DIR,
+			relativeFilePath: COMMANDCODE_GLOBAL_MCP_FILE_NAME
+		} : {
+			relativeDirPath: ".",
+			relativeFilePath: COMMANDCODE_PROJECT_MCP_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 CommandcodeMcp({
+			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 json = parseCommandcodeMcpConfig({
+			fileContent: await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: join(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const mcpServers = global ? convertToCommandcodeFormat(rulesyncMcp.getMcpServers(), logger) : rulesyncMcp.getMcpServers();
+		const commandcodeConfig = {
+			...json,
+			mcpServers
+		};
+		return new CommandcodeMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(commandcodeConfig, null, 2),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromCommandcodeFormat(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 CommandcodeMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/continue-mcp.ts
 /**
 * Parse a Continue MCP file. Continue reads the files under `mcpServers/` as
@@ -36899,6 +37452,7 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 	static async getAuxiliaryFiles({ outputRoot = process.cwd(), global = false, rulesyncMcp, logger }) {
 		const servers = rulesyncMcp.forTarget({
 			toolTarget: "rovodev",
+			global,
 			logger
 		}).getMcpServers();
 		const managedNames = Object.keys(servers).filter((name) => toRovodevServer(name, servers[name]) !== null);
@@ -38196,6 +38750,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["continue", {
 		class: ContinueMcp,
 		meta: {
@@ -38589,6 +39152,7 @@ var McpProcessor = class extends FeatureProcessor {
 		const toolMcps = await Promise.all([rulesyncMcp].map(async (mcp) => {
 			const targetedRulesyncMcp = mcp.forTarget({
 				toolTarget: this.toolTarget,
+				global: this.global,
 				logger: this.logger
 			});
 			const fieldsToStrip = [];
@@ -42583,6 +43147,622 @@ function mapBashActionToDecision(action) {
 	return "forbidden";
 }
 //#endregion
+//#region src/features/permissions/commandcode-permissions.ts
+/** Top-level key of `.commandcode/settings.json` that rulesync owns. */
+const COMMANDCODE_PERMISSIONS_KEY = "permissions";
+const CATCH_ALL_PATTERN$6 = "*";
+const MCP_CANONICAL_PREFIX$5 = "mcp__";
+const COMMANDCODE_ALL_MCP_RULE = "mcp__*";
+const CATEGORY_TO_COMMANDCODE_TOOL = {
+	bash: "Shell",
+	read: "Read",
+	edit: "Edit",
+	write: "Write",
+	grep: "Grep",
+	glob: "Glob",
+	webfetch: "WebFetch",
+	websearch: "WebSearch"
+};
+const COMMANDCODE_TOOL_TO_CATEGORY = {
+	...Object.fromEntries(Object.entries(CATEGORY_TO_COMMANDCODE_TOOL).map(([category, tool]) => [tool.toLowerCase(), category])),
+	bash: "bash",
+	powershell: "bash",
+	shell_command: "bash",
+	monitor_command: "bash",
+	kill_shell: "bash",
+	notebookedit: "edit",
+	write_file: "write",
+	web_fetch: "webfetch",
+	web_search: "websearch"
+};
+const ACTION_RANK$1 = {
+	allow: 0,
+	ask: 1,
+	deny: 2
+};
+/** Whether `action` outranks `existing` (deny > ask > allow). */
+function isStricterAction({ action, existing }) {
+	return existing === void 0 || ACTION_RANK$1[action] > ACTION_RANK$1[existing];
+}
+/**
+* Why a padded `Shell( * )` cannot stand in for the bare `Shell` in `allow`:
+* the whitespace makes it a pattern rule, and a shell pattern grants only
+* commands that pass Command Code's pattern gate.
+*/
+const PADDED_SHELL_WILDCARD_REASON = "a pattern narrower than the bare 'Shell' (the command must parse into words and carry no environment assignment)";
+/**
+* Build a Command Code rule (`Shell(git *)`, `Read`, `mcp__github__get_issue`,
+* `mcp__*`, `*`) from a canonical category + pattern. Returns `null` for
+* categories Command Code cannot express so the caller can skip them.
+*
+* MCP tools are keyed by their canonical `mcp__server__tool` name, so a
+* scoped `mcp__<remainder>` category is written verbatim and the bare `mcp`
+* category becomes `mcp__*` (or `mcp__<pattern>` when the pattern names a
+* server or tool). A pattern on an MCP category is still written as the
+* `(specifier)` here; `writableCommandcodeRule` decides what to do with it,
+* because Command Code ignores it. The all-tools `*` category is only
+* written for its catch-all pattern; narrower `*` patterns are shell
+* restrictions and reach the `Shell` entries through `honorAllToolsOnBash`.
+*/
+function buildCommandcodeRule(category, pattern) {
+	const catchAll = pattern === CATCH_ALL_PATTERN$6 || pattern === "";
+	if (category.startsWith(MCP_CANONICAL_PREFIX$5)) return catchAll ? category : `${category}(${pattern})`;
+	if (category === "mcp") return catchAll ? COMMANDCODE_ALL_MCP_RULE : `${MCP_CANONICAL_PREFIX$5}${pattern}`;
+	if (category === "*") return catchAll ? CATCH_ALL_PATTERN$6 : null;
+	const tool = Object.hasOwn(CATEGORY_TO_COMMANDCODE_TOOL, category) ? CATEGORY_TO_COMMANDCODE_TOOL[category] : void 0;
+	if (tool === void 0) return null;
+	return catchAll ? tool : `${tool}(${pattern})`;
+}
+/**
+* Split `Tool(specifier)` into its two halves the way Command Code's
+* `splitRule` does (`command-code` 1.54.0): the rule is split at the first
+* unescaped `(` and must end with `)`, the tool half is trimmed (so
+* `Shell (rm -rf *)` is a `Shell` rule), and a `\(` / `\)` in the specifier
+* is an escaped parenthesis. `Tool` alone has an empty specifier. A rule that
+* opens a parenthesis without closing one is not a rule to Command Code at
+* all, so it comes back with an empty tool half and stays unmodeled. Nothing
+* else in the specifier is touched: Command Code does not trim it (the shell
+* matcher normalizes whitespace on its own, see `parseCommandcodeRule`), so
+* `Read( )` is a rule for the pattern `" "`, which matches nothing, not for
+* the whole tool.
+*/
+function splitCommandcodeRule(rule) {
+	const trimmed = rule.trim();
+	const parenIndex = trimmed.search(/(?<!\\)\(/);
+	if (parenIndex === -1) return {
+		tool: trimmed,
+		inner: ""
+	};
+	if (!trimmed.endsWith(")")) return {
+		tool: "",
+		inner: ""
+	};
+	return {
+		tool: trimmed.slice(0, parenIndex).trim(),
+		inner: trimmed.slice(parenIndex + 1, -1).replace(/\\([()])/g, "$1")
+	};
+}
+/** Whether a specifier means "no specifier" to Command Code: only `` and `*` do. */
+function isCatchAllSpecifier(inner) {
+	return inner === "" || inner === CATCH_ALL_PATTERN$6;
+}
+/**
+* Read an MCP-shaped rule the way Command Code does (`command-code` 1.54.0,
+* `parsePermissionRule` / `parseMcpToken`). The MCP shape is only recognized
+* by its exact `mcp__` prefix, and such a rule never carries a specifier:
+* `mcp__<server>__<tool>(owner:foo)` denies, asks or allows the whole tool.
+* Its names are matched case-sensitively against the registered server and
+* tool (Command Code never lowercases them), so the remainder keeps its case
+* as the canonical category. `mcp__<server>`, `mcp__<server>__` and
+* `mcp__<server>__*` are the whole server (category `mcp__<server>`), and a
+* `*` server (`mcp__*`, `mcp__*__<tool>`) is every MCP tool, honored in
+* `deny`/`ask` only. A differently-cased `MCP__...` spelling is read as a
+* plain tool-name rule instead, matched case-insensitively:
+* `MCP__<server>__<tool>` matches that tool by name (so it folds onto the
+* `mcp__` category, remainder as written), `MCP__<server>__<tool>(specifier)`
+* globs the specifier against the call's `command` / `file_path` / `path` /
+* `url` / `pattern` argument (in `deny`/`ask` a `param:glob` form is tried
+* first) — kept as a pattern in `deny`/`ask`, but not imported from `allow`,
+* where a grant scoped that way cannot be modeled without widening it; the
+* globs
+* `MCP__*` (every MCP tool) and `MCP__<server>__*` (the whole server) match
+* by name in `deny`/`ask` only, and `MCP__<server>` names no tool at all.
+* Whatever matches nothing anywhere (or a glob rulesync does not model)
+* returns `null` and is left alone.
+*/
+function parseMcpCommandcodeRule({ tool, inner }) {
+	const remainder = tool.slice(5);
+	const separator = remainder.indexOf("__");
+	const server = separator === -1 ? remainder : remainder.slice(0, separator);
+	const rest = separator === -1 ? "" : remainder.slice(separator + 2);
+	if (server.length === 0) return null;
+	const everyServer = {
+		category: "mcp",
+		pattern: CATCH_ALL_PATTERN$6,
+		notInAllow: true
+	};
+	if (tool.startsWith(MCP_CANONICAL_PREFIX$5)) {
+		if (server === CATCH_ALL_PATTERN$6) return everyServer;
+		if (server.includes(CATCH_ALL_PATTERN$6)) return null;
+		return {
+			category: rest === "" || rest === CATCH_ALL_PATTERN$6 ? `${MCP_CANONICAL_PREFIX$5}${server}` : `${MCP_CANONICAL_PREFIX$5}${remainder}`,
+			pattern: CATCH_ALL_PATTERN$6,
+			notInAllow: false
+		};
+	}
+	const category = `${MCP_CANONICAL_PREFIX$5}${remainder}`;
+	const namesTool = separator !== -1 && rest.length > 0 && !remainder.includes(CATCH_ALL_PATTERN$6);
+	if (!isCatchAllSpecifier(inner)) return namesTool ? {
+		category,
+		pattern: inner,
+		notInAllow: true
+	} : null;
+	if (remainder === CATCH_ALL_PATTERN$6) return everyServer;
+	if (rest === CATCH_ALL_PATTERN$6 && !server.includes(CATCH_ALL_PATTERN$6)) return {
+		category: `${MCP_CANONICAL_PREFIX$5}${server}`,
+		pattern: CATCH_ALL_PATTERN$6,
+		notInAllow: true
+	};
+	return namesTool ? {
+		category,
+		pattern: CATCH_ALL_PATTERN$6,
+		notInAllow: false
+	} : null;
+}
+/**
+* A rule on one of the friendly tools, with its specifier read as Command
+* Code matches it. The shell matcher trims and collapses whitespace on both
+* the pattern and the command, so `Shell( git  * )` is `Shell(git *)` and a
+* pattern that is blank once normalized (`Shell( )`), or a bare `:*` whose
+* prefix is empty (`Shell(:*)`), matches nothing. A padded `Shell( * )` is
+* not the bare `Shell`: only a specifier of exactly
+* `` or `*` is dropped by the rule parser, so `( * )` stays a pattern rule —
+* in `deny`/`ask` it matches every command (the whole tool), while in `allow`
+* it is narrower than the bare `Shell` (it needs a command that parses into
+* words and has no environment-assignment prefix), so it is the whole tool
+* marked `notInAllow`. The path, web and tool-name matchers use the
+* specifier as written, so one that is blank or `*` only once trimmed
+* (`Read( * )`) matches nothing. What matches nothing comes back as `null`:
+* the rule is unmodeled and left alone.
+*/
+function friendlyToolRule({ category, inner }) {
+	if (category === "bash") {
+		if (isCatchAllSpecifier(inner)) return {
+			category,
+			pattern: CATCH_ALL_PATTERN$6,
+			notInAllow: false
+		};
+		const normalized = inner.trim().replace(/\s+/g, " ");
+		if (normalized === "" || normalized === ":*") return null;
+		return isCatchAllSpecifier(normalized) ? {
+			category,
+			pattern: CATCH_ALL_PATTERN$6,
+			notInAllow: true
+		} : {
+			category,
+			pattern: normalized,
+			notInAllow: false
+		};
+	}
+	if (isCatchAllSpecifier(inner)) return {
+		category,
+		pattern: CATCH_ALL_PATTERN$6,
+		notInAllow: false
+	};
+	return isCatchAllSpecifier(inner.trim()) ? null : {
+		category,
+		pattern: inner,
+		notInAllow: false
+	};
+}
+/**
+* Parse a Command Code rule back into canonical terms. Tool names fold case;
+* `Tool`, `Tool()` and `Tool(*)` all mean the whole tool; MCP-shaped rules
+* go through `parseMcpCommandcodeRule`. Returns `null` for a rule rulesync
+* cannot model (an exact internal tool name such as `edit_file`, a
+* name-wildcard like `edit_*`, a specifier on a rule that takes none, or a
+* rule Command Code enforces nothing for, such as `Agent`).
+*/
+function parseCommandcodeRule(rule) {
+	const { tool, inner } = splitCommandcodeRule(rule);
+	if (tool === CATCH_ALL_PATTERN$6) return isCatchAllSpecifier(inner) ? {
+		category: "*",
+		pattern: CATCH_ALL_PATTERN$6,
+		notInAllow: true
+	} : null;
+	const lowered = tool.toLowerCase();
+	if (lowered.startsWith(MCP_CANONICAL_PREFIX$5)) return parseMcpCommandcodeRule({
+		tool,
+		inner
+	});
+	const category = Object.hasOwn(COMMANDCODE_TOOL_TO_CATEGORY, lowered) ? COMMANDCODE_TOOL_TO_CATEGORY[lowered] : void 0;
+	if (category === void 0) return null;
+	return friendlyToolRule({
+		category,
+		inner
+	});
+}
+/**
+* Whether an imported rule is a differently-cased `MCP__<server>__<tool>`
+* name that folded onto an exact-prefix `mcp__` category (which Command Code
+* matches case-sensitively, unlike the name rule it came from).
+*/
+function isFoldedMcpToolNameRule({ rule, category }) {
+	const { tool } = splitCommandcodeRule(rule);
+	return category.startsWith(MCP_CANONICAL_PREFIX$5) && !tool.startsWith(MCP_CANONICAL_PREFIX$5);
+}
+/** The `Tool` half of `Tool(specifier)`, when the rule is an exact-prefix MCP rule with a specifier. */
+function scopedMcpRuleTool(rule) {
+	const { tool, inner } = splitCommandcodeRule(rule);
+	return !isCatchAllSpecifier(inner) && tool.startsWith(MCP_CANONICAL_PREFIX$5) ? tool : null;
+}
+/**
+* The string entries of a Command Code permission list. Command Code reads
+* each entry on its own and skips one that is not a string, so a stray
+* `null` beside `Shell(rm -rf *)` must not throw the deny away with it; the
+* skipped entries are counted in a warning because they cannot be kept.
+*/
+function stringRules({ list, action, outcome, warn }) {
+	if (!Array.isArray(list)) return [];
+	const rules = list.filter((entry) => typeof entry === "string");
+	const skipped = list.length - rules.length;
+	if (skipped > 0) warn(`Command Code permission list "${action}" holds ${skipped} ${skipped === 1 ? "entry" : "entries"} that ${skipped === 1 ? "is" : "are"} not a string, which Command Code skips; ${skipped === 1 ? "that entry was" : "those entries were"} ${outcome}.`);
+	return rules;
+}
+/**
+* The canonical categories this run rebuilds — every category the canonical
+* config names (an empty `bash: {}` still reclaims the previous `Shell(...)`
+* entries, as in the Claude Code adapter) plus every rule it emits, keyed the
+* way an existing entry parses back (so `mcp: { github: "deny" }`, written as
+* `mcp__github`, claims the `mcp__github` entries of the previous run; case
+* variants of the friendly tool names fold together, while MCP names are
+* matched exactly, as Command Code does). An existing entry whose tool folds onto one of them is
+* rulesync's to replace, whatever list it sits in — otherwise flipping a rule
+* from deny to allow would leave the old deny behind and win. Every other
+* entry — an internal tool name rulesync cannot model, or a modeled tool the
+* canonical config does not mention — is the user's (Command Code writes
+* interactive approvals into the same lists) and is preserved verbatim.
+* A `deny`/`ask` entry that is reclaimed without an equally strict rule
+* taking its place (say a hand-written `mcp__*` deny next to a canonical
+* `mcp: { github: "deny" }`) is reported, so regenerating never silently
+* loosens what the user wrote. Mirrors `managedClaudeToolNames` in the
+* Claude Code adapter.
+*/
+function preservedRules({ existingPermissions, key, managedCategories, written, logger }) {
+	return stringRules({
+		list: existingPermissions[key],
+		action: key,
+		outcome: "dropped from the regenerated list",
+		warn: (message) => logger?.warn(message)
+	}).filter((rule) => {
+		const parsed = parseCommandcodeRule(rule);
+		if (parsed === null || !managedCategories.has(parsed.category)) return true;
+		const replacement = written.get(`${parsed.category}(${parsed.pattern})`) ?? written.get(`${parsed.category}(${CATCH_ALL_PATTERN$6})`);
+		if (key !== "allow" && isStricterAction({
+			action: key,
+			existing: replacement
+		})) logger?.warn(`Command Code permission rule '${rule}' in "${key}" belongs to the '${parsed.category}' category, which the rulesync config now manages, and was replaced by its rules.`);
+		return false;
+	});
+}
+/**
+* The rule to write for a canonical rule, or `null` when Command Code would
+* ignore it in the `action` list. A server-less wildcard (`*`, `mcp__*`) in
+* `allow` is warned about and left unwritten rather than written dead. A
+* specifier on an MCP rule is ignored by Command Code in every list, so a
+* scoped `deny`/`ask` is written as the bare tool (which is what Command
+* Code would enforce anyway, only now visibly) with a warning, and a scoped
+* `allow` — which would grant the whole tool — is refused. Judged on the
+* rule as written, so the bare `mcp` category cannot smuggle a specifier in
+* through a `<server>__<tool>(specifier)` pattern.
+*/
+function writableCommandcodeRule({ rule, emitted, action, logger }) {
+	if (action === "allow" && emitted.notInAllow) {
+		logger?.warn(emitted.category === "bash" ? `Command Code reads '${rule}' in "allow" as ${PADDED_SHELL_WILDCARD_REASON}, so the '${emitted.category}' allow rule was not written; use the '*' pattern for the whole tool.` : `Command Code does not honor '${rule}' in "allow" as written (an allow rule must name what it grants), so the '${emitted.category}' allow rule was not written.`);
+		return null;
+	}
+	const tool = scopedMcpRuleTool(rule);
+	if (tool === null) return rule;
+	if (action === "allow") {
+		logger?.warn(`Command Code ignores the specifier of an MCP rule and would allow the whole '${tool}' tool, so the '${rule}' allow rule was not written.`);
+		return null;
+	}
+	logger?.warn(`Command Code ignores the specifier of an MCP rule, so '${rule}' was written as '${tool}' and applies "${action}" to the whole tool.`);
+	return tool;
+}
+/**
+* Record `action` for `rule`, keeping the stricter one (deny > ask > allow)
+* when two canonical rules collapse onto the same Command Code entry.
+*/
+function rankCommandcodeRule({ ranked, rule, action, logger }) {
+	const existing = ranked.get(rule);
+	if (existing !== void 0 && existing !== action) logger?.warn(`Command Code permission rule '${rule}' received conflicting actions ('${existing}' and '${action}'); keeping the stricter one (deny > ask > allow).`);
+	if (isStricterAction({
+		action,
+		existing
+	})) ranked.set(rule, action);
+}
+/**
+* Bucket the canonical rules into Command Code's `allow`/`ask`/`deny` lists.
+* Collisions resolve to the strictest action (deny > ask > allow); categories
+* Command Code cannot express are skipped with a warning when they carry a
+* `deny`; rules Command Code would ignore in the target list are dropped or
+* rewritten by `writableCommandcodeRule`.
+*/
+function buildCommandcodeRuleLists({ config, existingPermissions, logger }) {
+	const permission = honorAllToolsOnBash(config.permission);
+	const ranked = /* @__PURE__ */ new Map();
+	const managedCategories = /* @__PURE__ */ new Set();
+	for (const [category, rules] of Object.entries(permission)) {
+		const categoryRule = buildCommandcodeRule(category, CATCH_ALL_PATTERN$6);
+		const managedCategory = categoryRule === null ? null : parseCommandcodeRule(categoryRule);
+		if (managedCategory !== null) managedCategories.add(managedCategory.category);
+		for (const [pattern, action] of Object.entries(rules)) {
+			const rule = buildCommandcodeRule(category, pattern);
+			const emitted = rule === null ? null : parseCommandcodeRule(rule);
+			if (rule === null || emitted === null) {
+				const honoredOnShell = category === "*" && permission.bash !== void 0;
+				if (action === "deny" && !honoredOnShell) logger?.warn(`Command Code has no permission rule for the '${category}' category with pattern '${pattern}'; its 'deny' rule could not be represented and was skipped.`);
+				continue;
+			}
+			managedCategories.add(emitted.category);
+			const written = writableCommandcodeRule({
+				rule,
+				emitted,
+				action,
+				logger
+			});
+			if (written !== null) rankCommandcodeRule({
+				ranked,
+				rule: written,
+				action,
+				logger
+			});
+		}
+	}
+	const written = /* @__PURE__ */ new Map();
+	for (const [rule, action] of ranked) {
+		const parsed = parseCommandcodeRule(rule);
+		if (parsed !== null) written.set(`${parsed.category}(${parsed.pattern})`, action);
+	}
+	const preserved = {
+		existingPermissions,
+		managedCategories,
+		written,
+		logger
+	};
+	const allow = preservedRules({
+		...preserved,
+		key: "allow"
+	});
+	const ask = preservedRules({
+		...preserved,
+		key: "ask"
+	});
+	const deny = preservedRules({
+		...preserved,
+		key: "deny"
+	});
+	for (const [rule, action] of ranked) if (action === "allow") allow.push(rule);
+	else if (action === "ask") ask.push(rule);
+	else deny.push(rule);
+	return {
+		allow: uniq(allow.toSorted()),
+		ask: uniq(ask.toSorted()),
+		deny: uniq(deny.toSorted())
+	};
+}
+/**
+* Why a rule marked `notInAllow` is not imported from `allow`: Command Code
+* ignores a server-less wildcard or a tool-name glob there, while it does
+* enforce a scoped `MCP__<server>__<tool>(specifier)` — as a glob over the
+* call's arguments — and a padded `Shell( * )` — as a pattern narrower than
+* the bare `Shell` — which rulesync cannot model in `allow` without widening
+* the grant.
+*/
+function skippedAllowImportMessage({ rule, category }) {
+	const { tool, inner } = splitCommandcodeRule(rule);
+	if (category === "bash") return `Command Code reads '${rule}' in "allow" as ${PADDED_SHELL_WILDCARD_REASON}, which rulesync cannot import without widening the grant to every command, so it was not imported.`;
+	if (tool.startsWith(MCP_CANONICAL_PREFIX$5) || isCatchAllSpecifier(inner)) return `Command Code ignores '${rule}' in "allow" (an allow rule must name what it grants), so it was not imported.`;
+	return `Command Code globs the specifier of '${rule}' in "allow" against the call's arguments, which rulesync cannot import without widening the grant to the whole tool, so it was not imported.`;
+}
+/**
+* Parse Command Code's `permissions` lists back into a canonical permission
+* map with `deny > ask > allow` precedence, so a tool described more than
+* once resolves to the strictest action. Each rule is imported as what
+* Command Code enforces for it, never as what it looks like: a rule Command
+* Code ignores in `allow` (`*`, `mcp__*`, an `MCP__...` glob) is skipped
+* there with a warning, since importing it would turn a dead line into a
+* live grant for every other target, and so is a scoped
+* `MCP__<server>__<tool>(specifier)` allow, which Command Code enforces as a
+* glob over the call's arguments but rulesync cannot import without widening
+* it to the whole tool; the specifier of an exact-prefix `mcp__...` rule,
+* which Command Code drops, is folded to the whole tool in every list — with
+* a warning in `allow`, where the fold widens the grant the user wrote. A
+* tool-half glob in that exact-prefix spelling (`mcp__<server>__get_*`), which
+* Command Code matches against tool names in every list, is imported as the
+* category spelled that way, the same one the generator writes back; other
+* targets read it as a literal tool name.
+*/
+function parseCommandcodeRuleLists(permissions) {
+	const permission = {};
+	const lists = [
+		["allow", permissions.allow],
+		["ask", permissions.ask],
+		["deny", permissions.deny]
+	];
+	for (const [action, rawList] of lists) {
+		const list = stringRules({
+			list: rawList,
+			action,
+			outcome: "not imported",
+			warn: (message) => fallbackLogger.warn(message)
+		});
+		for (const rule of list) {
+			const parsed = parseCommandcodeRule(rule);
+			if (parsed === null || isPrototypePollutionKey(parsed.category) || isPrototypePollutionKey(parsed.pattern)) {
+				if (action !== "allow") fallbackLogger.warn(`Command Code permission rule '${rule}' in "${action}" is not one rulesync can model, so it could not be imported; it stays in the Command Code settings, where a regenerate keeps it unless the canonical config manages its category.`);
+				continue;
+			}
+			const { category, pattern } = parsed;
+			if (action === "allow" && parsed.notInAllow) {
+				fallbackLogger.warn(skippedAllowImportMessage({
+					rule,
+					category
+				}));
+				continue;
+			}
+			if (action === "allow" && scopedMcpRuleTool(rule) !== null) fallbackLogger.warn(`Command Code ignores the specifier of an MCP rule, so '${rule}' in "allow" was imported as the whole '${category}' tool, which is what Command Code grants for it.`);
+			if (isFoldedMcpToolNameRule({
+				rule,
+				category
+			})) fallbackLogger.warn(`Command Code matches '${rule}' in "${action}" against MCP tool names case-insensitively, but the '${category}' rule generated from it matches the server and tool names exactly as written; spell the rule the way the tool is registered if they differ.`);
+			const rules = permission[category] ??= {};
+			if (isStricterAction({
+				action,
+				existing: rules[pattern]
+			})) rules[pattern] = action;
+		}
+	}
+	return permission;
+}
+/**
+* Permissions generator for Command Code.
+*
+* Rules live under the `permissions` key of `.commandcode/settings.json`
+* (project) and `~/.commandcode/settings.json` (user) as three lists of
+* Claude-style entries: `deny` (always wins), `ask`, `allow`. The same key
+* also carries `defaultMode`, `additionalDirectories` and `disableBypass`,
+* and the file holds `hooks` and other settings, so writes go through the
+* shared-config gateway: rulesync replaces the three lists, keeps every
+* sibling key, and never deletes the file.
+*
+* Generate: `permission.<category>.<pattern>` becomes `Tool(pattern)` with
+* the friendly names (`Shell`, `Read`, `Edit`, `Write`, `WebFetch`,
+* `WebSearch`), `mcp__<server>__<tool>` names pass through, and the all-tools
+* `*` category becomes the bare `*` rule Command Code accepts in `deny`/`ask`.
+* Only the entries of the categories the canonical config names are rebuilt;
+* every other existing entry is preserved verbatim.
+* Import: the lists are parsed back as what Command Code enforces for each
+* entry — friendly tool names case-insensitively (with the internal aliases
+* such as `Bash`, `PowerShell` and `write_file` folding onto their
+* category), MCP names exactly; rules for internal tool names rulesync does
+* not model are skipped.
+*
+* @see https://commandcode.ai/docs/permissions
+* @see https://commandcode.ai/docs/settings
+*/
+var CommandcodePermissions = class CommandcodePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	/**
+	* `settings.json` holds hooks and other user settings, so it is never
+	* deleted; clearing permissions happens via an in-place merge.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: COMMANDCODE_DIR,
+			relativeFilePath: COMMANDCODE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = CommandcodePermissions.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new CommandcodePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, global = false, logger }) {
+		const paths = CommandcodePermissions.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const existing = parseCommandcodeSettings({
+			fileContent: existingContent,
+			relativePath: join(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const existingPermissions = isRecord$1(existing[COMMANDCODE_PERMISSIONS_KEY]) ? existing[COMMANDCODE_PERMISSIONS_KEY] : {};
+		const lists = buildCommandcodeRuleLists({
+			config: rulesyncPermissions.getJson(),
+			existingPermissions,
+			logger
+		});
+		const permissions = { ...existingPermissions };
+		for (const key of [
+			"allow",
+			"ask",
+			"deny"
+		]) if (lists[key].length > 0) permissions[key] = lists[key];
+		else delete permissions[key];
+		return new CommandcodePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch: { [COMMANDCODE_PERMISSIONS_KEY]: permissions },
+				filePath
+			}),
+			validate: true,
+			global
+		});
+	}
+	toRulesyncPermissions() {
+		const settings = parseCommandcodeSettings({
+			fileContent: this.getFileContent() || "{}",
+			relativePath: join(this.getRelativeDirPath(), this.getRelativeFilePath())
+		});
+		const permissions = isRecord$1(settings[COMMANDCODE_PERMISSIONS_KEY]) ? settings[COMMANDCODE_PERMISSIONS_KEY] : {};
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission: parseCommandcodeRuleLists(permissions) }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new CommandcodePermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+/**
+* Fail closed on a syntax error or non-object root, matching the write path's
+* shared-config declaration, so a broken file is surfaced rather than
+* partially imported or overwritten.
+*/
+function parseCommandcodeSettings({ fileContent, relativePath }) {
+	try {
+		return parseSharedConfig({
+			format: "json",
+			fileContent,
+			filePath: relativePath,
+			invalidRootPolicy: "error"
+		});
+	} catch (error) {
+		throw new Error(`Failed to parse Command Code settings in ${relativePath}: ${formatError(error)}`, { cause: error });
+	}
+}
+//#endregion
 //#region src/features/permissions/continue-permissions.ts
 const CONTINUE_GLOBAL_ONLY_MESSAGE = "Continue permissions are global-only; use --global to sync ~/.continue/permissions.yaml";
 const CATCH_ALL_PATTERN$5 = "*";
@@ -53344,6 +54524,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["continue", {
 		class: ContinuePermissions,
 		meta: {
@@ -56110,6 +57298,154 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/commandcode-skill.ts
+const CommandcodeSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.string()
+});
+/**
+* Represents a Command Code skill directory.
+*
+* Command Code discovers Anthropic-style `<name>/SKILL.md` directories under
+* `<project>/.commandcode/skills/` (project scope) and
+* `~/.commandcode/skills/` (user scope). The frontmatter requires `name`
+* (matching the directory name) and `description`; supporting files next to
+* `SKILL.md` are carried along.
+*
+* @see https://commandcode.ai/docs/skills
+*/
+var CommandcodeSkill = class CommandcodeSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = COMMANDCODE_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 = {}) {
+		return { relativeDirPath: COMMANDCODE_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return CommandcodeSkillFrontmatterSchema.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 = CommandcodeSkillFrontmatterSchema.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, ...commandcodeSection } = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(commandcodeSection).length > 0 && { commandcode: commandcodeSection }
+		};
+		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 = CommandcodeSkill.getSettablePaths({ global });
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const { name: _sectionName, description: _sectionDescription, ...commandcodeSection } = rulesyncFrontmatter.commandcode ?? {};
+		const commandcodeFrontmatter = {
+			...commandcodeSection,
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		return new CommandcodeSkill({
+			outputRoot,
+			relativeDirPath: settablePaths.relativeDirPath,
+			dirName: commandcodeFrontmatter.name,
+			frontmatter: commandcodeFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("commandcode");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: CommandcodeSkill.getSettablePaths
+		});
+		const result = CommandcodeSkillFrontmatterSchema.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 CommandcodeSkill({
+			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 CommandcodeSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/skills/continue-skill.ts
 const ContinueSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -61299,6 +62635,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["continue", {
 		class: ContinueSkill,
 		meta: {
@@ -63402,6 +64746,143 @@ var CodexCliSubagent = class CodexCliSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/commandcode-subagent.ts
+const CommandcodeSubagentFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	tools: z.optional(z.union([z.string(), z.array(z.string())])),
+	disallowedTools: z.optional(z.union([z.string(), z.array(z.string())])),
+	model: z.optional(z.string()),
+	reasoningEffort: z.optional(z.string()),
+	maxTurns: z.optional(z.number()),
+	permissionMode: z.optional(z.string()),
+	background: z.optional(z.boolean()),
+	showOutput: z.optional(z.boolean())
+});
+/**
+* Command Code custom agent: a Markdown file with YAML frontmatter under
+* `.commandcode/agents/` (project) or `~/.commandcode/agents/` (user); the
+* body is the agent's system prompt.
+*
+* @see https://commandcode.ai/docs/custom-agents
+*/
+var CommandcodeSubagent = class CommandcodeSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = CommandcodeSubagentFrontmatterSchema.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: COMMANDCODE_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,
+				commandcode: { ...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 commandcodeSection = rulesyncFrontmatter.commandcode ?? {};
+		const commandcodeSubagentFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...commandcodeSection
+		};
+		const body = rulesyncSubagent.getBody();
+		const fileContent = stringifyFrontmatter(body, commandcodeSubagentFrontmatter, { avoidBlockScalars: true });
+		const paths = this.getSettablePaths({ global });
+		return new CommandcodeSubagent({
+			outputRoot,
+			frontmatter: commandcodeSubagentFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = CommandcodeSubagentFrontmatterSchema.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: "commandcode"
+		});
+	}
+	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 = CommandcodeSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new CommandcodeSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new CommandcodeSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/copilot-subagent.ts
 const CopilotSubagentFrontmatterSchema = z.looseObject({
 	name: z.string(),
@@ -67060,6 +68541,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.toml"
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["copilot", {
 		class: CopilotSubagent,
 		meta: {
@@ -69892,6 +71382,73 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/commandcode-rule.ts
+var CommandcodeRule = class CommandcodeRule extends ToolRule {
+	constructor({ fileContent, root, ...rest }) {
+		super({
+			...rest,
+			fileContent,
+			root: root ?? false
+		});
+	}
+	static getSettablePaths({ global = false } = {}) {
+		return { root: {
+			relativeDirPath: global ? COMMANDCODE_DIR : ".",
+			relativeFilePath: COMMANDCODE_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 CommandcodeRule({
+			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 CommandcodeRule({
+			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 CommandcodeRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeFilePath === "AGENTS.md" && (relativeDirPath === "." || relativeDirPath === ".commandcode")
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "commandcode"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/continue-rule.ts
 /**
 * Frontmatter schema for Continue rule files (`.continue/rules/*.md`).
@@ -74212,6 +75769,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["continue", {
 		class: ContinueRule,
 		meta: {
@@ -77708,4 +79274,4 @@ async function importChecksCore(params) {
 //#endregion
 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, HooksProcessor 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, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_MCP_FILE_NAME as yn, withFallbackLoggerTarget as yt, RulesyncSubagentFrontmatterSchema as z, formatError as zn, listFilePathsRecursively as zt };
 
-//# sourceMappingURL=import-C6R-lXFF.js.map
+//# sourceMappingURL=import-De13gNpF.js.map