rulesync 33.0.0 → 34.0.1

package/dist/{import-D_SV_C0k.cjs → import-Bx0zNGBx.cjs}

@@ -408,7 +408,11 @@ const DeprecatedIgnoreFeatureSchema = zod_mini.z.literal("ignore").check((0, zod
 const FeatureSchema = zod_mini.z.union([zod_mini.z.enum(ACTIVE_FEATURES), DeprecatedIgnoreFeatureSchema]);
 zod_mini.z.array(FeatureSchema);
 const FeatureWithWildcardSchema = zod_mini.z.union([zod_mini.z.enum([...ACTIVE_FEATURES, "*"]), DeprecatedIgnoreFeatureSchema]);
-const GitignoreDestinationSchema = zod_mini.z.enum(["gitignore", "gitattributes"]);
+const GitignoreDestinationSchema = zod_mini.z.enum([
+	"gitignore",
+	"gitattributes",
+	"gitexclude"
+]);
 const FlattenedCommandNamingSchema = zod_mini.z.enum(["basename", "path"]);
 const FeatureOptionsSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown());
 const FeatureValueSchema = zod_mini.z.union([
@@ -453,36 +457,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$417 } = node_path.posix;
+const { join: join$418 } = 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$417(RULES_FEATURE_SUBDIR, ".curated");
+const CURATED_RULES_FEATURE_SUBDIR = join$418(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$417(SKILLS_FEATURE_SUBDIR, ".curated");
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$417(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const CURATED_SKILLS_FEATURE_SUBDIR = join$418(SKILLS_FEATURE_SUBDIR, ".curated");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, RULES_FEATURE_SUBDIR);
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, CURATED_RULES_FEATURE_SUBDIR);
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, COMMANDS_FEATURE_SUBDIR);
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, SUBAGENTS_FEATURE_SUBDIR);
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, CHECKS_FEATURE_SUBDIR);
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$418(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$418(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$417(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$417(RULESYNC_RELATIVE_DIR_PATH, CURATED_SKILLS_FEATURE_SUBDIR);
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$418(RULESYNC_RELATIVE_DIR_PATH, SKILLS_FEATURE_SUBDIR);
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$418(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";
@@ -528,6 +532,7 @@ const rulesProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codebuddy",
+	"codebuff",
 	"codewhale",
 	"codexcli",
 	"commandcode",
@@ -1407,6 +1412,13 @@ async function getFileSize(filepath) {
 		throw new Error(`Failed to get file size for "${filepath}": ${formatError(error)}`, { cause: error });
 	}
 }
+/**
+* Whether a file carries any execute bit. Windows reports none, so a file
+* there is never seen as executable.
+*/
+async function hasExecutableBit(filepath) {
+	return ((await (0, node_fs_promises.stat)(filepath)).mode & 73) !== 0;
+}
 async function isSymlink(filepath) {
 	try {
 		return (await (0, node_fs_promises.lstat)(filepath)).isSymbolicLink();
@@ -3179,6 +3191,9 @@ var Config = class Config {
 		const featureValue = value[feature];
 		if (featureValue && typeof featureValue === "object" && isFeatureValueEnabled(featureValue)) return featureValue;
 	}
+	getRootGitignoreDestination() {
+		return this.gitignoreDestination;
+	}
 	getGitignoreDestination(target, feature) {
 		const rootLevel = this.gitignoreDestination;
 		if (!isRulesyncConfigTargetsObject(this.targets)) return rootLevel;
@@ -3196,7 +3211,8 @@ var Config = class Config {
 		return toolLevel ?? rootLevel;
 	}
 	static parseGitignoreDestination(value) {
-		if (value === "gitignore" || value === "gitattributes") return value;
+		const result = GitignoreDestinationSchema.safeParse(value);
+		return result.success ? result.data : void 0;
 	}
 	/**
 	* Check if per-target features configuration is being used.
@@ -5266,12 +5282,20 @@ const JUNIE_HOOK_EVENTS = [
 	"sessionEnd"
 ];
 /**
-* Hook events supported by the GitLab Duo CLI. Only `SessionStart` is
-* documented; its optional regex matcher filters on the session source
-* (`startup`, `resume`). Only `type: "command"` hooks are supported.
+* Hook events supported by the GitLab Duo CLI. `SessionStart` is documented;
+* `PreToolUse` and `SessionEnd` ship in gitlab-lsp (`HOOK_EVENT_NAMES`, v9.28.0+)
+* but are not on docs.gitlab.com yet. The optional regex matcher filters on the
+* session source (`startup`, `resume`) for `SessionStart`, on `tool_name` for
+* `PreToolUse`, and on the end reason for `SessionEnd`. Only `type: "command"`
+* hooks are supported.
 * @see https://docs.gitlab.com/user/gitlab_duo_cli/customize/
+* @see https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/blob/main/packages/core/hooks/src/schema.ts
 */
-const GITLABDUO_HOOK_EVENTS = ["sessionStart"];
+const GITLABDUO_HOOK_EVENTS = [
+	"sessionStart",
+	"preToolUse",
+	"sessionEnd"
+];
 /**
 * Hook events supported by Qwen Code.
 *
@@ -5612,7 +5636,10 @@ const CORTEXCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CA
 * or `agent` hooks with a `timeout` in seconds. The hooks reference documents ten events; the
 * plugins reference lists the full set, stating that plugin hooks "respond to
 * the same lifecycle events as user-defined hooks", so every event listed
-* there is supported here.
+* there is supported here. The hooks reference also names `Setup`
+* (bootstrap/maintenance), and the published package's settings schema
+* (`@tencent-ai/codebuddy-code` 2.167.0) accepts `UserPromptExpansion`, whose
+* matcher filters on `command_name` as in Claude Code.
 *
 * @see https://www.codebuddy.ai/docs/cli/hooks
 * @see https://www.codebuddy.ai/docs/cli/plugins-reference
@@ -5643,7 +5670,9 @@ const CODEBUDDY_HOOK_EVENTS = [
 	"postCompact",
 	"elicitation",
 	"elicitationResult",
-	"sessionEnd"
+	"sessionEnd",
+	"setup",
+	"userPromptExpansion"
 ];
 /**
 * CodeBuddy Code events that fire on every occurrence and take no `matcher`.
@@ -5692,7 +5721,9 @@ const CANONICAL_TO_CODEBUDDY_EVENT_NAMES = {
 	postCompact: "PostCompact",
 	elicitation: "Elicitation",
 	elicitationResult: "ElicitationResult",
-	sessionEnd: "SessionEnd"
+	sessionEnd: "SessionEnd",
+	setup: "Setup",
+	userPromptExpansion: "UserPromptExpansion"
 };
 const CODEBUDDY_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_CODEBUDDY_EVENT_NAMES).map(([k, v]) => [v, k]));
 /**
@@ -6546,7 +6577,11 @@ const KIRO_IDE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANO
 /**
 * Map canonical camelCase event names to GitLab Duo CLI PascalCase.
 */
-const CANONICAL_TO_GITLABDUO_EVENT_NAMES = { sessionStart: "SessionStart" };
+const CANONICAL_TO_GITLABDUO_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	preToolUse: "PreToolUse",
+	sessionEnd: "SessionEnd"
+};
 /**
 * Map GitLab Duo CLI PascalCase event names to canonical camelCase.
 */
@@ -8287,6 +8322,48 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 	]))
 });
 /**
+* Tool-scoped override block for Qoder. `outputStyle` is written to the
+* top-level `outputStyle` key of `.qoder/settings.json` (project) /
+* `~/.qoder/settings.json` (global): the name of the active output style, a
+* custom style from `.qoder/output-styles/` (see the `qoder.channel:
+* output-style` rule option) or a `plugin-name:style-name` reference. The
+* shared `permission` block continues to drive `permissions.allow`/`ask`/`deny`.
+*
+* @see https://docs.qoder.com/cli/output-styles
+* @see https://docs.qoder.com/cli/settings-reference
+* @example
+* { "outputStyle": "concise-review" }
+*/
+const QoderPermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	outputStyle: zod_mini.z.optional(zod_mini.z.string().check(zod_mini.z.trim(), zod_mini.z.minLength(1)))
+});
+/**
+* One native Factory Droid permission rule. `match.prefix` positions are either
+* a single token or a non-empty list of alternative tokens.
+*
+* @see https://docs.factory.com/autonomy-and-safety/permission-rules
+*/
+const FactorydroidPermissionRuleSchema = zod_mini.z.looseObject({
+	id: zod_mini.z.string(),
+	decision: zod_mini.z.enum([
+		"allow",
+		"ask",
+		"block"
+	]),
+	match: zod_mini.z.looseObject({ prefix: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string()).check(zod_mini.z.minLength(1))])).check(zod_mini.z.minLength(1))) }),
+	tests: zod_mini.z.optional(zod_mini.z.looseObject({
+		match: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+		noMatch: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+	})),
+	reason: zod_mini.z.optional(zod_mini.z.string()),
+	enabled: zod_mini.z.optional(zod_mini.z.boolean())
+});
+const FactorydroidPermissionRulesSchema = zod_mini.z.looseObject({
+	version: zod_mini.z.number(),
+	rules: zod_mini.z.array(FactorydroidPermissionRuleSchema)
+});
+/**
 * Tool-scoped override block for Factory Droid. Factory Droid's `settings.json`
 * exposes security controls with no canonical per-command allow/ask/deny slot —
 * `commandBlocklist` (a hard-block tier that can never be approved, distinct from
@@ -8294,7 +8371,8 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 * (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`,
 * `mcpAutonomyOverrides` (per-MCP-tool autonomy levels), `enableDroidShield`,
 * and autonomy settings (`sessionDefaultSettings`, `maxAutonomyLevel`,
-* `subagentAutonomyLevel`, `interactionMode`). Fields placed here are merged
+* `subagentAutonomyLevel`, `interactionMode`), and the native versioned
+* `permissionRules` (allow/ask/block). Fields placed here are merged
 * into `settings.json` and
 * emitted only for Factory Droid, while the shared `permission` block continues
 * to drive `commandAllowlist`/`commandDenylist`. Kept `looseObject` passthrough.
@@ -8305,7 +8383,8 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-	disabledSkills: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+	disabledSkills: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	permissionRules: zod_mini.z.optional(FactorydroidPermissionRulesSchema)
 });
 /**
 * Tool-scoped override block for Warp. Warp's `[agents.profiles]` table exposes
@@ -9110,6 +9189,7 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	codewhale: zod_mini.z.optional(CodewhalePermissionsOverrideSchema),
 	zed: zod_mini.z.optional(ZedPermissionsOverrideSchema),
 	devin: zod_mini.z.optional(DevinPermissionsOverrideSchema),
+	qoder: zod_mini.z.optional(QoderPermissionsOverrideSchema),
 	"antigravity-ide": zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	continue: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: zod_mini.z.optional(CopilotPermissionsOverrideSchema),
@@ -9121,7 +9201,6 @@ const PermissionsConfigSchema = zod_mini.z.looseObject({
 	goose: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	omp: zod_mini.z.optional(OmpPermissionsOverrideSchema),
 	pool: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
-	qoder: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
 	"kimi-code": zod_mini.z.optional(KimiCodePermissionsOverrideSchema),
 	roo: zod_mini.z.optional(CanonicalPermissionsOverrideSchema),
@@ -9642,7 +9721,9 @@ const RulesyncRuleFrontmatterSchema = zod_mini.z.object({
 	qoder: zod_mini.z.optional(zod_mini.z.looseObject({
 		trigger: zod_mini.z.optional(zod_mini.z.string()),
 		glob: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
-		description: zod_mini.z.optional(zod_mini.z.string())
+		description: zod_mini.z.optional(zod_mini.z.string()),
+		channel: zod_mini.z.optional(zod_mini.z.enum(["output-style"])),
+		name: zod_mini.z.optional(zod_mini.z.string().check(zod_mini.z.trim(), zod_mini.z.minLength(1)))
 	})),
 	augmentcode: zod_mini.z.optional(zod_mini.z.looseObject({
 		type: zod_mini.z.optional(zod_mini.z.string()),
@@ -13011,7 +13092,7 @@ const SHARED_CONFIG_OWNERSHIP = {
 			},
 			permissions: {
 				kind: "replace-owned-keys",
-				ownedKeys: ["permissions"]
+				ownedKeys: ["permissions", "outputStyle"]
 			}
 		}
 	},
@@ -22425,6 +22506,7 @@ const QODER_DIR = ".qoder";
 const QODER_RULE_FILE_NAME = "AGENTS.md";
 const QODER_LOCAL_RULE_FILE_NAME = "AGENTS.local.md";
 const QODER_RULES_DIR_PATH = (0, node_path.join)(QODER_DIR, "rules");
+const QODER_OUTPUT_STYLES_DIR_PATH = (0, node_path.join)(QODER_DIR, "output-styles");
 const QODER_SETTINGS_FILE_NAME = "settings.json";
 const QODER_PROJECT_MCP_FILE_NAME = ".mcp.json";
 const QODER_COMMANDS_DIR_PATH = (0, node_path.join)(QODER_DIR, "commands");
@@ -29799,6 +29881,11 @@ const CORTEXCODE_SPEC = {
 			canonical: "enabled",
 			tool: "enabled"
 		}],
+		stringPassthroughFields: [{
+			canonical: "statusMessage",
+			tool: "statusMessage",
+			commandOnly: true
+		}],
 		objectPassthroughFields: [{
 			canonical: "source",
 			tool: "source",
@@ -29813,7 +29900,7 @@ const CORTEXCODE_SPEC = {
 * (project scope) and of the dedicated `~/.snowflake/cortex/hooks.json` (user
 * scope), both in the Claude-Code shape: `{ "<Event>": [{ "matcher"?:
 * "<regex>", "hooks": [{ "type": "command" | "prompt", ..., "timeout"?:
-* <seconds>, "enabled"?: <boolean>, "source"?: { "source", "ref"? } }] }] }`.
+* <seconds>, "enabled"?: <boolean>, "statusMessage"?: <string> (command only), "source"?: { "source", "ref"? } }] }] }`.
 * The project file also holds settings rulesync does not own, so generation
 * merges the `hooks` key into
 * either file (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting it, and
@@ -30752,7 +30839,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
-	"missionPolicy"
+	"missionPolicy",
+	"permissionRules"
 ];
 //#endregion
 //#region src/utils/factorydroid-settings.ts
@@ -30967,7 +31055,7 @@ const GITLABDUO_CONVERTER_CONFIG = {
 *
 * Hooks live in a dedicated file, `<project>/.gitlab/duo/hooks.json` (project,
 * opt-in via `--enable-project-hooks` / `GITLAB_ENABLE_PROJECT_HOOKS=true`) or
-* `~/.gitlab/duo/hooks.json` (user), shaped as `{ "hooks": { "SessionStart": [...] } }`.
+* `~/.gitlab/duo/hooks.json` (user), shaped as `{ "hooks": { "SessionStart": [...], "PreToolUse": [...] } }`.
 * rulesync owns the whole file, so it is regenerated and deleted as a unit.
 */
 var GitlabduoHooks = class GitlabduoHooks extends ToolHooks {
@@ -36621,6 +36709,7 @@ var ClineIgnore = class ClineIgnore extends ToolIgnore {
 const CODEBUFF_IGNORE_FILE_NAME = ".codebuffignore";
 const CODEBUFF_AGENTS_DIR = ".agents";
 const CODEBUFF_MCP_FILE_NAME = "mcp.json";
+const CODEBUFF_GLOBAL_RULE_FILE_NAME = ".AGENTS.md";
 //#endregion
 //#region src/features/ignore/codebuff-ignore.ts
 /**
@@ -43522,11 +43611,45 @@ const CANONICAL_TO_GITLABDUO_TRANSPORT = {
 	sse: "sse"
 };
 /**
+* Map the canonical `timeout` (milliseconds) onto GitLab Duo's `timeoutMs`, a
+* per-server tool-call inactivity timeout (gitlab-lsp v9.25.0+) that must be a
+* positive integer. An explicit `timeoutMs` on the same server wins; a
+* `timeout` Duo would reject is dropped with a warning.
+*
+* @see https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/commit/e8c4a76a66e8f37d4c97fc03ffe983bfadf43f76
+*/
+function toGitlabduoTimeout({ serverName, server, logger }) {
+	const { timeout, ...rest } = server;
+	if (timeout === void 0 || rest.timeoutMs !== void 0) return rest;
+	if (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout <= 0) {
+		logger?.warn(`GitLab Duo CLI MCP server "${serverName}": dropping timeout ${JSON.stringify(timeout)}, as timeoutMs must be a positive integer of milliseconds.`);
+		return rest;
+	}
+	return {
+		...rest,
+		timeoutMs: timeout
+	};
+}
+/**
+* Read GitLab Duo's `timeoutMs` back into the canonical `timeout`
+* (milliseconds). A server that already carries a `timeout` is left as is, so
+* both keys round-trip and `timeoutMs` keeps winning on the next generate.
+*/
+function fromGitlabduoTimeout(server) {
+	if (typeof server !== "object" || server === null || Array.isArray(server)) return server;
+	const { timeoutMs, ...rest } = server;
+	if (timeoutMs === void 0 || rest.timeout !== void 0) return server;
+	return {
+		...rest,
+		timeout: timeoutMs
+	};
+}
+/**
 * Convert one canonical server into GitLab Duo's shape. Every documented
 * example spells the transport out as `type` (`stdio`, `http` or `sse`), so it
 * is always written, inferred from `command` / `url` when the source leaves it
-* implicit. Every other field — `args`, `env`, `approvedTools`, ... — is carried
-* through as authored.
+* implicit. The canonical `timeout` becomes `timeoutMs`; every other field —
+* `args`, `env`, `approvedTools`, ... — is carried through as authored.
 */
 function toGitlabduoServer({ serverName, serverConfig, logger }) {
 	if (declaresNoTransport(serverConfig)) return warnAndSkipMcpServer({
@@ -43535,7 +43658,7 @@ function toGitlabduoServer({ serverName, serverConfig, logger }) {
 		reason: "no command or url",
 		logger
 	});
-	const { type, transport, httpUrl: _httpUrl, url: _url, ...rest } = serverConfig;
+	const { type, transport, httpUrl: _httpUrl, url: _url, ...others } = serverConfig;
 	const declared = type ?? transport;
 	const mapped = declared ? CANONICAL_TO_GITLABDUO_TRANSPORT[declared] : isRemoteMcpServer(serverConfig) ? "http" : "stdio";
 	if (!mapped) return warnAndSkipMcpServer({
@@ -43544,8 +43667,13 @@ function toGitlabduoServer({ serverName, serverConfig, logger }) {
 		reason: `the unsupported transport "${declared}" (GitLab Duo CLI accepts stdio, http and sse)`,
 		logger
 	});
+	const rest = toGitlabduoTimeout({
+		serverName,
+		server: others,
+		logger
+	});
 	if (mapped === "stdio") {
-		const { command, args } = rest;
+		const { command, args } = serverConfig;
 		if (Array.isArray(command)) {
 			const [executable, ...leadingArgs] = command;
 			return {
@@ -43634,7 +43762,13 @@ var GitlabduoMcp = class GitlabduoMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		return this.toRulesyncMcpDefault();
+		const { mcpServers, ...others } = this.json;
+		if (typeof mcpServers !== "object" || mcpServers === null || Array.isArray(mcpServers)) return this.toRulesyncMcpDefault();
+		const servers = Object.fromEntries(Object.entries(mcpServers).map(([name, server]) => [name, fromGitlabduoTimeout(server)]));
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({
+			...others,
+			mcpServers: servers
+		}) });
 	}
 	validate() {
 		return {
@@ -46741,6 +46875,15 @@ const CONSUMED_CANONICAL_KEYS = /* @__PURE__ */ new Set([
 ]);
 const MILLISECONDS_PER_SECOND = 1e3;
 /**
+* The only keys a project override entry for a user-level server carries:
+* Pi reads a `.pi/mcp.json` entry without `command`, `url` or `type` as an
+* override of `enabled`, `exposure` and `toolExposure` of the user-level server
+* with the same name, and keeps the rest of that server.
+*
+* @see https://github.com/earendil-works/pi/blob/v1.1.0/packages/coding-agent/docs/mcp.md
+*/
+const PI_OVERRIDE_PASSTHROUGH_KEYS = ["exposure", "toolExposure"];
+/**
 * Pi rejects a server whose name has any other character, and treats names
 * that differ only in `-` and `_` as one server (its tools share the
 * `mcp__<name>` namespace with `-` replaced by `_`), rejecting the second.
@@ -46776,17 +46919,12 @@ function hasUnexpandedEnvVarRef(serverConfig) {
 /**
 * The transport fields Pi reads for one server: `type` `stdio` with a string
 * `command` plus `args`, or `type` `http` with a `url`. A server Pi cannot
-* start or reach — no transport, a remote transport without a URL, an SSE or
-* WebSocket server, or a stdio entry without a command — is rejected by Pi, so
-* it is skipped with a warning (`null`).
+* start or reach — a remote transport without a URL, an SSE or WebSocket
+* server, or a stdio entry without a command — is rejected by Pi, so it is
+* skipped with a warning (`null`). A server with no transport at all is a
+* project override instead (see `convertOverrideToPi`).
 */
 function convertTransportToPi({ serverName, serverConfig, logger }) {
-	if (declaresNoTransport(serverConfig)) return warnAndSkipMcpServer({
-		toolName: "Pi",
-		serverName,
-		reason: "no transport",
-		logger
-	});
 	if (isRemoteMcpServer(serverConfig)) {
 		const url = resolveRemoteMcpUrl(serverConfig);
 		const stated = serverConfig.type ?? serverConfig.transport;
@@ -46827,56 +46965,117 @@ function convertTransportToPi({ serverName, serverConfig, logger }) {
 	};
 }
 /**
-* Convert the canonical server map to Pi's `mcpServers` shape. Besides the
-* transport fields, Pi switches a server off with `enabled: false` and reads
-* `timeout` in seconds (canonical: milliseconds). A server name Pi rejects is
-* skipped with a warning, and so is `auth` in the project file, which Pi
-* accepts only in the global one (it drops the whole server otherwise).
+* A transport-less server in the project file becomes a Pi override entry for
+* the user-level server of the same name. `disabled` maps to `enabled` both
+* ways (an explicit `disabled: false` is "Enable in this project"), and any key
+* Pi ignores on an override is dropped with a warning. The global file has no
+* layer below it to override, so the entry is skipped there.
+*/
+function convertOverrideToPi({ serverName, serverConfig, global, logger }) {
+	if (global) return warnAndSkipMcpServer({
+		toolName: "Pi",
+		serverName,
+		reason: "no transport",
+		logger
+	});
+	const record = serverConfig;
+	const override = {};
+	if (typeof serverConfig.disabled === "boolean") override.enabled = !serverConfig.disabled;
+	for (const key of PI_OVERRIDE_PASSTHROUGH_KEYS) if (record[key] !== void 0) override[key] = record[key];
+	if (Object.keys(override).length === 0) return warnAndSkipMcpServer({
+		toolName: "Pi",
+		serverName,
+		reason: "no transport and nothing a Pi project override sets (disabled, exposure, toolExposure)",
+		logger
+	});
+	const droppedKeys = Object.keys(record).filter((key) => key !== "disabled" && !PI_OVERRIDE_PASSTHROUGH_KEYS.includes(key) && !PROTOTYPE_POLLUTION_KEYS.has(key));
+	if (droppedKeys.length > 0) logger?.warn(`Pi MCP: dropping ${droppedKeys.map((key) => quoteValueForWarning(key)).join(", ")} of the project override ${quoteValueForWarning(serverName)}: Pi reads only enabled, exposure and toolExposure from an entry without a transport.`);
+	return override;
+}
+/**
+* Whether Pi rejects the server name, either outright or because an earlier
+* server already took its `mcp__<name>` namespace; warns when it does.
+*/
+function isRejectedServerName({ serverName, namespaces, logger }) {
+	if (!PI_SERVER_NAME_PATTERN.test(serverName)) {
+		warnAndSkipMcpServer({
+			toolName: "Pi",
+			serverName,
+			reason: "a name Pi rejects (use letters, digits, \"_\" and \"-\")",
+			logger
+		});
+		return true;
+	}
+	const clash = namespaces.get(toPiNamespace(serverName));
+	if (clash !== void 0) {
+		warnAndSkipMcpServer({
+			toolName: "Pi",
+			serverName,
+			reason: `a name Pi treats as the same server as ${quoteValueForWarning(clash)} ("-" and "_" are equivalent)`,
+			logger
+		});
+		return true;
+	}
+	return false;
+}
+/**
+* Convert one canonical server to its Pi entry, or `null` when it is skipped.
+* Besides the transport fields, Pi switches a server off with `enabled: false`
+* and reads `timeout` in seconds (canonical: milliseconds). `auth` is dropped
+* with a warning from the project file, since Pi accepts it only in the global
+* one (it drops the whole server otherwise). A server without a transport is a
+* project override entry instead.
+*/
+function convertServerToPi({ serverName, serverConfig, global, logger }) {
+	if (declaresNoTransport(serverConfig)) return convertOverrideToPi({
+		serverName,
+		serverConfig,
+		global,
+		logger
+	});
+	const converted = convertTransportToPi({
+		serverName,
+		serverConfig,
+		logger
+	});
+	if (!converted) return null;
+	for (const [key, value] of Object.entries(serverConfig)) {
+		if (CONSUMED_CANONICAL_KEYS.has(key) || PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+		converted[key] = value;
+	}
+	if (serverConfig.timeout !== void 0) {
+		if (Number.isFinite(serverConfig.timeout) && serverConfig.timeout > 0) converted.timeout = serverConfig.timeout / MILLISECONDS_PER_SECOND;
+		else logger?.warn(`Pi MCP: dropping the "timeout" of ${quoteValueForWarning(serverName)}: expected a positive number of milliseconds.`);
+	}
+	if (serverConfig.disabled === true) converted.enabled = false;
+	if (!global && "auth" in converted) {
+		delete converted.auth;
+		logger?.warn(`Pi MCP: dropping the "auth" of ${quoteValueForWarning(serverName)}: Pi accepts it only in the global ~/.pi/agent/mcp.json.`);
+	}
+	if (hasUnexpandedEnvVarRef(converted)) logger?.warn(`Pi MCP: ${quoteValueForWarning(serverName)} carries an environment variable reference Pi does not expand. Pi expands only \${VAR} and $VAR in env and headers values, and only a leading ~/ in command, args and cwd.`);
+	return converted;
+}
+/**
+* Convert the canonical server map to Pi's `mcpServers` shape. A server name
+* Pi rejects is skipped with a warning.
 */
 function convertToPiFormat({ mcpServers, global, logger }) {
 	const result = {};
 	const namespaces = /* @__PURE__ */ new Map();
 	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
-		if (!PI_SERVER_NAME_PATTERN.test(serverName)) {
-			warnAndSkipMcpServer({
-				toolName: "Pi",
-				serverName,
-				reason: "a name Pi rejects (use letters, digits, \"_\" and \"-\")",
-				logger
-			});
-			continue;
-		}
-		const clash = namespaces.get(toPiNamespace(serverName));
-		if (clash !== void 0) {
-			warnAndSkipMcpServer({
-				toolName: "Pi",
-				serverName,
-				reason: `a name Pi treats as the same server as ${quoteValueForWarning(clash)} ("-" and "_" are equivalent)`,
-				logger
-			});
-			continue;
-		}
-		const converted = convertTransportToPi({
+		if (isRejectedServerName({
+			serverName,
+			namespaces,
+			logger
+		})) continue;
+		const converted = convertServerToPi({
 			serverName,
 			serverConfig,
+			global,
 			logger
 		});
 		if (!converted) continue;
-		for (const [key, value] of Object.entries(serverConfig)) {
-			if (CONSUMED_CANONICAL_KEYS.has(key) || PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
-			converted[key] = value;
-		}
-		if (serverConfig.timeout !== void 0) {
-			if (Number.isFinite(serverConfig.timeout) && serverConfig.timeout > 0) converted.timeout = serverConfig.timeout / MILLISECONDS_PER_SECOND;
-			else logger?.warn(`Pi MCP: dropping the "timeout" of ${quoteValueForWarning(serverName)}: expected a positive number of milliseconds.`);
-		}
-		if (serverConfig.disabled === true) converted.enabled = false;
-		if (!global && "auth" in converted) {
-			delete converted.auth;
-			logger?.warn(`Pi MCP: dropping the "auth" of ${quoteValueForWarning(serverName)}: Pi accepts it only in the global ~/.pi/agent/mcp.json.`);
-		}
-		if (hasUnexpandedEnvVarRef(converted)) logger?.warn(`Pi MCP: ${quoteValueForWarning(serverName)} carries an environment variable reference Pi does not expand. Pi expands only \${VAR} and $VAR in env and headers values, and only a leading ~/ in command, args and cwd.`);
 		namespaces.set(toPiNamespace(serverName), serverName);
 		result[serverName] = converted;
 	}
@@ -46885,16 +47084,19 @@ function convertToPiFormat({ mcpServers, global, logger }) {
 /**
 * Convert Pi's `mcpServers` back to the canonical shape: `enabled: false`
 * becomes `disabled: true` and `timeout` (seconds) becomes milliseconds; every
-* other key is already canonical.
+* other key is already canonical. On a transport-less override entry an
+* explicit `enabled: true` is kept as `disabled: false`, since it switches on a
+* user-level server the user turned off.
 */
 function convertFromPiFormat(mcpServers) {
 	const result = {};
 	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(serverName) || !isRecord$1(serverConfig)) continue;
 		const { enabled, timeout, ...rest } = serverConfig;
-		const converted = enabled === false ? {
+		const keepsEnabled = enabled === true && declaresNoTransport(rest);
+		const converted = enabled === false || keepsEnabled ? {
 			...rest,
-			disabled: true
+			disabled: !enabled
 		} : rest;
 		if (typeof timeout === "number") converted.timeout = timeout * MILLISECONDS_PER_SECOND;
 		else if (timeout !== void 0) converted.timeout = timeout;
@@ -46970,8 +47172,11 @@ var PiMcp = class PiMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		const mcpServers = isMcpServers(this.json.mcpServers) ? this.json.mcpServers : {};
-		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: convertFromPiFormat(mcpServers) }, null, 2) });
+		const { shared, toolOnly } = splitMcpServersByTransport(convertFromPiFormat(isMcpServers(this.json.mcpServers) ? this.json.mcpServers : {}));
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({
+			mcpServers: shared,
+			...Object.keys(toolOnly).length > 0 && { pi: { mcpServers: toolOnly } }
+		}, null, 2) });
 	}
 	validate() {
 		return {
@@ -64764,9 +64969,11 @@ const DEFAULT_TOOLS_KEY = "defaultTools";
 * the built-in tools enabled at startup (v0.84.2) — authored through the `pi`
 * permissions override.
 *
-* Scope semantics are the **opposite** of the union-merge most targets use:
-* a project `defaultTools` array *replaces* the global array rather than adding
-* to it, so the two scopes are written independently and never combined.
+* Scope layering is Pi's own rather than the union-merge most targets use:
+* a project `defaultTools` array with a plain name *replaces* the global
+* array, while one made only of `+name` / `-name` entries (Pi v0.99.0+) changes
+* the global selection instead. Entries are written verbatim, so the two
+* scopes are written independently and never combined by rulesync.
 * Project scope writes `.pi/settings.json`; global scope writes
 * `~/.pi/agent/settings.json`.
 *
@@ -65426,6 +65633,13 @@ function convertPoolToRulesync({ tools, paths }) {
 //#region src/features/permissions/qoder-permissions.ts
 /** Top-level key of `.qoder/settings.json` that rulesync owns. */
 const QODER_PERMISSIONS_KEY = "permissions";
+/**
+* Top-level key the `qoder` override authors: the active output style. Qoder
+* also reads `general.outputStyle`, but the top-level key wins, so that is the
+* one written and imported.
+* @see https://docs.qoder.com/cli/settings-reference
+*/
+const QODER_OUTPUT_STYLE_KEY = "outputStyle";
 const CATCH_ALL_PATTERN$2 = "*";
 /** Prefix of the fully qualified MCP tool names (`mcp__<server>__<tool>`). */
 const MCP_TOOL_PREFIX = "mcp__";
@@ -65585,9 +65799,11 @@ function buildQoderRuleLists({ config, existingPermissions, logger }) {
 * through the shared-config gateway, the sibling keys of `permissions`
 * (`additionalDirectories`, `trustDirectories`) are kept, and the file is
 * never deleted. `.qoder/settings.local.json` (where `/allow` and `/deny`
-* persist) is left to the user.
+* persist) is left to the user. The `qoder` override's `outputStyle` is
+* written to (and imported from) the top-level `outputStyle` key.
 *
 * @see https://docs.qoder.com/en/cli/permissions
+* @see https://docs.qoder.com/cli/output-styles
 */
 var QoderPermissions = class QoderPermissions extends ToolPermissions {
 	constructor(params) {
@@ -65626,11 +65842,14 @@ var QoderPermissions = class QoderPermissions extends ToolPermissions {
 			relativePath: (0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)
 		});
 		const existingPermissions = isRecord$1(existing[QODER_PERMISSIONS_KEY]) ? existing[QODER_PERMISSIONS_KEY] : {};
+		const config = rulesyncPermissions.getJson();
 		const lists = buildQoderRuleLists({
-			config: rulesyncPermissions.getJson(),
+			config,
 			existingPermissions,
 			logger
 		});
+		const outputStyle = config.qoder?.outputStyle?.trim();
+		if (outputStyle !== void 0) logger?.warn(`Qoder permissions: qoder.outputStyle = ${JSON.stringify(outputStyle)} was written to ${(0, node_path.join)(paths.relativeDirPath, paths.relativeFilePath)}${global ? " in the home directory" : ""}, so Qoder appends that style's instructions to the system prompt of every session it applies to.`);
 		const permissions = { ...existingPermissions };
 		for (const action of ACTIONS) if (lists[action].length > 0) permissions[action] = lists[action];
 		else delete permissions[action];
@@ -65642,7 +65861,10 @@ var QoderPermissions = class QoderPermissions extends ToolPermissions {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "permissions",
 				existingContent,
-				patch: { [QODER_PERMISSIONS_KEY]: Object.keys(permissions).length > 0 ? permissions : void 0 },
+				patch: {
+					[QODER_PERMISSIONS_KEY]: Object.keys(permissions).length > 0 ? permissions : void 0,
+					...outputStyle !== void 0 && { [QODER_OUTPUT_STYLE_KEY]: outputStyle }
+				},
 				filePath
 			}),
 			validate: true,
@@ -65663,7 +65885,12 @@ var QoderPermissions = class QoderPermissions extends ToolPermissions {
 			const existing = rules[parsed.pattern];
 			if (existing === void 0 || ACTION_RANK[action] > ACTION_RANK[existing]) rules[parsed.pattern] = action;
 		}
-		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
+		const outputStyle = settings[QODER_OUTPUT_STYLE_KEY];
+		const hasOutputStyle = typeof outputStyle === "string" && outputStyle.trim() !== "";
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({
+			permission,
+			...hasOutputStyle && { qoder: { outputStyle } }
+		}, null, 2) });
 	}
 	validate() {
 		return {
@@ -84711,8 +84938,8 @@ var DevinSubagent = class extends ToolSubagent {
 	* Derive the subagent name from this instance's relative file path.
 	*
 	* The tool-side layout is `<name>/AGENT.md`, so the name is the parent
-	* directory of the file. If the path is unexpectedly flat (e.g. a legacy
-	* `<name>.md`), fall back to the basename without extension.
+	* directory of the file. Devin also reads a flat `<name>.md`, which import
+	* picks up too; its name is the basename without extension.
 	*/
 	getSubagentName() {
 		const relativeFilePath = this.getRelativeFilePath();
@@ -84805,8 +85032,9 @@ var DevinSubagent = class extends ToolSubagent {
 /**
 * Subagent inside a Devin plugin bundle (`<plugin>/agents/<name>/AGENT.md`).
 * Plugin subagents use the same profile format as project ones and are
-* exposed as `<plugin>:<name>`. Devin also reads a flat `agents/<name>.md`;
-* the directory form is written to match the `devin` target.
+* exposed as `<plugin>:<name>`. Devin also reads a flat `agents/<name>.md`,
+* which import picks up too; the directory form is written to match the
+* `devin` target.
 *
 * @see https://docs.devin.ai/cli/extensibility/plugins/overview
 */
@@ -88368,6 +88596,17 @@ var ZoocodeSubagent = class extends RooSubagent {
 };
 //#endregion
 //#region src/features/subagents/subagents-processor.ts
+/**
+* The globs import scans for a tool: its import-only patterns when it reads
+* more layouts than Rulesync writes, otherwise the generation pattern.
+*/
+function importFilePatternsOf(meta) {
+	return meta.importFilePatterns ?? meta.filePattern;
+}
+/** Whether unparseable files are left out of this import or orphan sweep. */
+function skipsInvalidFiles(meta, forDeletion) {
+	return meta.skipInvalidFiles === true || !forDeletion && meta.skipInvalidImportFiles === true;
+}
 const SubagentsProcessorToolTargetSchema = zod_mini.z.enum(subagentsProcessorToolTargetTuple);
 /**
 * Factory Map mapping tool targets to their subagent factories.
@@ -88564,7 +88803,9 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: true,
-			filePattern: "*/AGENT.md"
+			filePattern: "*/AGENT.md",
+			importFilePatterns: ["*.md", "*/AGENT.md"],
+			skipInvalidImportFiles: true
 		}
 	}],
 	["devin-plugin", {
@@ -88573,7 +88814,9 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsSimulated: false,
 			supportsGlobal: false,
-			filePattern: "*/AGENT.md"
+			filePattern: "*/AGENT.md",
+			importFilePatterns: ["*.md", "*/AGENT.md"],
+			skipInvalidImportFiles: true
 		}
 	}],
 	["factorydroid", {
@@ -89052,6 +89295,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		const paths = factory.class.getSettablePaths({ global: this.global });
 		const roots = forDeletion ? [paths.relativeDirPath] : [paths.relativeDirPath, ...paths.importDirPaths ?? []];
+		const filePatterns = forDeletion ? factory.meta.filePattern : importFilePatternsOf(factory.meta);
 		const toolSubagents = [];
 		const claimedRelativeFilePaths = /* @__PURE__ */ new Map();
 		const claimedImportIdentities = new ClaimedIdentities();
@@ -89068,7 +89312,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				this.logger.warn(`Skipping the orphan sweep for ${quoteForLog(baseDir)}; nothing under it is deleted: ${stripControlCharacters(formatError(error))}`);
 				continue;
 			}
-			const subagentFilePaths = (await findFilesByGlobs(factory.meta.filePattern, {
+			const subagentFilePaths = (await findFilesByGlobs(filePatterns, {
 				cwd: baseDir,
 				followSymbolicLinks: !forDeletion
 			})).toSorted((left, right) => compareRelativePathsShallowestFirst((0, node_path.relative)(baseDir, left), (0, node_path.relative)(baseDir, right)));
@@ -89082,7 +89326,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				})));
 				ownedFilePaths = subagentFilePaths.filter((_, index) => ownership[index]);
 			}
-			const parsedFiles = factory.meta.skipInvalidFiles ? (await Promise.all(ownedFilePaths.map(async (path) => {
+			const parsedFiles = skipsInvalidFiles(factory.meta, forDeletion) ? (await Promise.all(ownedFilePaths.map(async (path) => {
 				try {
 					return {
 						path,
@@ -91958,6 +92202,85 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/codebuff-rule.ts
+/**
+* Rule generator for Codebuff (Freebuff), global scope only.
+*
+* Codebuff reads one user-level instructions file from the home directory:
+* the first hidden file matching `AGENTS.md` or `CLAUDE.md` (case-insensitive,
+* in that priority order), so the root rule is written to `~/.AGENTS.md`. There
+* is no user-level rules directory, so non-root rules fold into that file.
+*
+* Project scope is not supported here: Codebuff reads the project-root
+* `AGENTS.md`, which the `agentsmd` target already writes. The RulesProcessor
+* keeps this target out of project mode (`supportsProject: false`), so the
+* settable paths are the home-directory ones regardless of `global`.
+*
+* @see https://github.com/CodebuffAI/freebuff/blob/main/sdk/src/run-state.ts
+* @see https://github.com/CodebuffAI/freebuff/blob/main/common/src/constants/knowledge.ts
+*/
+var CodebuffRule = class CodebuffRule extends ToolRule {
+	static getSettablePaths(_options = {}) {
+		return { root: {
+			relativeDirPath: ".",
+			relativeFilePath: CODEBUFF_GLOBAL_RULE_FILE_NAME
+		} };
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
+		const { root } = this.getSettablePaths({ global: true });
+		if (relativeFilePath !== root.relativeFilePath) throw new Error(`CodebuffRule only supports the root rule: ${relativeFilePath}`);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, root.relativeDirPath, root.relativeFilePath));
+		return new CodebuffRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent,
+			validate,
+			root: true
+		});
+	}
+	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
+		const { root } = this.getSettablePaths({ global: true });
+		const frontmatter = rulesyncRule.getFrontmatter();
+		return new CodebuffRule({
+			outputRoot,
+			relativeDirPath: root.relativeDirPath,
+			relativeFilePath: root.relativeFilePath,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: frontmatter.root ?? false,
+			description: frontmatter.description,
+			globs: frontmatter.globs
+		});
+	}
+	toRulesyncRule() {
+		return this.toRulesyncRuleDefault();
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const { root } = this.getSettablePaths({ global: true });
+		return new CodebuffRule({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false,
+			root: relativeDirPath === root.relativeDirPath && relativeFilePath === root.relativeFilePath
+		});
+	}
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "codebuff"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/codewhale-rule.ts
 /**
 * Rule generator for Codewhale.
@@ -93595,7 +93918,7 @@ var DshRule = class extends NestedAgentsmdRule {
 * `getExtraFixedFiles`): Droid loads "direct `.md` children of each
 * `output-styles` directory".
 */
-const OUTPUT_STYLE_FILE_GLOB = "*.md";
+const OUTPUT_STYLE_FILE_GLOB$1 = "*.md";
 /**
 * Rule generator for Factory Droid.
 *
@@ -93717,7 +94040,7 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	static getExtraFixedFiles({ global = false } = {}) {
 		return [...this.getChannelPaths({ global }).map(({ path }) => path), {
 			relativeDirPath: this.getOutputStylesDirPath(),
-			relativeFilePath: OUTPUT_STYLE_FILE_GLOB,
+			relativeFilePath: OUTPUT_STYLE_FILE_GLOB$1,
 			importOnly: true
 		}];
 	}
@@ -95572,6 +95895,12 @@ const UNIVERSAL_GLOBS$1 = /* @__PURE__ */ new Set([
 * Any other mode is kept in the `qoder` section so it survives a round trip.
 */
 const INFERABLE_TRIGGERS = /* @__PURE__ */ new Set(["always_on", "glob"]);
+/**
+* The file-name glob `getExtraFixedFiles` returns for the output-styles
+* directory, so import enumerates every style in it (never deletion: the
+* directory also holds hand-written styles).
+*/
+const OUTPUT_STYLE_FILE_GLOB = "*.md";
 function normalizeGlobList(value) {
 	if (value === void 0) return [];
 	return (typeof value === "string" ? splitBraceAwareList(value) : value).map((glob) => glob.trim()).filter((glob) => glob !== "");
@@ -95605,22 +95934,59 @@ function resolveTrigger(frontmatter) {
 * A `qoder.trigger` (for example `model_decision` or `manual`) always takes
 * precedence and round-trips through import.
 *
+* A non-root rule with `qoder.channel: output-style` becomes a custom output
+* style instead, `.qoder/output-styles/<rule file name>.md` (both scopes),
+* with the rule's `description` and optional `qoder.name` as the style's
+* `description` / `name` frontmatter.
+*
 * @see https://docs.qoder.com/en/cli/04-extending-qoder-cli/memory
+* @see https://docs.qoder.com/cli/output-styles
 */
 var QoderRule = class QoderRule extends ToolRule {
 	frontmatter;
 	body;
-	constructor({ frontmatter, body, ...rest }) {
+	outputStyle;
+	constructor({ frontmatter, body, outputStyle = false, ...rest }) {
 		if (rest.validate) {
 			const result = QoderRuleFrontmatterSchema.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 : stringifyFrontmatter(body, frontmatter)
+			fileContent: rest.root || outputStyle && Object.keys(frontmatter).length === 0 ? body : stringifyFrontmatter(body, frontmatter)
 		});
 		this.frontmatter = frontmatter;
 		this.body = body;
+		this.outputStyle = outputStyle;
+	}
+	/**
+	* Whether the given path is a custom output style: a direct `.md` child of
+	* `.qoder/output-styles/`, at either scope.
+	*/
+	static isOutputStylePath({ relativeDirPath, relativeFilePath }) {
+		return relativeDirPath === QODER_OUTPUT_STYLES_DIR_PATH && (0, node_path.extname)(relativeFilePath) === ".md" && (0, node_path.basename)(relativeFilePath) === relativeFilePath;
+	}
+	/** Whether a rule opts into the `output-style` channel (non-root only). */
+	static isOutputStyleRule(rulesyncRule) {
+		const frontmatter = rulesyncRule.getFrontmatter();
+		return !frontmatter.root && frontmatter.qoder?.channel === "output-style";
+	}
+	/**
+	* The output-styles directory, enumerated for import only: it also holds
+	* styles users write by hand (including personal ones in
+	* `~/.qoder/output-styles/`) that rulesync cannot tell from its own, so
+	* `--delete` leaves it alone.
+	*/
+	static getExtraFixedFiles(_params = {}) {
+		return [{
+			relativeDirPath: QODER_OUTPUT_STYLES_DIR_PATH,
+			relativeFilePath: OUTPUT_STYLE_FILE_GLOB,
+			importOnly: true
+		}];
+	}
+	/** Qoder loads output styles itself; they are not rules to reference. */
+	isExcludedFromRootReferences() {
+		return this.outputStyle;
 	}
 	static getSettablePaths({ global = false, excludeToolDir } = {}) {
 		return {
@@ -95633,6 +95999,23 @@ var QoderRule = class QoderRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		if (this.isOutputStylePath({
+			relativeDirPath,
+			relativeFilePath
+		})) {
+			const filePath = (0, node_path.join)(outputRoot, QODER_OUTPUT_STYLES_DIR_PATH, relativeFilePath);
+			const { frontmatter, body } = parseFrontmatter(await readFileContent(filePath), filePath);
+			return new QoderRule({
+				outputRoot,
+				relativeDirPath: QODER_OUTPUT_STYLES_DIR_PATH,
+				relativeFilePath,
+				frontmatter,
+				body: body.trim(),
+				validate,
+				root: false,
+				outputStyle: true
+			});
+		}
 		if (relativeDirPath !== void 0 ? relativeDirPath !== QODER_RULES_DIR_PATH : relativeFilePath === paths.root.relativeFilePath) {
 			const rootDirPath = relativeDirPath ?? paths.root.relativeDirPath;
 			const fileContent = await readFileContent((0, node_path.join)(outputRoot, rootDirPath, paths.root.relativeFilePath));
@@ -95665,6 +96048,11 @@ var QoderRule = class QoderRule extends ToolRule {
 		const root = rulesyncFrontmatter.root ?? false;
 		const paths = this.getSettablePaths({ global });
 		const body = rulesyncRule.getBody();
+		if (this.isOutputStyleRule(rulesyncRule)) return this.buildOutputStyle({
+			outputRoot,
+			rulesyncRule,
+			validate
+		});
 		if (root) return new QoderRule({
 			outputRoot,
 			relativeDirPath: paths.root.relativeDirPath,
@@ -95684,8 +96072,32 @@ var QoderRule = class QoderRule extends ToolRule {
 			root: false
 		});
 	}
+	/**
+	* Write an `output-style` rule as `.qoder/output-styles/<name>.md`. The file
+	* name is the rule's own, so a rule nested under `.rulesync/rules/` is
+	* refused: Qoder reads only the files directly in `output-styles/`.
+	*/
+	static buildOutputStyle({ outputRoot, rulesyncRule, validate }) {
+		const { description, qoder } = rulesyncRule.getFrontmatter();
+		const sourcePath = rulesyncRule.getRelativeFilePath();
+		if ((0, node_path.basename)(sourcePath) !== sourcePath) throw new Error(`Rule '${sourcePath}' sets qoder.channel: output-style but is nested in a subdirectory: Qoder reads only the files directly in .qoder/output-styles/, so move it to the top of ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`);
+		const name = qoder?.name;
+		return new QoderRule({
+			outputRoot,
+			relativeDirPath: QODER_OUTPUT_STYLES_DIR_PATH,
+			relativeFilePath: `${(0, node_path.basename)(sourcePath, (0, node_path.extname)(sourcePath))}.md`,
+			frontmatter: {
+				...name !== void 0 && { name },
+				...description !== void 0 && { description }
+			},
+			body: rulesyncRule.getBody(),
+			validate,
+			root: false,
+			outputStyle: true
+		});
+	}
 	static buildFrontmatter(rulesyncFrontmatter, relativeFilePath) {
-		const { trigger: storedTrigger, glob: storedGlob, ...section } = rulesyncFrontmatter.qoder ?? {};
+		const { trigger: storedTrigger, glob: storedGlob, channel: _channel, name: _name, ...section } = rulesyncFrontmatter.qoder ?? {};
 		const specificGlobs = normalizeGlobList(storedGlob ?? rulesyncFrontmatter.globs).filter((glob) => !UNIVERSAL_GLOBS$1.has(glob));
 		let trigger = storedTrigger ?? (specificGlobs.length > 0 ? "glob" : "always_on");
 		const description = section.description ?? rulesyncFrontmatter.description;
@@ -95703,6 +96115,25 @@ var QoderRule = class QoderRule extends ToolRule {
 	}
 	toRulesyncRule() {
 		if (this.isRoot()) return this.toRulesyncRuleDefault();
+		if (this.outputStyle) {
+			const { name, description } = this.frontmatter;
+			return new RulesyncRule({
+				outputRoot: this.getOutputRoot(),
+				relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+				relativeFilePath: this.getRelativeFilePath(),
+				frontmatter: {
+					root: false,
+					targets: ["qoder"],
+					...typeof description === "string" && { description },
+					qoder: {
+						channel: "output-style",
+						...typeof name === "string" && name.trim() !== "" && { name }
+					}
+				},
+				body: this.body,
+				validate: true
+			});
+		}
 		const trigger = resolveTrigger(this.frontmatter);
 		const { trigger: _trigger, alwaysApply: _alwaysApply, description, glob, paths, ...unmapped } = this.frontmatter;
 		const fileGlobs = normalizeGlobList(glob ?? paths);
@@ -95751,6 +96182,10 @@ var QoderRule = class QoderRule extends ToolRule {
 		return this.body;
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		const outputStyle = this.isOutputStylePath({
+			relativeDirPath,
+			relativeFilePath
+		});
 		return new QoderRule({
 			outputRoot,
 			relativeDirPath,
@@ -95758,7 +96193,8 @@ var QoderRule = class QoderRule extends ToolRule {
 			frontmatter: {},
 			body: "",
 			validate: false,
-			root: relativeDirPath !== QODER_RULES_DIR_PATH && relativeFilePath === "AGENTS.md"
+			root: !outputStyle && relativeDirPath !== QODER_RULES_DIR_PATH && relativeFilePath === "AGENTS.md",
+			outputStyle
 		});
 	}
 	static isTargetedByRulesyncRule(rulesyncRule) {
@@ -97445,6 +97881,16 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			localRootFileName: CODEBUDDY_LOCAL_RULE_FILE_NAME
 		}
 	}],
+	["codebuff", {
+		class: CodebuffRule,
+		meta: {
+			extension: "md",
+			supportsProject: false,
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["codewhale", {
 		class: CodewhaleRule,
 		meta: {
@@ -97875,7 +98321,9 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 	}]
 ]);
 const allToolTargetKeys = [...toolRuleFactories.keys()];
-const rulesProcessorToolTargets = allToolTargetKeys;
+const rulesProcessorToolTargets = allToolTargetKeys.filter((target) => {
+	return toolRuleFactories.get(target)?.meta.supportsProject !== false;
+});
 const rulesProcessorToolTargetsGlobal = allToolTargetKeys.filter((target) => {
 	return toolRuleFactories.get(target)?.meta.supportsGlobal ?? false;
 });
@@ -97954,7 +98402,7 @@ var RulesProcessor = class extends FeatureProcessor {
 		const factory = this.getFactory(this.toolTarget);
 		const { meta } = factory;
 		this.warnForIncludeRootOption(meta);
-		this.warnForFactorydroidRuleOptions({
+		this.warnForOutputStyleRuleOptions({
 			rules: alignedRules,
 			factory
 		});
@@ -98188,22 +98636,25 @@ var RulesProcessor = class extends FeatureProcessor {
 		}) !== "auto") this.logger.warn("The rules option `ruleDiscoveryMode` has no effect with `includeRoot: false` on claudecode: the rule references it adds are written into CLAUDE.md, which is not generated.");
 	}
 	/**
-	* Warn about `factorydroid` frontmatter that does not do what it looks like
-	* it does: an `output-style` rule that also targets other tools reaches them
-	* as an ordinary rule (so presentation instructions end up in their project
-	* rules), and `factorydroid.name` is read only with `channel: output-style`.
-	* Checked while generating for factorydroid only, so each warning prints once.
+	* Warn about `factorydroid` / `qoder` frontmatter that does not do what it
+	* looks like it does: an `output-style` rule that also targets other tools
+	* reaches them as an ordinary rule (so presentation instructions end up in
+	* their project rules), and `<tool>.name` is read only with
+	* `channel: output-style`. Checked while generating for that tool only, so
+	* each warning prints once.
 	*/
-	warnForFactorydroidRuleOptions({ rules, factory }) {
-		if (this.toolTarget !== "factorydroid") return;
+	warnForOutputStyleRuleOptions({ rules, factory }) {
+		const toolTarget = this.toolTarget;
+		if (toolTarget !== "factorydroid" && toolTarget !== "qoder") return;
 		for (const rule of rules) {
 			const frontmatter = rule.getFrontmatter();
-			if (frontmatter.root || !frontmatter.factorydroid || !factory.class.isTargetedByRulesyncRule(rule)) continue;
-			const { channel, name } = frontmatter.factorydroid;
+			const section = frontmatter[toolTarget];
+			if (frontmatter.root || !section || !factory.class.isTargetedByRulesyncRule(rule)) continue;
+			const { channel, name } = section;
 			const fileName = stripControlCharacters(rule.getRelativeFilePath());
 			const targets = frontmatter.targets ?? ["*"];
-			if (channel === "output-style" && targets.some((target) => target !== "factorydroid")) this.logger.warn(`${fileName} sets factorydroid.channel: output-style but also targets other tools, which receive it as an ordinary rule. Set \`targets: ["factorydroid"]\` to keep the output style to Factory Droid.`);
-			if (channel !== "output-style" && name !== void 0) this.logger.warn(`${fileName} sets factorydroid.name, which is read only with factorydroid.channel: output-style; ignoring it.`);
+			if (channel === "output-style" && targets.some((target) => target !== toolTarget)) this.logger.warn(`${fileName} sets ${toolTarget}.channel: output-style but also targets other tools, which receive it as an ordinary rule. Set \`targets: ["${toolTarget}"]\` to keep the output style to ${toolTarget === "qoder" ? "Qoder" : "Factory Droid"}.`);
+			if (channel !== "output-style" && name !== void 0) this.logger.warn(`${fileName} sets ${toolTarget}.name, which is read only with ${toolTarget}.channel: output-style; ignoring it.`);
 		}
 	}
 	/**
@@ -102650,6 +103101,12 @@ Object.defineProperty(exports, "hasEnclosingMarkOutsideKeycap", {
 		return hasEnclosingMarkOutsideKeycap;
 	}
 });
+Object.defineProperty(exports, "hasExecutableBit", {
+	enumerable: true,
+	get: function() {
+		return hasExecutableBit;
+	}
+});
 Object.defineProperty(exports, "importFromTool", {
 	enumerable: true,
 	get: function() {
@@ -102806,6 +103263,12 @@ Object.defineProperty(exports, "resolveRulesyncSourceWritePath", {
 		return resolveRulesyncSourceWritePath;
 	}
 });
+Object.defineProperty(exports, "resolvedPathEscapesRoot", {
+	enumerable: true,
+	get: function() {
+		return resolvedPathEscapesRoot;
+	}
+});
 Object.defineProperty(exports, "runWithDirectoryRollback", {
 	enumerable: true,
 	get: function() {