rulesync 32.0.0 → 34.0.0

package/dist/{import-Bmb7ofrF.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"]
 			}
 		}
 	},
@@ -21766,22 +21847,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);
@@ -21800,7 +21888,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);
@@ -21823,7 +21911,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)) {
@@ -21833,6 +21921,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 (!(0, node_util.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*$/;
 /**
@@ -22264,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");
@@ -29638,6 +29881,11 @@ const CORTEXCODE_SPEC = {
 			canonical: "enabled",
 			tool: "enabled"
 		}],
+		stringPassthroughFields: [{
+			canonical: "statusMessage",
+			tool: "statusMessage",
+			commandOnly: true
+		}],
 		objectPassthroughFields: [{
 			canonical: "source",
 			tool: "source",
@@ -29652,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
@@ -30591,7 +30839,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"allowManagedHooksOnly",
 	"disabledSkills",
 	"modelPolicy",
-	"missionPolicy"
+	"missionPolicy",
+	"permissionRules"
 ];
 //#endregion
 //#region src/utils/factorydroid-settings.ts
@@ -30806,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 {
@@ -36460,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
 /**
@@ -43361,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({
@@ -43374,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({
@@ -43383,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 {
@@ -43473,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 {
@@ -45581,18 +45876,21 @@ var KiroMcp = class KiroMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/opencode-mcp.ts
+const OpencodeMcpV2DisabledSchema = zod_mini.z.optional(zod_mini.z.boolean());
 const OpencodeMcpLocalServerSchema = zod_mini.z.looseObject({
 	type: zod_mini.z.literal("local"),
 	command: zod_mini.z.array(zod_mini.z.string()),
 	environment: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
 	enabled: zod_mini.z._default(zod_mini.z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema,
 	cwd: zod_mini.z.optional(zod_mini.z.string())
 });
 const OpencodeMcpRemoteServerSchema = zod_mini.z.looseObject({
 	type: zod_mini.z.literal("remote"),
 	url: zod_mini.z.string(),
 	headers: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.string())),
-	enabled: zod_mini.z._default(zod_mini.z.boolean(), true)
+	enabled: zod_mini.z._default(zod_mini.z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema
 });
 const OPENCODE_PASSTHROUGH_SERVER_FIELDS = [
 	"timeout",
@@ -45604,7 +45902,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
@@ -45732,7 +46030,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
@@ -45812,9 +46110,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((0, jsonc_parser.parse)(this.fileContent || "{}"));
+		this.json = OpencodeConfigSchema.parse(this.constructor.lowerConfig((0, jsonc_parser.parse)(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;
@@ -45831,7 +46155,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 = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
 		let fileContent = null;
@@ -45853,7 +46177,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 }) {
@@ -45872,7 +46197,12 @@ var OpencodeMcp = class extends ToolMcp {
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
 		});
-		const existingMcp = OpencodeConfigSchema.safeParse((0, jsonc_parser.parse)(fileContent || "{}"));
+		const existingJson = (0, jsonc_parser.parse)(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,
@@ -45972,7 +46302,7 @@ var OpencodeMcp = class extends ToolMcp {
 	}
 	validate() {
 		const json = parseJsonc$6(this.fileContent || "{}");
-		const result = OpencodeConfigSchema.safeParse(json);
+		const result = OpencodeConfigSchema.safeParse(this.constructor.lowerConfig(json));
 		if (!result.success) return {
 			success: false,
 			error: result.error
@@ -46545,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.
@@ -46580,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;
@@ -46631,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;
 	}
@@ -46689,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;
@@ -46774,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 {
@@ -64568,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`.
 *
@@ -65230,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__";
@@ -65389,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) {
@@ -65430,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];
@@ -65446,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,
@@ -65467,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 {
@@ -84515,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();
@@ -84609,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
 */
@@ -88172,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.
@@ -88368,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", {
@@ -88377,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", {
@@ -88856,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();
@@ -88872,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)));
@@ -88886,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,
@@ -91762,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.
@@ -93399,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.
 *
@@ -93521,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
 		}];
 	}
@@ -95376,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 !== "");
@@ -95409,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 {
@@ -95437,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));
@@ -95469,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,
@@ -95488,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;
@@ -95507,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);
@@ -95555,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,
@@ -95562,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) {
@@ -97249,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: {
@@ -97679,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;
 });
@@ -97758,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
 		});
@@ -97992,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.`);
 		}
 	}
 	/**
@@ -102454,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() {
@@ -102610,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() {