rulesync 16.33.0 → 16.34.0

package/dist/{import-DVRU6cLB.cjs → import-9T9fnjNn.cjs}

@@ -444,36 +444,36 @@ const isFeatureValueEnabled = (value) => {
 const parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$342 } = node_path.posix;
+const { join: join$350 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_USER_CONFIG_DIR_NAME = "rulesync";
 const RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME = ".config";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
 const RULES_FEATURE_SUBDIR = "rules";
-const CURATED_RULES_FEATURE_SUBDIR = join$342(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$350(RULES_FEATURE_SUBDIR, ".curated");
 const COMMANDS_FEATURE_SUBDIR = "commands";
 const SUBAGENTS_FEATURE_SUBDIR = "subagents";
 const CHECKS_FEATURE_SUBDIR = "checks";
 const SKILLS_FEATURE_SUBDIR = "skills";
-const CURATED_SKILLS_FEATURE_SUBDIR = join$342(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$342(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$350(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$350(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$342(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$350(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.jsonc";
@@ -503,6 +503,7 @@ const rulesProcessorToolTargetTuple = [
 	"cline",
 	"codebuddy",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -579,6 +580,7 @@ const mcpProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -622,6 +624,7 @@ const commandsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"cursor",
@@ -659,6 +662,7 @@ const subagentsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -700,6 +704,7 @@ const skillsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -747,6 +752,7 @@ const hooksProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-plugin",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -781,6 +787,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"commandcode",
 	"continue",
 	"copilot",
 	"copilotcli",
@@ -3295,6 +3302,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",
@@ -4952,6 +4960,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
@@ -5160,6 +5192,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	crush: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	bob: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	commandcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	continue: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	tabnine: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	qwencode: zod_mini.z.optional(zod_mini.z.looseObject({
@@ -6179,6 +6212,7 @@ const RulesyncMcpFileSchema = zod_mini.z.looseObject({
 	claudecode: zod_mini.z.optional(toolScopedMcpSchema),
 	cline: zod_mini.z.optional(toolScopedMcpSchema),
 	codexcli: zod_mini.z.optional(toolScopedMcpSchema),
+	commandcode: zod_mini.z.optional(toolScopedMcpSchema),
 	continue: zod_mini.z.optional(toolScopedMcpSchema),
 	copilot: zod_mini.z.optional(toolScopedMcpSchema),
 	copilotcli: zod_mini.z.optional(toolScopedMcpSchema),
@@ -6574,12 +6608,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);
@@ -6666,9 +6704,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"])
 	};
@@ -7833,6 +7886,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	continue: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	commandcode: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	copilotcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	crush: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
@@ -9555,6 +9609,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 	})),
+	commandcode: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	continue: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	tabnine: zod_mini.z.optional(zod_mini.z.looseObject({})),
@@ -13166,6 +13221,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",
@@ -15367,6 +15436,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 = (0, node_path.join)(COMMANDCODE_DIR, "commands");
+const COMMANDCODE_AGENTS_DIR_PATH = (0, node_path.join)(COMMANDCODE_DIR, "agents");
+const COMMANDCODE_SKILLS_DIR_PATH = (0, node_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 = (0, node_path.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";
@@ -19610,6 +19767,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: {
@@ -22980,6 +23147,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((0, node_path.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 = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+		const config = rulesyncHooks.getJson();
+		const hooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.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 = (0, node_path.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",
@@ -28099,6 +28392,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: {
@@ -31956,6 +32261,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$6(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: (0, node_path.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((0, node_path.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((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: (0, node_path.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
@@ -36924,6 +37477,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);
@@ -38221,6 +38775,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["continue", {
 		class: ContinueMcp,
 		meta: {
@@ -38614,6 +39177,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 = [];
@@ -42608,6 +43172,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: (0, es_toolkit.uniq)(allow.toSorted()),
+		ask: (0, es_toolkit.uniq)(ask.toSorted()),
+		deny: (0, es_toolkit.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((0, node_path.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 = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const existing = parseCommandcodeSettings({
+			fileContent: existingContent,
+			relativePath: (0, node_path.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: (0, node_path.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 = "*";
@@ -53369,6 +54549,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["continue", {
 		class: ContinuePermissions,
 		meta: {
@@ -56135,6 +57323,154 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/commandcode-skill.ts
+const CommandcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.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 = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
+		}
+		return new 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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -61324,6 +62660,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["continue", {
 		class: ContinueSkill,
 		meta: {
@@ -63427,6 +64771,143 @@ var CodexCliSubagent = class CodexCliSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/commandcode-subagent.ts
+const CommandcodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	tools: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	disallowedTools: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	reasoningEffort: zod_mini.z.optional(zod_mini.z.string()),
+	maxTurns: zod_mini.z.optional(zod_mini.z.number()),
+	permissionMode: zod_mini.z.optional(zod_mini.z.string()),
+	background: zod_mini.z.optional(zod_mini.z.boolean()),
+	showOutput: zod_mini.z.optional(zod_mini.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 ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: 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 ${(0, node_path.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 = (0, node_path.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 = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -67085,6 +68566,15 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.toml"
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeSubagent,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: "*.md"
+		}
+	}],
 	["copilot", {
 		class: CopilotSubagent,
 		meta: {
@@ -69917,6 +71407,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 = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.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`).
@@ -74237,6 +75794,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["commandcode", {
+		class: CommandcodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["continue", {
 		class: ContinueRule,
 		meta: {