rulesync 16.4.0 → 16.5.0

package/dist/{import-C9wxpZey.cjs → import-D87qlRUj.cjs}

@@ -15,7 +15,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -134,27 +134,27 @@ const isFeatureValueEnabled = (value) => {
 };
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$281 } = node_path.posix;
+const { join: join$282 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$281(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$281(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$282(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$282(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$281(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$282(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$281(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$281(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$282(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$282(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 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";
@@ -166,7 +166,7 @@ const RULESYNC_PERMISSIONS_LEGACY_FILE_NAME = "permissions.json";
 const RULESYNC_CONFIG_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/config-schema.json";
 const RULESYNC_MCP_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/mcp-schema.json";
 const RULESYNC_PERMISSIONS_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/permissions-schema.json";
-const MAX_FILE_SIZE = 10 * 1024 * 1024;
+const MAX_FILE_SIZE = 10485760;
 //#endregion
 //#region src/types/tool-target-tuples.ts
 const rulesProcessorToolTargetTuple = [
@@ -207,7 +207,8 @@ const rulesProcessorToolTargetTuple = [
 	"vibe",
 	"warp",
 	"devin",
-	"zed"
+	"zed",
+	"zoocode"
 ];
 const ignoreProcessorToolTargetTuple = [
 	"aiassistant",
@@ -229,7 +230,8 @@ const ignoreProcessorToolTargetTuple = [
 	"devin",
 	"vibe",
 	"warp",
-	"zed"
+	"zed",
+	"zoocode"
 ];
 const mcpProcessorToolTargetTuple = [
 	"aiassistant",
@@ -266,7 +268,8 @@ const mcpProcessorToolTargetTuple = [
 	"vibe",
 	"warp",
 	"devin",
-	"zed"
+	"zed",
+	"zoocode"
 ];
 const commandsProcessorToolTargetTuple = [
 	"agentsmd",
@@ -294,6 +297,7 @@ const commandsProcessorToolTargetTuple = [
 	"qwencode",
 	"reasonix",
 	"roo",
+	"zoocode",
 	"rovodev",
 	"takt",
 	"devin",
@@ -329,6 +333,7 @@ const subagentsProcessorToolTargetTuple = [
 	"qwencode",
 	"reasonix",
 	"roo",
+	"zoocode",
 	"rovodev",
 	"takt",
 	"vibe"
@@ -372,7 +377,8 @@ const skillsProcessorToolTargetTuple = [
 	"vibe",
 	"warp",
 	"devin",
-	"zed"
+	"zed",
+	"zoocode"
 ];
 const hooksProcessorToolTargetTuple = [
 	"amp",
@@ -685,7 +691,8 @@ async function findFilesByGlobs(globs, options = {}) {
 		onlyFiles: false,
 		onlyDirectories: false
 	};
-	const results = (0, globby.globbySync)(Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/"), {
+	const normalizedGlobs = Array.isArray(globs) ? globs.map((g) => g.replaceAll("\\", "/")) : globs.replaceAll("\\", "/");
+	const results = (0, globby.globbySync)(normalizedGlobs, {
 		absolute: true,
 		followSymbolicLinks,
 		...ignore ? { ignore: ignore.map((pattern) => pattern.replaceAll("\\", "/")) } : {},
@@ -796,7 +803,8 @@ function validateOutputRoot(outputRoot) {
 function toKebabCaseFilename(filename) {
 	const lastDotIndex = filename.lastIndexOf(".");
 	const extension = lastDotIndex > 0 ? filename.slice(lastDotIndex) : "";
-	return (0, es_toolkit.kebabCase)(lastDotIndex > 0 ? filename.slice(0, lastDotIndex) : filename) + extension;
+	const nameWithoutExt = lastDotIndex > 0 ? filename.slice(0, lastDotIndex) : filename;
+	return (0, es_toolkit.kebabCase)(nameWithoutExt) + extension;
 }
 /**
 * Create a temporary directory atomically and return its path.
@@ -1458,7 +1466,8 @@ const getDefaults = () => ({
 });
 const loadConfigFromFile = async (filePath) => {
 	if (!await fileExists(filePath)) return {};
-	const jsonData = (0, jsonc_parser.parse)(await readFileContent(filePath));
+	const fileContent = await readFileContent(filePath);
+	const jsonData = (0, jsonc_parser.parse)(fileContent);
 	const { $schema: _schema, ...configParams } = ConfigFileSchema.parse(jsonData);
 	assertTargetsFeaturesExclusive({
 		targets: configParams.targets,
@@ -1548,7 +1557,8 @@ var ConfigResolver = class {
 		if (inputRoot !== void 0) validateOutputRoot(inputRoot);
 		const validatedConfigPath = resolvePath(configPath, (0, node_path.resolve)(inputRoot ?? cwd));
 		const baseConfig = await loadConfigFromFile(validatedConfigPath);
-		const localConfigPath = (0, node_path.join)((0, node_path.dirname)(validatedConfigPath), RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+		const configDir = (0, node_path.dirname)(validatedConfigPath);
+		const localConfigPath = (0, node_path.join)(configDir, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
 		const localConfig = await loadConfigFromFile(localConfigPath);
 		const configByFile = mergeConfigs(baseConfig, localConfig);
 		if (inputRoot === void 0 && configByFile.inputRoot !== void 0) validateOutputRoot(configByFile.inputRoot);
@@ -1713,6 +1723,8 @@ const SHARED_USER_MANAGED_CONFIG_PATHS = [
 	".devin/config.json",
 	".factory/settings.json",
 	".grok/config.toml",
+	".rovodev/config.yml",
+	".rovodev/mcp.json",
 	".vibe/config.toml",
 	"reasonix.toml",
 	".vscode/settings.json",
@@ -1782,7 +1794,8 @@ var AiFile = class {
 	getFilePath() {
 		const fullPath = node_path.default.join(this.outputRoot, this.relativeDirPath, this.relativeFilePath);
 		const resolvedFull = (0, node_path.resolve)(fullPath);
-		const rel = (0, node_path.relative)((0, node_path.resolve)(this.outputRoot), resolvedFull);
+		const resolvedBase = (0, node_path.resolve)(this.outputRoot);
+		const rel = (0, node_path.relative)(resolvedBase, resolvedFull);
 		if (rel.startsWith("..") || node_path.default.isAbsolute(rel)) throw new Error(`Path traversal detected: Final path escapes outputRoot. outputRoot="${this.outputRoot}", relativeDirPath="${this.relativeDirPath}", relativeFilePath="${this.relativeFilePath}"`);
 		return fullPath;
 	}
@@ -2350,6 +2363,7 @@ const OPENCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"stop",
 	"afterFileEdit",
+	"beforeShellExecution",
 	"afterShellExecution",
 	"permissionRequest",
 	"preCompact",
@@ -3055,7 +3069,6 @@ const CANONICAL_TO_OPENCODE_EVENT_NAMES = {
 	postToolUse: "tool.execute.after",
 	stop: "session.idle",
 	afterFileEdit: "file.edited",
-	afterShellExecution: "command.executed",
 	permissionRequest: "permission.asked",
 	preCompact: "experimental.session.compacting",
 	postCompact: "session.compacted",
@@ -4122,10 +4135,22 @@ const ClaudecodePermissionsOverrideSchema = zod_mini.z.looseObject({
 * category; the shared `permission` block still drives the base permission and
 * allow/deny lists. Keyed by canonical category (e.g. `bash`, `edit`).
 *
+* Vibe's top-level `enabled_tools` is an **exclusive** allowlist — when set,
+* only the listed tools (name or pattern) are active and every other builtin
+* and MCP tool is off. That narrowing cannot be derived from canonical `allow`
+* rules (an allow grants one tool without revoking the rest), so the list is
+* only ever authored explicitly here, verbatim in Vibe's tool-name vocabulary,
+* and round-trips through this override on import.
+*
 * @example
 * { "permission": { "bash": { "sensitive_patterns": ["rm *", "sudo *"] } } }
+* @example
+* { "enabled_tools": ["bash", "read_file", "grep"] }
 */
-const VibePermissionsOverrideSchema = zod_mini.z.looseObject({ permission: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.looseObject({ sensitive_patterns: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) }))) });
+const VibePermissionsOverrideSchema = zod_mini.z.looseObject({
+	permission: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), zod_mini.z.looseObject({ sensitive_patterns: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) }))),
+	enabled_tools: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
 /**
 * Tool-scoped override block for Cursor CLI. Cursor's `cli.json` carries scalar
 * autonomy settings with no canonical permission category — `approvalMode`
@@ -4197,7 +4222,10 @@ const QwencodePermissionsOverrideSchema = zod_mini.z.looseObject({
 const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	sandbox: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	agent: zod_mini.z.optional(zod_mini.z.looseObject({}))
+	agent: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	rawAllow: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	rawAsk: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	rawDeny: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
 /**
 * Tool-scoped override block for Factory Droid. Factory Droid's `settings.json`
@@ -4228,12 +4256,69 @@ const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
 * `agent_mode_execute_readonly_commands` (a read-only auto-execution boolean).
 * Fields placed here are merged into `[agents.profiles]` of Warp's global
 * `settings.toml`, while the shared `permission` block continues to drive the
-* `agent_mode_command_execution_allowlist`/`_denylist` command regex arrays.
-* Warp permissions are global-only.
+* command regex arrays (legacy `agent_mode_command_execution_allowlist`/
+* `_denylist` plus the `default` execution profile's `command_allowlist`/
+* `command_denylist`). On migrated installs the `[agents.profiles]` keys are
+* inert; their execution-profile counterparts are authored via the nested
+* `execution_profile` block instead, which is merged into the `default` record
+* of `[agents.execution_profiles.<id>]`. Warp permissions are global-only.
 *
 * @example
-* { "agent_mode_coding_permissions": "always_allow_reading", "agent_mode_execute_readonly_commands": true }
+* {
+*   "agent_mode_coding_permissions": "always_allow_reading",
+*   "agent_mode_execute_readonly_commands": true,
+*   "execution_profile": { "read_files": "always_allow", "mcp_denylist": ["untrusted-server"] }
+* }
+*/
+/**
+* Per-action autonomy value of Warp's execution profiles
+* (`FileActionPermission` in the Warp repository's
+* `app/src/ai/execution_profiles/config.rs`, serialized snake_case).
 */
+const WarpFileActionPermissionSchema = zod_mini.z.enum([
+	"agent_decides",
+	"always_allow",
+	"always_ask"
+]);
+/**
+* Permission keys of the `default` record in Warp's
+* `[agents.execution_profiles.<id>]` collection (the surface runtime
+* enforcement reads on migrated installs). Loose so forward-compat keys pass
+* through verbatim. The rulesync-owned `command_allowlist`/`command_denylist`
+* are driven by the shared `permission.bash` block and always win over values
+* placed here.
+*
+* @see https://github.com/warpdotdev/warp/blob/main/app/src/ai/execution_profiles/config.rs (`ExecutionProfileFile`)
+*/
+const WarpExecutionProfileOverrideSchema = zod_mini.z.looseObject({
+	read_files: zod_mini.z.optional(WarpFileActionPermissionSchema),
+	apply_code_diffs: zod_mini.z.optional(WarpFileActionPermissionSchema),
+	execute_commands: zod_mini.z.optional(WarpFileActionPermissionSchema),
+	mcp_permissions: zod_mini.z.optional(WarpFileActionPermissionSchema),
+	write_to_pty: zod_mini.z.optional(zod_mini.z.enum([
+		"always_allow",
+		"always_ask",
+		"ask_on_first_write"
+	])),
+	ask_user_question: zod_mini.z.optional(zod_mini.z.enum([
+		"never",
+		"ask_except_in_auto_approve",
+		"always_ask"
+	])),
+	run_agents: zod_mini.z.optional(zod_mini.z.enum([
+		"never_allow",
+		"always_allow",
+		"always_ask"
+	])),
+	computer_use: zod_mini.z.optional(zod_mini.z.enum([
+		"never",
+		"always_ask",
+		"always_allow"
+	])),
+	directory_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	mcp_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	mcp_denylist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+});
 const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	agent_mode_coding_permissions: zod_mini.z.optional(zod_mini.z.enum([
@@ -4242,7 +4327,8 @@ const WarpPermissionsOverrideSchema = zod_mini.z.looseObject({
 		"allow_reading_specific_files"
 	])),
 	agent_mode_coding_file_read_allowlist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
-	agent_mode_execute_readonly_commands: zod_mini.z.optional(zod_mini.z.boolean())
+	agent_mode_execute_readonly_commands: zod_mini.z.optional(zod_mini.z.boolean()),
+	execution_profile: zod_mini.z.optional(WarpExecutionProfileOverrideSchema)
 });
 /**
 * The actions Junie's allowlist accepts. Verified against the shipped Junie
@@ -4974,7 +5060,8 @@ var AiDir = class {
 	getDirPath() {
 		const fullPath = node_path.default.join(this.outputRoot, this.relativeDirPath, this.dirName);
 		const resolvedFull = (0, node_path.resolve)(fullPath);
-		const rel = (0, node_path.relative)((0, node_path.resolve)(this.outputRoot), resolvedFull);
+		const resolvedBase = (0, node_path.resolve)(this.outputRoot);
+		const rel = (0, node_path.relative)(resolvedBase, resolvedFull);
 		if (rel.startsWith("..") || node_path.default.isAbsolute(rel)) throw new Error(`Path traversal detected: Final path escapes outputRoot. outputRoot="${this.outputRoot}", relativeDirPath="${this.relativeDirPath}", dirName="${this.dirName}"`);
 		return fullPath;
 	}
@@ -5257,6 +5344,9 @@ const RulesyncSubagentFrontmatterSchema = zod_mini.z.looseObject({
 		customInstructions: zod_mini.z.optional(zod_mini.z.string()),
 		groups: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.unknown()))
 	})),
+	zoocode: zod_mini.z.optional(zod_mini.z.looseObject({ 
+	/** Per-mode MCP server allowlist (Zoo Code v3.60.0+); omitted = all. */
+allowedMcpServers: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())) })),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({
 		agent_type: zod_mini.z.optional(zod_mini.z.enum(["agent", "subagent"])),
 		display_name: zod_mini.z.optional(zod_mini.z.string()),
@@ -5396,7 +5486,6 @@ const ROVODEV_SKILLS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "skills");
 const ROVODEV_SUBAGENTS_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, "subagents");
 const ROVODEV_MODULAR_RULES_DIR_PATH = (0, node_path.join)(ROVODEV_DIR, ".rulesync", "modular-rules");
 const ROVODEV_RULE_FILE_NAME = "AGENTS.md";
-const ROVODEV_LEGACY_RULE_FILE_NAME = "AGENTS.local.md";
 const ROVODEV_MCP_FILE_NAME = "mcp.json";
 const ROVODEV_CONFIG_FILE_NAME = "config.yml";
 const ROVODEV_AGENTS_SKILLS_DIR_PATH = (0, node_path.join)(".agents", "skills");
@@ -6615,6 +6704,7 @@ const KIMI_CODE_CONFIG_SHARED_FILE_KEY = ".kimi-code/config.toml";
 const KIMI_CODE_HOME_CONFIG_SHARED_FILE_KEY = "config.toml";
 const REASONIX_PROJECT_CONFIG_SHARED_FILE_KEY = "reasonix.toml";
 const REASONIX_GLOBAL_CONFIG_SHARED_FILE_KEY = ".reasonix/config.toml";
+const ROVODEV_CONFIG_SHARED_FILE_KEY = ".rovodev/config.yml";
 /**
 * Build the `SHARED_CONFIG_OWNERSHIP` lookup key from a tool's settable paths.
 * Mirrors `sharedFileKey` in `src/lib/shared-file-derive.ts` (kept separate so
@@ -6954,6 +7044,10 @@ const SHARED_CONFIG_OWNERSHIP = {
 			permissions: {
 				kind: "replace-owned-keys",
 				ownedKeys: ["permission"]
+			},
+			rules: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["instructions"]
 			}
 		}
 	},
@@ -7071,6 +7165,19 @@ const SHARED_CONFIG_OWNERSHIP = {
 				]
 			}
 		}
+	},
+	[ROVODEV_CONFIG_SHARED_FILE_KEY]: {
+		format: "yaml",
+		features: {
+			mcp: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["mcp"]
+			},
+			permissions: {
+				kind: "replace-owned-keys",
+				ownedKeys: ["toolPermissions"]
+			}
+		}
 	}
 };
 /**
@@ -7492,7 +7599,8 @@ const toolCheckFactories = /* @__PURE__ */ new Map([
 		class: CursorCheck,
 		meta: {
 			supportsGlobal: false,
-			filePattern: CURSOR_BUGBOT_FILE_NAME
+			filePattern: CURSOR_BUGBOT_FILE_NAME,
+			committedOutput: true
 		}
 	}],
 	["hermesagent", {
@@ -7506,7 +7614,8 @@ const toolCheckFactories = /* @__PURE__ */ new Map([
 		class: RovodevCheck,
 		meta: {
 			supportsGlobal: false,
-			filePattern: ROVODEV_REVIEW_AGENT_FILE_NAME
+			filePattern: ROVODEV_REVIEW_AGENT_FILE_NAME,
+			committedOutput: true
 		}
 	}],
 	["takt", {
@@ -9668,7 +9777,8 @@ var GrokcliCommand = class GrokcliCommand extends ToolCommand {
 	static async validateRulesyncCommands({ inputRoot, rulesyncCommands, logger }) {
 		const commandNames = new Set(rulesyncCommands.filter((command) => this.isTargetedByRulesyncCommand(command)).map((command) => (0, node_path.basename)(command.getRelativeFilePath(), ".md")));
 		if (commandNames.size === 0) return;
-		const shadowed = (await findFilesByGlobs((0, node_path.join)((0, node_path.join)(inputRoot, RULESYNC_SKILLS_RELATIVE_DIR_PATH), "**", "SKILL.md"))).map((filePath) => (0, node_path.basename)((0, node_path.dirname)(filePath))).filter((skillName) => commandNames.has(skillName));
+		const skillsRoot = (0, node_path.join)(inputRoot, RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+		const shadowed = (await findFilesByGlobs((0, node_path.join)(skillsRoot, "**", "SKILL.md"))).map((filePath) => (0, node_path.basename)((0, node_path.dirname)(filePath))).filter((skillName) => commandNames.has(skillName));
 		if (shadowed.length > 0) logger.warn(`Grok CLI resolves skills before commands, so these skills shadow the same-named commands, which will never be reachable: ${[...new Set(shadowed)].toSorted().join(", ")}. Rename either side to make both invocable.`);
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
@@ -9703,6 +9813,20 @@ var GrokcliCommand = class GrokcliCommand extends ToolCommand {
 function toolSkillSearchRoots(paths) {
 	return [paths.relativeDirPath, ...paths.alternativeSkillRoots ?? []];
 }
+/**
+* The Agent Skills interoperability roots: project `.agents/skills/`, global
+* `~/.agents/skills/` (same relative path, home output root), and Amp's global
+* equivalent `~/.config/agents/skills/`. Foreign-authored — potentially
+* non-conformant — skills are the most likely to live here, so every tool that
+* scans one of these roots imports it leniently (skip-and-warn per skill), per
+* the Agent Skills client-implementation guide, while keeping fail-fast
+* behavior for its own native root.
+* https://agentskills.io/client-implementation/adding-skills-support
+*/
+const AGENT_SKILLS_INTEROP_ROOTS = /* @__PURE__ */ new Set([toPosixPath(AGENTSMD_SKILLS_DIR_PATH), toPosixPath(AMP_SKILLS_GLOBAL_DIR)]);
+function isAgentSkillsInteropRoot(relativeDirPath) {
+	return AGENT_SKILLS_INTEROP_ROOTS.has(toPosixPath(relativeDirPath));
+}
 /** Ordered import roots: managed roots first, followed by read-only discovery roots. */
 function toolSkillImportRoots(paths) {
 	return [...toolSkillSearchRoots(paths), ...paths.importOnlySkillRoots ?? []];
@@ -11646,7 +11770,7 @@ var RooCommand = class RooCommand extends ToolCommand {
 		};
 		const body = rulesyncCommand.getBody();
 		const fileContent = stringifyFrontmatter(body, rooFrontmatter);
-		return new RooCommand({
+		return new this({
 			outputRoot,
 			frontmatter: rooFrontmatter,
 			body,
@@ -11683,7 +11807,7 @@ var RooCommand = class RooCommand extends ToolCommand {
 		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
 		const result = RooCommandFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
-		return new RooCommand({
+		return new this({
 			outputRoot,
 			relativeDirPath: RooCommand.getSettablePaths().relativeDirPath,
 			relativeFilePath,
@@ -11694,7 +11818,7 @@ var RooCommand = class RooCommand extends ToolCommand {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new RooCommand({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
@@ -12152,6 +12276,39 @@ var WarpCommand = class WarpCommand extends ToolCommand {
 	}
 };
 //#endregion
+//#region src/features/commands/zoocode-command.ts
+/**
+* Command generator for **Zoo Code** (the community continuation of Roo Code).
+* Zoo Code keeps Roo's `.roo/commands/` layout, so this target reuses
+* {@link RooCommand} verbatim and only narrows the targeting.
+*
+* @see https://docs.zoocode.dev
+*/
+var ZoocodeCommand = class extends RooCommand {
+	static isTargetedByRulesyncCommand(rulesyncCommand) {
+		return this.isTargetedByRulesyncCommandDefault({
+			rulesyncCommand,
+			toolTarget: "zoocode"
+		});
+	}
+	toRulesyncCommand() {
+		const command = super.toRulesyncCommand();
+		const frontmatter = {
+			...command.getFrontmatter(),
+			targets: ["zoocode"]
+		};
+		return new RulesyncCommand({
+			outputRoot: command.getOutputRoot(),
+			relativeDirPath: command.getRelativeDirPath(),
+			relativeFilePath: command.getRelativeFilePath(),
+			frontmatter,
+			body: command.getBody(),
+			fileContent: stringifyFrontmatter(command.getBody(), frontmatter),
+			validate: true
+		});
+	}
+};
+//#endregion
 //#region src/features/commands/commands-processor.ts
 const CommandsProcessorToolTargetSchema = zod_mini.z.enum(commandsProcessorToolTargetTuple);
 /**
@@ -12411,6 +12568,16 @@ const toolCommandFactories = /* @__PURE__ */ new Map([
 			supportsSubdirectory: true
 		}
 	}],
+	["zoocode", {
+		class: ZoocodeCommand,
+		meta: {
+			extension: "md",
+			supportsProject: true,
+			supportsGlobal: true,
+			isSimulated: false,
+			supportsSubdirectory: true
+		}
+	}],
 	["rovodev", {
 		class: RovodevCommand,
 		meta: {
@@ -13790,16 +13957,17 @@ var ClaudecodeHooks = class extends ToolHooks {
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
 		const config = rulesyncHooks.getJson();
+		const claudeHooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.claudecode?.hooks,
+			converterConfig: CLAUDE_CONVERTER_CONFIG,
+			logger
+		});
 		const fileContent = applySharedConfigPatch({
 			fileKey: CLAUDE_SETTINGS_SHARED_FILE_KEY,
 			feature: "hooks",
 			existingContent,
-			patch: { hooks: canonicalToToolHooks({
-				config,
-				toolOverrideHooks: config.claudecode?.hooks,
-				converterConfig: CLAUDE_CONVERTER_CONFIG,
-				logger
-			}) },
+			patch: { hooks: claudeHooks },
 			filePath
 		});
 		return new this({
@@ -15553,6 +15721,30 @@ const NAMED_HOOK_MATCHER_SUBJECTS = {
 	"tool.execute.after": "input.tool",
 	"experimental.session.compacting": null
 };
+/**
+* OpenCode (and Kilo) have no shell-execution lifecycle event — the
+* `command.executed` event these canonical events were once mapped to is a
+* *slash-command* event, so a hook wired there never fired on bash commands
+* and fired on every slash command instead. Observing a shell invocation is
+* done with the named `tool.execute.before/after` hooks gated on the `bash`
+* tool (the `.env protection` pattern in the OpenCode plugins doc), so these
+* canonical events are emitted into those named hooks with an implicit
+* `input.tool === "bash"` gate. Matchers on them are dropped upstream with a
+* warning (`matcherEvents` covers only `preToolUse`/`postToolUse`) — the
+* named hooks expose no command text to match against.
+*
+* @see https://opencode.ai/docs/plugins/
+*/
+const SHELL_EVENT_TOOL_GATES = {
+	beforeShellExecution: {
+		toolEvent: "tool.execute.before",
+		tool: "bash"
+	},
+	afterShellExecution: {
+		toolEvent: "tool.execute.after",
+		tool: "bash"
+	}
+};
 function escapeForTemplateLiteral(command) {
 	return command.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
@@ -15573,15 +15765,19 @@ function validateAndSanitizeMatcher(matcher) {
 */
 function collectOpencodeStyleHandlers({ effectiveHooks, eventMap, namedEventHandlers, genericEventHandlers }) {
 	for (const [canonicalEvent, definitions] of Object.entries(effectiveHooks)) {
-		const toolEvent = eventMap[canonicalEvent];
+		const shellGate = SHELL_EVENT_TOOL_GATES[canonicalEvent];
+		const toolEvent = shellGate?.toolEvent ?? eventMap[canonicalEvent];
 		if (!toolEvent) continue;
+		const matcherSupported = !shellGate && Object.hasOwn(NAMED_HOOK_MATCHER_SUBJECTS, toolEvent) && NAMED_HOOK_MATCHER_SUBJECTS[toolEvent] !== null;
 		const handlers = [];
 		for (const def of definitions) {
 			if ((def.type ?? "command") !== "command") continue;
 			if (!def.command) continue;
+			if (def.matcher && !matcherSupported) continue;
 			handlers.push({
 				command: def.command,
-				matcher: def.matcher ? def.matcher : void 0
+				matcher: def.matcher ? def.matcher : void 0,
+				...shellGate ? { toolGate: shellGate.tool } : {}
 			});
 		}
 		if (handlers.length > 0) {
@@ -15618,7 +15814,11 @@ function buildNamedEventBodyLines(namedEventHandlers) {
 		bodyLines.push(`    "${eventName}": async (input) => {`);
 		for (const handler of handlers) {
 			const escapedCommand = escapeForTemplateLiteral(handler.command);
-			if (handler.matcher && matcherSubject !== null) {
+			if (handler.toolGate) {
+				bodyLines.push(`      if (input.tool === "${handler.toolGate}") {`);
+				bodyLines.push(`        await $\`${escapedCommand}\`;`);
+				bodyLines.push("      }");
+			} else if (handler.matcher && matcherSubject !== null) {
 				const safeMatcher = validateAndSanitizeMatcher(handler.matcher);
 				bodyLines.push("      {");
 				bodyLines.push(`        const __re = new RegExp("${safeMatcher}");`);
@@ -17348,7 +17548,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		},
 		supportedEvents: KILO_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
-		supportsMatcher: true
+		supportsMatcher: true,
+		matcherEvents: ["preToolUse", "postToolUse"]
 	}],
 	["opencode", {
 		class: OpencodeHooks,
@@ -17359,7 +17560,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		},
 		supportedEvents: OPENCODE_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
-		supportsMatcher: true
+		supportsMatcher: true,
+		matcherEvents: ["preToolUse", "postToolUse"]
 	}],
 	["pi", {
 		class: PiHooks,
@@ -19033,6 +19235,7 @@ const toolIgnoreFactories = /* @__PURE__ */ new Map([
 	["qwencode", { class: QwencodeIgnore }],
 	["reasonix", { class: ReasonixIgnore }],
 	["roo", { class: RooIgnore }],
+	["zoocode", { class: RooIgnore }],
 	["devin", { class: DevinIgnore }],
 	["vibe", { class: VibeIgnore }],
 	["warp", { class: WarpIgnore }],
@@ -20402,7 +20605,6 @@ const resolveCopilotcliServerType = (server) => {
 		case "streamable-http": return "http";
 		case "stdio":
 		case "local": return declared;
-		default: break;
 	}
 	if (server.command !== void 0) return "stdio";
 	return isRemoteMcpServer(server) ? "http" : "stdio";
@@ -22175,9 +22377,12 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = KILO_JSON_FILE_NAME;
 		}
+		if (instructions.length === 0 && fileContent === null) return null;
 		const json = fileContent ? (0, jsonc_parser.parse)(fileContent) : {};
 		const existingInstructions = Array.isArray(json.instructions) ? json.instructions.filter((entry) => typeof entry === "string") : [];
-		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...existingInstructions, ...instructions])).toSorted();
+		const managedPrefix = `${toPosixPath((0, node_path.join)(KILO_DIR, KILO_RULES_DIR_NAME))}/`;
+		const preservedInstructions = existingInstructions.filter((entry) => !toPosixPath(entry).replace(/^\.\//, "").startsWith(managedPrefix));
+		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...preservedInstructions, ...instructions])).toSorted();
 		return new KiloMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -22186,7 +22391,7 @@ var KiloMcp = class KiloMcp extends ToolMcp {
 				fileKey: sharedConfigFileKey(basePaths),
 				feature: "rules",
 				existingContent: fileContent ?? "",
-				patch: { instructions: mergedInstructions },
+				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
 				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
 			}),
 			validate
@@ -22908,6 +23113,8 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 	static async fromInstructions({ outputRoot = process.cwd(), instructions, validate = true, global = false }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = (0, node_path.join)(outputRoot, basePaths.relativeDirPath);
+		const configDirPrefix = `${toPosixPath(basePaths.relativeDirPath).replace(/\/+$/, "")}/`;
+		const normalizedInstructions = instructions.map((path) => global && path.startsWith(configDirPrefix) ? path.slice(configDirPrefix.length) : path);
 		let fileContent = null;
 		let relativeFilePath = OPENCODE_JSONC_FILE_NAME;
 		const jsoncPath = (0, node_path.join)(jsonDir, OPENCODE_JSONC_FILE_NAME);
@@ -22917,9 +23124,15 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 			fileContent = await readFileContentOrNull(jsonPath);
 			if (fileContent) relativeFilePath = OPENCODE_JSON_FILE_NAME;
 		}
+		if (instructions.length === 0 && fileContent === null) return null;
 		const json = fileContent ? (0, jsonc_parser.parse)(fileContent) : {};
 		const existingInstructions = Array.isArray(json.instructions) ? json.instructions.filter((entry) => typeof entry === "string") : [];
-		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...existingInstructions, ...instructions])).toSorted();
+		const managedPrefixes = global ? ["memories/", `${configDirPrefix}memories/`] : [`${toPosixPath(OPENCODE_DIR)}/memories/`];
+		const preservedInstructions = existingInstructions.filter((entry) => {
+			const normalized = toPosixPath(entry).replace(/^\.\//, "");
+			return !managedPrefixes.some((prefix) => normalized.startsWith(prefix));
+		});
+		const mergedInstructions = Array.from(/* @__PURE__ */ new Set([...preservedInstructions, ...normalizedInstructions])).toSorted();
 		return new OpencodeMcp({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -22928,7 +23141,7 @@ var OpencodeMcp = class OpencodeMcp extends ToolMcp {
 				fileKey: sharedConfigFileKey(basePaths),
 				feature: "rules",
 				existingContent: fileContent ?? "",
-				patch: { instructions: mergedInstructions },
+				patch: { instructions: mergedInstructions.length > 0 ? mergedInstructions : void 0 },
 				filePath: (0, node_path.join)(jsonDir, relativeFilePath)
 			}),
 			validate
@@ -23368,9 +23581,13 @@ function parseRovodevMcpJson(fileContent, relativeDirPath, relativeFilePath) {
 	return parsed;
 }
 /**
-* Rovodev MCP: global only at ~/.rovodev/mcp.json.
-* Same shape as Cursor: { mcpServers: { ... } }. See Rovodev MCP docs.
-* Project-level MCP is not supported; use --global when generating.
+* Rovodev MCP: `~/.rovodev/mcp.json` (global) and the repo-committed project
+* `.rovodev/mcp.json` documented by the Bitbucket Cloud Agentic Pipelines
+* guide ("Register your MCP server in `.rovodev/mcp.json`", referenced via
+* `mcp.mcpConfigPath`). Same shape as Cursor: { mcpServers: { ... } }.
+* A server the canonical config marks `disabled: true` is still written here
+* and switched off through `mcp.disabledMcpServers` in the sibling
+* `config.yml` — the file Rovo Dev actually consults for disabling.
 */
 /**
 * Rovo Dev documents the per-server transport key as `transport`, with the
@@ -23396,11 +23613,7 @@ function lookupTransport(map, key) {
 	return Object.hasOwn(map, key) ? map[key] : void 0;
 }
 function toRovodevServer(name, server, logger) {
-	const { type, transport, disabled, ...rest } = server;
-	if (disabled === true) {
-		logger?.warn(`Rovo Dev MCP: skipping "${name}" because it is disabled and mcp.json has no disable flag.`);
-		return null;
-	}
+	const { type, transport, disabled: _disabled, ...rest } = server;
 	const declared = typeof transport === "string" ? transport : typeof type === "string" ? type : void 0;
 	if (declared === void 0) return rest;
 	const mapped = lookupTransport(CANONICAL_TO_ROVODEV_TRANSPORT, declared);
@@ -23422,6 +23635,44 @@ function fromRovodevServer(server) {
 		type: mapped
 	};
 }
+/**
+* Read the sibling `config.yml` (same scope root as `mcp.json`) and return the
+* parsed document, `null` when the file does not exist. A malformed file
+* **throws**: the disable toggle lives here, so pretending a broken file says
+* nothing would silently re-enable servers on import and leave disabled ones
+* running on generate — both flip a security toggle the wrong way.
+*/
+async function readRovodevConfigYaml({ outputRoot }) {
+	const content = await readFileContentOrNull((0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_CONFIG_FILE_NAME));
+	if (content === null) return null;
+	return parseSharedConfig({
+		format: "yaml",
+		fileContent: content,
+		filePath: (0, node_path.join)(ROVODEV_DIR, ROVODEV_CONFIG_FILE_NAME)
+	});
+}
+function disabledNamesOf(config) {
+	const mcpBlock = config && isRecord(config.mcp) ? config.mcp : {};
+	return isStringArray$1(mcpBlock.disabledMcpServers) ? mcpBlock.disabledMcpServers : [];
+}
+/**
+* Auxiliary writer for the `mcp:` block of `.rovodev/config.yml` (project) /
+* `~/.rovodev/config.yml` (global). Carries `disabledMcpServers` — the key
+* Rovo Dev actually consults to switch a server off — recomputed from the
+* existing block so user keys (`mcpConfigPath`, `allowedMcpServers`, ...) and
+* disabled names for servers rulesync does not manage survive.
+*/
+var RovodevMcpConfigYaml = class extends ToolFile {
+	isDeletable() {
+		return false;
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+};
 var RovodevMcp = class RovodevMcp extends ToolMcp {
 	json;
 	constructor(params) {
@@ -23442,13 +23693,24 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error("Rovodev MCP is global-only; use --global to sync ~/.rovodev/mcp.json");
 		const paths = this.getSettablePaths({ global });
 		const json = parseRovodevMcpJson(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"mcpServers\":{}}", paths.relativeDirPath, paths.relativeFilePath);
 		const newJson = {
 			...json,
 			mcpServers: json.mcpServers ?? {}
 		};
+		const disabledNames = disabledNamesOf(await readRovodevConfigYaml({ outputRoot }));
+		if (disabledNames.length > 0 && isMcpServers(newJson.mcpServers)) {
+			const servers = newJson.mcpServers;
+			for (const name of disabledNames) {
+				if (!Object.hasOwn(servers, name)) continue;
+				const server = servers[name];
+				if (isPlainObject$1(server)) servers[name] = {
+					...server,
+					disabled: true
+				};
+			}
+		}
 		return new RovodevMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -23459,11 +23721,21 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 		});
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
-		if (!global) throw new Error("Rovodev MCP is global-only; use --global to sync ~/.rovodev/mcp.json");
 		const paths = this.getSettablePaths({ global });
 		const json = parseRovodevMcpJson(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2), paths.relativeDirPath, paths.relativeFilePath);
+		let canWriteDisableToggle = true;
+		try {
+			await readRovodevConfigYaml({ outputRoot });
+		} catch {
+			canWriteDisableToggle = false;
+		}
 		const mcpServers = Object.fromEntries(Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => {
-			const converted = toRovodevServer(name, server, logger);
+			const record = server;
+			if (record.disabled === true && !canWriteDisableToggle) {
+				logger?.warn(`Rovo Dev MCP: skipping disabled server "${name}" because config.yml cannot be parsed, so mcp.disabledMcpServers cannot be written to switch it off.`);
+				return null;
+			}
+			const converted = toRovodevServer(name, record, logger);
 			return converted === null ? null : [name, converted];
 		}).filter((entry) => entry !== null));
 		const rovodevConfig = {
@@ -23479,6 +23751,64 @@ var RovodevMcp = class RovodevMcp extends ToolMcp {
 			global
 		});
 	}
+	/**
+	* `mcp.disabledMcpServers` lives in the shared `config.yml` the permissions
+	* feature also writes. Declared here so the write-order derivation sees this
+	* feature as one of that file's writers — it is not a settable path, since
+	* the servers themselves live in `mcp.json`.
+	*/
+	static getExtraSharedWritePaths() {
+		return [{
+			relativeDirPath: ROVODEV_DIR,
+			relativeFilePath: ROVODEV_CONFIG_FILE_NAME
+		}];
+	}
+	static async getAuxiliaryFiles({ outputRoot = process.cwd(), global = false, rulesyncMcp, logger }) {
+		const servers = rulesyncMcp.forTarget({
+			toolTarget: "rovodev",
+			logger
+		}).getMcpServers();
+		const managedNames = Object.keys(servers).filter((name) => toRovodevServer(name, servers[name]) !== null);
+		const disabledNames = managedNames.filter((name) => {
+			const server = servers[name];
+			return isRecord(server) && server.disabled === true;
+		});
+		const existingContent = await readFileContentOrNull((0, node_path.join)(outputRoot, ROVODEV_DIR, ROVODEV_CONFIG_FILE_NAME)) ?? "";
+		let existingParsed;
+		try {
+			existingParsed = parseSharedConfig({
+				format: "yaml",
+				fileContent: existingContent,
+				filePath: (0, node_path.join)(ROVODEV_DIR, ROVODEV_CONFIG_FILE_NAME)
+			});
+		} catch (error) {
+			logger?.warn(`Skipping the Rovo Dev mcp.disabledMcpServers update: ${formatError(error)}`);
+			return [];
+		}
+		const existingMcp = isRecord(existingParsed.mcp) ? { ...existingParsed.mcp } : {};
+		const existingDisabled = isStringArray$1(existingMcp.disabledMcpServers) ? existingMcp.disabledMcpServers : [];
+		const managedNameSet = new Set(managedNames);
+		const reEnabled = existingDisabled.filter((name) => managedNameSet.has(name) && !disabledNames.includes(name));
+		if (reEnabled.length > 0) logger?.warn(`Rovo Dev MCP: re-enabling ${reEnabled.join(", ")} — the canonical config does not mark ${reEnabled.length === 1 ? "it" : "them"} disabled. Set "disabled": true in .rulesync/mcp.jsonc to keep a managed server off.`);
+		const mergedDisabled = [...existingDisabled.filter((name) => !managedNameSet.has(name)), ...disabledNames].toSorted();
+		if (mergedDisabled.length > 0) existingMcp.disabledMcpServers = mergedDisabled;
+		else delete existingMcp.disabledMcpServers;
+		if (mergedDisabled.length === 0 && existingContent.trim() === "") return [];
+		const fileContent = applySharedConfigPatch({
+			fileKey: ROVODEV_CONFIG_SHARED_FILE_KEY,
+			feature: "mcp",
+			existingContent,
+			patch: { mcp: Object.keys(existingMcp).length > 0 ? existingMcp : void 0 },
+			filePath: (0, node_path.join)(ROVODEV_DIR, ROVODEV_CONFIG_FILE_NAME)
+		});
+		return [new RovodevMcpConfigYaml({
+			outputRoot,
+			relativeDirPath: ROVODEV_DIR,
+			relativeFilePath: ROVODEV_CONFIG_FILE_NAME,
+			fileContent,
+			global
+		})];
+	}
 	toRulesyncMcp() {
 		const rawServers = isMcpServers(this.json.mcpServers) ? this.json.mcpServers : {};
 		const mcpServers = Object.fromEntries(Object.entries(rawServers).filter(([, server]) => isPlainObject$1(server)).map(([name, server]) => [name, fromRovodevServer(server)]));
@@ -23627,7 +23957,6 @@ function transportOf(server) {
 		case "http":
 		case "streamable-http":
 		case "ws": return "http";
-		default: break;
 	}
 	if (server.command !== void 0) return "stdio";
 	if (server.url !== void 0 || server.httpUrl !== void 0) return "http";
@@ -23655,6 +23984,20 @@ function deriveTransportAllowlist(servers) {
 	return allowlist;
 }
 //#endregion
+//#region src/features/shared/vibe-config-scope.ts
+/**
+* Vibe selects exactly **one** persistence TOML and does not merge scopes: the
+* trusted project `.vibe/config.toml` when one is discovered, otherwise
+* `~/.vibe/config.toml` (single code path since v2.22.0's ConfigOrchestrator
+* migration). A `--global` run that writes the home file is therefore inert in
+* any project that has its own config — worth a heads-up, since the other Vibe
+* surfaces (rules, hooks, agents, skills) genuinely combine scopes.
+*/
+async function warnIfGlobalVibeConfigIsShadowed(logger) {
+	if (!await fileExists((0, node_path.join)(process.cwd(), ".vibe", "config.toml"))) return;
+	logger?.warn("Vibe reads exactly one config.toml (project .vibe/config.toml when present, otherwise ~/.vibe/config.toml — a fallback, not a merge). This project has .vibe/config.toml, so the global file written by --global is ignored here.");
+}
+//#endregion
 //#region src/features/mcp/vibe-mcp.ts
 const VIBE_MCP_SERVER_FIELDS = [
 	"transport",
@@ -23723,8 +24066,9 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 			global
 		});
 	}
-	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, logger, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		if (global) await warnIfGlobalVibeConfigIsShadowed(logger);
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		const existingServers = normalizeMcpServersArray(parseSharedConfig({
@@ -23733,7 +24077,10 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 			filePath
 		}).mcp_servers);
 		const existingByName = new Map(existingServers.map((server) => [server.name, server]));
-		const mcpServers = Object.entries(rulesyncMcp.getMcpServers()).map(([name, server]) => rulesyncMcpServerToVibe(name, server, existingByName.get(name)));
+		const rulesyncServers = rulesyncMcp.getMcpServers();
+		const managedNames = new Set(Object.keys(rulesyncServers));
+		const mcpServers = Object.entries(rulesyncServers).map(([name, server]) => rulesyncMcpServerToVibe(name, server, existingByName.get(name)));
+		const unmanagedServers = existingServers.filter((server) => !managedNames.has(server.name));
 		return new VibeMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -23742,7 +24089,7 @@ var VibeMcp = class VibeMcp extends ToolMcp {
 				fileKey: sharedConfigFileKey(paths),
 				feature: "mcp",
 				existingContent,
-				patch: { mcp_servers: mcpServers },
+				patch: { mcp_servers: [...mcpServers, ...unmanagedServers] },
 				filePath
 			}),
 			validate,
@@ -24444,10 +24791,19 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsDisabledTools: false
 		}
 	}],
+	["zoocode", {
+		class: RooMcp,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsEnabledTools: false,
+			supportsDisabledTools: false
+		}
+	}],
 	["rovodev", {
 		class: RovodevMcp,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
 			supportsDisabledTools: false
@@ -25313,9 +25669,7 @@ function convertRulesyncToAntigravityCliPermissions(config) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -25526,9 +25880,7 @@ function convertRulesyncToAntigravityIdePermissions(config) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -26260,9 +26612,7 @@ function convertRulesyncToClaudePermissions({ config, logger }) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -27512,9 +27862,7 @@ function convertRulesyncToCursorPermissions(config, logger) {
 				case "ask":
 					logger?.warn(`Cursor CLI permissions do not support the "ask" action. Skipping ${category} rule: ${pattern}`);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -27751,9 +28099,7 @@ function convertRulesyncToDevinPermissions(config) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -27941,10 +28287,7 @@ function convertRulesyncToFactorydroidPermissions({ config, logger }) {
 			case "allow":
 				allow.push(pattern);
 				break;
-			case "deny":
-				deny.push(pattern);
-				break;
-			case "ask": break;
+			case "deny": deny.push(pattern);
 		}
 	}
 	return {
@@ -28063,10 +28406,11 @@ var GoosePermissions = class GoosePermissions extends ToolPermissions {
 			throw new Error(`Failed to parse existing Goose permission.yaml at ${filePath}: ${formatError(error)}`, { cause: error });
 		}
 		const config = isRecord(parsed) ? { ...parsed } : {};
-		config[GOOSE_USER_KEY] = convertRulesyncToGoosePermissionConfig({
+		const userPermission = convertRulesyncToGoosePermissionConfig({
 			config: rulesyncPermissions.getJson(),
 			logger
 		});
+		config[GOOSE_USER_KEY] = userPermission;
 		return new GoosePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -30284,9 +30628,7 @@ function convertRulesyncToQwenPermissions(config) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -30359,6 +30701,20 @@ function toCanonicalToolName$2(reasonixName) {
 	return REASONIX_TO_CANONICAL_TOOL_NAMES[reasonixName] ?? reasonixName;
 }
 /**
+* Whether an entry uses the first-class `Tool=<literal>` exact-command form
+* (SPEC §3.7, v1.18.0): metacharacters in the literal are ordinary characters
+* and only the identical complete command matches. These entries have no
+* canonical tool→pattern→action equivalent — glob-style `Tool(...)` matches
+* differently by design — so they are preserved verbatim and round-trip
+* through the `reasonix` override's rawAllow/rawAsk/rawDeny arrays.
+*/
+function isReasonixExactCommandEntry(entry) {
+	const eqIndex = entry.indexOf("=");
+	if (eqIndex <= 0) return false;
+	const parenIndex = entry.indexOf("(");
+	return parenIndex === -1 || eqIndex < parenIndex;
+}
+/**
 * Parse a Reasonix permission entry like "Bash(npm run *)" into tool name and pattern.
 * If no parentheses, returns the tool name with "*" as the pattern.
 */
@@ -30447,10 +30803,22 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 		const config = rulesyncPermissions.getJson();
 		const { allow, ask, deny } = convertRulesyncToReasonixPermissions(config);
 		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toReasonixToolName(category)));
+		const override = config.reasonix;
+		const rawAllow = toReasonixStringArray(override?.rawAllow);
+		const rawAsk = toReasonixStringArray(override?.rawAsk);
+		const rawDeny = toReasonixStringArray(override?.rawDeny);
+		const rawOwnedEntries = /* @__PURE__ */ new Set([
+			...rawAllow,
+			...rawAsk,
+			...rawDeny
+		]);
 		const existingPermissions = toReasonixTable(parsed.permissions);
-		const preservedAllow = toReasonixStringArray(existingPermissions.allow).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
-		const preservedAsk = toReasonixStringArray(existingPermissions.ask).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
-		const preservedDeny = toReasonixStringArray(existingPermissions.deny).filter((entry) => !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName));
+		const { allow: preservedAllow, ask: preservedAsk, deny: preservedDeny } = preserveExistingEntries({
+			existingPermissions,
+			managedToolNames,
+			rawOwnedEntries,
+			logger
+		});
 		if (logger && managedToolNames.has("Read")) {
 			const droppedReadDenyEntries = toReasonixStringArray(existingPermissions.deny).filter((entry) => {
 				const { toolName } = parseReasonixPermissionEntry(entry);
@@ -30459,17 +30827,22 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 			if (droppedReadDenyEntries.length > 0) logger.warn(`Permissions feature manages 'Read' tool and will overwrite ${droppedReadDenyEntries.length} existing Read deny entries (possibly from ignore feature). Permissions take precedence.`);
 		}
 		const mergedPermissions = { ...existingPermissions };
-		const mergedAllow = (0, es_toolkit.uniq)([...preservedAllow, ...allow].toSorted());
-		const mergedAsk = (0, es_toolkit.uniq)([...preservedAsk, ...ask].toSorted());
-		const mergedDeny = (0, es_toolkit.uniq)([...preservedDeny, ...deny].toSorted());
-		if (mergedAllow.length > 0) mergedPermissions.allow = mergedAllow;
-		else delete mergedPermissions.allow;
-		if (mergedAsk.length > 0) mergedPermissions.ask = mergedAsk;
-		else delete mergedPermissions.ask;
-		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
-		else delete mergedPermissions.deny;
+		setOrDeleteEntries(mergedPermissions, "allow", [
+			...preservedAllow,
+			...allow,
+			...rawAllow
+		]);
+		setOrDeleteEntries(mergedPermissions, "ask", [
+			...preservedAsk,
+			...ask,
+			...rawAsk
+		]);
+		setOrDeleteEntries(mergedPermissions, "deny", [
+			...preservedDeny,
+			...deny,
+			...rawDeny
+		]);
 		const patch = { permissions: mergedPermissions };
-		const override = config.reasonix;
 		if (override?.sandbox !== void 0) patch.sandbox = {
 			...asReasonixRecord(parsed.sandbox),
 			...asReasonixRecord(override.sandbox)
@@ -30500,16 +30873,29 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 	}
 	toRulesyncPermissions() {
 		const permissions = toReasonixTable(this.toml.permissions);
+		const splitExact = (entries) => {
+			const exact = entries.filter((entry) => isReasonixExactCommandEntry(entry));
+			return {
+				translated: entries.filter((entry) => !isReasonixExactCommandEntry(entry)),
+				exact
+			};
+		};
+		const allowSplit = splitExact(toReasonixStringArray(permissions.allow));
+		const askSplit = splitExact(toReasonixStringArray(permissions.ask));
+		const denySplit = splitExact(toReasonixStringArray(permissions.deny));
 		const config = convertReasonixToRulesyncPermissions({
-			allow: toReasonixStringArray(permissions.allow),
-			ask: toReasonixStringArray(permissions.ask),
-			deny: toReasonixStringArray(permissions.deny)
+			allow: allowSplit.translated,
+			ask: askSplit.translated,
+			deny: denySplit.translated
 		});
 		const sandbox = asReasonixRecord(this.toml.sandbox);
 		const agentPlanMode = pickReasonixKeys(this.toml.agent, [...REASONIX_OVERRIDE_AGENT_KEYS, ...REASONIX_RETIRED_AGENT_KEYS]);
 		const reasonixOverride = {};
 		if (Object.keys(sandbox).length > 0) reasonixOverride.sandbox = sandbox;
 		if (Object.keys(agentPlanMode).length > 0) reasonixOverride.agent = agentPlanMode;
+		if (allowSplit.exact.length > 0) reasonixOverride.rawAllow = allowSplit.exact;
+		if (askSplit.exact.length > 0) reasonixOverride.rawAsk = askSplit.exact;
+		if (denySplit.exact.length > 0) reasonixOverride.rawDeny = denySplit.exact;
 		const result = { ...config };
 		if (Object.keys(reasonixOverride).length > 0) result.reasonix = reasonixOverride;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -30539,6 +30925,41 @@ var ReasonixPermissions = class ReasonixPermissions extends ToolPermissions {
 	}
 };
 /**
+* Preserve existing permission entries rulesync does not manage: entries for
+* tools NOT in the permissions config, plus exact `Tool=<literal>` entries not
+* owned by the override's raw arrays — Reasonix writes those itself as
+* remembered approvals, and dropping them would revoke grants the canonical
+* glob rules cannot re-express. Remove one by deleting it from `reasonix.toml`
+* (or by naming it in a raw array, which takes ownership). Preserved exact
+* entries are logged so the kept-alive grants stay visible.
+*/
+function preserveExistingEntries({ existingPermissions, managedToolNames, rawOwnedEntries, logger }) {
+	const isPreserved = (entry) => {
+		if (isReasonixExactCommandEntry(entry)) return !rawOwnedEntries.has(entry);
+		return !managedToolNames.has(parseReasonixPermissionEntry(entry).toolName);
+	};
+	const allow = toReasonixStringArray(existingPermissions.allow).filter(isPreserved);
+	const ask = toReasonixStringArray(existingPermissions.ask).filter(isPreserved);
+	const deny = toReasonixStringArray(existingPermissions.deny).filter(isPreserved);
+	const preservedExact = [
+		...allow,
+		...ask,
+		...deny
+	].filter((entry) => isReasonixExactCommandEntry(entry));
+	if (preservedExact.length > 0) logger?.info(`Preserving ${preservedExact.length} exact Reasonix permission entries (remembered approvals): ${preservedExact.join(", ")}`);
+	return {
+		allow,
+		ask,
+		deny
+	};
+}
+/** Sort, dedupe and set a permissions array key, deleting it when empty. */
+function setOrDeleteEntries(table, key, entries) {
+	const merged = (0, es_toolkit.uniq)(entries.toSorted());
+	if (merged.length > 0) table[key] = merged;
+	else delete table[key];
+}
+/**
 * Convert rulesync permissions config to Reasonix allow/ask/deny arrays.
 */
 function convertRulesyncToReasonixPermissions(config) {
@@ -30556,9 +30977,7 @@ function convertRulesyncToReasonixPermissions(config) {
 				case "ask":
 					ask.push(entry);
 					break;
-				case "deny":
-					deny.push(entry);
-					break;
+				case "deny": deny.push(entry);
 			}
 		}
 	}
@@ -30588,7 +31007,6 @@ function convertReasonixToRulesyncPermissions(params) {
 }
 //#endregion
 //#region src/features/permissions/rovodev-permissions.ts
-const ROVODEV_GLOBAL_ONLY_MESSAGE = "Rovodev permissions are global-only; use --global to sync ~/.rovodev/config.yml";
 const CATCH_ALL_PATTERN$1 = "*";
 const CATEGORY_TO_TOOL_KEYS = {
 	read: [
@@ -30648,9 +31066,12 @@ const OWNED_TOOL_PERMISSION_KEYS = [
 /**
 * Permissions adapter for Rovo Dev CLI.
 *
-* Rovo Dev reads tool permissions from the `toolPermissions` block of the global
-* `~/.rovodev/config.yml`. This surface is **global only** — there is no
-* project-scoped Rovo Dev permissions file (mirrors the Rovodev MCP adapter).
+* Rovo Dev reads tool permissions from the `toolPermissions` block of
+* `config.yml` — the global `~/.rovodev/config.yml`, and since the Bitbucket
+* Cloud Agentic Pipelines docs, also the repo-committed project
+* `.rovodev/config.yml` (referenced from `bitbucket-pipelines.yml` via
+* `config.path`, or the `--config-file` CLI flag). Both scopes use the
+* same relative path, resolved against the project root or home directory.
 *
 * Rovo Dev's three levels (`allow`/`ask`/`deny`) are an exact 1:1 with rulesync's
 * canonical action enum, so action values pass through verbatim.
@@ -30697,7 +31118,6 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error(ROVODEV_GLOBAL_ONLY_MESSAGE);
 		const paths = RovodevPermissions.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		return new RovodevPermissions({
@@ -30706,11 +31126,10 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
 			validate,
-			global: true
+			global
 		});
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
-		if (!global) throw new Error(ROVODEV_GLOBAL_ONLY_MESSAGE);
 		const paths = RovodevPermissions.getSettablePaths({ global });
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
@@ -30733,14 +31152,20 @@ var RovodevPermissions = class RovodevPermissions extends ToolPermissions {
 			filePath,
 			logger
 		});
-		if (resolvedToolPermissions !== void 0) config.toolPermissions = resolvedToolPermissions;
+		const fileContent = resolvedToolPermissions !== void 0 ? applySharedConfigPatch({
+			fileKey: ROVODEV_CONFIG_SHARED_FILE_KEY,
+			feature: "permissions",
+			existingContent,
+			patch: { toolPermissions: resolvedToolPermissions },
+			filePath
+		}) : (0, js_yaml.dump)(config);
 		return new RovodevPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: (0, js_yaml.dump)(config),
+			fileContent,
 			validate: true,
-			global: true
+			global
 		});
 	}
 	toRulesyncPermissions() {
@@ -31277,6 +31702,7 @@ const CANONICAL_TO_VIBE_TOOL_NAMES = {
 	write: "write_file",
 	webfetch: "web_fetch",
 	websearch: "web_search",
+	grep: "grep",
 	agent: "task"
 };
 const VIBE_TO_CANONICAL_TOOL_NAMES = {
@@ -31286,6 +31712,7 @@ const VIBE_TO_CANONICAL_TOOL_NAMES = {
 	write_file: "write",
 	web_fetch: "webfetch",
 	web_search: "websearch",
+	grep: "grep",
 	task: "agent"
 };
 var VibePermissions = class VibePermissions extends ToolPermissions {
@@ -31323,6 +31750,7 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, validate = true, logger, global = false }) {
 		const paths = this.getSettablePaths({ global });
+		if (global) await warnIfGlobalVibeConfigIsShadowed(logger);
 		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
 		const config = parseVibeConfig(existingContent);
@@ -31330,46 +31758,31 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 		const tools = toVibeToolsRecord(config.tools);
 		const enabledTools = new Set(toStringArray(config.enabled_tools));
 		const disabledTools = new Set(toStringArray(config.disabled_tools));
+		const removedEnabledTools = [];
 		for (const category of Object.keys(permission)) {
+			if (!hasVibeToolName(category)) continue;
 			const vibeToolName = toVibeToolName(category);
-			enabledTools.delete(vibeToolName);
+			if (enabledTools.delete(vibeToolName)) removedEnabledTools.push(vibeToolName);
 			disabledTools.delete(vibeToolName);
 		}
 		for (const [category, rules] of Object.entries(permission)) {
-			const vibeToolName = toVibeToolName(category);
-			const existingTool = toVibeToolConfig(tools[vibeToolName]);
-			const nextTool = { ...existingTool };
-			const allow = new Set(toStringArray(existingTool.allow ?? existingTool.allowlist));
-			const deny = new Set(toStringArray(existingTool.deny ?? existingTool.denylist));
-			for (const [pattern, action] of Object.entries(rules)) {
-				if (pattern === "*") {
-					applyWildcardPermission({
-						action,
-						toolConfig: nextTool
-					});
-					if (action === "deny") {
-						disabledTools.add(vibeToolName);
-						enabledTools.delete(vibeToolName);
-					} else if (action === "allow") {
-						enabledTools.add(vibeToolName);
-						disabledTools.delete(vibeToolName);
-					}
-					continue;
-				}
-				if (action === "ask") {
-					logger?.warn(`Vibe permissions do not support pattern-level "ask" rules. Skipping ${category}: ${pattern}`);
-					continue;
-				}
-				if (action === "allow") allow.add(pattern);
-				else deny.add(pattern);
+			if (!hasVibeToolName(category)) {
+				const ruleCount = Object.keys(rules).length;
+				if (ruleCount > 0) logger?.warn(`Vibe has no builtin tool for the '${category}' category; skipping ${ruleCount} rule(s) instead of emitting an inert [tools.${category}] table.`);
+				continue;
 			}
-			delete nextTool.allow;
-			delete nextTool.deny;
-			if (allow.size > 0) nextTool.allowlist = [...allow].toSorted();
-			if (deny.size > 0) nextTool.denylist = [...deny].toSorted();
-			tools[vibeToolName] = nextTool;
+			applyCategoryRules({
+				category,
+				rules,
+				tools,
+				enabledTools,
+				disabledTools,
+				logger
+			});
 		}
-		applyVibeSensitivePatterns(tools, rulesyncPermissions.getJson().vibe);
+		const vibeOverride = rulesyncPermissions.getJson().vibe;
+		applyVibeSensitivePatterns(tools, vibeOverride, logger);
+		if (removedEnabledTools.length > 0 && vibeOverride?.enabled_tools === void 0 && logger) logger.warn(`Removed ${removedEnabledTools.join(", ")} from Vibe's exclusive enabled_tools list (rulesync owns the tools it configures and no longer expresses allows through that key). If the exclusive narrowing was intentional, declare the full list explicitly via vibe.enabled_tools in .rulesync/permissions.jsonc.`);
 		return new VibePermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -31380,7 +31793,10 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 				existingContent,
 				patch: {
 					tools,
-					enabled_tools: enabledTools.size > 0 ? [...enabledTools].toSorted() : void 0,
+					enabled_tools: resolveEnabledToolsPatch({
+						vibeOverride,
+						enabledTools
+					}),
 					disabled_tools: disabledTools.size > 0 ? [...disabledTools].toSorted() : void 0
 				},
 				filePath
@@ -31392,7 +31808,7 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 	toRulesyncPermissions() {
 		const permission = {};
 		const vibeOverridePermission = {};
-		for (const tool of toStringArray(this.toml.enabled_tools)) ensurePermission(permission, toCanonicalToolName$1(tool))["*"] = "allow";
+		const enabledToolsList = toStringArray(this.toml.enabled_tools);
 		for (const tool of toStringArray(this.toml.disabled_tools)) ensurePermission(permission, toCanonicalToolName$1(tool))["*"] = "deny";
 		for (const [vibeToolName, toolConfig] of Object.entries(toVibeToolsRecord(this.toml.tools))) {
 			const category = toCanonicalToolName$1(vibeToolName);
@@ -31405,9 +31821,12 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 			if (sensitivePatterns.length > 0) vibeOverridePermission[category] = { sensitive_patterns: sensitivePatterns };
 		}
 		for (const [category, rules] of Object.entries(permission)) if (Object.keys(rules).length === 0) delete permission[category];
-		const json = Object.keys(vibeOverridePermission).length > 0 ? {
+		const vibeOverride = {};
+		if (Object.keys(vibeOverridePermission).length > 0) vibeOverride.permission = vibeOverridePermission;
+		if (enabledToolsList.length > 0) vibeOverride.enabled_tools = enabledToolsList;
+		const json = Object.keys(vibeOverride).length > 0 ? {
 			permission,
-			vibe: { permission: vibeOverridePermission }
+			vibe: vibeOverride
 		} : { permission };
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(json, null, 2) });
 	}
@@ -31442,8 +31861,12 @@ var VibePermissions = class VibePermissions extends ToolPermissions {
 * list for any category the override names: a present list is set, an empty
 * one clears it. Categories not named keep whatever the existing file had.
 */
-function applyVibeSensitivePatterns(tools, vibeOverride) {
+function applyVibeSensitivePatterns(tools, vibeOverride, logger) {
 	for (const [category, toolOverride] of Object.entries(vibeOverride?.permission ?? {})) {
+		if (!hasVibeToolName(category)) {
+			logger?.warn(`Vibe has no builtin tool for the '${category}' category; skipping its vibe.permission.${category}.sensitive_patterns override.`);
+			continue;
+		}
 		const vibeToolName = toVibeToolName(category);
 		const nextTool = toVibeToolConfig(tools[vibeToolName]);
 		const patterns = toStringArray(toolOverride.sensitive_patterns);
@@ -31452,6 +31875,57 @@ function applyVibeSensitivePatterns(tools, vibeOverride) {
 		tools[vibeToolName] = nextTool;
 	}
 }
+/**
+* Translate one canonical category's rules into the tool's `[tools.<name>]`
+* table and the top-level `disabled_tools` filter, mutating `tools` and the
+* filter sets in place.
+*/
+function applyCategoryRules({ category, rules, tools, enabledTools, disabledTools, logger }) {
+	const vibeToolName = toVibeToolName(category);
+	const existingTool = toVibeToolConfig(tools[vibeToolName]);
+	const nextTool = { ...existingTool };
+	const allow = new Set(toStringArray(existingTool.allow ?? existingTool.allowlist));
+	const deny = new Set(toStringArray(existingTool.deny ?? existingTool.denylist));
+	for (const [pattern, action] of Object.entries(rules)) {
+		if (pattern === "*") {
+			applyWildcardPermission({
+				action,
+				toolConfig: nextTool
+			});
+			if (action === "deny") {
+				disabledTools.add(vibeToolName);
+				enabledTools.delete(vibeToolName);
+			} else if (action === "allow") disabledTools.delete(vibeToolName);
+			continue;
+		}
+		if (action === "ask") {
+			logger?.warn(`Vibe permissions do not support pattern-level "ask" rules. Skipping ${category}: ${pattern}`);
+			continue;
+		}
+		if (action === "allow") allow.add(pattern);
+		else deny.add(pattern);
+	}
+	delete nextTool.allow;
+	delete nextTool.deny;
+	if (allow.size > 0) nextTool.allowlist = [...allow].toSorted();
+	if (deny.size > 0) nextTool.denylist = [...deny].toSorted();
+	tools[vibeToolName] = nextTool;
+}
+/**
+* `enabled_tools` is an exclusive allowlist and therefore only ever
+* rulesync-authored explicitly, through `vibe.enabled_tools`. When the
+* override declares it (even empty), rulesync owns the whole list; when it
+* does not, the on-disk list survives minus the entries the caller's cleanup
+* loop removed for rulesync-configured tools (which also migrates away the
+* exclusive entries earlier rulesync versions wrote for allow rules).
+*/
+function resolveEnabledToolsPatch({ vibeOverride, enabledTools }) {
+	if (vibeOverride?.enabled_tools !== void 0) {
+		const declared = [...new Set(toStringArray(vibeOverride.enabled_tools))];
+		return declared.length > 0 ? declared.toSorted() : void 0;
+	}
+	return enabledTools.size > 0 ? [...enabledTools].toSorted() : void 0;
+}
 function parseVibeConfig(fileContent) {
 	const parsed = smol_toml.parse(fileContent || smol_toml.stringify({}));
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
@@ -31460,6 +31934,17 @@ function parseVibeConfig(fileContent) {
 function toVibeToolName(category) {
 	return CANONICAL_TO_VIBE_TOOL_NAMES[category] ?? category;
 }
+/**
+* Whether a canonical category has a Vibe builtin tool to land on. Categories
+* without one (e.g. `glob`, `notebookedit`) must not emit a
+* `[tools.<category>]` table: Vibe has no such tool, so a `deny` authored
+* there would look applied while being silently inert — the dangerous
+* direction. Unlike `agent` → `task` there is no correct name to rename to,
+* so the category is skipped with a warning (the grokcli adapter's pattern).
+*/
+function hasVibeToolName(category) {
+	return Object.hasOwn(CANONICAL_TO_VIBE_TOOL_NAMES, category);
+}
 function toCanonicalToolName$1(vibeToolName) {
 	return VIBE_TO_CANONICAL_TOOL_NAMES[vibeToolName] ?? vibeToolName;
 }
@@ -31477,7 +31962,7 @@ function toStringArray(value) {
 function applyWildcardPermission({ action, toolConfig }) {
 	if (action === "allow") toolConfig.permission = "always";
 	else if (action === "ask") toolConfig.permission = "ask";
-	else if (toolConfig.permission !== void 0) delete toolConfig.permission;
+	else toolConfig.permission = "never";
 }
 function fromVibePermission(value) {
 	if (value === "always" || value === "allow") return "allow";
@@ -31505,6 +31990,20 @@ const WARP_OVERRIDE_KEYS = [
 	"agent_mode_coding_file_read_allowlist",
 	"agent_mode_execute_readonly_commands"
 ];
+const WARP_EXECUTION_PROFILE_OVERRIDE_KEY = "execution_profile";
+const WARP_EXECUTION_PROFILE_KEYS = [
+	"read_files",
+	"apply_code_diffs",
+	"execute_commands",
+	"mcp_permissions",
+	"write_to_pty",
+	"ask_user_question",
+	"run_agents",
+	"computer_use",
+	"directory_allowlist",
+	"mcp_allowlist",
+	"mcp_denylist"
+];
 /**
 * Warp's `settings.toml` lives in a different directory per platform (Stable
 * channel). The home directory is resolved by the processor through
@@ -31559,7 +32058,14 @@ function warpSettingsDir() {
 * through the `warp` override namespace (see `WarpPermissionsOverrideSchema`):
 * on **import** they are lifted from `settings.toml` into the override, and on
 * **export** they are merged back into `[agents.profiles]` (the override wins).
-* MCP allow/deny is a separate surface not modeled here.
+*
+* On migrated installs those legacy keys are inert; their execution-profile
+* counterparts (`read_files` / `apply_code_diffs` / `execute_commands`
+* action permissions, `directory_allowlist`, `mcp_allowlist` /
+* `mcp_denylist`) are authored through the nested `warp.execution_profile`
+* override, merged into the `default` record of
+* `[agents.execution_profiles.<id>]` under the same collection-exists guard as
+* the command lists, and lifted back from the `default` profile on import.
 *
 * The `settings.toml` file holds all of Warp's settings, so the
 * `[agents.profiles]` block is merged in place and the file is never deleted.
@@ -31612,7 +32118,11 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		const agents = isRecord(settings.agents) ? { ...settings.agents } : {};
 		const profiles = isRecord(agents.profiles) ? { ...agents.profiles } : {};
 		const override = config.warp;
-		if (isRecord(override)) Object.assign(profiles, override);
+		const executionProfileOverride = isRecord(override) && isRecord(override[WARP_EXECUTION_PROFILE_OVERRIDE_KEY]) ? override[WARP_EXECUTION_PROFILE_OVERRIDE_KEY] : void 0;
+		if (isRecord(override)) {
+			const { [WARP_EXECUTION_PROFILE_OVERRIDE_KEY]: _executionProfile, ...legacyOverride } = override;
+			Object.assign(profiles, legacyOverride);
+		}
 		const mergedAllow = (0, es_toolkit.uniq)(allow.toSorted());
 		const mergedDeny = (0, es_toolkit.uniq)(deny.toSorted());
 		if (mergedAllow.length > 0) profiles[ALLOWLIST_KEY] = mergedAllow;
@@ -31620,18 +32130,13 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		if (mergedDeny.length > 0) profiles[DENYLIST_KEY] = mergedDeny;
 		else delete profiles[DENYLIST_KEY];
 		agents.profiles = profiles;
-		if (isRecord(agents[EXECUTION_PROFILES_KEY])) {
-			const executionProfiles = { ...agents[EXECUTION_PROFILES_KEY] };
-			const defaultProfile = isRecord(executionProfiles[DEFAULT_PROFILE_KEY]) ? { ...executionProfiles[DEFAULT_PROFILE_KEY] } : {};
-			if (mergedAllow.length > 0) defaultProfile[PROFILE_ALLOWLIST_KEY] = mergedAllow;
-			else delete defaultProfile[PROFILE_ALLOWLIST_KEY];
-			if (mergedDeny.length > 0) defaultProfile[PROFILE_DENYLIST_KEY] = mergedDeny;
-			else delete defaultProfile[PROFILE_DENYLIST_KEY];
-			executionProfiles[DEFAULT_PROFILE_KEY] = defaultProfile;
-			agents[EXECUTION_PROFILES_KEY] = executionProfiles;
-			const otherProfileIds = Object.keys(executionProfiles).filter((id) => id !== DEFAULT_PROFILE_KEY);
-			if (mergedDeny.length > 0 && otherProfileIds.length > 0 && logger) logger.warn(`Warp command deny rules were written to the 'default' execution profile only; they are not enforced while another profile (${otherProfileIds.join(", ")}) is active.`);
-		}
+		mergeIntoDefaultExecutionProfile({
+			agents,
+			mergedAllow,
+			mergedDeny,
+			executionProfileOverride,
+			logger
+		});
 		settings.agents = agents;
 		return new WarpPermissions({
 			outputRoot,
@@ -31659,6 +32164,11 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 		});
 		const warpOverride = {};
 		for (const key of WARP_OVERRIDE_KEYS) if (profiles[key] !== void 0) warpOverride[key] = profiles[key];
+		if (defaultProfile) {
+			const executionProfileOverride = {};
+			for (const key of WARP_EXECUTION_PROFILE_KEYS) if (defaultProfile[key] !== void 0) executionProfileOverride[key] = defaultProfile[key];
+			if (Object.keys(executionProfileOverride).length > 0) warpOverride[WARP_EXECUTION_PROFILE_OVERRIDE_KEY] = executionProfileOverride;
+		}
 		const result = { ...config };
 		if (Object.keys(warpOverride).length > 0) result.warp = warpOverride;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -31681,6 +32191,36 @@ var WarpPermissions = class WarpPermissions extends ToolPermissions {
 	}
 };
 /**
+* On migrated installs the legacy `[agents.profiles]` keys are inert: runtime
+* enforcement reads the active `[agents.execution_profiles.<id>]` record.
+* Merge the command lists (and the `warp.execution_profile` override's
+* autonomy keys) into the `default` profile in place so every other profile
+* key and profile ID survives. When the collection does not exist yet the
+* install is un-migrated — the legacy keys are still live there, and creating
+* the collection ourselves would mark Warp's one-shot migration complete early
+* and strand the user's other legacy settings (file-read allowlist, preferred
+* model), so it is deliberately left unset and the override is skipped with a
+* warning instead.
+*/
+function mergeIntoDefaultExecutionProfile({ agents, mergedAllow, mergedDeny, executionProfileOverride, logger }) {
+	const hasOverrideKeys = executionProfileOverride !== void 0 && Object.keys(executionProfileOverride).length > 0;
+	if (!isRecord(agents[EXECUTION_PROFILES_KEY])) {
+		if (hasOverrideKeys && logger) logger.warn("The warp.execution_profile permissions override was skipped: settings.toml has no [agents.execution_profiles] collection yet (un-migrated install). Open Warp once to run its settings migration, then re-run rulesync generate.");
+		return;
+	}
+	const executionProfiles = { ...agents[EXECUTION_PROFILES_KEY] };
+	const defaultProfile = isRecord(executionProfiles[DEFAULT_PROFILE_KEY]) ? { ...executionProfiles[DEFAULT_PROFILE_KEY] } : {};
+	if (executionProfileOverride) Object.assign(defaultProfile, executionProfileOverride);
+	if (mergedAllow.length > 0) defaultProfile[PROFILE_ALLOWLIST_KEY] = mergedAllow;
+	else delete defaultProfile[PROFILE_ALLOWLIST_KEY];
+	if (mergedDeny.length > 0) defaultProfile[PROFILE_DENYLIST_KEY] = mergedDeny;
+	else delete defaultProfile[PROFILE_DENYLIST_KEY];
+	executionProfiles[DEFAULT_PROFILE_KEY] = defaultProfile;
+	agents[EXECUTION_PROFILES_KEY] = executionProfiles;
+	const otherProfileIds = Object.keys(executionProfiles).filter((id) => id !== DEFAULT_PROFILE_KEY);
+	if ((mergedDeny.length > 0 || hasOverrideKeys) && otherProfileIds.length > 0 && logger) logger.warn(`Warp command deny rules and execution_profile override keys were written to the 'default' execution profile only; they are not enforced while another profile (${otherProfileIds.join(", ")}) is active.`);
+}
+/**
 * Convert rulesync permissions config to Warp command allow/deny regex lists.
 * Only the `bash` category maps; `ask` rules and non-`bash` categories are
 * dropped (the latter with a warning when they carry `deny` rules).
@@ -31697,10 +32237,7 @@ function convertRulesyncToWarpPermissions({ config, logger }) {
 			case "allow":
 				allow.push(pattern);
 				break;
-			case "deny":
-				deny.push(pattern);
-				break;
-			case "ask": break;
+			case "deny": deny.push(pattern);
 		}
 	}
 	return {
@@ -32155,7 +32692,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["rovodev", {
 		class: RovodevPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -33352,6 +33889,38 @@ var AugmentcodeSkill = class AugmentcodeSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/rules/nested-scan-exclusions.ts
+/**
+* Shared exclusion lists for the nested rule-file scans (`AGENTS.md`,
+* `REASONIX.md`), which walk the whole project tree on import rather than a
+* rulesync-owned directory.
+*/
+/**
+* Dependency trees never scanned for nested rule files, at any depth. A rule
+* file there describes somebody else's project, and neither name is ever a
+* package name. Hidden directories are excluded separately, because a rule
+* file inside one is another tool's generated output (rulesync writes several
+* itself).
+*/
+const NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH = ["node_modules", "__pycache__"];
+/**
+* Build, vendoring and scratch directories, excluded at the **project root
+* only**. A top-level `build/` is a build directory; `packages/build/` is a
+* package, and dropping it silently would lose a real subproject.
+*/
+const NESTED_SCAN_EXCLUDED_ROOT_DIRS = [
+	"vendor",
+	"third_party",
+	"dist",
+	"build",
+	"out",
+	"target",
+	"coverage",
+	"tmp",
+	"temp",
+	"venv"
+];
+//#endregion
 //#region src/features/skills/claudecode-skill.ts
 const ClaudecodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
@@ -33437,6 +34006,41 @@ var ClaudecodeSkill = class extends ToolSkill {
 			alternativeSkillRoots: [CLAUDECODE_SCHEDULED_TASKS_DIR_PATH]
 		};
 	}
+	/**
+	* Claude Code v2.1.178+ also loads skills from **nested** `.claude/skills/`
+	* directories below the working directory (a skill in
+	* `apps/web/.claude/skills/` becomes available when working on files
+	* there). Discover those directories so `rulesync import` sees them —
+	* import-only and lenient, like every configured root; the project-root
+	* `.claude/skills/` stays the sole generation target. The scan reuses the
+	* nested-rule-file exclusions (dependency trees at any depth, build/vendor
+	* dirs at the root, hidden dirs other than the `.claude` being matched) and
+	* never runs in global mode. On a name clash with a root skill, the root
+	* one wins the import (Claude Code itself keeps both under a
+	* directory-qualified name, which rulesync's flat skill namespace cannot
+	* express).
+	*
+	* @see https://code.claude.com/docs/en/skills
+	*/
+	static async getConfiguredImportRoots({ outputRoot, global = false }) {
+		if (global) return [];
+		const root = toPosixPath(outputRoot);
+		return filterOutPathsInGitIgnoredDirectories({
+			rootDir: outputRoot,
+			filePaths: await findFilesByGlobs([`${root}/*/**/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}`], {
+				type: "dir",
+				followSymbolicLinks: false,
+				ignore: [
+					`${root}/**/.*/**/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}`,
+					...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `${root}/**/${dir}/**`),
+					...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${root}/${dir}/**`)
+				]
+			})
+		}).toSorted().map((dirPath) => ({
+			outputRoot,
+			relativeDirPath: (0, node_path.relative)(outputRoot, dirPath)
+		}));
+	}
 	getFrontmatter() {
 		return ClaudecodeSkillFrontmatterSchema.parse(this.requireMainFileFrontmatter());
 	}
@@ -36835,7 +37439,8 @@ var TaktSkill = class TaktSkill extends ToolSkill {
 	getDirPath() {
 		const fullPath = (0, node_path.join)(this.outputRoot, this.relativeDirPath);
 		const resolvedFull = (0, node_path.resolve)(fullPath);
-		const rel = (0, node_path.relative)((0, node_path.resolve)(this.outputRoot), resolvedFull);
+		const resolvedBase = (0, node_path.resolve)(this.outputRoot);
+		const rel = (0, node_path.relative)(resolvedBase, resolvedFull);
 		if (rel.startsWith("..") || node_path.default.isAbsolute(rel)) throw new Error(`Path traversal detected: Final path escapes outputRoot. outputRoot="${this.outputRoot}", relativeDirPath="${this.relativeDirPath}"`);
 		return fullPath;
 	}
@@ -37385,6 +37990,23 @@ var ZedSkill = class ZedSkill extends ToolSkill {
 	}
 };
 //#endregion
+//#region src/features/skills/zoocode-skill.ts
+/**
+* Skill generator for **Zoo Code** (the community continuation of Roo Code).
+* Zoo Code keeps Roo's skills layout (`.roo/skills/` project,
+* `~/.roo/skills/` global) and the `roo:` frontmatter section (`modeSlugs`),
+* so this target reuses {@link RooSkill} verbatim and only narrows the
+* targeting.
+*
+* @see https://docs.zoocode.dev/features/skills
+*/
+var ZoocodeSkill = class extends RooSkill {
+	static isTargetedByRulesyncSkill(rulesyncSkill) {
+		const targets = rulesyncSkill.getFrontmatter().targets;
+		return targets.includes("*") || targets.includes("zoocode");
+	}
+};
+//#endregion
 //#region src/features/skills/skills-processor.ts
 const SkillsProcessorToolTargetSchema = zod_mini.z.enum(skillsProcessorToolTargetTuple);
 /**
@@ -37657,6 +38279,14 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true
 		}
 	}],
+	["zoocode", {
+		class: ZoocodeSkill,
+		meta: {
+			supportsProject: true,
+			supportsSimulated: false,
+			supportsGlobal: true
+		}
+	}],
 	["rovodev", {
 		class: RovodevSkill,
 		meta: {
@@ -37819,7 +38449,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 		for (const root of roots) {
 			const rootOutputRoot = typeof root === "string" ? this.outputRoot : root.outputRoot;
 			const relativeDirPath = typeof root === "string" ? root : root.relativeDirPath;
-			const isConfiguredRoot = configuredRootPaths.has(relativeDirPath);
+			const isLenientRoot = configuredRootPaths.has(relativeDirPath) || factory.meta.lenientImport === true || isAgentSkillsInteropRoot(relativeDirPath);
 			const skillsDirPath = (0, node_path.join)(rootOutputRoot, relativeDirPath);
 			if (!await directoryExists(skillsDirPath)) continue;
 			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
@@ -37843,7 +38473,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 						global: this.global
 					});
 				} catch (error) {
-					if (!isConfiguredRoot && !factory.meta.lenientImport) throw error;
+					if (!isLenientRoot) throw error;
 					this.logger.warn(`Skipping ${(0, node_path.join)(relativeDirPath, dirName)}: ${formatError(error)}`);
 					return null;
 				}
@@ -37858,12 +38488,20 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			const fromFlatFile = factory.class.fromFlatFile;
 			const directoryStems = new Set(ownedDirNames);
 			const flatFilePaths = (await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*.md"), { type: "file" })).filter((filePath) => !directoryStems.has((0, node_path.basename)(filePath, ".md")));
-			const flatSkills = await Promise.all(flatFilePaths.map((filePath) => fromFlatFile({
-				outputRoot: rootOutputRoot,
-				relativeDirPath,
-				relativeFilePath: (0, node_path.basename)(filePath),
-				global: this.global
-			})));
+			const flatSkills = (await Promise.all(flatFilePaths.map(async (filePath) => {
+				try {
+					return await fromFlatFile({
+						outputRoot: rootOutputRoot,
+						relativeDirPath,
+						relativeFilePath: (0, node_path.basename)(filePath),
+						global: this.global
+					});
+				} catch (error) {
+					if (!isLenientRoot) throw error;
+					this.logger.warn(`Skipping ${(0, node_path.join)(relativeDirPath, (0, node_path.basename)(filePath))}: ${formatError(error)}`);
+					return null;
+				}
+			}))).filter((skill) => skill !== null);
 			for (const skill of flatSkills) {
 				const skillName = skill.getImportIdentity();
 				if (seenSkillNames.has(skillName)) continue;
@@ -37936,14 +38574,15 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 	*/
 	static getSimulatedConventionSection({ skillList }) {
 		if (!skillList || skillList.length === 0) return "";
+		const skillListWithAtPrefix = skillList.map((skill) => ({
+			...skill,
+			path: `@${skill.path}`
+		}));
 		return `## Simulated Skills
 
 Simulated skills are specialized capabilities that can be invoked to handle specific types of tasks. When you determine that a skill would be helpful for the current task, read the corresponding SKILL.md file and execute its instructions.
 
-${(0, _toon_format_toon.encode)({ skillList: skillList.map((skill) => ({
-			...skill,
-			path: `@${skill.path}`
-		})) })}`;
+${(0, _toon_format_toon.encode)({ skillList: skillListWithAtPrefix })}`;
 	}
 	/**
 	* Return the tool targets that this processor supports in global mode
@@ -40547,7 +41186,8 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 		return getHermesagentSharedConfigWritePaths();
 	}
 	static getSettablePathsForRulesyncSubagent(rulesyncSubagent) {
-		return [(0, node_path.join)(HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH, `${subagentSlug(rulesyncSubagent.getRelativePathFromCwd())}.json`)];
+		const slug = subagentSlug(rulesyncSubagent.getRelativePathFromCwd());
+		return [(0, node_path.join)(HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH, `${slug}.json`)];
 	}
 	toRulesyncSubagent() {
 		const slug = (0, node_path.basename)(this.getRelativeFilePath(), ".json");
@@ -41782,7 +42422,7 @@ function stringifyRooModes(modes) {
 *
 * @see https://roocodeinc.github.io/Roo-Code/features/custom-modes
 */
-var RooSubagent = class RooSubagent extends ToolSubagent {
+var RooSubagent = class extends ToolSubagent {
 	modes;
 	constructor({ modes, ...rest }) {
 		if (rest.validate !== false) {
@@ -41838,7 +42478,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 			const mode = this.toRooMode(rulesyncSubagent);
 			bySlug.set(mode.slug, mode);
 		}
-		return new RooSubagent({
+		return new this({
 			outputRoot,
 			relativeDirPath: this.getSettablePaths().relativeDirPath,
 			relativeFilePath: ROO_MODES_FILE_NAME,
@@ -41917,7 +42557,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		}
 		const result = RooModesFileSchema.safeParse(parsed ?? { customModes: [] });
 		if (!result.success) throw new Error(`Invalid .roomodes in ${filePath}: ${formatError(result.error)}`);
-		return new RooSubagent({
+		return new this({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: (0, node_path.basename)(relativeFilePath),
@@ -41926,7 +42566,7 @@ var RooSubagent = class RooSubagent extends ToolSubagent {
 		});
 	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
-		return new RooSubagent({
+		return new this({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
@@ -42172,6 +42812,60 @@ var VibeSubagent = class VibeSubagent extends ToolSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/zoocode-subagent.ts
+/**
+* Subagent (custom-mode) generator for **Zoo Code**, the community
+* continuation of Roo Code. Zoo Code keeps the aggregated `.roomodes` file and
+* Roo's mode schema, and the shared mode fields keep riding the `roo:`
+* frontmatter section — one rulesync source must not produce two different
+* spellings of the same field.
+*
+* The post-fork divergence is carried by the `zoocode:` section:
+* `allowedMcpServers` (Zoo Code v3.60.0+) — a per-mode MCP server allowlist.
+* "When omitted, all servers are available. When set, only the listed servers
+* are injected." On import the key is lifted back into `zoocode:` so it
+* round-trips (and never leaks into the `roo:` section, where the archived
+* Roo Code would not understand it).
+*
+* @see https://github.com/Zoo-Code-Org/Zoo-Code
+* @see https://docs.zoocode.dev/features/custom-modes
+*/
+var ZoocodeSubagent = class extends RooSubagent {
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "zoocode"
+		});
+	}
+	static toRooMode(rulesyncSubagent) {
+		const mode = super.toRooMode(rulesyncSubagent);
+		const frontmatter = rulesyncSubagent.getFrontmatter();
+		const zoocodeSection = isRecord(frontmatter.zoocode) ? frontmatter.zoocode : {};
+		if (isStringArray$1(zoocodeSection.allowedMcpServers)) mode.allowedMcpServers = zoocodeSection.allowedMcpServers;
+		return mode;
+	}
+	toRulesyncSubagents() {
+		return super.toRulesyncSubagents().map((subagent) => {
+			const frontmatter = subagent.getFrontmatter();
+			const { allowedMcpServers, ...restRooSection } = isRecord(frontmatter.roo) ? { ...frontmatter.roo } : {};
+			const rebuilt = {
+				...frontmatter,
+				targets: ["zoocode"],
+				roo: restRooSection
+			};
+			if (isStringArray$1(allowedMcpServers)) rebuilt.zoocode = { allowedMcpServers };
+			return new RulesyncSubagent({
+				outputRoot: ".",
+				frontmatter: rebuilt,
+				body: subagent.getBody(),
+				relativeDirPath: subagent.getRelativeDirPath(),
+				relativeFilePath: subagent.getRelativeFilePath(),
+				validate: true
+			});
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/subagents-processor.ts
 const SubagentsProcessorToolTargetSchema = zod_mini.z.enum(subagentsProcessorToolTargetTuple);
 /**
@@ -42411,6 +43105,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: ".roomodes"
 		}
 	}],
+	["zoocode", {
+		class: ZoocodeSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: false,
+			filePattern: ".roomodes"
+		}
+	}],
 	["rovodev", {
 		class: RovodevSubagent,
 		meta: {
@@ -42671,11 +43373,13 @@ For example, if the user instructs \`Call planner subagent to plan the refactori
 //#region src/features/rules/tool-rule.ts
 var ToolRule = class extends ToolFile {
 	root;
+	localRoot;
 	description;
 	globs;
-	constructor({ root = false, description, globs, ...rest }) {
+	constructor({ root = false, localRoot = false, description, globs, ...rest }) {
 		super(rest);
 		this.root = root;
+		this.localRoot = localRoot;
 		this.description = description;
 		this.globs = globs;
 	}
@@ -42758,6 +43462,38 @@ var ToolRule = class extends ToolFile {
 	isRoot() {
 		return this.root;
 	}
+	isLocalRoot() {
+		return this.localRoot;
+	}
+	/**
+	* Convert a tool's separate personal local-root file (see
+	* {@link ToolRuleParams.localRoot}) back to a canonical `localRoot: true`
+	* rulesync rule. The rulesync file keeps the tool-side basename
+	* (`CLAUDE.local.md`, `AGENTS.local.md`, ...), which the derived `.gitignore`
+	* already covers via `.rulesync/rules/*.local.md`, so personal content stays
+	* untracked after import.
+	*
+	* `targets` is scoped to the importing tool rather than `"*"`. A wildcard
+	* would spread the personal content to every tool on the next generate —
+	* including being appended into the committed root file of tools without a
+	* separate local file — and a multi-target import would produce several
+	* wildcard localRoot rules, which the per-target validation rejects.
+	*/
+	toLocalRootRulesyncRule({ targets }) {
+		return new RulesyncRule({
+			outputRoot: this.getOutputRoot(),
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: this.getRelativeFilePath(),
+			frontmatter: {
+				root: false,
+				localRoot: true,
+				targets,
+				globs: []
+			},
+			body: this.getFileContent(),
+			validate: true
+		});
+	}
 	/**
 	* Whether this rule must be left out of the root rule's reference/MCP
 	* instruction listings even though it is a non-root survivor. Used by files
@@ -42790,31 +43526,6 @@ function buildToolPath(toolDir, subDir, excludeToolDir) {
 }
 //#endregion
 //#region src/features/rules/agentsmd-rule.ts
-/**
-* Dependency trees never scanned for nested `AGENTS.md` files, at any depth. An
-* `AGENTS.md` there describes somebody else's project, and neither name is ever
-* a package name. Hidden directories are excluded separately, because an
-* `AGENTS.md` inside one is another tool's generated output (rulesync writes
-* several itself).
-*/
-const NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH = ["node_modules", "__pycache__"];
-/**
-* Build, vendoring and scratch directories, excluded at the **project root
-* only**. A top-level `build/` is a build directory; `packages/build/` is a
-* package, and dropping it silently would lose a real subproject.
-*/
-const NESTED_SCAN_EXCLUDED_ROOT_DIRS = [
-	"vendor",
-	"third_party",
-	"dist",
-	"build",
-	"out",
-	"target",
-	"coverage",
-	"tmp",
-	"temp",
-	"venv"
-];
 var AgentsMdRule = class AgentsMdRule extends ToolRule {
 	constructor({ fileContent, root, ...rest }) {
 		super({
@@ -42871,7 +43582,8 @@ var AgentsMdRule = class AgentsMdRule extends ToolRule {
 		const normalizedDirPath = relativeDirPath === void 0 ? "." : toPosixPath(relativeDirPath);
 		const isNested = relativeFilePath === "AGENTS.md" && normalizedDirPath !== "." && normalizedDirPath !== "" && !normalizedDirPath.startsWith(".");
 		const isRoot = !isNested && relativeFilePath === "AGENTS.md" && (normalizedDirPath === "." || normalizedDirPath === "");
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, isNested ? (0, node_path.join)(normalizedDirPath, relativeFilePath) : isRoot ? AGENTSMD_RULE_FILE_NAME : (0, node_path.join)(AGENTSMD_MEMORIES_DIR_PATH, relativeFilePath)));
+		const relativePath = isNested ? (0, node_path.join)(normalizedDirPath, relativeFilePath) : isRoot ? AGENTSMD_RULE_FILE_NAME : (0, node_path.join)(AGENTSMD_MEMORIES_DIR_PATH, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new AgentsMdRule({
 			outputRoot,
 			relativeDirPath: isNested ? (0, node_path.join)(normalizedDirPath) : isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -43178,7 +43890,8 @@ var AntigravityCliRule = class AntigravityCliRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new AntigravityCliRule({
 			outputRoot,
 			relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -43639,7 +44352,8 @@ var AugmentcodeLegacyRule = class AugmentcodeLegacyRule extends ToolRule {
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
 		const settablePaths = this.getSettablePaths();
 		const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, isRoot ? settablePaths.root.relativeFilePath : (0, node_path.join)(settablePaths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = isRoot ? settablePaths.root.relativeFilePath : (0, node_path.join)(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new AugmentcodeLegacyRule({
 			outputRoot,
 			relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
@@ -43863,7 +44577,8 @@ var ClaudecodeLegacyRule = class ClaudecodeLegacyRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new ClaudecodeLegacyRule({
 			outputRoot,
 			relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -43984,7 +44699,8 @@ var ClaudecodeRule = class ClaudecodeRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const filePath = (0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const filePath = (0, node_path.join)(outputRoot, relativePath);
 		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
 		const result = ClaudecodeRuleFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
@@ -44371,7 +45087,8 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new CodexcliRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -44540,7 +45257,8 @@ var CopilotRule = class CopilotRule extends ToolRule {
 		}) : relativeFilePath === paths.root.relativeFilePath;
 		const resolvedRelativeDirPath = relativeDirPath ?? (isRoot ? paths.root.relativeDirPath : paths.nonRoot?.relativeDirPath ?? paths.root.relativeDirPath);
 		if (isRoot) {
-			const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath)));
+			const relativePath = (0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath);
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 			return new CopilotRule({
 				outputRoot,
 				relativeDirPath: paths.root.relativeDirPath,
@@ -44552,7 +45270,8 @@ var CopilotRule = class CopilotRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const filePath = (0, node_path.join)(outputRoot, (0, node_path.join)(resolvedRelativeDirPath, relativeFilePath));
+		const relativePath = (0, node_path.join)(resolvedRelativeDirPath, relativeFilePath);
+		const filePath = (0, node_path.join)(outputRoot, relativePath);
 		const { frontmatter, body: content } = parseFrontmatter(await readFileContent(filePath), filePath);
 		const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
@@ -44824,7 +45543,8 @@ var DeepagentsRule = class DeepagentsRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
 		const settablePaths = this.getSettablePaths({ global });
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(settablePaths.root.relativeDirPath, settablePaths.root.relativeFilePath)));
+		const relativePath = (0, node_path.join)(settablePaths.root.relativeDirPath, settablePaths.root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new DeepagentsRule({
 			outputRoot,
 			relativeDirPath: settablePaths.root.relativeDirPath,
@@ -45251,7 +45971,8 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
 		if (relativeFilePath === paths.root.relativeFilePath) {
-			const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath)));
+			const relativePath = (0, node_path.join)(paths.root.relativeDirPath, paths.root.relativeFilePath);
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 			return new FactorydroidRule({
 				outputRoot,
 				relativeDirPath: paths.root.relativeDirPath,
@@ -45262,7 +45983,8 @@ var FactorydroidRule = class FactorydroidRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new FactorydroidRule({
 			outputRoot,
 			relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -45492,7 +46214,8 @@ var HermesagentRule = class HermesagentRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true }) {
 		const { root } = this.getSettablePaths();
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new HermesagentRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -45603,7 +46326,8 @@ var JunieRule = class JunieRule extends ToolRule {
 			});
 		}
 		const relativeDirPath = this.getSettablePaths().root.relativeDirPath;
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new JunieRule({
 			outputRoot,
 			relativeDirPath,
@@ -45703,7 +46427,8 @@ var KiloRule = class KiloRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new KiloRule({
 			outputRoot,
 			relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -46040,10 +46765,13 @@ var KiroIdeRule = class extends KiroRule {
 //#region src/features/rules/opencode-rule.ts
 var OpenCodeRule = class OpenCodeRule extends ToolRule {
 	static getSettablePaths({ global, excludeToolDir } = {}) {
-		if (global) return { root: {
-			relativeDirPath: buildToolPath(OPENCODE_GLOBAL_DIR, ".", excludeToolDir),
-			relativeFilePath: OPENCODE_RULE_FILE_NAME
-		} };
+		if (global) return {
+			root: {
+				relativeDirPath: buildToolPath(OPENCODE_GLOBAL_DIR, ".", excludeToolDir),
+				relativeFilePath: OPENCODE_RULE_FILE_NAME
+			},
+			nonRoot: { relativeDirPath: buildToolPath(OPENCODE_GLOBAL_DIR, "memories", excludeToolDir) }
+		};
 		return {
 			root: {
 				relativeDirPath: ".",
@@ -46053,7 +46781,7 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 		};
 	}
 	static getExtraSharedWritePaths({ global = false } = {}) {
-		return global ? [] : [OpencodeMcp.getSettablePaths({ global: false })];
+		return [OpencodeMcp.getSettablePaths({ global })];
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const paths = this.getSettablePaths({ global });
@@ -46070,7 +46798,8 @@ var OpenCodeRule = class OpenCodeRule extends ToolRule {
 			});
 		}
 		if (!paths.nonRoot) throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath)));
+		const relativePath = (0, node_path.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new OpenCodeRule({
 			outputRoot,
 			relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -46185,7 +46914,8 @@ var PiRule = class PiRule extends ToolRule {
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
 		const { root, appendSystemPrompt } = this.getSettablePaths({ global });
 		if (relativeFilePath === "APPEND_SYSTEM.md") {
-			const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(appendSystemPrompt.relativeDirPath, appendSystemPrompt.relativeFilePath)));
+			const relativePath = (0, node_path.join)(appendSystemPrompt.relativeDirPath, appendSystemPrompt.relativeFilePath);
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 			return new PiRule({
 				outputRoot,
 				relativeDirPath: appendSystemPrompt.relativeDirPath,
@@ -46196,7 +46926,8 @@ var PiRule = class PiRule extends ToolRule {
 				appendSystemPrompt: true
 			});
 		}
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new PiRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -46496,7 +47227,7 @@ var QwencodeRule = class QwencodeRule extends ToolRule {
 	* The personal local context file lives under `.qwen/`, not at the project
 	* root where the settable root path points, so override the deletion glob.
 	*/
-	static getLocalRootDeletionGlob({ outputRoot, fileName }) {
+	static getLocalRootFileGlob({ outputRoot, fileName }) {
 		return (0, node_path.join)(outputRoot, QWENCODE_DIR, fileName);
 	}
 };
@@ -46516,9 +47247,51 @@ var ReasonixRule = class ReasonixRule extends ToolRule {
 			relativeFilePath: REASONIX_RULE_FILE_NAME
 		} };
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
+	/**
+	* Context Engine v2 (v1.18.0) walks from the workspace root to the target
+	* path loading per-directory instruction files, so nested `REASONIX.md`
+	* files are a real scoping surface: "Deeper directories beat broader
+	* directories." The scan mirrors the AGENTS.md standard's nested discovery
+	* (same exclusions, import-only, project scope).
+	* @see https://github.com/esengine/DeepSeek-Reasonix/blob/v1.18.0/docs/SESSION_MEMORY_RETRIEVAL.md
+	*/
+	static getNestedFilePatterns({ outputRoot }) {
+		const root = toPosixPath(outputRoot);
+		return {
+			include: [`${root}/**/${REASONIX_RULE_FILE_NAME}`],
+			ignore: [
+				`${root}/${REASONIX_RULE_FILE_NAME}`,
+				`${root}/**/.*/**`,
+				...NESTED_SCAN_EXCLUDED_DIRS_ANY_DEPTH.map((dir) => `${root}/**/${dir}/**`),
+				...NESTED_SCAN_EXCLUDED_ROOT_DIRS.map((dir) => `${root}/${dir}/**`)
+			]
+		};
+	}
+	/**
+	* The subproject directory this rule scopes, or `undefined` for the root
+	* file (project or global).
+	*/
+	getSubprojectPath() {
+		if (this.isRoot()) return;
+		const relativeDirPath = toPosixPath(this.getRelativeDirPath());
+		if (relativeDirPath === "." || relativeDirPath === "" || relativeDirPath.startsWith(".")) return;
+		return relativeDirPath;
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, relativeDirPath: overrideDirPath, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		if (overrideDirPath !== void 0 && overrideDirPath !== root.relativeDirPath && overrideDirPath !== ".") {
+			const fileContent = await readFileContent((0, node_path.join)(outputRoot, overrideDirPath, REASONIX_RULE_FILE_NAME));
+			return new ReasonixRule({
+				outputRoot,
+				relativeDirPath: overrideDirPath,
+				relativeFilePath: REASONIX_RULE_FILE_NAME,
+				fileContent,
+				validate,
+				root: false
+			});
+		}
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new ReasonixRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -46530,7 +47303,17 @@ var ReasonixRule = class ReasonixRule extends ToolRule {
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const isRoot = rulesyncRule.getFrontmatter().root ?? false;
+		const frontmatter = rulesyncRule.getFrontmatter();
+		const isRoot = frontmatter.root ?? false;
+		const subprojectPath = frontmatter.agentsmd?.subprojectPath;
+		if (!global && !isRoot && subprojectPath) return new ReasonixRule({
+			outputRoot,
+			relativeDirPath: (0, node_path.join)(subprojectPath),
+			relativeFilePath: REASONIX_RULE_FILE_NAME,
+			fileContent: rulesyncRule.getBody(),
+			validate,
+			root: false
+		});
 		return new ReasonixRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -46541,7 +47324,22 @@ var ReasonixRule = class ReasonixRule extends ToolRule {
 		});
 	}
 	toRulesyncRule() {
-		return this.toRulesyncRuleDefault();
+		const subprojectPath = this.getSubprojectPath();
+		if (subprojectPath === void 0) return this.toRulesyncRuleDefault();
+		const slug = subprojectPath.replaceAll("/", "-");
+		return new RulesyncRule({
+			outputRoot: this.getOutputRoot(),
+			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
+			relativeFilePath: `${slug}-reasonix.md`,
+			frontmatter: {
+				targets: ["reasonix"],
+				root: false,
+				globs: [`${subprojectPath}/**/*`],
+				agentsmd: { subprojectPath }
+			},
+			body: this.getFileContent(),
+			validate: true
+		});
 	}
 	validate() {
 		return {
@@ -46711,7 +47509,7 @@ var RooRule = class RooRule extends ToolRule {
 	* Glob for the `separate-local-file` deletion; Roo reads `AGENTS.local.md`
 	* at the project root, not under `.roo/` (mirrors rovodev).
 	*/
-	static getLocalRootDeletionGlob({ outputRoot, fileName }) {
+	static getLocalRootFileGlob({ outputRoot, fileName }) {
 		return (0, node_path.join)(outputRoot, fileName);
 	}
 };
@@ -46843,19 +47641,6 @@ var RovodevRule = class RovodevRule extends ToolRule {
 		}));
 	}
 	toRulesyncRule() {
-		if (this.getRelativeFilePath() === "AGENTS.local.md") return new RulesyncRule({
-			outputRoot: this.getOutputRoot(),
-			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
-			relativeFilePath: ROVODEV_LEGACY_RULE_FILE_NAME,
-			frontmatter: {
-				targets: ["rovodev"],
-				root: false,
-				localRoot: true,
-				globs: []
-			},
-			body: this.getFileContent(),
-			validate: true
-		});
 		if (!this.isRoot()) return new RulesyncRule({
 			outputRoot: this.getOutputRoot(),
 			relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH,
@@ -46912,7 +47697,7 @@ var RovodevRule = class RovodevRule extends ToolRule {
 		};
 	}
 	/** Glob for the `separate-local-file` deletion; rovodev writes it at project root, not under `.rovodev/`. */
-	static getLocalRootDeletionGlob({ outputRoot, fileName }) {
+	static getLocalRootFileGlob({ outputRoot, fileName }) {
 		return (0, node_path.join)(outputRoot, fileName);
 	}
 };
@@ -47114,7 +47899,8 @@ var WarpRule = class WarpRule extends ToolRule {
 	}
 	static async fromFile({ outputRoot = process.cwd(), relativeFilePath: _relativeFilePath, validate = true, global = false }) {
 		const { root } = this.getSettablePaths({ global });
-		const fileContent = await readFileContent((0, node_path.join)(outputRoot, (0, node_path.join)(root.relativeDirPath, root.relativeFilePath)));
+		const relativePath = (0, node_path.join)(root.relativeDirPath, root.relativeFilePath);
+		const fileContent = await readFileContent((0, node_path.join)(outputRoot, relativePath));
 		return new WarpRule({
 			outputRoot,
 			relativeDirPath: root.relativeDirPath,
@@ -47239,6 +48025,27 @@ var ZedRule = class ZedRule extends ToolRule {
 	}
 };
 //#endregion
+//#region src/features/rules/zoocode-rule.ts
+/**
+* Rule generator for **Zoo Code**, the community continuation of Roo Code
+* (named by the Roo shutdown notice; releases continue Roo's numbering from
+* v3.54.0). Zoo Code still resolves `~/.roo` and the project `.roo/` layout —
+* the `.zoo` renaming is confined to provider/auth code — so this target
+* reuses {@link RooRule}'s behavior verbatim and only narrows the targeting to
+* the `zoocode` tool name.
+*
+* @see https://github.com/Zoo-Code-Org/Zoo-Code
+* @see https://docs.zoocode.dev
+*/
+var ZoocodeRule = class extends RooRule {
+	static isTargetedByRulesyncRule(rulesyncRule) {
+		return this.isTargetedByRulesyncRuleDefault({
+			rulesyncRule,
+			toolTarget: "zoocode"
+		});
+	}
+};
+//#endregion
 //#region src/features/rules/rules-processor.ts
 const RulesProcessorToolTargetSchema = zod_mini.z.enum(rulesProcessorToolTargetTuple);
 const formatRulePaths = (rules) => rules.map((r) => (0, node_path.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
@@ -47501,6 +48308,7 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true,
 			ruleDiscoveryMode: "toon",
 			mcpInstructionsRegistrar: OpencodeMcp,
+			mcpInstructionsRegistrarGlobal: true,
 			collisionPolicy: "compose"
 		}
 	}],
@@ -47565,6 +48373,16 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			localRootFileName: "AGENTS.local.md"
 		}
 	}],
+	["zoocode", {
+		class: ZoocodeRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			localRootMode: "separate-local-file",
+			localRootFileName: "AGENTS.local.md"
+		}
+	}],
 	["takt", {
 		class: TaktRule,
 		meta: {
@@ -47737,18 +48555,19 @@ var RulesProcessor = class extends FeatureProcessor {
 	/**
 	* Non-root rules of some tools are not auto-loaded; the tool's MCP feature
 	* registers them in its shared config's `instructions` key. The root rule is
-	* auto-loaded and never registered. Project scope only.
+	* auto-loaded and never registered. Global scope opt-in via
+	* `mcpInstructionsRegistrarGlobal`.
 	*/
 	async buildMcpInstructionFiles({ toolRules, meta }) {
-		if (!meta.mcpInstructionsRegistrar || this.global) return [];
+		if (!meta.mcpInstructionsRegistrar || this.global && !meta.mcpInstructionsRegistrarGlobal) return [];
 		const instructionPaths = toolRules.filter((rule) => !rule.isRoot() && !rule.isExcludedFromRootReferences()).map((rule) => toPosixPath((0, node_path.join)(rule.getRelativeDirPath(), rule.getRelativeFilePath())));
-		if (instructionPaths.length === 0) return [];
-		return [await meta.mcpInstructionsRegistrar.fromInstructions({
+		const registered = await meta.mcpInstructionsRegistrar.fromInstructions({
 			outputRoot: this.outputRoot,
 			instructions: instructionPaths,
 			validate: true,
 			global: this.global
-		})];
+		});
+		return registered ? [registered] : [];
 	}
 	/**
 	* For tools that don't create a separate conventions rule, prepend the
@@ -47879,53 +48698,58 @@ var RulesProcessor = class extends FeatureProcessor {
 		const rootRule = toolRules.find((rule) => rule.isRoot());
 		if (rootRule) rootRule.setFileContent(rootRule.getFileContent() + "\n\n" + localRootBody);
 	}
-	buildLocalRootFile({ factory, fileName, body }) {
+	buildLocalRootFile({ factory, fileName, body, relativeDirPath, localRoot = false }) {
 		if (factory.class === ClaudecodeRule) {
 			const paths = ClaudecodeRule.getSettablePaths({ global: this.global });
 			return new ClaudecodeRule({
 				outputRoot: this.outputRoot,
-				relativeDirPath: paths.root.relativeDirPath,
+				relativeDirPath: relativeDirPath ?? paths.root.relativeDirPath,
 				relativeFilePath: fileName,
 				frontmatter: {},
 				body,
 				validate: true,
-				root: true
+				root: true,
+				localRoot
 			});
 		}
 		if (factory.class === ClaudecodeLegacyRule) {
 			const paths = ClaudecodeLegacyRule.getSettablePaths({ global: this.global });
 			return new ClaudecodeLegacyRule({
 				outputRoot: this.outputRoot,
-				relativeDirPath: paths.root.relativeDirPath,
+				relativeDirPath: relativeDirPath ?? paths.root.relativeDirPath,
 				relativeFilePath: fileName,
 				fileContent: body,
 				validate: true,
-				root: true
+				root: true,
+				localRoot
 			});
 		}
 		if (factory.class === RovodevRule) return new RovodevRule({
 			outputRoot: this.outputRoot,
-			relativeDirPath: ".",
+			relativeDirPath: relativeDirPath ?? ".",
 			relativeFilePath: fileName,
 			fileContent: body,
 			validate: true,
-			root: true
+			root: true,
+			localRoot
 		});
 		if (factory.class === RooRule) return new RooRule({
 			outputRoot: this.outputRoot,
-			relativeDirPath: ".",
+			relativeDirPath: relativeDirPath ?? ".",
 			relativeFilePath: fileName,
 			fileContent: body,
 			validate: true,
-			root: true
+			root: true,
+			localRoot
 		});
 		if (factory.class === QwencodeRule) return new QwencodeRule({
 			outputRoot: this.outputRoot,
-			relativeDirPath: QWENCODE_DIR,
+			relativeDirPath: relativeDirPath ?? ".qwen",
 			relativeFilePath: fileName,
 			fileContent: body,
 			validate: true,
-			root: true
+			root: true,
+			localRoot
 		});
 		return null;
 	}
@@ -47963,6 +48787,7 @@ As this project's AI coding tool, you must follow the additional conventions bel
 	async convertToolFilesToRulesyncFiles(toolFiles) {
 		const toolRules = toolFiles.filter((file) => file instanceof ToolRule);
 		const rulesyncRules = toolRules.map((toolRule) => {
+			if (toolRule.isLocalRoot()) return toolRule.toLocalRootRulesyncRule({ targets: [this.toolTarget] });
 			return toolRule.toRulesyncRule();
 		});
 		const claimedBy = /* @__PURE__ */ new Map();
@@ -48096,20 +48921,34 @@ As this project's AI coding tool, you must follow the additional conventions bel
 			})();
 			this.logger.debug(`Found ${rootToolRules.length} root tool rule files`);
 			const localRootToolRules = await (async () => {
-				if (!forDeletion || this.global || factory.meta.localRootMode !== "separate-local-file" || !factory.meta.localRootFileName) return [];
+				if (this.global || factory.meta.localRootMode !== "separate-local-file" || !factory.meta.localRootFileName) return [];
 				const fileName = factory.meta.localRootFileName;
-				if (factory.class.getLocalRootDeletionGlob) {
-					const filePaths = await findFilesByGlobs(factory.class.getLocalRootDeletionGlob({
+				const filePaths = await (async () => {
+					if (factory.class.getLocalRootFileGlob) return await findFilesByGlobs(factory.class.getLocalRootFileGlob({
 						outputRoot: this.outputRoot,
 						fileName
 					}));
-					return buildDeletionRulesFromPaths(filePaths);
-				}
-				if (!settablePaths.root) return [];
-				const filePaths = await findFilesWithFallback((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName));
-				return buildDeletionRulesFromPaths(filePaths);
+					if (!settablePaths.root) return [];
+					return await findFilesWithFallback((0, node_path.join)(this.outputRoot, settablePaths.root.relativeDirPath ?? ".", fileName), settablePaths.alternativeRoots, (alt) => (0, node_path.join)(this.outputRoot, alt.relativeDirPath, fileName));
+				})();
+				if (forDeletion) return buildDeletionRulesFromPaths(filePaths);
+				return (await Promise.all(filePaths.map(async (filePath) => {
+					const relativeDirPath = resolveRelativeDirPath(filePath);
+					checkPathTraversal({
+						relativePath: relativeDirPath,
+						intendedRootDir: this.outputRoot
+					});
+					const body = await readFileContent(filePath);
+					return this.buildLocalRootFile({
+						factory,
+						fileName: (0, node_path.basename)(filePath),
+						body,
+						relativeDirPath,
+						localRoot: true
+					});
+				}))).filter((rule) => rule !== null);
 			})();
-			this.logger.debug(`Found ${localRootToolRules.length} local root tool rule files for deletion`);
+			this.logger.debug(`Found ${localRootToolRules.length} local root tool rule files`);
 			const rootMirrorDeletionRules = await (async () => {
 				const rootMirror = factory.class.getRootMirror?.();
 				if (!forDeletion || this.global || !rootMirror) return [];
@@ -48235,13 +49074,14 @@ As this project's AI coding tool, you must follow the additional conventions bel
 		const lines = [];
 		lines.push("Please also reference the following rules as needed. The list below is provided in TOON format, and `@` stands for the project root directory.");
 		lines.push("");
-		const toonContent = (0, _toon_format_toon.encode)({ rules: toolRulesWithoutRoot.map((toolRule) => {
+		const rules = toolRulesWithoutRoot.map((toolRule) => {
 			const frontmatter = toolRule.toRulesyncRule().getFrontmatter();
 			const rule = { path: `@${toolRule.getRelativePathFromCwd()}` };
 			if (frontmatter.description) rule.description = frontmatter.description;
 			if (frontmatter.globs && frontmatter.globs.length > 0) rule.applyTo = frontmatter.globs;
 			return rule;
-		}) });
+		});
+		const toonContent = (0, _toon_format_toon.encode)({ rules });
 		lines.push(toonContent);
 		return lines.join("\n") + "\n\n";
 	}
@@ -49403,8 +50243,8 @@ async function generateIgnoreCore(params) {
 			allPaths.push(...result.paths);
 			if (result.hasDiff) hasDiff = true;
 		} catch (error) {
-			logger.warn(`Failed to generate ${toolTarget} ignore files for ${outputRoot}: ${formatError(error)}`);
-			continue;
+			logger.error(`Failed to generate ${toolTarget} ignore files for ${outputRoot}: ${formatError(error)}`);
+			throw error;
 		}
 	}
 	return {
@@ -49676,8 +50516,8 @@ async function generatePermissionsCore(params) {
 			allPaths.push(...result.paths);
 			if (result.hasDiff) hasDiff = true;
 		} catch (error) {
-			logger.warn(`Failed to generate ${toolTarget} permissions files for ${outputRoot}: ${formatError(error)}`);
-			continue;
+			logger.error(`Failed to generate ${toolTarget} permissions files for ${outputRoot}: ${formatError(error)}`);
+			throw error;
 		}
 	}
 	return {