rulesync 32.0.0 → 34.0.0

package/dist/{import-DgKWnDni.js → import-DFwX4TTE.js}

@@ -386,7 +386,11 @@ const DeprecatedIgnoreFeatureSchema = z.literal("ignore").check(meta({
 const FeatureSchema = z.union([z.enum(ACTIVE_FEATURES), DeprecatedIgnoreFeatureSchema]);
 z.array(FeatureSchema);
 const FeatureWithWildcardSchema = z.union([z.enum([...ACTIVE_FEATURES, "*"]), DeprecatedIgnoreFeatureSchema]);
-const GitignoreDestinationSchema = z.enum(["gitignore", "gitattributes"]);
+const GitignoreDestinationSchema = z.enum([
+	"gitignore",
+	"gitattributes",
+	"gitexclude"
+]);
 const FlattenedCommandNamingSchema = z.enum(["basename", "path"]);
 const FeatureOptionsSchema = z.record(z.string(), z.unknown());
 const FeatureValueSchema = z.union([
@@ -506,6 +510,7 @@ const rulesProcessorToolTargetTuple = [
 	"claudecode-legacy",
 	"cline",
 	"codebuddy",
+	"codebuff",
 	"codewhale",
 	"codexcli",
 	"commandcode",
@@ -1385,6 +1390,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 stat(filepath)).mode & 73) !== 0;
+}
 async function isSymlink(filepath) {
 	try {
 		return (await lstat(filepath)).isSymbolicLink();
@@ -3157,6 +3169,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;
@@ -3174,7 +3189,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.
@@ -5244,12 +5260,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.
 *
@@ -5590,7 +5614,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
@@ -5621,7 +5648,9 @@ const CODEBUDDY_HOOK_EVENTS = [
 	"postCompact",
 	"elicitation",
 	"elicitationResult",
-	"sessionEnd"
+	"sessionEnd",
+	"setup",
+	"userPromptExpansion"
 ];
 /**
 * CodeBuddy Code events that fire on every occurrence and take no `matcher`.
@@ -5670,7 +5699,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]));
 /**
@@ -6524,7 +6555,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.
 */
@@ -8265,6 +8300,48 @@ const ReasonixPermissionsOverrideSchema = 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 = z.looseObject({
+	permission: z.optional(ToolScopedPermissionSchema),
+	outputStyle: z.optional(z.string().check(z.trim(), 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 = z.looseObject({
+	id: z.string(),
+	decision: z.enum([
+		"allow",
+		"ask",
+		"block"
+	]),
+	match: z.looseObject({ prefix: z.optional(z.array(z.union([z.string(), z.array(z.string()).check(z.minLength(1))])).check(z.minLength(1))) }),
+	tests: z.optional(z.looseObject({
+		match: z.optional(z.array(z.string())),
+		noMatch: z.optional(z.array(z.string()))
+	})),
+	reason: z.optional(z.string()),
+	enabled: z.optional(z.boolean())
+});
+const FactorydroidPermissionRulesSchema = z.looseObject({
+	version: z.number(),
+	rules: 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
@@ -8272,7 +8349,8 @@ const ReasonixPermissionsOverrideSchema = 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.
@@ -8283,7 +8361,8 @@ const ReasonixPermissionsOverrideSchema = z.looseObject({
 const FactorydroidPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
 	commandBlocklist: z.optional(z.array(z.string())),
-	disabledSkills: z.optional(z.array(z.string()))
+	disabledSkills: z.optional(z.array(z.string())),
+	permissionRules: z.optional(FactorydroidPermissionRulesSchema)
 });
 /**
 * Tool-scoped override block for Warp. Warp's `[agents.profiles]` table exposes
@@ -9088,6 +9167,7 @@ const PermissionsConfigSchema = z.looseObject({
 	codewhale: z.optional(CodewhalePermissionsOverrideSchema),
 	zed: z.optional(ZedPermissionsOverrideSchema),
 	devin: z.optional(DevinPermissionsOverrideSchema),
+	qoder: z.optional(QoderPermissionsOverrideSchema),
 	"antigravity-ide": z.optional(CanonicalPermissionsOverrideSchema),
 	continue: z.optional(CanonicalPermissionsOverrideSchema),
 	copilot: z.optional(CopilotPermissionsOverrideSchema),
@@ -9099,7 +9179,6 @@ const PermissionsConfigSchema = z.looseObject({
 	goose: z.optional(CanonicalPermissionsOverrideSchema),
 	omp: z.optional(OmpPermissionsOverrideSchema),
 	pool: z.optional(CanonicalPermissionsOverrideSchema),
-	qoder: z.optional(CanonicalPermissionsOverrideSchema),
 	grokcli: z.optional(CanonicalPermissionsOverrideSchema),
 	"kimi-code": z.optional(KimiCodePermissionsOverrideSchema),
 	roo: z.optional(CanonicalPermissionsOverrideSchema),
@@ -9620,7 +9699,9 @@ const RulesyncRuleFrontmatterSchema = z.object({
 	qoder: z.optional(z.looseObject({
 		trigger: z.optional(z.string()),
 		glob: z.optional(z.union([z.string(), z.array(z.string())])),
-		description: z.optional(z.string())
+		description: z.optional(z.string()),
+		channel: z.optional(z.enum(["output-style"])),
+		name: z.optional(z.string().check(z.trim(), z.minLength(1)))
 	})),
 	augmentcode: z.optional(z.looseObject({
 		type: z.optional(z.string()),
@@ -12989,7 +13070,7 @@ const SHARED_CONFIG_OWNERSHIP = {
 			},
 			permissions: {
 				kind: "replace-owned-keys",
-				ownedKeys: ["permissions"]
+				ownedKeys: ["permissions", "outputStyle"]
 			}
 		}
 	},
@@ -21744,22 +21825,29 @@ function mergeOpencodeV2Entries({ config, legacyKey, pluralKey, lower }) {
 		const entry = asOpencodeEntries(value);
 		const lowered = entry === null ? null : lower(entry);
 		if (Object.hasOwn(merged, name) || lowered === null) continue;
-		Object.defineProperty(merged, name, {
-			value: lowered,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		});
+		setOwnEntry(merged, name, lowered);
 	}
 	return Object.keys(merged).length > 0 ? merged : legacy;
 }
 /**
+* Sets `target[key]` as an own, enumerable property. A plain assignment to a
+* key named `__proto__` would set the prototype instead.
+*/
+function setOwnEntry(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
+/**
 * Returns the inline agent entries of an OpenCode config in the V1 `agent`
 * shape. Since v1.18.24 OpenCode V1 also reads the V2 `agents` spelling and
 * lowers it, so a layout that does so (`readsV2ConfigSpellings`) gets those
 * entries too.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeAgentEntries({ config, layout = OPENCODE_LAYOUT }) {
 	if (!layout.readsV2ConfigSpellings) return asOpencodeEntries(config.agent);
@@ -21778,7 +21866,7 @@ function getOpencodeAgentEntries({ config, layout = OPENCODE_LAYOUT }) {
 * Other fields are kept: V1 drops a V2 `subagent`, but rulesync reads it as
 * `subtask` everywhere (as V2 does), so it is left for the command importer.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeCommandEntries({ config, layout = OPENCODE_LAYOUT }) {
 	if (!layout.readsV2ConfigSpellings) return asOpencodeEntries(config.command);
@@ -21801,7 +21889,7 @@ function getOpencodeCommandEntries({ config, layout = OPENCODE_LAYOUT }) {
 * reads V2 spellings, a flat V2 `skills` array is accepted too: its entries
 * that are not `http(s)://` URLs are the paths, as OpenCode V1 lowers them.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeSkillPaths({ config, layout = OPENCODE_LAYOUT }) {
 	if (Array.isArray(config.skills)) {
@@ -21811,6 +21899,160 @@ function getOpencodeSkillPaths({ config, layout = OPENCODE_LAYOUT }) {
 	const skills = asOpencodeEntries(config.skills);
 	return skills !== null && Array.isArray(skills.paths) ? skills.paths : [];
 }
+/**
+* Whether a record is itself an MCP server entry rather than a V2 container
+* (`mcp.servers`, `mcp.timeout`): a server — or a server literally named
+* `type` / `enabled` — carries a scalar `type` or `enabled`. Mirrors OpenCode
+* V1's `isDirectServer`.
+*/
+function isDirectOpencodeMcpServer(value) {
+	return ["type", "enabled"].some((key) => Object.hasOwn(value, key) && (value[key] === null || typeof value[key] !== "object" || Array.isArray(value[key])));
+}
+const OPENCODE_V2_TIMEOUT_KEYS = [
+	"startup",
+	"catalog",
+	"execution"
+];
+/**
+* Whether an MCP server entry uses a V2-only per-server spelling, so that
+* OpenCode V1 lowers it: `disabled`, `codemode`, an object `timeout`, or a
+* snake_case `oauth` key.
+*/
+function isOpencodeV2NativeServer(value) {
+	const oauth = value.oauth;
+	return Object.hasOwn(value, "disabled") || Object.hasOwn(value, "codemode") || isRecord$1(value.timeout) || isRecord$1(oauth) && [
+		"client_id",
+		"client_secret",
+		"callback_port",
+		"redirect_uri"
+	].some((key) => Object.hasOwn(oauth, key));
+}
+/**
+* Lowers a V2 timeout object (`{ startup, catalog, execution }`) to V1's single
+* number, the way OpenCode V1 does: only a `catalog` equal to `execution`, with
+* no `startup`, has a V1 equivalent. Anything else — including a value that is
+* not a positive integer — is `undefined` (dropped).
+*/
+function lowerOpencodeV2Timeout(value) {
+	if (!hasPositiveIntegerTimeouts(value) || value.startup !== void 0 || typeof value.catalog !== "number") return;
+	return value.catalog === value.execution ? value.catalog : void 0;
+}
+const OPENCODE_V2_OAUTH_KEYS = /* @__PURE__ */ new Map([
+	["client_id", "clientId"],
+	["client_secret", "clientSecret"],
+	["callback_port", "callbackPort"],
+	["redirect_uri", "redirectUri"]
+]);
+/**
+* V2 `oauth` keys that have no V1 spelling. OpenCode V1 drops them when it
+* lowers a server, so they are dropped (and reported) here too rather than
+* being written back as a snake_case key among camelCase ones.
+*/
+const OPENCODE_V2_UNSUPPORTED_OAUTH_KEYS = /* @__PURE__ */ new Set(["auth_server_metadata_url"]);
+function lowerOpencodeV2OAuth(oauth, path, onDropped) {
+	const lowered = {};
+	for (const [key, value] of Object.entries(oauth)) {
+		if (OPENCODE_V2_UNSUPPORTED_OAUTH_KEYS.has(key)) {
+			onDropped?.(`${path}.${key}`, "unsupported");
+			continue;
+		}
+		setOwnEntry(lowered, OPENCODE_V2_OAUTH_KEYS.get(key) ?? key, value);
+	}
+	return lowered;
+}
+/**
+* Lowers one V2-spelled MCP server entry to V1's shape, as OpenCode V1 does:
+* `disabled` becomes `enabled` (an explicit `enabled` wins), an object
+* `timeout` becomes a number or is dropped, and snake_case `oauth` keys become
+* camelCase. `codemode` is kept: Rulesync passes it through where V1 drops it.
+*
+* Like V1, only an entry that is a local or remote server is lowered, and one
+* whose `enabled` or `disabled` is not a boolean is left as it is. Unlike V1,
+* such an entry is not dropped but passed on, so the schema rejects it loudly.
+*/
+function lowerOpencodeV2Server(value, path, onDropped) {
+	if (!isRecord$1(value) || value.type !== "local" && value.type !== "remote" || Object.hasOwn(value, "enabled") && typeof value.enabled !== "boolean" || Object.hasOwn(value, "disabled") && typeof value.disabled !== "boolean") return value;
+	const { disabled, timeout, ...rest } = value;
+	const lowered = { ...rest };
+	if (!Object.hasOwn(value, "enabled")) lowered.enabled = disabled !== true;
+	else if (value.enabled === disabled) onDropped?.(`${path}.disabled`, "conflict");
+	const lowTimeout = isRecord$1(timeout) ? lowerOpencodeV2Timeout(timeout) : timeout;
+	if (lowTimeout !== void 0) lowered.timeout = lowTimeout;
+	else if (isRecord$1(timeout) && Object.keys(timeout).length > 0) onDropped?.(`${path}.timeout`, "unsupported");
+	if (isRecord$1(value.oauth)) lowered.oauth = lowerOpencodeV2OAuth(value.oauth, `${path}.oauth`, onDropped);
+	return lowered;
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+/** Whether each V2 timeout value a record carries is a positive integer. */
+function hasPositiveIntegerTimeouts(value) {
+	return OPENCODE_V2_TIMEOUT_KEYS.every((key) => value[key] === void 0 || isPositiveInteger(value[key]));
+}
+/**
+* Whether `mcp.timeout` is V2's global timeout object rather than a server
+* named `timeout`. As in OpenCode V1, each of its values must be a positive
+* integer; anything else is read as a server, which the schema then rejects.
+*/
+function isOpencodeV2GlobalTimeout(value) {
+	return isRecord$1(value) && !isDirectOpencodeMcpServer(value) && (Object.keys(value).length === 0 || OPENCODE_V2_TIMEOUT_KEYS.some((key) => Object.hasOwn(value, key))) && hasPositiveIntegerTimeouts(value);
+}
+function getOpencodeV2McpEnvelope(mcp) {
+	const nested = mcp.servers;
+	return isRecord$1(nested) && !isDirectOpencodeMcpServer(nested) ? nested : null;
+}
+/**
+* Returns the paths of the V2-only containers in an OpenCode `mcp` value that
+* a write in V1's flat shape does not keep: a non-empty `mcp.servers`
+* envelope, and a non-empty global `mcp.timeout`.
+*/
+function findOpencodeV2McpContainers(mcp) {
+	if (!isRecord$1(mcp)) return [];
+	const envelope = getOpencodeV2McpEnvelope(mcp);
+	return [...envelope !== null && Object.keys(envelope).length > 0 ? ["mcp.servers"] : [], ...isOpencodeV2GlobalTimeout(mcp.timeout) && Object.keys(mcp.timeout).length > 0 ? ["mcp.timeout"] : []];
+}
+/**
+* Lowers OpenCode V2 `mcp` spellings found in a V1 config to the flat V1 map,
+* the way OpenCode V1 itself does since v1.18.24 (`normalizeMcp`):
+*
+* - entries of the `mcp.servers` envelope are merged into the map, a flat entry
+*   of the same name winning;
+* - V2-spelled server entries (`disabled`, an object `timeout`, snake_case
+*   `oauth` keys) are lowered by {@link lowerOpencodeV2Server};
+* - the global `mcp.timeout` object is skipped. V1 moves it to
+*   `experimental.mcp_timeout`, a default request timeout that has no
+*   canonical counterpart, so it is not read as a server either.
+*
+* Unlike V1, an envelope entry that is not a valid server is not dropped: it
+* is passed on, so the schema rejects it loudly rather than it vanishing
+* without a word. Each value that is dropped — a non-empty global timeout, a
+* per-server timeout object or `oauth` key with no V1 equivalent, or an
+* envelope entry shadowed by a different flat entry — is reported through
+* `onDropped`.
+*
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
+* @see https://opencode.ai/v2/docs/mcp-servers/
+*/
+function lowerOpencodeV2Mcp(mcp, onDropped) {
+	if (!isRecord$1(mcp)) return mcp;
+	const envelope = getOpencodeV2McpEnvelope(mcp);
+	const globalTimeout = isOpencodeV2GlobalTimeout(mcp.timeout);
+	if (findOpencodeV2McpContainers(mcp).includes("mcp.timeout")) onDropped?.("mcp.timeout", "unsupported");
+	const servers = {};
+	for (const [name, value] of Object.entries(mcp)) {
+		if (name === "servers" && envelope !== null || name === "timeout" && globalTimeout) continue;
+		setOwnEntry(servers, name, isRecord$1(value) && isOpencodeV2NativeServer(value) ? lowerOpencodeV2Server(value, `mcp.${name}`, onDropped) : value);
+	}
+	for (const [name, value] of Object.entries(envelope ?? {})) {
+		const path = `mcp.servers.${name}`;
+		if (Object.hasOwn(servers, name)) {
+			if (!isDeepStrictEqual(servers[name], value)) onDropped?.(path, "conflict");
+			continue;
+		}
+		setOwnEntry(servers, name, lowerOpencodeV2Server(value, path, onDropped));
+	}
+	return servers;
+}
 /** Matches a string whose entire value is an OpenCode `{file:...}` reference. */
 const OPENCODE_FILE_TEMPLATE_PATTERN = /^\s*\{file:(.+?)\}\s*$/;
 /**
@@ -22242,6 +22484,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 = join(QODER_DIR, "rules");
+const QODER_OUTPUT_STYLES_DIR_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 = join(QODER_DIR, "commands");
@@ -29616,6 +29859,11 @@ const CORTEXCODE_SPEC = {
 			canonical: "enabled",
 			tool: "enabled"
 		}],
+		stringPassthroughFields: [{
+			canonical: "statusMessage",
+			tool: "statusMessage",
+			commandOnly: true
+		}],
 		objectPassthroughFields: [{
 			canonical: "source",
 			tool: "source",
@@ -29630,7 +29878,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
@@ -30569,7 +30817,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
-	"missionPolicy"
+	"missionPolicy",
+	"permissionRules"
 ];
 //#endregion
 //#region src/utils/factorydroid-settings.ts
@@ -30784,7 +31033,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 {
@@ -36438,6 +36687,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
 /**
@@ -43339,11 +43589,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({
@@ -43352,7 +43636,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({
@@ -43361,8 +43645,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 {
@@ -43451,7 +43740,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 {
@@ -45559,18 +45854,21 @@ var KiroMcp = class KiroMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/opencode-mcp.ts
+const OpencodeMcpV2DisabledSchema = z.optional(z.boolean());
 const OpencodeMcpLocalServerSchema = z.looseObject({
 	type: z.literal("local"),
 	command: z.array(z.string()),
 	environment: z.optional(z.record(z.string(), z.string())),
 	enabled: z._default(z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema,
 	cwd: z.optional(z.string())
 });
 const OpencodeMcpRemoteServerSchema = z.looseObject({
 	type: z.literal("remote"),
 	url: z.string(),
 	headers: z.optional(z.record(z.string(), z.string())),
-	enabled: z._default(z.boolean(), true)
+	enabled: z._default(z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema
 });
 const OPENCODE_PASSTHROUGH_SERVER_FIELDS = [
 	"timeout",
@@ -45582,7 +45880,7 @@ const OPENCODE_MCP_TRANSPORT_KEYS = [
 	...Object.keys(OpencodeMcpLocalServerSchema.def.shape),
 	...Object.keys(OpencodeMcpRemoteServerSchema.def.shape),
 	...OPENCODE_PASSTHROUGH_SERVER_FIELDS
-].filter((key) => key !== "enabled");
+].filter((key) => key !== "enabled" && key !== "disabled");
 /**
 * A bare toggle entry: `{"enabled": <bool>}` with no transport of its own,
 * disabling a server another config layer defines. It is the third member of
@@ -45710,7 +46008,7 @@ const OPENCODE_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
 function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
 	const dropped = Object.keys(serverConfig).filter((key) => !OPENCODE_TOGGLE_KEPT_KEYS.has(key));
 	if (dropped.length === 0) return;
-	logger?.warn(`OpenCode MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
+	logger?.warn(`OpenCode MCP: ${quoteValueForWarning(serverName)} declares no transport, so it is written as a toggle entry and ${dropped.toSorted().map(quoteValueForWarning).join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
 }
 /**
 * Convert standard MCP format to OpenCode native format
@@ -45790,9 +46088,35 @@ var OpencodeMcp = class extends ToolMcp {
 	/** Directory layout; OpenCode forks (MiMo Code) override it. */
 	static layout = OPENCODE_LAYOUT;
 	json;
-	constructor(params) {
+	/**
+	* With a `logger`, the V2 values that lowering the content drops are warned
+	* about (see {@link OpencodeMcp.lowerConfig}); `fromFile` passes one so the
+	* warnings come from the lowering that builds the parsed view rather than
+	* from an extra pass of their own. (`validate()`, which the parent
+	* constructor calls before this view exists, lowers separately and silently.)
+	*/
+	constructor({ logger, ...params }) {
 		super(params);
-		this.json = OpencodeConfigSchema.parse(parse$1(this.fileContent || "{}"));
+		this.json = OpencodeConfigSchema.parse(this.constructor.lowerConfig(parse$1(this.fileContent || "{}"), logger));
+	}
+	/**
+	* Lowers the OpenCode V2 `mcp` spellings of a parsed config for a layout
+	* that reads them (see {@link lowerOpencodeV2Mcp}), so every reader — import,
+	* the toggle lookup on generate, and the rules feature's `instructions`
+	* write to the same file — accepts a V2-shaped `mcp`. Only the parsed view
+	* is lowered; content written back keeps whatever `mcp` a feature that does
+	* not own the key found there. With a `logger`, each V2 value the lowering
+	* drops is warned about.
+	*/
+	static lowerConfig(json, logger) {
+		if (!this.layout.readsV2ConfigSpellings || !isRecord$1(json) || json.mcp === void 0) return json;
+		return {
+			...json,
+			mcp: lowerOpencodeV2Mcp(json.mcp, (path, reason) => {
+				const quoted = quoteValueForWarning(path);
+				logger?.warn(reason === "conflict" ? `OpenCode MCP: ${quoted} conflicts with a V1 value that takes precedence (the flat "mcp" entry of the same name, or "enabled"), so it is dropped on import.` : `OpenCode MCP: ${quoted} has no Rulesync equivalent, so it is dropped on import.`);
+			})
+		};
 	}
 	getJson() {
 		return this.json;
@@ -45809,7 +46133,7 @@ var OpencodeMcp = class extends ToolMcp {
 			relativeFilePath: this.layout.jsonFileName
 		};
 	}
-	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false, logger }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = join(outputRoot, basePaths.relativeDirPath);
 		let fileContent = null;
@@ -45831,7 +46155,8 @@ var OpencodeMcp = class extends ToolMcp {
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
 			fileContent: JSON.stringify(newJson, null, 2),
-			validate
+			validate,
+			logger
 		});
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
@@ -45850,7 +46175,12 @@ var OpencodeMcp = class extends ToolMcp {
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
 		});
-		const existingMcp = OpencodeConfigSchema.safeParse(parse$1(fileContent || "{}"));
+		const existingJson = parse$1(fileContent || "{}");
+		const existingMcp = OpencodeConfigSchema.safeParse(this.lowerConfig(existingJson));
+		if (this.layout.readsV2ConfigSpellings && isRecord$1(existingJson)) {
+			const containers = findOpencodeV2McpContainers(existingJson.mcp);
+			if (containers.length > 0) logger?.warn(`OpenCode MCP: the whole "mcp" key is rewritten in the flat V1 shape, so ${containers.map(quoteValueForWarning).join(" and ")} ${containers.length === 1 ? "is" : "are"} not kept.`);
+		}
 		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(transformedServers, (existingMcp.success ? existingMcp.data.mcp : void 0) ?? {}, logger);
 		return new this({
 			outputRoot,
@@ -45950,7 +46280,7 @@ var OpencodeMcp = class extends ToolMcp {
 	}
 	validate() {
 		const json = parseJsonc(this.fileContent || "{}");
-		const result = OpencodeConfigSchema.safeParse(json);
+		const result = OpencodeConfigSchema.safeParse(this.constructor.lowerConfig(json));
 		if (!result.success) return {
 			success: false,
 			error: result.error
@@ -46523,6 +46853,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.
@@ -46558,17 +46897,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;
@@ -46609,56 +46943,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;
 	}
@@ -46667,16 +47062,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;
@@ -46752,8 +47150,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 {
@@ -64546,9 +64947,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`.
 *
@@ -65208,6 +65611,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__";
@@ -65367,9 +65777,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) {
@@ -65408,11 +65820,14 @@ var QoderPermissions = class QoderPermissions extends ToolPermissions {
 			relativePath: 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 ${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];
@@ -65424,7 +65839,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,
@@ -65445,7 +65863,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 {
@@ -84493,8 +84916,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();
@@ -84587,8 +85010,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
 */
@@ -88150,6 +88574,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 = z.enum(subagentsProcessorToolTargetTuple);
 /**
 * Factory Map mapping tool targets to their subagent factories.
@@ -88346,7 +88781,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", {
@@ -88355,7 +88792,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", {
@@ -88834,6 +89273,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();
@@ -88850,7 +89290,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(relative(baseDir, left), relative(baseDir, right)));
@@ -88864,7 +89304,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,
@@ -91740,6 +92180,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(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.
@@ -93377,7 +93896,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.
 *
@@ -93499,7 +94018,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
 		}];
 	}
@@ -95354,6 +95873,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 !== "");
@@ -95387,22 +95912,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 ${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 && extname(relativeFilePath) === ".md" && 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 {
@@ -95415,6 +95977,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 = 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(join(outputRoot, rootDirPath, paths.root.relativeFilePath));
@@ -95447,6 +96026,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,
@@ -95466,8 +96050,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 (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: `${basename(sourcePath, 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;
@@ -95485,6 +96093,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);
@@ -95533,6 +96160,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,
@@ -95540,7 +96171,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) {
@@ -97227,6 +97859,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: {
@@ -97657,7 +98299,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;
 });
@@ -97736,7 +98380,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
 		});
@@ -97970,22 +98614,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.`);
 		}
 	}
 	/**
@@ -101730,6 +102377,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { RulesyncHooks as $, removeFile as $t, groupSpellingsByCaseFoldedIdentity as A, RULESYNC_RELATIVE_DIR_PATH as An, applyFileMode as At, QWENCODE_LOCAL_RULE_FILE_NAME as B, DEPRECATED_FEATURE_REPLACEMENTS as Bn, getFileSize as Bt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as C, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Cn, fallbackLogger as Ct, FACTORYDROID_DIR as D, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, withWarnOnceScope as Dt, ChecksProcessor as E, RULESYNC_MCP_SCHEMA_URL as En, resetRunWarningState as Et, CLAUDECODE_LOCAL_RULE_FILE_NAME as F, RULESYNC_USER_CONFIG_DIR_NAME as Fn, createTempDirectory as Ft, RulesyncSubagentFrontmatterSchema as G, quoteForLog as Gn, listDirectoryEntryNames as Gt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as H, truncateText as Hn, isFileNotFoundError as Ht, CLAUDECODE_MEMORIES_DIR_NAME as I, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as In, directoryExists as It, RulesyncRule as J, stripHiddenCharacters as Jn, pathEscapesRoot as Jt, RulesyncSkill as K, stripControlCharacters as Kn, listFilePathsRecursively as Kt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as L, parseCommaSeparatedList as Ln, ensureDir as Lt, CODEXCLI_DIR as M, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Mn, assertTreeContainsNoSymlinks as Mt, CLAUDECODE_AGENT_MEMORY_LOCAL_DIR_NAME as N, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Nn, assertWritablePathInsideRoot as Nt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as O, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as On, CLIError as Ot, CLAUDECODE_DIR as P, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Pn, checkPathTraversal as Pt, RulesyncIgnore as Q, removeDirectoryStrict as Qt, CLAUDECODE_SKILLS_DIR_PATH as R, ALL_FEATURES as Rn, fileExists as Rt, COMMANDCODE_DIR as S, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Sn, WarningCollectingLogger as St, CODEBUDDY_LOCAL_RULE_FILE_NAME as T, RULESYNC_MCP_RELATIVE_FILE_PATH as Tn, withFallbackLoggerTarget as Tt, getLocalSkillDirNames as U, hasDeceptiveHiddenCharacters as Un, isFileSystemError as Ut, AUGMENTCODE_DIR as V, formatError as Vn, getHomeDirectory as Vt, RulesyncSubagent as W, hasEnclosingMarkOutsideKeycap as Wn, isSymlink as Wt, RulesyncPermissions as X, readFileContentOrNull as Xt, RulesyncRuleFrontmatterSchema as Y, readFileContent as Yt, RulesyncMcp as Z, removeDirectory as Zt, LETTACODE_DIR as _, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as _n, SourceEntrySchema as _t, getProcessorRegistryEntry as a, toPosixPath as an, RulesyncCheck as at, CommandsProcessor as b, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as bn, ConsoleLogger as bt, RulesProcessor as c, ALL_TOOL_TARGETS as cn, loadYaml as ct, ELLIPSIS_WIDTH as d, ToolTargetSchema as dn, ConfigResolver as dt, removeFileStrict as en, getRulesyncSourceCandidates as et, displayWidthOf as f, CURATED_RULES_FEATURE_SUBDIR as fn, mergeInputRootConfigs as ft, HooksProcessor as g, RULESYNC_CHECKS_RELATIVE_DIR_PATH as gn, GITIGNORE_DESTINATION_KEY as gt, IgnoreProcessor as h, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as hn, ConfigFileSchema as ht, inspectInputRoots as i, splitPathSegments as in, RulesyncCommandFrontmatterSchema as it, CODEXCLI_BASH_RULES_FILE_NAME as j, RULESYNC_RULES_RELATIVE_DIR_PATH as jn, assertDirectoryIfExists as jt, caseFoldIdentity as k, RULESYNC_PERMISSIONS_SCHEMA_URL as kn, ErrorCodes as kt, SubagentsProcessor as l, ALL_TOOL_TARGETS_WITH_WILDCARD as ln, SHARED_USER_MANAGED_CONFIG_PATHS as lt, McpProcessor as m, MAX_FILE_SIZE as mn, CONFLICTING_TARGET_PAIRS as mt, formatSourceLoadFailure as n, resolvePath as nn, parseJsonc as nt, convertFromTool as o, writeFileBuffer as on, RulesyncCheckFrontmatterSchema as ot, shortenToWidth as p, FEATURE_SOURCE_TREE_ENTRIES as pn, resolveEffectiveInputRoots as pt, RulesyncSkillFrontmatterSchema as q, stripControlCharactersKeepingLineFeeds as qn, listSubdirectoryNames as qt, generate as r, runWithDirectoryRollback as rn, RulesyncCommand as rt, isPackagingToolTarget as s, writeFileContent as sn, stringifyFrontmatter as st, importFromTool as t, removeTempDirectory as tn, resolveRulesyncSourceWritePath as tt, SkillsProcessor as u, PACKAGING_TOOL_TARGETS as un, SKILL_FILE_NAME as ut, LETTACODE_SETTINGS_LOCAL_FILE_NAME as v, RULESYNC_CONFIG_RELATIVE_FILE_PATH as vn, assertTargetsFeaturesExclusive as vt, CODEBUDDY_DIR as w, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as wn, warnOnConflictingFlags as wt, REASONIX_LOCAL_RULE_FILE_NAME as x, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as xn, JsonLogger as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_CONFIG_SCHEMA_URL as yn, findControlCharacter as yt, QWENCODE_DIR as z, ALL_FEATURES_WITH_WILDCARD as zn, findFilesByGlobs as zt };
+export { RulesyncHooks as $, removeDirectoryStrict as $t, groupSpellingsByCaseFoldedIdentity as A, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as An, applyFileMode as At, QWENCODE_LOCAL_RULE_FILE_NAME as B, ALL_FEATURES as Bn, getFileSize as Bt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as C, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as Cn, fallbackLogger as Ct, FACTORYDROID_DIR as D, RULESYNC_MCP_RELATIVE_FILE_PATH as Dn, withWarnOnceScope as Dt, ChecksProcessor as E, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as En, resetRunWarningState as Et, CLAUDECODE_LOCAL_RULE_FILE_NAME as F, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Fn, createTempDirectory as Ft, RulesyncSubagentFrontmatterSchema as G, hasDeceptiveHiddenCharacters as Gn, isSymlink as Gt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as H, DEPRECATED_FEATURE_REPLACEMENTS as Hn, hasExecutableBit as Ht, CLAUDECODE_MEMORIES_DIR_NAME as I, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as In, directoryExists as It, RulesyncRule as J, stripControlCharacters as Jn, listSubdirectoryNames as Jt, RulesyncSkill as K, hasEnclosingMarkOutsideKeycap as Kn, listDirectoryEntryNames as Kt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as L, RULESYNC_USER_CONFIG_DIR_NAME as Ln, ensureDir as Lt, CODEXCLI_DIR as M, RULESYNC_RELATIVE_DIR_PATH as Mn, assertTreeContainsNoSymlinks as Mt, CLAUDECODE_AGENT_MEMORY_LOCAL_DIR_NAME as N, RULESYNC_RULES_RELATIVE_DIR_PATH as Nn, assertWritablePathInsideRoot as Nt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as O, RULESYNC_MCP_SCHEMA_URL as On, CLIError as Ot, CLAUDECODE_DIR as P, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Pn, checkPathTraversal as Pt, RulesyncIgnore as Q, removeDirectory as Qt, CLAUDECODE_SKILLS_DIR_PATH as R, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as Rn, fileExists as Rt, COMMANDCODE_DIR as S, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as Sn, WarningCollectingLogger as St, CODEBUDDY_LOCAL_RULE_FILE_NAME as T, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Tn, withFallbackLoggerTarget as Tt, getLocalSkillDirNames as U, formatError as Un, isFileNotFoundError as Ut, AUGMENTCODE_DIR as V, ALL_FEATURES_WITH_WILDCARD as Vn, getHomeDirectory as Vt, RulesyncSubagent as W, truncateText as Wn, isFileSystemError as Wt, RulesyncPermissions as X, stripHiddenCharacters as Xn, readFileContent as Xt, RulesyncRuleFrontmatterSchema as Y, stripControlCharactersKeepingLineFeeds as Yn, pathEscapesRoot as Yt, RulesyncMcp as Z, readFileContentOrNull as Zt, LETTACODE_DIR as _, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as _n, SourceEntrySchema as _t, getProcessorRegistryEntry as a, runWithDirectoryRollback as an, RulesyncCheck as at, CommandsProcessor as b, RULESYNC_CONFIG_RELATIVE_FILE_PATH as bn, ConsoleLogger as bt, RulesProcessor as c, writeFileBuffer as cn, loadYaml as ct, ELLIPSIS_WIDTH as d, ALL_TOOL_TARGETS_WITH_WILDCARD as dn, ConfigResolver as dt, removeFile as en, getRulesyncSourceCandidates as et, displayWidthOf as f, PACKAGING_TOOL_TARGETS as fn, mergeInputRootConfigs as ft, HooksProcessor as g, MAX_FILE_SIZE as gn, GITIGNORE_DESTINATION_KEY as gt, IgnoreProcessor as h, FEATURE_SOURCE_TREE_ENTRIES as hn, ConfigFileSchema as ht, inspectInputRoots as i, resolvedPathEscapesRoot as in, RulesyncCommandFrontmatterSchema as it, CODEXCLI_BASH_RULES_FILE_NAME as j, RULESYNC_PERMISSIONS_SCHEMA_URL as jn, assertDirectoryIfExists as jt, caseFoldIdentity as k, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as kn, ErrorCodes as kt, SubagentsProcessor as l, writeFileContent as ln, SHARED_USER_MANAGED_CONFIG_PATHS as lt, McpProcessor as m, CURATED_RULES_FEATURE_SUBDIR as mn, CONFLICTING_TARGET_PAIRS as mt, formatSourceLoadFailure as n, removeTempDirectory as nn, parseJsonc as nt, convertFromTool as o, splitPathSegments as on, RulesyncCheckFrontmatterSchema as ot, shortenToWidth as p, ToolTargetSchema as pn, resolveEffectiveInputRoots as pt, RulesyncSkillFrontmatterSchema as q, quoteForLog as qn, listFilePathsRecursively as qt, generate as r, resolvePath as rn, RulesyncCommand as rt, isPackagingToolTarget as s, toPosixPath as sn, stringifyFrontmatter as st, importFromTool as t, removeFileStrict as tn, resolveRulesyncSourceWritePath as tt, SkillsProcessor as u, ALL_TOOL_TARGETS as un, SKILL_FILE_NAME as ut, LETTACODE_SETTINGS_LOCAL_FILE_NAME as v, RULESYNC_CHECKS_RELATIVE_DIR_PATH as vn, assertTargetsFeaturesExclusive as vt, CODEBUDDY_DIR as w, RULESYNC_HOOKS_RELATIVE_FILE_PATH as wn, warnOnConflictingFlags as wt, REASONIX_LOCAL_RULE_FILE_NAME as x, RULESYNC_CONFIG_SCHEMA_URL as xn, JsonLogger as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as yn, findControlCharacter as yt, QWENCODE_DIR as z, parseCommaSeparatedList as zn, findFilesByGlobs as zt };
 
-//# sourceMappingURL=import-DgKWnDni.js.map
+//# sourceMappingURL=import-DFwX4TTE.js.map