rulesync 16.31.0 → 16.32.0

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

@@ -478,6 +478,7 @@ const rulesProcessorToolTargetTuple = [
 	"cline",
 	"codebuddy",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -521,6 +522,7 @@ const ignoreProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-legacy",
 	"cline",
+	"continue",
 	"crush",
 	"cursor",
 	"hermesagent",
@@ -552,6 +554,7 @@ const mcpProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -593,6 +596,7 @@ const commandsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"cursor",
 	"factorydroid",
@@ -670,6 +674,7 @@ const skillsProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -715,6 +720,7 @@ const hooksProcessorToolTargetTuple = [
 	"claudecode",
 	"claudecode-plugin",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cortexcode",
@@ -747,6 +753,7 @@ const permissionsProcessorToolTargetTuple = [
 	"claudecode",
 	"cline",
 	"codexcli",
+	"continue",
 	"copilot",
 	"copilotcli",
 	"cursor",
@@ -3259,6 +3266,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",
@@ -4883,6 +4891,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
@@ -5037,6 +5098,7 @@ const HooksConfigSchema = z.looseObject({
 	zcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	bob: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	cortexcode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	continue: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	tabnine: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
@@ -6043,6 +6105,7 @@ const RulesyncMcpFileSchema = z.looseObject({
 	claudecode: z.optional(toolScopedMcpSchema),
 	cline: z.optional(toolScopedMcpSchema),
 	codexcli: z.optional(toolScopedMcpSchema),
+	continue: z.optional(toolScopedMcpSchema),
 	copilot: z.optional(toolScopedMcpSchema),
 	copilotcli: z.optional(toolScopedMcpSchema),
 	cursor: z.optional(toolScopedMcpSchema),
@@ -7676,6 +7739,7 @@ const PermissionsConfigSchema = z.looseObject({
 	zed: z.optional(ZedPermissionsOverrideSchema),
 	devin: z.optional(DevinPermissionsOverrideSchema),
 	"antigravity-ide": z.optional(CanonicalPermissionsOverrideSchema),
+	continue: z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: z.optional(CanonicalPermissionsOverrideSchema),
 	copilotcli: z.optional(CanonicalPermissionsOverrideSchema),
 	goose: z.optional(CanonicalPermissionsOverrideSchema),
@@ -8104,6 +8168,13 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		enabled: z.optional(z.boolean()),
 		description: z.optional(z.string())
 	})),
+	continue: z.optional(z.looseObject({
+		alwaysApply: z.optional(z.boolean()),
+		description: z.optional(z.string()),
+		globs: z.optional(z.union([z.string(), z.array(z.string())])),
+		name: z.optional(z.string()),
+		regex: z.optional(z.union([z.string(), z.array(z.string())]))
+	})),
 	cursor: z.optional(z.looseObject({
 		alwaysApply: z.optional(z.boolean()),
 		description: z.optional(z.string()),
@@ -9392,6 +9463,7 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
 	})),
 	cortexcode: z.optional(z.looseObject({})),
+	continue: z.optional(z.looseObject({})),
 	tabnine: z.optional(z.looseObject({})),
 	takt: z.optional(z.looseObject({
 		name: z.optional(z.string()),
@@ -12971,6 +13043,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",
@@ -15172,6 +15252,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 = join(CONTINUE_DIR, "prompts");
+const CONTINUE_MCP_DIR_PATH = join(CONTINUE_DIR, "mcpServers");
+const CONTINUE_MCP_FILE_NAME = "mcp.json";
+const CONTINUE_SKILLS_DIR_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 = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	invokable: z.optional(z.boolean())
+});
+/** The command name Continue derives from a prompt file: its stem. */
+function commandNameFromFilePath(relativeFilePath) {
+	return 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 ${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 ${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 = 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";
@@ -19272,6 +19498,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: {
@@ -22621,6 +22857,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(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 = 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 = 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.
@@ -27603,6 +27992,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: {
@@ -28323,6 +28741,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(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 = join(".config", "crush");
@@ -29437,6 +29909,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 }],
@@ -29457,6 +29930,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 ]);
 const ignoreProcessorToolTargets = [...toolIgnoreFactories.keys()];
 const ignoreProcessorGlobalToolTargets = [
+	"continue",
 	"devin",
 	"kiro",
 	"kiro-cli",
@@ -31160,6 +31634,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(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] = (typeof serverConfig.command === "string" ? serverConfig.command !== "" : Array.isArray(serverConfig.command) && serverConfig.command.length > 0) ? 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 "${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: 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(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(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}",
+			relativePath: 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 ?? {};
@@ -36892,6 +37590,15 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: true
 		}
 	}],
+	["continue", {
+		class: ContinueMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["copilot", {
 		class: CopilotMcp,
 		meta: {
@@ -38350,7 +39057,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;
 }
 /**
@@ -38566,7 +39273,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;
 		}
@@ -38826,7 +39533,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) {
@@ -39273,7 +39980,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;
@@ -39508,7 +40215,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;
 }
 /**
@@ -40403,7 +41110,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;
 		}
@@ -41226,6 +41933,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(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 = 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 ? "" : 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 ${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
@@ -51274,6 +52239,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		}
 	}],
+	["continue", {
+		class: ContinuePermissions,
+		meta: {
+			supportsProject: false,
+			supportsGlobal: true,
+			supportsImport: true
+		}
+	}],
 	["copilot", {
 		class: CopilotPermissions,
 		meta: {
@@ -54024,6 +54997,154 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/continue-skill.ts
+const ContinueSkillFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: 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 = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
+			throw new Error(`Invalid frontmatter in ${join(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
+		}
+		if (result.data.name !== loaded.dirName) {
+			const skillFilePath = join(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME);
+			throw new Error(`Frontmatter name (${result.data.name}) must match directory name (${loaded.dirName}) in ${skillFilePath}`);
+		}
+		return new 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 = z.looseObject({
 	name: z.string(),
@@ -58888,6 +60009,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["continue", {
+		class: ContinueSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["copilot", {
 		class: CopilotSkill,
 		meta: {
@@ -67456,6 +68585,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 = z.looseObject({
+	name: z.optional(z.string()),
+	description: z.optional(z.string()),
+	globs: z.optional(z.union([z.string(), z.array(z.string())])),
+	regex: z.optional(z.union([z.string(), z.array(z.string())])),
+	alwaysApply: z.optional(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 ${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(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 = join(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const filePath = 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 ${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 = z.looseObject({
 	description: z.optional(z.string()),
@@ -71537,6 +72923,14 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["continue", {
+		class: ContinueRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto"
+		}
+	}],
 	["copilot", {
 		class: CopilotRule,
 		meta: {
@@ -75025,4 +76419,4 @@ async function importChecksCore(params) {
 //#endregion
 export { RulesyncCheck as $, writeFileContent as $t, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SKILLS_RELATIVE_DIR_PATH as An, directoryExists as At, RulesyncSkill as B, truncateText as Bn, listSubdirectoryNames as Bt, ChecksProcessor as C, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Cn, ErrorCodes as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_PERMISSIONS_SCHEMA_URL as Dn, assertWritablePathInsideRoot as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as En, assertTreeContainsNoSymlinks as Et, AUGMENTCODE_DIR as F, parseCommaSeparatedList as Fn, isFileNotFoundError as Ft, RulesyncMcp as G, stripControlCharactersKeepingLineFeeds as Gn, removeDirectoryStrict as Gt, RulesyncRule as H, hasEnclosingMarkOutsideKeycap as Hn, readFileContent as Ht, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as I, ALL_FEATURES as In, isFileSystemError as It, getRulesyncSourceCandidates as J, removeTempDirectory as Jt, RulesyncIgnore as K, stripHiddenCharacters as Kn, removeFile as Kt, getLocalSkillDirNames as L, ALL_FEATURES_WITH_WILDCARD as Ln, isSymlink as Lt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as M, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Mn, fileExists as Mt, caseFoldIdentity as N, RULESYNC_USER_CONFIG_DIR_NAME as Nn, getFileSize as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RELATIVE_DIR_PATH as On, checkPathTraversal as Ot, groupSpellingsByCaseFoldedIdentity as P, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as Pn, getHomeDirectory as Pt, RulesyncCommandFrontmatterSchema as Q, writeFileBuffer as Qt, RulesyncSubagent as R, DEPRECATED_FEATURE_REPLACEMENTS as Rn, listDirectoryEntryNames as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_MCP_SCHEMA_URL as Sn, CLIError as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as Tn, assertDirectoryIfExists as Tt, RulesyncRuleFrontmatterSchema as U, quoteForLog as Un, readFileContentOrNull as Ut, RulesyncSkillFrontmatterSchema as V, hasDeceptiveHiddenCharacters as Vn, pathEscapesRoot as Vt, RulesyncPermissions as W, stripControlCharacters as Wn, removeDirectory as Wt, parseJsonc as X, runWithDirectoryRollback as Xt, resolveRulesyncSourceWritePath as Y, resolvePath as Yt, RulesyncCommand as Z, toPosixPath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, fallbackLogger as _t, getProcessorRegistryEntry as a, MAX_FILE_SIZE as an, ConfigResolver as at, CommandsProcessor as b, RULESYNC_MCP_LEGACY_FILE_NAME as bn, resetRunWarningState as bt, RulesProcessor as c, RULESYNC_CHECKS_RELATIVE_DIR_PATH as cn, CONFLICTING_TARGET_PAIRS as ct, CODEBUDDY_DIR as d, RULESYNC_CONFIG_SCHEMA_URL as dn, SourceEntrySchema as dt, ALL_TOOL_TARGETS as en, RulesyncCheckFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as fn, assertTargetsFeaturesExclusive as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, WarningCollectingLogger as gt, shortenToWidth as h, RULESYNC_HOOKS_LEGACY_FILE_NAME as hn, JsonLogger as ht, inspectInputRoots as i, CURATED_RULES_FEATURE_SUBDIR as in, SKILL_FILE_NAME as it, FACTORYDROID_DIR as j, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as jn, ensureDir as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_RULES_RELATIVE_DIR_PATH as kn, createTempDirectory as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ln, ConfigFileSchema as lt, displayWidthOf as m, RULESYNC_HOOKS_FILE_NAME as mn, ConsoleLogger as mt, formatSourceLoadFailure as n, PACKAGING_TOOL_TARGETS as nn, loadYaml as nt, convertFromTool as o, RULESYNC_AIIGNORE_FILE_NAME as on, mergeInputRootConfigs as ot, ELLIPSIS_WIDTH as p, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as pn, findControlCharacter as pt, RulesyncHooks as q, removeFileStrict as qt, generate as r, ToolTargetSchema as rn, SHARED_USER_MANAGED_CONFIG_PATHS as rt, isPackagingToolTarget as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as sn, resolveEffectiveInputRoots as st, importFromTool as t, ALL_TOOL_TARGETS_WITH_WILDCARD as tn, stringifyFrontmatter as tt, SkillsProcessor as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as un, GITIGNORE_DESTINATION_KEY as ut, CRUSH_LOCAL_RULE_FILE_NAME as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, warnOnConflictingFlags as vt, CODEXCLI_BASH_RULES_FILE_NAME as w, RULESYNC_PERMISSIONS_FILE_NAME as wn, applyFileMode as wt, QWENCODE_DIR as x, RULESYNC_MCP_RELATIVE_FILE_PATH as xn, withWarnOnceScope as xt, HooksProcessor as y, RULESYNC_MCP_FILE_NAME as yn, withFallbackLoggerTarget as yt, RulesyncSubagentFrontmatterSchema as z, formatError as zn, listFilePathsRecursively as zt };
 
-//# sourceMappingURL=import-D2GhBXJV.js.map
+//# sourceMappingURL=import-D5n_V39C.js.map