rulesync 10.1.0 → 12.0.0

package/dist/{import-Dcj5HiOE.cjs → import-C0N0Lo_F.cjs}

@@ -114,25 +114,25 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$251 } = node_path.posix;
+const { join: join$252 } = 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$251(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$251(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$252(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$251(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$251(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$252(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$252(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_FILE_NAME = "hooks.json";
@@ -289,6 +289,7 @@ const subagentsProcessorToolTargetTuple = [
 	"kiro-ide",
 	"opencode",
 	"qwencode",
+	"reasonix",
 	"roo",
 	"rovodev",
 	"takt",
@@ -5118,6 +5119,9 @@ const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "commands");
 const REASONIX_RULE_FILE_NAME = "REASONIX.md";
 const REASONIX_SKILLS_DIR_PATH = (0, node_path.join)(REASONIX_DIR, "skills");
+const REASONIX_SUBAGENTS_DIR_PATH = REASONIX_SKILLS_DIR_PATH;
+const REASONIX_SUBAGENT_INVOCATION = "manual";
+const REASONIX_SUBAGENT_RUN_AS = "subagent";
 //#endregion
 //#region src/features/commands/reasonix-command.ts
 /**
@@ -17454,7 +17458,11 @@ const CodexApprovalPolicySchema = zod_mini.z.enum([
 ]);
 /**
 * Codex CLI's classic sandbox mode. Serialized as a kebab-case string in
-* `.codex/config.toml`.
+* `.codex/config.toml`. Deprecated in favor of permission profiles
+* (`base_permission_profile`): Codex prioritizes these legacy sandbox keys
+* over permission profiles when both are present, so authoring one disables
+* the managed `[permissions.rulesync]` profile. Kept so existing configs
+* round-trip.
 * @see https://learn.chatgpt.com/docs/config-file/config-reference
 */
 const CodexSandboxModeSchema = zod_mini.z.enum([
@@ -17474,6 +17482,18 @@ const CodexApprovalsReviewerSchema = zod_mini.z.enum([
 	"guardian_subagent"
 ]);
 /**
+* Codex CLI's built-in permission profiles that the managed
+* `[permissions.rulesync]` profile may extend. Codex ships three built-in
+* profiles (`:read-only`, `:workspace`, `:danger-full-access`; the leading
+* colon is reserved for built-ins), but `extends` rejects
+* `:danger-full-access` at config load time, so only the two extendable
+* baselines are accepted here. The value list is exported so the Codex CLI
+* translator derives its import-side baseline check from the same source.
+* @see https://learn.chatgpt.com/docs/permissions
+*/
+const CODEX_BASE_PERMISSION_PROFILES = [":read-only", ":workspace"];
+const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_PROFILES);
+/**
 * Codex CLI-scoped permission override.
 *
 * Codex CLI's permission surface is richer than the canonical allow/ask/deny
@@ -17482,16 +17502,37 @@ const CodexApprovalsReviewerSchema = zod_mini.z.enum([
 * override whose fields are written verbatim as top-level `.codex/config.toml`
 * keys (the override wins per key; existing sibling keys the user set directly
 * are preserved):
+* - `base_permission_profile` — the built-in profile the managed
+*   `[permissions.rulesync]` profile extends (`:read-only` | `:workspace`).
+*   Unlike the other keys it is not a top-level config key: it is emitted as
+*   the profile's `extends` value. Defaults to `:workspace` when unspecified.
 * - `approval_policy` — `untrusted` | `on-request` (legacy alias `on-failure`) |
 *   `never`, or a `{ granular = { … } }` table (kept verbatim; the granular
 *   schema has required fields that are brittle to model as typed keys).
-* - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
-*   with the sibling `sandbox_workspace_write` table (`network_access`,
-*   `writable_roots`, …).
+*   Defaults to `on-request` when neither the override nor the existing
+*   config sets it.
+* - `sandbox_mode` — **deprecated.** `read-only` | `workspace-write` |
+*   `danger-full-access`, with the sibling `sandbox_workspace_write` table
+*   (`network_access`, `writable_roots`, …). Codex has superseded the classic
+*   sandbox system with permission profiles and prioritizes these legacy keys
+*   over profiles when both are present, so setting them disables the managed
+*   `[permissions.rulesync]` profile. Use `base_permission_profile` and the
+*   shared `permission` block instead. Still accepted so existing configs
+*   round-trip.
 * - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
 *   `.enabled`, `apps.<id>.default_tools_approval_mode`).
 * - `approvals_reviewer` — the reviewer-approval surface (`user` | `auto_review`
 *   | `guardian_subagent`), or a table for the richer reviewer config.
+*   Defaults to `auto_review` when neither the override nor the existing
+*   config sets it.
+* - `git_write_rules` — whether the managed profile's `:workspace_roots` table
+*   emits the default `.git` carve-outs (`".git/**" = "write"` with
+*   `".git/config" = "read"` kept read-only as a security guard). Codex's
+*   `:workspace` baseline makes `.git` read-only, which denies basic git
+*   workflows (commit/stage writes to `.git/index`, `.git/objects`, refs,
+*   logs), so the carve-outs are emitted by default. Defaults to `true`; only
+*   an explicit `false` suppresses them. Like `base_permission_profile` it is
+*   consumed by the profile builder, not written as a top-level config key.
 *
 * Two surfaces are deliberately NOT authorable here so the override can never
 * clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
@@ -17510,11 +17551,15 @@ const CodexApprovalsReviewerSchema = zod_mini.z.enum([
 */
 const CodexcliPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
+	base_permission_profile: zod_mini.z.optional(CodexBasePermissionProfileSchema),
 	approval_policy: zod_mini.z.optional(zod_mini.z.union([CodexApprovalPolicySchema, zod_mini.z.looseObject({})])),
+	/** @deprecated Superseded by `base_permission_profile` (permission profiles). */
 	sandbox_mode: zod_mini.z.optional(CodexSandboxModeSchema),
+	/** @deprecated Superseded by `base_permission_profile` (permission profiles). */
 	sandbox_workspace_write: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	apps: zod_mini.z.optional(zod_mini.z.looseObject({})),
-	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})]))
+	approvals_reviewer: zod_mini.z.optional(zod_mini.z.union([CodexApprovalsReviewerSchema, zod_mini.z.looseObject({})])),
+	git_write_rules: zod_mini.z.optional(zod_mini.z.boolean())
 });
 /**
 * Permissions configuration.
@@ -19483,14 +19528,16 @@ var ClinePermissions = class ClinePermissions extends ToolPermissions {
 const RULESYNC_PROFILE_NAME = "rulesync";
 const CODEX_WORKSPACE_ROOTS_KEY = ":workspace_roots";
 const CODEX_WORKSPACE_BASELINE = ":workspace";
+const CODEX_READ_ONLY_BASELINE = ":read-only";
+const CODEX_EXTENDABLE_BASELINES = new Set(CODEX_BASE_PERMISSION_PROFILES);
+const CODEX_DEFAULT_APPROVAL_POLICY = "on-request";
+const CODEX_DEFAULT_APPROVALS_REVIEWER = "auto_review";
 const CODEX_GLOB_SCAN_MAX_DEPTH = 8;
-const WORKSPACE_WIDE_WRITE_PATTERNS = /* @__PURE__ */ new Set([
-	".",
-	"./",
-	"**",
-	"./**"
-]);
 const CODEX_MINIMAL_KEY = ":minimal";
+const CODEX_GIT_WRITE_RULES = {
+	".git/**": "write",
+	".git/config": "read"
+};
 const GLOBAL_WILDCARD_DOMAIN = "*";
 var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 	static getSettablePaths(_options = {}) {
@@ -19579,6 +19626,7 @@ var CodexcliPermissions = class CodexcliPermissions extends ToolPermissions {
 			domainsHadUnknown
 		});
 		const override = extractCodexcliOverride(table);
+		if (typeof profile?.extends === "string" && CODEX_EXTENDABLE_BASELINES.has(profile.extends)) override.base_permission_profile = profile.extends;
 		const result = Object.keys(override).length > 0 ? {
 			...config,
 			codexcli: override
@@ -19656,23 +19704,34 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 		}
 		logger?.warn(`Codex CLI permissions support only read/edit/write/webfetch categories. Skipping: ${toolName}`);
 	}
+	applyDefaultGitWriteRules({
+		config,
+		filesystem,
+		workspaceRootFilesystem
+	});
 	if (Object.keys(workspaceRootFilesystem).length > 0) {
 		if (typeof filesystem[CODEX_WORKSPACE_ROOTS_KEY] === "string") logger?.warn(`"${CODEX_WORKSPACE_ROOTS_KEY}" is set as a direct filesystem access rule in the permissions, but it will be overwritten by workspace-root rules. Consider removing the direct "${CODEX_WORKSPACE_ROOTS_KEY}" entry.`);
 		if (Object.keys(workspaceRootFilesystem).some((pattern) => pattern.includes("**"))) filesystem.glob_scan_max_depth = CODEX_GLOB_SCAN_MAX_DEPTH;
 		filesystem[CODEX_WORKSPACE_ROOTS_KEY] = workspaceRootFilesystem;
 	}
-	const hasWorkspaceWideWrite = Object.entries(workspaceRootFilesystem).some(([pattern, access]) => access === "write" && WORKSPACE_WIDE_WRITE_PATTERNS.has(pattern));
+	const basePermissionProfile = config.codexcli?.base_permission_profile ?? CODEX_WORKSPACE_BASELINE;
 	const hasAllowDomain = Object.values(domains).some((action) => action === "allow");
 	const network = Object.keys(domains).length > 0 ? {
 		...hasAllowDomain ? { enabled: true } : {},
 		domains
 	} : void 0;
 	return {
-		...hasWorkspaceWideWrite ? { extends: CODEX_WORKSPACE_BASELINE } : {},
+		extends: basePermissionProfile,
 		filesystem,
 		...network ? { network } : {}
 	};
 }
+function applyDefaultGitWriteRules({ config, filesystem, workspaceRootFilesystem }) {
+	if (config.codexcli?.git_write_rules === false) return;
+	if (config.codexcli?.base_permission_profile === CODEX_READ_ONLY_BASELINE) return;
+	if (typeof filesystem[CODEX_WORKSPACE_ROOTS_KEY] === "string") return;
+	for (const [pattern, access] of Object.entries(CODEX_GIT_WRITE_RULES)) workspaceRootFilesystem[pattern] ??= access;
+}
 function convertCodexProfileToRulesync({ profile, domainsHadUnknown }) {
 	const permission = {};
 	if (profile?.filesystem) {
@@ -19684,13 +19743,12 @@ function convertCodexProfileToRulesync({ profile, domainsHadUnknown }) {
 				addRulesyncFilesystemRule(permission, pattern, access);
 				continue;
 			}
-			if (isCodexFilesystemRuleTable(access)) for (const [nestedPattern, nestedAccess] of Object.entries(access)) addRulesyncFilesystemRule(permission, nestedPattern, nestedAccess);
+			if (isCodexFilesystemRuleTable(access)) for (const [nestedPattern, nestedAccess] of Object.entries(access)) {
+				if (pattern === CODEX_WORKSPACE_ROOTS_KEY && CODEX_GIT_WRITE_RULES[nestedPattern] === nestedAccess) continue;
+				addRulesyncFilesystemRule(permission, nestedPattern, nestedAccess);
+			}
 		}
 	}
-	if (profile?.extends === CODEX_WORKSPACE_BASELINE) {
-		permission.edit ??= {};
-		permission.edit["."] ??= "allow";
-	}
 	if (profile?.network && profile.network.enabled !== false) {
 		const networkEnabled = profile.network.enabled === true;
 		const importedEntries = (profile.network.domains ? Object.entries(profile.network.domains) : []).filter(([, value]) => value === "deny" || networkEnabled);
@@ -19729,10 +19787,29 @@ function toCodexProfile(value) {
 	};
 }
 function warnAboutPreservedProfileState({ existingProfile, newProfile, existingDomainsHadUnknown, logger }) {
-	if (existingProfile?.extends !== void 0 && existingProfile.extends !== newProfile.extends) logger?.warn(`Existing "extends" value "${existingProfile.extends}" will be replaced by Rulesync-managed "${newProfile.extends ?? "(none)"}".`);
+	if (existingProfile !== void 0 && existingProfile.extends !== newProfile.extends) logger?.warn(`Existing "extends" value "${existingProfile.extends ?? "(none)"}" will be replaced by Rulesync-managed "${newProfile.extends ?? "(none)"}".`);
+	warnAboutPreservedNetworkState({
+		existingProfile,
+		newProfile,
+		logger
+	});
+	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
+}
+function networkHasAllowDomain(network) {
+	return Object.values(network?.domains ?? {}).some((action) => action === "allow");
+}
+function warnAboutNetworkEnabledState({ existingProfile, newProfile, logger }) {
+	if (existingProfile?.network?.enabled !== void 0 && newProfile.network?.enabled === void 0 && !networkHasAllowDomain(existingProfile.network)) logger?.warn(`Preserving existing "network.enabled" from config. Review this value manually as it may enable network access beyond the Rulesync-managed domain rules.`);
+	if (existingProfile?.network?.enabled === false && newProfile.network?.enabled === true) logger?.warn(`Existing "network.enabled = false" will be replaced by Rulesync-managed "enabled = true" because the canonical model contains an allow domain.`);
+}
+function warnAboutPreservedNetworkState({ existingProfile, newProfile, logger }) {
 	if (existingProfile?.network?.unix_sockets !== void 0) logger?.warn(`Preserving existing "network.unix_sockets" from config. Review these entries manually as they may grant broad system access.`);
+	warnAboutNetworkEnabledState({
+		existingProfile,
+		newProfile,
+		logger
+	});
 	if (existingProfile?.network?.mode !== void 0) logger?.warn(`Preserving existing "network.mode" from config. Review this value manually as it may grant broader network access than the Rulesync-managed domain rules.`);
-	if (existingDomainsHadUnknown) logger?.warn(`Existing "network.domains" contained unrecognized values. These entries were skipped and will not be imported.`);
 }
 const MANAGED_PROFILE_KEYS = /* @__PURE__ */ new Set([
 	"description",
@@ -19774,6 +19851,7 @@ function preserveUnmanagedProfileKeys({ rawExistingProfile, profile, logger }) {
 function mergeWithExistingProfile({ newProfile, existingProfile }) {
 	if (!existingProfile) return newProfile;
 	const mergedNetwork = { ...newProfile.network };
+	if (existingProfile.network?.enabled !== void 0 && mergedNetwork.enabled === void 0 && !networkHasAllowDomain(existingProfile.network)) mergedNetwork.enabled = existingProfile.network.enabled;
 	if (existingProfile.network?.mode !== void 0 && mergedNetwork.mode === void 0) mergedNetwork.mode = existingProfile.network.mode;
 	if (existingProfile.network?.unix_sockets !== void 0 && mergedNetwork.unix_sockets === void 0) mergedNetwork.unix_sockets = existingProfile.network.unix_sockets;
 	const hasNetwork = Object.keys(mergedNetwork).length > 0;
@@ -19823,20 +19901,26 @@ function isPlainObject(value) {
 }
 function computeCodexcliOverridePatch({ existing, override, logger }) {
 	const patch = {};
-	if (!override) return patch;
 	const allowed = new Set(CODEXCLI_OVERRIDE_KEYS);
-	for (const [key, value] of Object.entries(override)) {
+	for (const [key, value] of Object.entries(override ?? {})) {
+		if (key === "base_permission_profile" || key === "git_write_rules") continue;
 		if (!allowed.has(key)) {
 			logger?.warn(`Codex CLI permission override key "${key}" is not managed and was skipped. "permissions"/"default_permissions" are owned by the canonical permission model and "mcp_servers" gating by the MCP feature.`);
 			continue;
 		}
 		if (value === void 0) continue;
+		if (key === "sandbox_mode" || key === "sandbox_workspace_write") logger?.warn(`Codex CLI permission override key "${key}" is deprecated. Codex prioritizes the legacy sandbox settings over permission profiles when both are present, so it disables the generated "${RULESYNC_PROFILE_NAME}" permissions profile. Use "base_permission_profile" and the shared "permission" block instead.`);
 		const existingValue = existing[key];
 		patch[key] = isPlainObject(existingValue) && isPlainObject(value) ? {
 			...existingValue,
 			...value
 		} : value;
 	}
+	const defaults = {
+		approval_policy: CODEX_DEFAULT_APPROVAL_POLICY,
+		approvals_reviewer: CODEX_DEFAULT_APPROVALS_REVIEWER
+	};
+	for (const [key, value] of Object.entries(defaults)) if (patch[key] === void 0 && existing[key] === void 0) patch[key] = value;
 	return patch;
 }
 function extractCodexcliOverride(table) {
@@ -28459,6 +28543,24 @@ var ReasonixSkill = class ReasonixSkill extends ToolSkill {
 			global: loaded.global
 		});
 	}
+	/**
+	* Whether the skill directory belongs to the skills feature.
+	*
+	* `.reasonix/skills/` is shared with the subagents feature: a directory whose
+	* SKILL.md declares `runAs: subagent` is a subagent profile, not a regular
+	* skill, so it must be neither imported as a skill nor deleted as an orphan
+	* skill. Directories without a readable/parsable SKILL.md keep the default
+	* skills-feature ownership, matching the previous behavior for such dirs.
+	*/
+	static async isDirOwned({ outputRoot, relativeDirPath, dirName }) {
+		const skillFilePath = (0, node_path.join)(outputRoot, relativeDirPath, dirName, SKILL_FILE_NAME);
+		try {
+			const { frontmatter } = parseFrontmatter(await readFileContent(skillFilePath), skillFilePath);
+			return frontmatter["runAs"] !== REASONIX_SUBAGENT_RUN_AS;
+		} catch {
+			return true;
+		}
+	}
 	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
 		return new ReasonixSkill({
 			outputRoot,
@@ -29757,6 +29859,11 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			for (const dirPath of dirPaths) {
 				const dirName = (0, node_path.basename)(dirPath);
 				if (seenDirNames.has(dirName)) continue;
+				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: root,
+					dirName
+				})) continue;
 				seenDirNames.add(dirName);
 				loadEntries.push({
 					root,
@@ -29783,6 +29890,11 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			const dirPaths = await findFilesByGlobs((0, node_path.join)(skillsDirPath, "*"), { type: "dir" });
 			for (const dirPath of dirPaths) {
 				const dirName = (0, node_path.basename)(dirPath);
+				if (factory.class.isDirOwned && !await factory.class.isDirOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: root,
+					dirName
+				})) continue;
 				const toolSkill = factory.class.forDeletion({
 					outputRoot: this.outputRoot,
 					relativeDirPath: root,
@@ -33082,6 +33194,188 @@ var OpenCodeSubagent = class OpenCodeSubagent extends OpenCodeStyleSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/reasonix-subagent.ts
+const ReasonixSubagentFrontmatterSchema = zod_mini.z.looseObject({
+	name: zod_mini.z.string(),
+	description: zod_mini.z.optional(zod_mini.z.string()),
+	invocation: zod_mini.z.optional(zod_mini.z.string()),
+	runAs: zod_mini.z.optional(zod_mini.z.string()),
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	effort: zod_mini.z.optional(zod_mini.z.string()),
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	color: zod_mini.z.optional(zod_mini.z.string())
+});
+/**
+* Represents a DeepSeek-Reasonix subagent profile.
+*
+* Reasonix discovers subagents as directory-layout Skills (`<name>/SKILL.md`)
+* under `.reasonix/skills/` (project) and `~/.reasonix/skills/` (global); the
+* global scope is served by the processor supplying the home directory as
+* outputRoot, so the relative directory path is identical for both scopes. A
+* subagent is a Skill whose frontmatter declares `invocation: manual` and
+* `runAs: subagent`.
+*
+* @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/SUBAGENT_PROFILES.md
+*/
+var ReasonixSubagent = class ReasonixSubagent extends ToolSubagent {
+	frontmatter;
+	body;
+	constructor({ frontmatter, body, fileContent, ...rest }) {
+		if (rest.validate !== false) {
+			const result = ReasonixSubagentFrontmatterSchema.safeParse(frontmatter);
+			if (!result.success) throw new Error(`Invalid frontmatter in ${(0, node_path.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`);
+		}
+		super({
+			...rest,
+			fileContent: fileContent ?? stringifyFrontmatter(body, frontmatter)
+		});
+		this.frontmatter = frontmatter;
+		this.body = body;
+	}
+	static getSettablePaths({ global: _global = false } = {}) {
+		return { relativeDirPath: REASONIX_SUBAGENTS_DIR_PATH };
+	}
+	getFrontmatter() {
+		return this.frontmatter;
+	}
+	getBody() {
+		return this.body;
+	}
+	toRulesyncSubagent() {
+		const { name, description, invocation: _invocation, runAs: _runAs, ...restFields } = this.frontmatter;
+		const reasonixSection = { ...restFields };
+		const rulesyncFrontmatter = {
+			targets: ["*"],
+			name,
+			description,
+			...Object.keys(reasonixSection).length > 0 && { reasonix: reasonixSection }
+		};
+		return new RulesyncSubagent({
+			outputRoot: this.getOutputRoot(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.body,
+			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+			relativeFilePath: `${this.getSubagentName()}.md`,
+			validate: true
+		});
+	}
+	/**
+	* Derive the subagent name from this instance's relative file path.
+	*
+	* The tool-side layout is `<name>/SKILL.md`, so the name is the parent
+	* directory of the file. If the path is unexpectedly flat (e.g. a legacy
+	* `<name>.md`), fall back to the basename without extension.
+	*/
+	getSubagentName() {
+		const relativeFilePath = this.getRelativeFilePath();
+		const dir = (0, node_path.dirname)(relativeFilePath);
+		if (dir && dir !== ".") return (0, node_path.basename)(dir);
+		return (0, node_path.basename)(relativeFilePath, (0, node_path.extname)(relativeFilePath));
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+		const reasonixSection = this.filterToolSpecificSection(rulesyncFrontmatter.reasonix ?? {}, ["name", "description"]);
+		const rawReasonixFrontmatter = {
+			name: rulesyncFrontmatter.name,
+			description: rulesyncFrontmatter.description,
+			...reasonixSection,
+			invocation: REASONIX_SUBAGENT_INVOCATION,
+			runAs: REASONIX_SUBAGENT_RUN_AS
+		};
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(rawReasonixFrontmatter);
+		if (!result.success) throw new Error(`Invalid reasonix subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
+		const reasonixFrontmatter = result.data;
+		const body = rulesyncSubagent.getBody();
+		const fileContent = stringifyFrontmatter(body, reasonixFrontmatter);
+		const paths = this.getSettablePaths({ global });
+		const subagentName = (0, node_path.basename)(rulesyncSubagent.getRelativeFilePath(), (0, node_path.extname)(rulesyncSubagent.getRelativeFilePath()));
+		return new ReasonixSubagent({
+			outputRoot,
+			frontmatter: reasonixFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: (0, node_path.join)(subagentName, SKILL_FILE_NAME),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	validate() {
+		if (!this.frontmatter) return {
+			success: true,
+			error: null
+		};
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(this.frontmatter);
+		if (result.success) return {
+			success: true,
+			error: null
+		};
+		else return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid frontmatter in ${(0, node_path.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`)
+		};
+	}
+	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+		return this.isTargetedByRulesyncSubagentDefault({
+			rulesyncSubagent,
+			toolTarget: "reasonix"
+		});
+	}
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true, global = false }) {
+		const paths = this.getSettablePaths({ global });
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, relativeFilePath);
+		const fileContent = await readFileContent(filePath);
+		const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
+		const result = ReasonixSubagentFrontmatterSchema.safeParse(frontmatter);
+		if (!result.success) throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+		return new ReasonixSubagent({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath,
+			frontmatter: result.data,
+			body: content.trim(),
+			fileContent,
+			validate,
+			global
+		});
+	}
+	/**
+	* Whether the SKILL.md at the given path is a subagent profile.
+	*
+	* `.reasonix/skills/` is shared with the skills feature: a regular skill and
+	* a subagent profile differ only by their frontmatter markers. Only files
+	* carrying `runAs: subagent` belong to this feature, so regular skills are
+	* neither imported as subagents nor deleted as orphans by the subagents
+	* feature. `runAs` alone is checked (not `invocation`) because it is the
+	* marker that switches the execution mode; generation always emits both.
+	* Unreadable or unparsable files are treated as not owned, erring on the
+	* side of leaving foreign files untouched.
+	*/
+	static async isFileOwned({ outputRoot, relativeDirPath, relativeFilePath }) {
+		const filePath = (0, node_path.join)(outputRoot, relativeDirPath, relativeFilePath);
+		try {
+			const { frontmatter } = parseFrontmatter(await readFileContent(filePath), filePath);
+			return frontmatter["runAs"] === REASONIX_SUBAGENT_RUN_AS;
+		} catch {
+			return false;
+		}
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ReasonixSubagent({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/subagents/roo-subagent.ts
 /**
 * Default tool groups assigned to a generated mode when the rulesync source
@@ -33716,6 +34010,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: (0, node_path.join)("*", "SKILL.md")
+		}
+	}],
 	["roo", {
 		class: RooSubagent,
 		meta: {
@@ -33868,8 +34170,17 @@ var SubagentsProcessor = class extends FeatureProcessor {
 			const baseDir = (0, node_path.join)(this.outputRoot, dirPath);
 			const subagentFilePaths = await findFilesByGlobs((0, node_path.join)(baseDir, factory.meta.filePattern));
 			const toRelativeFilePath = (path) => (0, node_path.relative)(baseDir, path);
+			let ownedFilePaths = subagentFilePaths;
+			if (factory.class.isFileOwned) {
+				const ownership = await Promise.all(subagentFilePaths.map((path) => factory.class.isFileOwned({
+					outputRoot: this.outputRoot,
+					relativeDirPath: dirPath,
+					relativeFilePath: toRelativeFilePath(path)
+				})));
+				ownedFilePaths = subagentFilePaths.filter((_, index) => ownership[index]);
+			}
 			if (forDeletion) {
-				toolSubagents.push(...subagentFilePaths.map((path) => factory.class.forDeletion({
+				toolSubagents.push(...ownedFilePaths.map((path) => factory.class.forDeletion({
 					outputRoot: this.outputRoot,
 					relativeDirPath: dirPath,
 					relativeFilePath: toRelativeFilePath(path),
@@ -33877,7 +34188,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
 				})).filter((subagent) => subagent.isDeletable()));
 				continue;
 			}
-			const loaded = await Promise.all(subagentFilePaths.map((path) => factory.class.fromFile({
+			const loaded = await Promise.all(ownedFilePaths.map((path) => factory.class.fromFile({
 				outputRoot: this.outputRoot,
 				relativeDirPath: dirPath,
 				relativeFilePath: toRelativeFilePath(path),
@@ -39696,11 +40007,51 @@ const GENERATION_STEP_GRAPH = [
 	}
 ];
 /**
+* Warn when a rulesync skill and a rulesync subagent share a name for a tool
+* that emits both features into the same directory (e.g. Reasonix, where both
+* write `<name>/SKILL.md` under `.reasonix/skills/`). The colliding outputs
+* target the same on-disk file, so whichever generation step runs later
+* silently overwrites the other's file.
+*/
+async function warnSkillSubagentNameCollisions(params) {
+	const { config, logger } = params;
+	const global = config.getGlobal();
+	for (const toolTarget of config.getTargets()) {
+		const features = config.getFeatures(toolTarget);
+		if (!features.includes("skills") || !features.includes("subagents")) continue;
+		if (!SubagentsProcessor.getToolTargets({ global }).includes(toolTarget) || !SkillsProcessor.getToolTargets({ global }).includes(toolTarget)) continue;
+		const subagentFactory = SubagentsProcessor.getFactory(toolTarget);
+		const skillFactory = SkillsProcessor.getFactory(toolTarget);
+		if (!subagentFactory || !skillFactory) continue;
+		const subagentsDirPath = subagentFactory.class.getSettablePaths({ global }).relativeDirPath;
+		if (subagentsDirPath !== skillFactory.class.getSettablePaths({ global }).relativeDirPath) continue;
+		const subagentsProcessor = new SubagentsProcessor({
+			inputRoot: config.getInputRoot(),
+			toolTarget,
+			global,
+			logger
+		});
+		const subagentNames = new Set((await subagentsProcessor.loadRulesyncFiles()).filter((file) => file instanceof RulesyncSubagent).filter((file) => subagentFactory.class.isTargetedByRulesyncSubagent(file)).map((file) => (0, node_path.basename)(file.getRelativeFilePath(), (0, node_path.extname)(file.getRelativeFilePath()))));
+		if (subagentNames.size === 0) continue;
+		const skillNames = (await new SkillsProcessor({
+			inputRoot: config.getInputRoot(),
+			toolTarget,
+			global,
+			logger
+		}).loadRulesyncDirs()).filter((dir) => dir instanceof RulesyncSkill).filter((skill) => skillFactory.class.isTargetedByRulesyncSkill(skill)).map((skill) => skill.getDirName());
+		for (const name of skillNames) if (subagentNames.has(name)) logger.warn(`Skill "${name}" and subagent "${name}" both target '${toolTarget}' and write the same path '${(0, node_path.join)(subagentsDirPath, name)}'; the later generation step overwrites the other's output. Rename one of them or narrow their targets.`);
+	}
+}
+/**
 * Generate configuration files for AI tools.
 * @throws Error if generation fails
 */
 async function generate(params) {
 	const { config, logger } = params;
+	await warnSkillSubagentNameCollisions({
+		config,
+		logger
+	});
 	let skillsResult;
 	const runners = {
 		ignore: () => generateIgnoreCore({