rulesync 16.31.0 → 16.32.1

package/dist/{import-Cwe8RKJs.cjs → import-NHZnMc--.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$332 } = node_path.posix;
+const { join: join$340 } = 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$332(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$340(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$332(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$332(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$340(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$340(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$340(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$332(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$332(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$340(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$340(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",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -546,6 +547,7 @@ const ignoreProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
+	"continue",
 	"crush",
 	"cursor",
 	"hermesagent",
@@ -577,6 +579,7 @@ const mcpProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -618,6 +621,7 @@ const commandsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"cursor",
 	"factorydroid",
@@ -695,6 +699,7 @@ const skillsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -740,6 +745,7 @@ const hooksProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-plugin",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -772,6 +778,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cursor",
@@ -3284,6 +3291,7 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".claude/settings.json",
 	".claude/settings.local.json",
 	".codex/config.toml",
+	".continue/settings.json",
 	".copilot/settings.json",
 	".github/copilot/settings.json",
 	".cortex/settings.json",
@@ -4908,6 +4916,59 @@ 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 the Continue CLI (`cn`).
+*
+* Continue reads a Claude-Code-compatible `hooks` key from
+* `~/.continue/settings.json` (user) and `.continue/settings.json` (project):
+* PascalCase event names, a regex `matcher` over the event's subject (tool
+* name, session source, ...), and `command` / `http` / `prompt` / `agent`
+* handlers with a `timeout` in seconds. `$CONTINUE_PROJECT_DIR` resolves to
+* the working directory inside commands. The event list is the CLI's
+* `HOOK_EVENT_NAMES`.
+*
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/hooks/types.ts
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/hooks/hookConfig.ts
+*/
+const CONTINUE_HOOK_EVENTS = [
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionRequest",
+	"beforeSubmitPrompt",
+	"sessionStart",
+	"sessionEnd",
+	"stop",
+	"notification",
+	"subagentStart",
+	"subagentStop",
+	"preCompact",
+	"configChange",
+	"teammateIdle",
+	"taskCompleted",
+	"worktreeCreate",
+	"worktreeRemove"
+];
+const CANONICAL_TO_CONTINUE_EVENT_NAMES = {
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionRequest: "PermissionRequest",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	stop: "Stop",
+	notification: "Notification",
+	subagentStart: "SubagentStart",
+	subagentStop: "SubagentStop",
+	preCompact: "PreCompact",
+	configChange: "ConfigChange",
+	teammateIdle: "TeammateIdle",
+	taskCompleted: "TaskCompleted",
+	worktreeCreate: "WorktreeCreate",
+	worktreeRemove: "WorktreeRemove"
+};
+const CONTINUE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CONTINUE_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
 *
 * Hermes validates hook events against a fixed `VALID_HOOKS` set — 37 entries as
@@ -5062,6 +5123,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	zcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	bob: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	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({
 		hooks: zod_mini.z.optional(hooksRecordSchema),
@@ -6068,6 +6130,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),
+	continue: zod_mini.z.optional(toolScopedMcpSchema),
 	copilot: zod_mini.z.optional(toolScopedMcpSchema),
 	copilotcli: zod_mini.z.optional(toolScopedMcpSchema),
 	cursor: zod_mini.z.optional(toolScopedMcpSchema),
@@ -7701,6 +7764,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	zed: zod_mini.z.optional(ZedPermissionsOverrideSchema),
 	devin: zod_mini.z.optional(DevinPermissionsOverrideSchema),
 	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
+	continue: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	copilotcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
@@ -8129,6 +8193,13 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 		enabled: zod_mini.z.optional(zod_mini.z.boolean()),
 		description: zod_mini.z.optional(zod_mini.z.string())
 	})),
+	continue: zod_mini.z.optional(zod_mini.z.looseObject({
+		alwaysApply: zod_mini.z.optional(zod_mini.z.boolean()),
+		description: zod_mini.z.optional(zod_mini.z.string()),
+		globs: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+		name: zod_mini.z.optional(zod_mini.z.string()),
+		regex: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	})),
 	cursor: zod_mini.z.optional(zod_mini.z.looseObject({
 		alwaysApply: zod_mini.z.optional(zod_mini.z.boolean()),
 		description: zod_mini.z.optional(zod_mini.z.string()),
@@ -9417,6 +9488,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 	})),
 	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({})),
 	takt: zod_mini.z.optional(zod_mini.z.looseObject({
 		name: zod_mini.z.optional(zod_mini.z.string()),
@@ -12996,6 +13068,14 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: ["hooks"]
 		} }
 	},
+	".continue/settings.json": {
+		format: "json",
+		invalidRootPolicy: "error",
+		features: { hooks: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["hooks"]
+		} }
+	},
 	".cortex/settings.json": {
 		format: "json",
 		invalidRootPolicy: "error",
@@ -15197,6 +15277,152 @@ var CodexcliCommand = class CodexcliCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/constants/continue-paths.ts
+const CONTINUE_DIR = ".continue";
+const CONTINUE_ROOT_RULE_FILE_NAME = "AGENTS.md";
+const CONTINUE_PROMPTS_DIR_PATH = (0, node_path.join)(CONTINUE_DIR, "prompts");
+const CONTINUE_MCP_DIR_PATH = (0, node_path.join)(CONTINUE_DIR, "mcpServers");
+const CONTINUE_MCP_FILE_NAME = "mcp.json";
+const CONTINUE_SKILLS_DIR_PATH = (0, node_path.join)(CONTINUE_DIR, "skills");
+const CONTINUE_SETTINGS_FILE_NAME = "settings.json";
+const CONTINUE_PERMISSIONS_FILE_NAME = "permissions.yaml";
+const CONTINUE_IGNORE_FILE_NAME = ".continueignore";
+//#endregion
+//#region src/features/commands/continue-command.ts
+/**
+* Continue prompt files are Markdown files under `<project>/.continue/prompts/`
+* (project scope) and `~/.continue/prompts/` (user scope). A prompt with
+* `invokable: true` becomes a `/name` slash command in the chat input and the
+* CLI; without it the file is treated as a plain rule, so rulesync always sets
+* the flag. `name` is the command name (the file stem by default) and
+* `description` the hint shown next to it.
+*
+* @see https://docs.continue.dev/customize/deep-dives/prompts
+*/
+const ContinueCommandFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	invokable: zod_mini.z.optional(zod_mini.z.boolean())
+});
+/** The command name Continue derives from a prompt file: its stem. */
+function commandNameFromFilePath(relativeFilePath) {
+	return (0, node_path.basename)(relativeFilePath).replace(/\.md$/, "");
+}
+var ContinueCommand = class ContinueCommand extends ToolCommand {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = ContinueCommandFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths(_options = {}) {
+		return { relativeDirPath: CONTINUE_PROMPTS_DIR_PATH };
+	}
+	getBody() {
+		return this.body;
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	toRulesyncCommand() {
+		const { description, name, invokable: _invokable, ...restFields } = this.frontmatter;
+		const continueFields = {
+			...name !== void 0 && name !== commandNameFromFilePath(this.relativeFilePath) && { name },
+			...restFields
+		};
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			description,
+			...Object.keys(continueFields).length > 0 && { continue: continueFields }
+		};
+		const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
+		return new RulesyncCommand({
+			outputRoot: ".",
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RulesyncCommand.getSettablePaths().relativeDirPath,
+			relativeFilePath: this.relativeFilePath,
+			fileContent,
+			validate: true
+		});
+	}
+	static fromRulesyncCommand({ outputRoot = process.cwd(), rulesyncCommand, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncCommand.getFrontmatter();
+		const relativeFilePath = rulesyncCommand.getRelativeFilePath();
+		const continueFields = rulesyncFrontmatter.continue ?? {};
+		const continueFrontmatter = {
+			name: commandNameFromFilePath(relativeFilePath),
+			description: rulesyncFrontmatter.description,
+			...continueFields,
+			invokable: true
+		};
+		const body = rulesyncCommand.getBody();
+		const paths = this.getSettablePaths({ global });
+		return new ContinueCommand({
+			outputRoot,
+			frontmatter: continueFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			validate
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = ContinueCommandFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "continue"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = ContinueCommandFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new ContinueCommand({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			validate
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ContinueCommand({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: { description: "" },
+			body: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/constants/copilot-paths.ts
 const COPILOT_DIR = ".copilot";
 const GITHUB_DIR = ".github";
@@ -19297,6 +19523,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: false
 		}
 	}],
+	["continue", {
+		class: ContinueCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: false
+		}
+	}],
 	["copilot", {
 		class: CopilotCommand,
 		meta: {
@@ -22646,6 +22882,159 @@ var CodexcliHooks = class CodexcliHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/continue-hooks.ts
+const CONTINUE_CONVERTER_CONFIG = {
+	supportedEvents: CONTINUE_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_CONTINUE_EVENT_NAMES,
+	toolToCanonicalEventNames: CONTINUE_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "$CONTINUE_PROJECT_DIR",
+	prefixDotRelativeCommandsOnly: true,
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"beforeSubmitPrompt",
+		"stop",
+		"teammateIdle",
+		"taskCompleted",
+		"worktreeCreate",
+		"worktreeRemove"
+	]),
+	supportedHookTypes: /* @__PURE__ */ new Set([
+		"command",
+		"prompt",
+		"http",
+		"agent"
+	]),
+	emitsPromptModel: true,
+	stringPassthroughFields: [{
+		canonical: "statusMessage",
+		tool: "statusMessage"
+	}],
+	booleanPassthroughFields: [{
+		canonical: "once",
+		tool: "once"
+	}, {
+		canonical: "async",
+		tool: "async",
+		commandOnly: true
+	}]
+};
+/**
+* Single spelling of the settings/hooks codec/policy: fail closed on an
+* unparseable root rather than replacing the user's Continue settings with
+* generated output.
+*/
+function parseContinueSettings(fileContent, filePath) {
+	return parseSharedConfig({
+		format: "json",
+		fileContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+}
+/**
+* Continue CLI hooks.
+*
+* Hooks live under the top-level `hooks` key of `<project>/.continue/settings.json`
+* (project scope) and `~/.continue/settings.json` (user scope), in the
+* Claude-Code shape: `{ "<Event>": [{ "matcher"?: "<regex>", "hooks": [{
+* "type": "command" | "http" | "prompt" | "agent", ..., "timeout"?: <seconds>
+* }] }] }`. Both files also hold settings rulesync does not own, so generation
+* merges the `hooks` key into the existing file (see `SHARED_CONFIG_OWNERSHIP`)
+* instead of overwriting it. The CLI additionally reads
+* `.continue/settings.local.json` and the Claude Code settings files; rulesync
+* writes only the committable project file and the user file.
+*
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/hooks/hookConfig.ts
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/hooks/types.ts
+*/
+var ContinueHooks = class ContinueHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: CONTINUE_DIR,
+			relativeFilePath: CONTINUE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = ContinueHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new ContinueHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = ContinueHooks.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.continue?.hooks,
+			converterConfig: CONTINUE_CONVERTER_CONFIG,
+			logger
+		});
+		const fileContent = applySharedConfigPatch({
+			fileKey: sharedConfigFileKey(paths),
+			feature: "hooks",
+			existingContent,
+			patch: { hooks },
+			filePath,
+			logger
+		});
+		return new ContinueHooks({
+			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 = parseContinueSettings(this.getFileContent(), configPath);
+		} catch (error) {
+			throw new Error(`Failed to parse Continue hooks content in ${configPath}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			logger,
+			hooks: settings.hooks,
+			converterConfig: CONTINUE_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
+			hooks,
+			overrideKey: "continue"
+		}), null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ContinueHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/copilot-hooks.ts
 /**
 * Copilot hook entry as stored in .github/hooks/copilot-hooks.json.
@@ -27628,6 +28017,35 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportsMatcher: true,
 		matcherEvents: ["preToolUse", "postToolUse"]
 	}],
+	["continue", {
+		class: ContinueHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: CONTINUE_HOOK_EVENTS,
+		supportedHookTypes: [
+			"command",
+			"http",
+			"prompt",
+			"agent"
+		],
+		supportsMatcher: true,
+		matcherEvents: [
+			"preToolUse",
+			"postToolUse",
+			"postToolUseFailure",
+			"permissionRequest",
+			"sessionStart",
+			"sessionEnd",
+			"notification",
+			"subagentStart",
+			"subagentStop",
+			"preCompact",
+			"configChange"
+		]
+	}],
 	["cortexcode", {
 		class: CortexcodeHooks,
 		meta: {
@@ -28348,6 +28766,60 @@ var ClineIgnore = class ClineIgnore extends ToolIgnore {
 	}
 };
 //#endregion
+//#region src/features/ignore/continue-ignore.ts
+/**
+* Continue ignore file implementation.
+*
+* - Project scope: the workspace-root `.continueignore`, which follows the
+*   exact same rules as `.gitignore` and is layered on top of it.
+* - Global scope: `~/.continue/.continueignore`, respected for all workspaces.
+*
+* @see https://docs.continue.dev/reference/deprecated-codebase
+*/
+var ContinueIgnore = class ContinueIgnore extends ToolIgnore {
+	static getSettablePaths({ global = false } = {}) {
+		return {
+			relativeDirPath: global ? CONTINUE_DIR : ".",
+			relativeFilePath: CONTINUE_IGNORE_FILE_NAME
+		};
+	}
+	toRulesyncIgnore() {
+		return this.toRulesyncIgnoreDefault();
+	}
+	static fromRulesyncIgnore({ outputRoot = process.cwd(), rulesyncIgnore, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		return new ContinueIgnore({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: rulesyncIgnore.getFileContent(),
+			global
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const { relativeDirPath, relativeFilePath } = this.getSettablePaths({ global });
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath));
+		return new ContinueIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent,
+			validate,
+			global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		return new ContinueIgnore({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/constants/crush-paths.ts
 const CRUSH_RULE_FILE_NAME = "CRUSH.md";
 const CRUSH_GLOBAL_DIR = (0, node_path.join)(".config", "crush");
@@ -29462,6 +29934,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["claudecode", { class: ClaudecodeIgnore }],
 	["claudecode-legacy", { class: ClaudecodeIgnore }],
 	["cline", { class: ClineIgnore }],
+	["continue", { class: ContinueIgnore }],
 	["crush", { class: CrushIgnore }],
 	["cursor", { class: CursorIgnore }],
 	["hermesagent", { class: HermesagentIgnore }],
@@ -29482,6 +29955,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 ]);
 const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
 const ignoreProcessorGlobalToolTargets = [
+	"continue",
 	"devin",
 	"kiro",
 	"kiro-cli",
@@ -30240,13 +30714,17 @@ function isRemoteMcpServer(serverConfig) {
 function resolveRemoteMcpUrl(serverConfig) {
 	return serverConfig.url || serverConfig.httpUrl || void 0;
 }
-/** The `command` array a `local` server is spawned with, `args` merged in. */
+/**
+* The `command` array a `local` server is spawned with, `args` merged in. An
+* entry carrying `args` but no `command` comes back empty rather than with
+* `args[0]` promoted to its program: every adapter writes element 0 back out
+* as the executable (or the whole array as the command line), so the caller
+* skips such an entry the same way as one with nothing to spawn at all.
+*/
 function resolveLocalMcpCommand(serverConfig) {
-	const commandArray = [];
-	if (serverConfig.command) {
-		if (Array.isArray(serverConfig.command)) commandArray.push(...serverConfig.command);
-		else commandArray.push(serverConfig.command);
-	}
+	const { command } = serverConfig;
+	const commandArray = Array.isArray(command) ? [...command] : command ? [command] : [];
+	if (commandArray.length === 0) return [];
 	if (serverConfig.args) commandArray.push(...serverConfig.args);
 	return commandArray;
 }
@@ -30256,9 +30734,13 @@ function resolveLocalMcpCommand(serverConfig) {
 * spells the transport out. Writing `{type: "local", command: []}` for it would
 * give the tool a server it cannot start and the importer a file it cannot read
 * back, so it is skipped out loud instead.
+*
+* The server name comes straight from the user's config, so it is quoted
+* through `quoteValueForWarning` rather than interpolated: a crafted name could
+* otherwise carry a line break or control characters into the log.
 */
 function warnAndSkipMcpServer({ toolName, serverName, reason, logger }) {
-	logger?.warn(`${toolName} MCP: skipping "${serverName}" because it declares ${reason}.`);
+	logger?.warn(`${toolName} MCP: skipping ${quoteValueForWarning(serverName)} because it declares ${reason}.`);
 	return null;
 }
 /**
@@ -30346,8 +30828,10 @@ function asBobRemoteType(stated, url) {
 * streamable HTTP server carries `type: "streamable-http"` and `url`, and an
 * SSE server carries a bare `url`. The canonical `transport` alias and the
 * Claude-style `httpUrl` alias are folded into `type`/`url`; `env`, `cwd`,
-* `headers`, `timeout`, `alwaysAllow` and `disabled` pass through unchanged,
-* as Bob documents all of them.
+* `headers`, `timeout`, `alwaysAllow` and `disabled` pass through, as Bob
+* documents all of them (`env` and `headers` with their prototype-pollution
+* keys dropped, since Bob spreads those maps into the process environment and
+* the HTTP requests).
 *
 * Bob Shell documents the same file with an `httpURL` key instead of
 * `type` + `url` for streamable HTTP. rulesync writes the IDE spelling (the two
@@ -31185,6 +31669,230 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 	}
 };
 //#endregion
+//#region src/features/mcp/continue-mcp.ts
+/**
+* Parse a Continue MCP file. Continue reads the files under `mcpServers/` as
+* JSONC, so comments and trailing commas in a hand-written file are accepted;
+* malformed content or a non-object root (`null`, an array, a scalar) fails
+* closed rather than being spread into the regenerated file.
+*/
+function parseContinueMcpConfig({ fileContent, relativePath }) {
+	let parsed;
+	try {
+		parsed = parseJsonc$6(fileContent);
+	} catch (error) {
+		throw new Error(`Failed to parse Continue MCP config at ${relativePath}: ${formatError(error)}`, { cause: error });
+	}
+	if (!isPlainObject$1(parsed)) throw new Error(`Failed to parse Continue MCP config at ${relativePath}: expected a JSON object at the root`);
+	return parsed;
+}
+/**
+* The remote transport Continue reads a server as. Continue's JSON schema
+* accepts `type: "sse"` or `type: "http"` (streamable HTTP) 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 Continue equivalent, so `undefined` tells the
+* caller to skip the server.
+* @see https://docs.continue.dev/customize/deep-dives/mcp
+*/
+function asContinueRemoteType(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 Continue's JSON MCP schema
+* accepts: a remote server is `{ type, url, headers? }` and a stdio server is
+* `{ type: "stdio", command, args?, env? }`. Continue validates the whole
+* file with a strict union — one server that matches neither shape (an
+* unknown transport, a non-string `env` value) makes Continue drop every
+* server in the file — so only the documented keys are emitted and anything
+* else (`timeout`, `oauth`, rulesync-only fields) is left out. `envFile` is
+* accepted by Continue's schema but ignored with a warning at load time, so
+* it is dropped here with a warning instead of being written as if it worked.
+*
+* A server Continue cannot start or reach — no transport at all, a remote
+* transport without a URL, a WebSocket URL, or a stdio entry without a
+* command — is skipped with a warning rather than written in a form that
+* would invalidate the file.
+* @see https://docs.continue.dev/customize/deep-dives/mcp
+*/
+function convertToContinueFormat(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: "Continue",
+				serverName,
+				reason: "no transport",
+				logger
+			});
+			continue;
+		}
+		const converted = isRemoteMcpServer(serverConfig) ? convertRemoteServer({
+			serverName,
+			serverConfig,
+			logger
+		}) : convertStdioServer({
+			serverName,
+			serverConfig,
+			logger
+		});
+		if (converted !== void 0) result[serverName] = converted;
+	}
+	return result;
+}
+function convertRemoteServer({ serverName, serverConfig, logger }) {
+	const url = resolveRemoteMcpUrl(serverConfig);
+	if (!url) {
+		warnAndSkipMcpServer({
+			toolName: "Continue",
+			serverName,
+			reason: "a remote transport without a url",
+			logger
+		});
+		return;
+	}
+	const stated = serverConfig.type ?? serverConfig.transport;
+	const remoteType = asContinueRemoteType(typeof stated === "string" ? stated : void 0, url);
+	if (remoteType === void 0) {
+		warnAndSkipMcpServer({
+			toolName: "Continue",
+			serverName,
+			reason: stated === void 0 ? "a WebSocket url, which Continue's remote transports (http and sse) cannot reach" : `the "${String(stated)}" transport, which Continue does not offer for remote servers (only http and sse)`,
+			logger
+		});
+		return;
+	}
+	const converted = {
+		type: remoteType,
+		url
+	};
+	if (isRecord$1(serverConfig.headers)) converted.headers = omitPrototypePollutionKeys(serverConfig.headers);
+	return converted;
+}
+function convertStdioServer({ serverName, serverConfig, logger }) {
+	const [command, ...args] = resolveLocalMcpCommand(serverConfig);
+	if (!command) {
+		warnAndSkipMcpServer({
+			toolName: "Continue",
+			serverName,
+			reason: "a stdio transport without a command",
+			logger
+		});
+		return;
+	}
+	const converted = {
+		type: "stdio",
+		command
+	};
+	if (args.length > 0) converted.args = args;
+	if (isRecord$1(serverConfig.env)) converted.env = omitPrototypePollutionKeys(serverConfig.env);
+	if (typeof serverConfig.envFile === "string") logger?.warn(`Continue ignores "envFile" for MCP servers, so the envFile of server ${quoteValueForWarning(serverName)} was not written; put the variables in "env" instead.`);
+	return converted;
+}
+/**
+* Convert Continue's server map back to the canonical shape. The documented
+* spelling (`type` + `command`/`url`) is already canonical, so entries pass
+* through with only prototype-pollution keys dropped.
+*/
+function convertFromContinueFormat(mcpServers) {
+	if (!isMcpServers(mcpServers)) return {};
+	const result = {};
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
+		result[serverName] = omitPrototypePollutionKeys(serverConfig);
+	}
+	return result;
+}
+/**
+* Continue MCP configuration.
+*
+* Continue loads every `*.json` file under `.continue/mcpServers/` (project)
+* and `~/.continue/mcpServers/` (global); rulesync owns one of them,
+* `mcp.json`, in the `{ "mcpServers": { ... } }` shape the docs show. Other
+* files in the directory, and top-level sibling keys of `mcp.json`, are left
+* alone. The global file is not deleted by `--delete` (it lives outside the
+* project), while the project file is rulesync's own and is.
+*
+* @see https://docs.continue.dev/customize/deep-dives/mcp
+*/
+var ContinueMcp = class ContinueMcp extends ToolMcp {
+	json;
+	constructor(params) {
+		super(params);
+		this.json = this.fileContent === void 0 ? {} : parseContinueMcpConfig({
+			fileContent: this.fileContent,
+			relativePath: (0, node_path.join)(this.relativeDirPath, this.relativeFilePath)
+		});
+	}
+	getJson() {
+		return this.json;
+	}
+	isDeletable() {
+		return !this.global;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: CONTINUE_MCP_DIR_PATH,
+			relativeFilePath: CONTINUE_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 ContinueMcp({
+			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 = parseContinueMcpConfig({
+			fileContent: await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
+		});
+		const mcpServers = convertToContinueFormat(rulesyncMcp.getMcpServers(), logger);
+		const continueConfig = {
+			...json,
+			mcpServers
+		};
+		return new ContinueMcp({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: JSON.stringify(continueConfig, null, 2),
+			validate,
+			global
+		});
+	}
+	toRulesyncMcp() {
+		const mcpServers = convertFromContinueFormat(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 ContinueMcp({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/mcp/copilot-mcp.ts
 function convertFromCopilotFormat(copilotConfig) {
 	return copilotConfig.servers ?? {};
@@ -36917,6 +37625,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["continue", {
+		class: ContinueMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["copilot", {
 		class: CopilotMcp,
 		meta: {
@@ -38375,7 +39092,7 @@ const ANTIGRAVITY_CLI_TO_CANONICAL_TOOL_NAMES = {
 function toAntigravityCliToolName(canonical) {
 	return CANONICAL_TO_ANTIGRAVITY_CLI_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$6(cliName) {
+function toCanonicalToolName$7(cliName) {
 	return ANTIGRAVITY_CLI_TO_CANONICAL_TOOL_NAMES[cliName] ?? cliName;
 }
 /**
@@ -38591,7 +39308,7 @@ function convertAntigravityCliToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { toolName, pattern } = parsePermissionEntry$1(entry);
-			const canonical = toCanonicalToolName$6(toolName);
+			const canonical = toCanonicalToolName$7(toolName);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
 		}
@@ -38851,7 +39568,7 @@ const AUGMENT_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONI
 function toAugmentToolName(canonical) {
 	return CANONICAL_TO_AUGMENT_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$5(augmentName) {
+function toCanonicalToolName$6(augmentName) {
 	return AUGMENT_TO_CANONICAL_TOOL_NAMES[augmentName] ?? augmentName;
 }
 function actionToAugmentType(action) {
@@ -39298,7 +40015,7 @@ function convertAugmentToRulesyncPermissions({ entries, logger }) {
 		if (isSpecialEntry(entry)) continue;
 		const type = entry.permission.type;
 		if (!isBasicAugmentType(type)) continue;
-		const canonical = toCanonicalToolName$5(entry.toolName);
+		const canonical = toCanonicalToolName$6(entry.toolName);
 		if (forbiddenMapKeys.has(canonical)) {
 			logger?.warn(`AugmentCode permissions: skipping entry for tool '${entry.toolName}' because it maps to the reserved object key '${canonical}', which cannot be used as a permission key.`);
 			continue;
@@ -39533,7 +40250,7 @@ const CLAUDE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONIC
 function toClaudeToolName(canonical) {
 	return CANONICAL_TO_CLAUDE_TOOL_NAMES[canonical] ?? canonical;
 }
-function toCanonicalToolName$4(claudeName) {
+function toCanonicalToolName$5(claudeName) {
 	return CLAUDE_TO_CANONICAL_TOOL_NAMES[claudeName] ?? claudeName;
 }
 /**
@@ -40428,7 +41145,7 @@ function convertClaudeToRulesyncPermissions(params) {
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
 			const { toolName, pattern } = parseClaudePermissionEntry(entry);
-			const canonical = toCanonicalToolName$4(toolName);
+			const canonical = toCanonicalToolName$5(toolName);
 			if (!permission[canonical]) permission[canonical] = {};
 			permission[canonical][pattern] = action;
 		}
@@ -41251,6 +41968,264 @@ function mapBashActionToDecision(action) {
 	return "forbidden";
 }
 //#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$4 = "*";
+const CANONICAL_TO_CONTINUE_TOOL_NAMES = {
+	bash: "Bash",
+	read: "Read",
+	edit: "Edit",
+	write: "Write",
+	webfetch: "Fetch"
+};
+const CONTINUE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CONTINUE_TOOL_NAMES).map(([k, v]) => [v, k]));
+const ACTION_TO_CONTINUE_LIST = {
+	allow: "allow",
+	ask: "ask",
+	deny: "exclude"
+};
+const CONTINUE_LIST_TO_ACTION = {
+	allow: "allow",
+	ask: "ask",
+	exclude: "deny"
+};
+const CONTINUE_PERMISSION_LIST_KEYS = [
+	"exclude",
+	"ask",
+	"allow"
+];
+const CONTINUE_PATTERN_RE = /^([^(]+)(?:\(([^)]*)\))?$/;
+function toContinueToolName(canonical) {
+	return Object.hasOwn(CANONICAL_TO_CONTINUE_TOOL_NAMES, canonical) ? CANONICAL_TO_CONTINUE_TOOL_NAMES[canonical] ?? canonical : canonical;
+}
+function toCanonicalToolName$4(continueName) {
+	return Object.hasOwn(CONTINUE_TO_CANONICAL_TOOL_NAMES, continueName) ? CONTINUE_TO_CANONICAL_TOOL_NAMES[continueName] ?? continueName : continueName;
+}
+/**
+* Build a permissions.yaml entry: the bare tool name for the catch-all, else
+* `Tool(pattern)`.
+*/
+function buildContinuePermissionEntry(toolName, pattern) {
+	return pattern === CATCH_ALL_PATTERN$4 ? toolName : `${toolName}(${pattern})`;
+}
+/**
+* Split a permissions.yaml entry into its tool name and argument pattern, or
+* `undefined` for an entry outside the loader's grammar.
+*/
+function parseContinuePermissionEntry(entry) {
+	const match = CONTINUE_PATTERN_RE.exec(entry);
+	if (!match) return;
+	const toolName = match[1]?.trim() ?? "";
+	const pattern = match[2]?.trim() ?? "";
+	if (toolName === "") return;
+	return {
+		toolName,
+		pattern: pattern === "" ? CATCH_ALL_PATTERN$4 : pattern
+	};
+}
+/**
+* Permissions adapter for the Continue CLI (`cn`).
+*
+* Continue reads tool policies from `~/.continue/permissions.yaml`, three
+* string lists (`allow`, `ask`, `exclude`) of `Tool` / `Tool(pattern)` entries
+* evaluated exclude-first, then ask, then allow, first match wins. `exclude`
+* disables the tool. A `Tool(pattern)` entry glob-matches (`*` / `?`) the
+* tool's primary argument — the shell command for `Bash`, the path for
+* `Read` / `Edit` / `Write`, the URL for `Fetch`. The file is **global only**:
+* no project-scoped permissions file is read.
+*
+* Mapping (rulesync canonical -> Continue):
+*   - Action: `allow` -> `allow`, `ask` -> `ask`, `deny` -> `exclude`.
+*   - Tool name: `bash` -> `Bash`, `read` -> `Read`, `edit` -> `Edit`,
+*     `write` -> `Write`, `webfetch` -> `Fetch`; any other category passes
+*     through verbatim, and the all-tools `*` category becomes the bare `*`
+*     entry that matches every tool.
+*   - Entry: the catch-all `*` pattern is the bare tool name; every other
+*     pattern is written as `Tool(pattern)`. A pattern holding a parenthesis
+*     cannot be written (the loader would refuse the whole file) and is
+*     reported and skipped.
+*
+* The CLI appends the user's own "always allow" decisions to the same file,
+* so entries naming a tool the canonical config does not manage are preserved
+* verbatim, the managed tools' entries are rebuilt, and the file is never
+* deleted.
+*
+* @see https://docs.continue.dev/cli/tool-permissions
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/permissions/permissionsYamlLoader.ts
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/permissions/permissionChecker.ts
+*/
+var ContinuePermissions = class ContinuePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? ""
+		});
+	}
+	isDeletable() {
+		return false;
+	}
+	/**
+	* `permissions.yaml` is Continue's file: rulesync merges into it when it
+	* exists but does not create one that holds three empty lists — an absent
+	* file and empty lists both mean "no policy, ask for everything".
+	*/
+	shouldSkipCreationWhenPayloadEmpty() {
+		return true;
+	}
+	static getSettablePaths(_options) {
+		return {
+			relativeDirPath: CONTINUE_DIR,
+			relativeFilePath: CONTINUE_PERMISSIONS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		if (!global) throw new Error(CONTINUE_GLOBAL_ONLY_MESSAGE);
+		const paths = ContinuePermissions.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
+		return new ContinuePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate,
+			global: true
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
+		if (!global) throw new Error(CONTINUE_GLOBAL_ONLY_MESSAGE);
+		const paths = ContinuePermissions.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		let parsed;
+		try {
+			parsed = existingContent.trim() === "" ? {} : loadYaml(existingContent);
+		} catch (error) {
+			throw new Error(`Failed to parse existing Continue permissions.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
+		}
+		const existing = parseContinuePermissionLists(isRecord$1(parsed) ? parsed : {});
+		const config = rulesyncPermissions.getJson();
+		const generated = convertRulesyncToContinuePermissions({
+			config,
+			logger
+		});
+		const managedToolNames = managedContinueToolNames(config);
+		const lists = {};
+		for (const key of CONTINUE_PERMISSION_LIST_KEYS) {
+			const preserved = existing[key].filter((entry) => {
+				const parsedEntry = parseContinuePermissionEntry(entry);
+				return parsedEntry === void 0 || !managedToolNames.has(parsedEntry.toolName);
+			});
+			const merged = [.../* @__PURE__ */ new Set([...preserved, ...generated[key]])];
+			if (merged.length > 0) lists[key] = merged;
+		}
+		return new ContinuePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: Object.keys(lists).length === 0 ? "" : (0, js_yaml.dump)(lists),
+			validate: true,
+			global: true
+		});
+	}
+	toRulesyncPermissions() {
+		let parsed;
+		try {
+			const content = this.getFileContent();
+			parsed = content.trim() === "" ? {} : loadYaml(content);
+		} catch (error) {
+			throw new Error(`Failed to parse Continue permissions content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const rulesyncConfig = convertContinuePermissionsToRulesync(parseContinuePermissionLists(isRecord$1(parsed) ? parsed : {}));
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(rulesyncConfig, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ContinuePermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			global: true
+		});
+	}
+};
+/**
+* The Continue tool names the canonical config manages, i.e. the names its
+* categories map to. Entries naming any other tool are the user's (or the
+* CLI's) and survive a generate.
+*/
+function managedContinueToolNames(config) {
+	return new Set(Object.keys(config.permission).map((category) => toContinueToolName(category)));
+}
+/**
+* Read the three lists out of a parsed permissions.yaml, tolerating a missing
+* or malformed list (the CLI itself discards the file in that case).
+*/
+function parseContinuePermissionLists(parsed) {
+	return {
+		exclude: isStringArray$2(parsed.exclude) ? parsed.exclude : [],
+		ask: isStringArray$2(parsed.ask) ? parsed.ask : [],
+		allow: isStringArray$2(parsed.allow) ? parsed.allow : []
+	};
+}
+/**
+* Convert a rulesync permissions config into the three permissions.yaml lists.
+*/
+function convertRulesyncToContinuePermissions({ config, logger }) {
+	const lists = {
+		exclude: [],
+		ask: [],
+		allow: []
+	};
+	const actionByEntry = /* @__PURE__ */ new Map();
+	for (const [category, rules] of Object.entries(honorAllToolsOnBash(config.permission))) {
+		if (isPrototypePollutionKey(category)) continue;
+		const toolName = category === "*" ? "*" : toContinueToolName(category);
+		for (const [pattern, action] of Object.entries(rules)) {
+			if (isPrototypePollutionKey(pattern)) continue;
+			if (pattern.includes("(") || pattern.includes(")")) {
+				logger?.warn(`Continue permissions.yaml cannot hold a parenthesis inside a pattern, so the "${action}" rule for "${category}" (pattern ${quoteValueForWarning(pattern)}) was skipped.`);
+				continue;
+			}
+			if (toolName === "*" && pattern !== CATCH_ALL_PATTERN$4) {
+				logger?.warn(`Continue permissions.yaml cannot scope a pattern to every tool, so the "${action}" rule for "*" (pattern ${quoteValueForWarning(pattern)}) was skipped.`);
+				continue;
+			}
+			const entry = buildContinuePermissionEntry(toolName, pattern);
+			const previous = actionByEntry.get(entry);
+			if (previous !== void 0 && previous !== action) logger?.warn(`Continue permissions: rules from different categories both resolve to ${quoteValueForWarning(entry)} with conflicting actions (${previous} and ${action}). Both are written; Continue applies exclude first, then ask, then allow.`);
+			actionByEntry.set(entry, action);
+			lists[ACTION_TO_CONTINUE_LIST[action]].push(entry);
+		}
+	}
+	for (const key of CONTINUE_PERMISSION_LIST_KEYS) lists[key] = [...new Set(lists[key])];
+	return lists;
+}
+/**
+* Convert the three permissions.yaml lists back into a rulesync config.
+*/
+function convertContinuePermissionsToRulesync(lists) {
+	const permission = {};
+	for (const key of CONTINUE_PERMISSION_LIST_KEYS) {
+		const action = CONTINUE_LIST_TO_ACTION[key];
+		for (const entry of lists[key]) {
+			const parsedEntry = parseContinuePermissionEntry(entry);
+			if (parsedEntry === void 0) continue;
+			if (isPrototypePollutionKey(parsedEntry.toolName) || isPrototypePollutionKey(parsedEntry.pattern)) continue;
+			const category = toCanonicalToolName$4(parsedEntry.toolName);
+			permission[category] ??= {};
+			permission[category][parsedEntry.pattern] ??= action;
+		}
+	}
+	return { permission };
+}
+//#endregion
 //#region src/features/permissions/copilot-permissions.ts
 /**
 * The flat, dotted VS Code setting keys this adapter manages, one per canonical
@@ -51299,6 +52274,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["continue", {
+		class: ContinuePermissions,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["copilot", {
 		class: CopilotPermissions,
 		meta: {
@@ -54049,6 +55032,154 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/continue-skill.ts
+const ContinueSkillFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.string()
+});
+/**
+* Represents a Continue skill directory.
+*
+* Continue discovers Anthropic-style `<name>/SKILL.md` directories under
+* `<project>/.continue/skills/` (project scope) and `~/.continue/skills/`
+* (user scope); it also reads `.claude/skills/`, which the claudecode target
+* covers. The frontmatter requires `name` (matching the directory name) and
+* `description`; supporting files next to `SKILL.md` are carried along.
+*
+* @see https://github.com/continuedev/continue/blob/main/extensions/cli/src/util/loadMarkdownSkills.ts
+*/
+var ContinueSkill = class ContinueSkill extends ToolSkill {
+	constructor({ outputRoot = process.cwd(), relativeDirPath = CONTINUE_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: CONTINUE_SKILLS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return ContinueSkillFrontmatterSchema.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 = ContinueSkillFrontmatterSchema.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, ...continueSection } = this.getFrontmatter();
+		const rulesyncFrontmatter = {
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(continueSection).length > 0 && { continue: continueSection }
+		};
+		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 = ContinueSkill.getSettablePaths({ global });
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const { name: _sectionName, description: _sectionDescription, ...continueSection } = rulesyncFrontmatter.continue ?? {};
+		const continueFrontmatter = {
+			...continueSection,
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description
+		};
+		return new ContinueSkill({
+			outputRoot,
+			relativeDirPath: settablePaths.relativeDirPath,
+			dirName: continueFrontmatter.name,
+			frontmatter: continueFrontmatter,
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("continue");
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: ContinueSkill.getSettablePaths
+		});
+		const result = ContinueSkillFrontmatterSchema.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 ContinueSkill({
+			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 ContinueSkill({
+			outputRoot,
+			relativeDirPath,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
+};
+//#endregion
 //#region src/features/skills/copilot-skill.ts
 const CopilotSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -58913,6 +60044,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["continue", {
+		class: ContinueSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["copilot", {
 		class: CopilotSkill,
 		meta: {
@@ -67481,6 +68620,263 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/continue-rule.ts
+/**
+* Frontmatter schema for Continue rule files (`.continue/rules/*.md`).
+* `globs` and `regex` are documented as either a single pattern or a list.
+* @see https://docs.continue.dev/customize/deep-dives/rules
+*/
+const ContinueRuleFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.optional(zod_mini.z.string()),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	globs: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	regex: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	alwaysApply: zod_mini.z.optional(zod_mini.z.boolean())
+});
+/**
+* Normalizes the documented `string` / `string[]` shapes to the list form the
+* adapter works with. Continue treats a scalar as one pattern (no comma
+* splitting), so the scalar simply becomes a one-element list. An empty list
+* and an empty string both mean "not set".
+*/
+function normalizePatternList(value) {
+	if (value === void 0) return;
+	const list = (typeof value === "string" ? [value] : value).filter((pattern) => pattern.trim() !== "");
+	return list.length > 0 ? list : void 0;
+}
+/**
+* A universal glob is redundant on a Continue rule: a `.continue/rules/` file
+* with no `globs` is already implicitly always-on, and one with `globs` is
+* only pulled in when a context file matches, so emitting `**\/*` would turn
+* an always-on rule into a "when any file is in context" rule. Dropped on
+* generate and mapped back on import.
+*/
+const UNIVERSAL_GLOBS$1 = /* @__PURE__ */ new Set(["**/*", "*"]);
+/**
+* Rule generator for Continue (continuedev/continue), the open-source IDE
+* extension and CLI (`cn`).
+*
+* Rules format:
+* - {project}/AGENTS.md (root: true) — read from the workspace root and
+*   always applied.
+* - {project}/.continue/rules/*.md (root: false) — Markdown with optional
+*   `description` / `globs` / `regex` / `alwaysApply` frontmatter. A file
+*   with no `globs`/`regex` is always applied; one with `globs` is applied
+*   when a context file matches; `alwaysApply: true` forces it on and
+*   `alwaysApply: false` makes it depend on `globs`/`regex` only.
+* - Global: ~/.continue/rules/*.md. Continue does not read `~/AGENTS.md`, so
+*   the global root rule is written to `~/.continue/rules/AGENTS.md`, the
+*   same layout the Roo adapter uses.
+*
+* @see https://docs.continue.dev/customize/deep-dives/rules
+*/
+var ContinueRule = class ContinueRule extends ToolRule {
+	frontmatter;
+	body;
+	static getSettablePaths({ global, excludeToolDir } = {}) {
+		const rulesDirPath = buildToolPath(CONTINUE_DIR, "rules", excludeToolDir);
+		if (global) return {
+			root: {
+				relativeDirPath: rulesDirPath,
+				relativeFilePath: CONTINUE_ROOT_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: rulesDirPath }
+		};
+		return {
+			root: {
+				relativeDirPath: ".",
+				relativeFilePath: CONTINUE_ROOT_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: rulesDirPath }
+		};
+	}
+	constructor({ frontmatter, body, ...rest }) {
+		if (rest.validate) {
+			const result = ContinueRuleFrontmatterSchema.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: rest.root ? body : ContinueRule.generateFileContent(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static generateFileContent(body, frontmatter) {
+		if (frontmatter.name === void 0 && frontmatter.description === void 0 && frontmatter.globs === void 0 && frontmatter.regex === void 0 && frontmatter.alwaysApply === void 0) return body;
+		return stringifyFrontmatter(body, {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			globs: frontmatter.globs,
+			regex: frontmatter.regex,
+			alwaysApply: frontmatter.alwaysApply
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false, relativeDirPath: overrideDirPath }) {
+		const paths = this.getSettablePaths({ global });
+		const rootDirPath = overrideDirPath ?? paths.root.relativeDirPath;
+		if (relativeFilePath === paths.root.relativeFilePath && rootDirPath === paths.root.relativeDirPath) {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, rootDirPath, paths.root.relativeFilePath));
+			return new ContinueRule({
+				outputRoot,
+				relativeDirPath: rootDirPath,
+				relativeFilePath: paths.root.relativeFilePath,
+				frontmatter: {},
+				body: fileContent.trim(),
+				validate,
+				root: true
+			});
+		}
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const filePath = (0, node_path.join)(outputRoot, relativePath);
+		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
+		const result = ContinueRuleFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new ContinueRule({
+			outputRoot,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			validate,
+			root: false
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const isRoot = relativeFilePath === paths.root.relativeFilePath && relativeDirPath === paths.root.relativeDirPath;
+		return new ContinueRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {},
+			body: "",
+			validate: false,
+			root: isRoot
+		});
+	}
+	/**
+	* Resolves the `globs` to emit. A universal glob is dropped because a rule
+	* without `globs` is already always-on in Continue (see `UNIVERSAL_GLOBS`),
+	* and every glob is dropped alongside `alwaysApply: true`, which forces the
+	* rule on regardless of them.
+	*/
+	static resolveContinueGlobs({ continueGlobs, parentGlobs, alwaysApply }) {
+		if (alwaysApply === true) return;
+		const targetGlobs = continueGlobs ?? parentGlobs;
+		if (!targetGlobs || targetGlobs.length === 0) return;
+		if (targetGlobs.every((glob) => UNIVERSAL_GLOBS$1.has(glob.trim()))) return;
+		return targetGlobs;
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+		const root = rulesyncFrontmatter.root ?? false;
+		const paths = this.getSettablePaths({ global });
+		const body = rulesyncRule.getBody();
+		if (root) return new ContinueRule({
+			outputRoot,
+			frontmatter: {},
+			body,
+			relativeDirPath: paths.root.relativeDirPath,
+			relativeFilePath: paths.root.relativeFilePath,
+			validate,
+			root
+		});
+		const continueFrontmatter = rulesyncFrontmatter.continue;
+		const continueRuleFrontmatter = {
+			name: continueFrontmatter?.name,
+			description: continueFrontmatter?.description ?? rulesyncFrontmatter.description,
+			globs: ContinueRule.resolveContinueGlobs({
+				continueGlobs: normalizePatternList(continueFrontmatter?.globs),
+				parentGlobs: rulesyncFrontmatter.globs,
+				alwaysApply: continueFrontmatter?.alwaysApply
+			}),
+			regex: normalizePatternList(continueFrontmatter?.regex),
+			alwaysApply: continueFrontmatter?.alwaysApply
+		};
+		return new ContinueRule({
+			outputRoot,
+			frontmatter: continueRuleFrontmatter,
+			body,
+			relativeDirPath: paths.nonRoot.relativeDirPath,
+			relativeFilePath: rulesyncRule.getRelativeFilePath(),
+			validate,
+			root
+		});
+	}
+	toRulesyncRule() {
+		const targets = ["*"];
+		if (this.isRoot()) {
+			const rulesyncFrontmatter = {
+				targets,
+				root: true,
+				description: this.description,
+				globs: ["**/*"]
+			};
+			return new RulesyncRule({
+				outputRoot: this.getOutputRoot(),
+				frontmatter: rulesyncFrontmatter,
+				body: this.body,
+				relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+				relativeFilePath: RULESYNC_OVERVIEW_FILE_NAME,
+				validate: true
+			});
+		}
+		const sourceGlobs = normalizePatternList(this.frontmatter.globs) ?? [];
+		const regex = normalizePatternList(this.frontmatter.regex);
+		const isAlways = this.frontmatter.alwaysApply !== false;
+		const globs = sourceGlobs.length === 0 && isAlways ? ["**/*"] : sourceGlobs;
+		const { name, alwaysApply } = this.frontmatter;
+		const hasContinueSection = name !== void 0 || alwaysApply !== void 0 || regex !== void 0;
+		const rulesyncFrontmatter = {
+			targets,
+			root: false,
+			description: this.frontmatter.description,
+			globs,
+			...hasContinueSection && { continue: {
+				...name !== void 0 && { name },
+				alwaysApply,
+				regex
+			} }
+		};
+		return new RulesyncRule({
+			outputRoot: this.getOutputRoot(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			validate: true
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = ContinueRuleFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "continue"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/copilot-rule.ts
 const CopilotRuleFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
@@ -71562,6 +72958,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["continue", {
+		class: ContinueRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["copilot", {
 		class: CopilotRule,
 		meta: {