rulesync 11.0.0 → 12.0.0

package/dist/{import-AKytnIKl.js → import-hM4jDZn1.js}

@@ -264,6 +264,7 @@ const subagentsProcessorToolTargetTuple = [
 	"kiro-ide",
 	"opencode",
 	"qwencode",
+	"reasonix",
 	"roo",
 	"rovodev",
 	"takt",
@@ -5092,6 +5093,9 @@ const REASONIX_SETTINGS_FILE_NAME = "settings.json";
 const REASONIX_COMMANDS_DIR_PATH = join(REASONIX_DIR, "commands");
 const REASONIX_RULE_FILE_NAME = "REASONIX.md";
 const REASONIX_SKILLS_DIR_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
 /**
@@ -17495,6 +17499,14 @@ const CodexBasePermissionProfileSchema = z.enum(CODEX_BASE_PERMISSION_PROFILES);
 *   | `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
@@ -17520,7 +17532,8 @@ const CodexcliPermissionsOverrideSchema = z.looseObject({
 	/** @deprecated Superseded by `base_permission_profile` (permission profiles). */
 	sandbox_workspace_write: z.optional(z.looseObject({})),
 	apps: z.optional(z.looseObject({})),
-	approvals_reviewer: z.optional(z.union([CodexApprovalsReviewerSchema, z.looseObject({})]))
+	approvals_reviewer: z.optional(z.union([CodexApprovalsReviewerSchema, z.looseObject({})])),
+	git_write_rules: z.optional(z.boolean())
 });
 /**
 * Permissions configuration.
@@ -19489,11 +19502,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 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 = {}) {
@@ -19660,6 +19678,11 @@ 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;
@@ -19677,6 +19700,12 @@ function convertRulesyncToCodexProfile({ config, logger }) {
 		...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) {
@@ -19688,7 +19717,10 @@ 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?.network && profile.network.enabled !== false) {
@@ -19730,9 +19762,28 @@ function toCodexProfile(value) {
 }
 function warnAboutPreservedProfileState({ existingProfile, newProfile, existingDomainsHadUnknown, logger }) {
 	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 +19825,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;
@@ -19825,7 +19877,7 @@ function computeCodexcliOverridePatch({ existing, override, logger }) {
 	const patch = {};
 	const allowed = new Set(CODEXCLI_OVERRIDE_KEYS);
 	for (const [key, value] of Object.entries(override ?? {})) {
-		if (key === "base_permission_profile") continue;
+		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;
@@ -28465,6 +28517,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 = 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,
@@ -29763,6 +29833,11 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			for (const dirPath of dirPaths) {
 				const dirName = 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,
@@ -29789,6 +29864,11 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 			const dirPaths = await findFilesByGlobs(join(skillsDirPath, "*"), { type: "dir" });
 			for (const dirPath of dirPaths) {
 				const dirName = 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,
@@ -33088,6 +33168,188 @@ var OpenCodeSubagent = class OpenCodeSubagent extends OpenCodeStyleSubagent {
 	}
 };
 //#endregion
+//#region src/features/subagents/reasonix-subagent.ts
+const ReasonixSubagentFrontmatterSchema = z.looseObject({
+	name: z.string(),
+	description: z.optional(z.string()),
+	invocation: z.optional(z.string()),
+	runAs: z.optional(z.string()),
+	model: z.optional(z.string()),
+	effort: z.optional(z.string()),
+	"allowed-tools": z.optional(z.array(z.string())),
+	color: z.optional(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 ${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 = dirname(relativeFilePath);
+		if (dir && dir !== ".") return basename(dir);
+		return basename(relativeFilePath, 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 = basename(rulesyncSubagent.getRelativeFilePath(), extname(rulesyncSubagent.getRelativeFilePath()));
+		return new ReasonixSubagent({
+			outputRoot,
+			frontmatter: reasonixFrontmatter,
+			body,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: 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 ${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 = 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 = 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
@@ -33722,6 +33984,14 @@ const toolSubagentFactories = /* @__PURE__ */ new Map([
 			filePattern: "*.md"
 		}
 	}],
+	["reasonix", {
+		class: ReasonixSubagent,
+		meta: {
+			supportsSimulated: false,
+			supportsGlobal: true,
+			filePattern: join("*", "SKILL.md")
+		}
+	}],
 	["roo", {
 		class: RooSubagent,
 		meta: {
@@ -33874,8 +34144,17 @@ var SubagentsProcessor = class extends FeatureProcessor {
 			const baseDir = join(this.outputRoot, dirPath);
 			const subagentFilePaths = await findFilesByGlobs(join(baseDir, factory.meta.filePattern));
 			const toRelativeFilePath = (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),
@@ -33883,7 +34162,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),
@@ -39702,11 +39981,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) => basename(file.getRelativeFilePath(), 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 '${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({
@@ -40420,4 +40739,4 @@ async function importPermissionsCore(params) {
 //#endregion
 export { removeFile as $, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as At, ErrorCodes as B, RulesyncHooks as C, RULESYNC_PERMISSIONS_FILE_NAME as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_RELATIVE_DIR_PATH as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_SCHEMA_URL as Et, ConfigResolver as F, fileExists as G, createTempDirectory as H, findControlCharacter as I, getHomeDirectory as J, findFilesByGlobs as K, ConsoleLogger as L, RulesyncCommandFrontmatterSchema as M, formatError as Mt, stringifyFrontmatter as N, ALL_FEATURES as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RULES_RELATIVE_DIR_PATH as Ot, loadYaml as P, ALL_FEATURES_WITH_WILDCARD as Pt, removeDirectory as Q, JsonLogger as R, HooksProcessor as S, RULESYNC_OVERVIEW_FILE_NAME as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Tt, directoryExists as U, checkPathTraversal as V, ensureDir as W, listDirectoryFiles as X, isSymlink as Y, readFileContent as Z, RulesyncPermissions as _, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as _t, convertFromTool as a, ToolTargetSchema as at, IgnoreProcessor as b, RULESYNC_MCP_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CONFIG_SCHEMA_URL as dt, removeTempDirectory as et, SkillsProcessor as f, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as ft, SKILL_FILE_NAME as g, RULESYNC_IGNORE_RELATIVE_FILE_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_HOOKS_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ALL_TOOL_TARGETS_WITH_WILDCARD as it, RulesyncCommand as j, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_SKILLS_RELATIVE_DIR_PATH as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as lt, RulesyncSkill as m, RULESYNC_HOOKS_JSONC_FILE_NAME as mt, checkRulesyncDirExists as n, writeFileContent as nt, RulesProcessor as o, MAX_FILE_SIZE as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_FILE_NAME as pt, getFileSize as q, generate as r, ALL_TOOL_TARGETS as rt, RulesyncRule as s, RULESYNC_AIIGNORE_FILE_NAME as st, importFromTool as t, toPosixPath as tt, RulesyncSubagent as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ut, McpProcessor as v, RULESYNC_MCP_FILE_NAME as vt, CommandsProcessor as w, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as wt, RulesyncIgnore as x, RULESYNC_MCP_SCHEMA_URL as xt, RulesyncMcp as y, RULESYNC_MCP_JSONC_FILE_NAME as yt, CLIError as z };
 
-//# sourceMappingURL=import-AKytnIKl.js.map
+//# sourceMappingURL=import-hM4jDZn1.js.map